coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-03-05 08:18:03 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

coreapi: Interface for external test providers

Browse Source 
License: MIT
Signed-off-by: Łukasz Magiera <magik6k@gmail.com>
This commit is contained in:
Łukasz Magiera 2018-12-20 21:01:00 +01:00
parent 5a019ba713
commit 94724fdaf8
12 changed files with 344 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
core/coreapi/interface/tests/api.go
View File

@ -2,111 +2,13 @@ package tests
import (
"context"
"encoding/base64"
"fmt"
"testing"
"github.com/ipfs/go-ipfs/core"
"github.com/ipfs/go-ipfs/core/coreapi"
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
mock "github.com/ipfs/go-ipfs/core/mock"
"github.com/ipfs/go-ipfs/keystore"
"github.com/ipfs/go-ipfs/repo"
ci "gx/ipfs/QmNiJiXwWE3kRhZrC5ej3kSjWHm337pYfhjLGSCDNKJP2s/go-libp2p-crypto"
"gx/ipfs/QmRBaUEQEeFWywfrZJ64QgsmvcqgLSK3VbvGMR2NM2Edpf/go-libp2p/p2p/net/mock"
"gx/ipfs/QmY5Grm8pJdiSSVsYxx4uNRgweY72EmYwuSDbRnbFok3iY/go-libp2p-peer"
pstore "gx/ipfs/QmZ9zH2FnLcxv1xyzFeUpDUeo55xEhZQHgveZijcxr7TLj/go-libp2p-peerstore"
"gx/ipfs/QmcZfkbgwwwH5ZLTQRHkSQBDiDqd3skY2eU6MZRgWuXcse/go-ipfs-config"
"gx/ipfs/Qmf4xQhNomPNhrtZc67qSnfJSjxjXs9LWvknJtSXwimPrM/go-datastore"
syncds "gx/ipfs/Qmf4xQhNomPNhrtZc67qSnfJSjxjXs9LWvknJtSXwimPrM/go-datastore/sync"
)
func makeAPISwarm(ctx context.Context, fullIdentity bool, n int) ([]coreiface.CoreAPI, error) {
mn := mocknet.New(ctx)
nodes := make([]*core.IpfsNode, n)
apis := make([]coreiface.CoreAPI, n)
for i := 0; i < n; i++ {
var ident config.Identity
if fullIdentity {
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
return nil, err
}
id, err := peer.IDFromPublicKey(pk)
if err != nil {
return nil, err
}
kbytes, err := sk.Bytes()
if err != nil {
return nil, err
}
ident = config.Identity{
PeerID: id.Pretty(),
PrivKey: base64.StdEncoding.EncodeToString(kbytes),
}
} else {
ident = config.Identity{
PeerID: testPeerID,
}
}
c := config.Config{}
c.Addresses.Swarm = []string{fmt.Sprintf("/ip4/127.0.%d.1/tcp/4001", i)}
c.Identity = ident
r := &repo.Mock{
C: c,
D: syncds.MutexWrap(datastore.NewMapDatastore()),
K: keystore.NewMemKeystore(),
}
node, err := core.NewNode(ctx, &core.BuildCfg{
Repo: r,
Host: mock.MockHostOption(mn),
Online: fullIdentity,
ExtraOpts: map[string]bool{
"pubsub": true,
},
})
if err != nil {
return nil, err
}
nodes[i] = node
apis[i], err = coreapi.NewCoreAPI(node)
if err != nil {
return nil, err
}
}
err := mn.LinkAll()
if err != nil {
return nil, err
}
bsinf := core.BootstrapConfigWithPeers(
[]pstore.PeerInfo{
nodes[0].Peerstore.PeerInfo(nodes[0].Identity),
},
)
for _, n := range nodes[1:] {
if err := n.Bootstrap(bsinf); err != nil {
return nil, err
}
}
return apis, nil
}
func makeAPI(ctx context.Context) (coreiface.CoreAPI, error) {
api, err := makeAPISwarm(ctx, false, 1)
func (tp *provider) makeAPI(ctx context.Context) (coreiface.CoreAPI, error) {
api, err := tp.MakeAPISwarm(ctx, false, 1)
if err != nil {
return nil, err
}
@ -114,16 +16,28 @@ func makeAPI(ctx context.Context) (coreiface.CoreAPI, error) {
return api[0], nil
}
func TestApi(t *testing.T) {
t.Run("Block", TestBlock)
t.Run("TestDag", TestDag)
t.Run("TestDht", TestDht)
t.Run("TestKey", TestKey)
t.Run("TestName", TestName)
t.Run("TestObject", TestObject)
t.Run("TestPath", TestPath)
t.Run("TestPin", TestPin)
t.Run("TestPubSub", TestPubSub)
t.Run("TestUnixfs", TestUnixfs)
type Provider interface {
// Make creates n nodes. fullIdentity set to false can be ignored
MakeAPISwarm(ctx context.Context, fullIdentity bool, n int) ([]coreiface.CoreAPI, error)
}
type provider struct {
Provider
}
func TestApi(p Provider) func(t *testing.T) {
tp := &provider{p}
return func(t *testing.T) {
t.Run("Block", tp.TestBlock)
t.Run("Dag", tp.TestDag)
t.Run("Dht", tp.TestDht)
t.Run("Key", tp.TestKey)
t.Run("Name", tp.TestName)
t.Run("Object", tp.TestObject)
t.Run("Path", tp.TestPath)
t.Run("Pin", tp.TestPin)
t.Run("PubSub", tp.TestPubSub)
t.Run("Unixfs", tp.TestUnixfs)
}
}

38
core/coreapi/interface/tests/block.go
View File

@ -12,18 +12,18 @@ import (
mh "gx/ipfs/QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW/go-multihash"
)
func TestBlock(t *testing.T) {
t.Run("TestBlockPut", TestBlockPut)
t.Run("TestBlockPutFormat", TestBlockPutFormat)
t.Run("TestBlockPutHash", TestBlockPutHash)
t.Run("TestBlockGet", TestBlockGet)
t.Run("TestBlockRm", TestBlockRm)
t.Run("TestBlockStat", TestBlockStat)
func (tp *provider) TestBlock(t *testing.T) {
t.Run("TestBlockPut", tp.TestBlockPut)
t.Run("TestBlockPutFormat", tp.TestBlockPutFormat)
t.Run("TestBlockPutHash", tp.TestBlockPutHash)
t.Run("TestBlockGet", tp.TestBlockGet)
t.Run("TestBlockRm", tp.TestBlockRm)
t.Run("TestBlockStat", tp.TestBlockStat)
}
func TestBlockPut(t *testing.T) {
func (tp *provider) TestBlockPut(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -38,9 +38,9 @@ func TestBlockPut(t *testing.T) {
}
}
func TestBlockPutFormat(t *testing.T) {
func (tp *provider) TestBlockPutFormat(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -55,9 +55,9 @@ func TestBlockPutFormat(t *testing.T) {
}
}
func TestBlockPutHash(t *testing.T) {
func (tp *provider) TestBlockPutHash(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -72,9 +72,9 @@ func TestBlockPutHash(t *testing.T) {
}
}
func TestBlockGet(t *testing.T) {
func (tp *provider) TestBlockGet(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -112,9 +112,9 @@ func TestBlockGet(t *testing.T) {
}
}
func TestBlockRm(t *testing.T) {
func (tp *provider) TestBlockRm(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -165,9 +165,9 @@ func TestBlockRm(t *testing.T) {
}
}
func TestBlockStat(t *testing.T) {
func (tp *provider) TestBlockStat(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}

32
core/coreapi/interface/tests/dag.go
View File

@ -12,12 +12,12 @@ import (
mh "gx/ipfs/QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW/go-multihash"
)
func TestDag(t *testing.T) {
t.Run("TestPut", TestPut)
t.Run("TestPutWithHash", TestPutWithHash)
t.Run("TestPath", TestDagPath)
t.Run("TestTree", TestTree)
t.Run("TestBatch", TestBatch)
func (tp *provider) TestDag(t *testing.T) {
t.Run("TestPut", tp.TestPut)
t.Run("TestPutWithHash", tp.TestPutWithHash)
t.Run("TestPath", tp.TestDagPath)
t.Run("TestTree", tp.TestTree)
t.Run("TestBatch", tp.TestBatch)
}
var (
@ -30,9 +30,9 @@ var (
}
)
func TestPut(t *testing.T) {
func (tp *provider) TestPut(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -47,9 +47,9 @@ func TestPut(t *testing.T) {
}
}
func TestPutWithHash(t *testing.T) {
func (tp *provider) TestPutWithHash(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -64,9 +64,9 @@ func TestPutWithHash(t *testing.T) {
}
}
func TestDagPath(t *testing.T) {
func (tp *provider) TestDagPath(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -96,9 +96,9 @@ func TestDagPath(t *testing.T) {
}
}
func TestTree(t *testing.T) {
func (tp *provider) TestTree(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -125,9 +125,9 @@ func TestTree(t *testing.T) {
}
}
func TestBatch(t *testing.T) {
func (tp *provider) TestBatch(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}

20
core/coreapi/interface/tests/dht.go
View File

@ -8,15 +8,15 @@ import (
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestDht(t *testing.T) {
t.Run("TestDhtFindPeer", TestDhtFindPeer)
t.Run("TestDhtFindProviders", TestDhtFindProviders)
t.Run("TestDhtProvide", TestDhtProvide)
func (tp *provider) TestDht(t *testing.T) {
t.Run("TestDhtFindPeer", tp.TestDhtFindPeer)
t.Run("TestDhtFindProviders", tp.TestDhtFindProviders)
t.Run("TestDhtProvide", tp.TestDhtProvide)
}
func TestDhtFindPeer(t *testing.T) {
func (tp *provider) TestDhtFindPeer(t *testing.T) {
ctx := context.Background()
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
}
@ -50,9 +50,9 @@ func TestDhtFindPeer(t *testing.T) {
}
}
func TestDhtFindProviders(t *testing.T) {
func (tp *provider) TestDhtFindProviders(t *testing.T) {
ctx := context.Background()
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
}
@ -79,9 +79,9 @@ func TestDhtFindProviders(t *testing.T) {
}
}
func TestDhtProvide(t *testing.T) {
func (tp *provider) TestDhtProvide(t *testing.T) {
ctx := context.Background()
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
}

105
core/coreapi/interface/tests/key.go
View File

@ -8,31 +8,38 @@ import (
opt "github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestKey(t *testing.T) {
t.Run("TestListSelf", TestListSelf)
t.Run("TestRenameSelf", TestRenameSelf)
t.Run("TestRemoveSelf", TestRemoveSelf)
t.Run("TestGenerateSize", TestGenerateSize)
t.Run("TestGenerateExisting", TestGenerateExisting)
t.Run("TestList", TestList)
t.Run("TestRename", TestRename)
t.Run("TestRenameToSelf", TestRenameToSelf)
t.Run("TestRenameToSelfForce", TestRenameToSelfForce)
t.Run("TestRenameOverwriteNoForce", TestRenameOverwriteNoForce)
t.Run("TestRenameOverwrite", TestRenameOverwrite)
t.Run("TestRenameSameNameNoForce", TestRenameSameNameNoForce)
t.Run("TestRenameSameName", TestRenameSameName)
t.Run("TestRemove", TestRemove)
func (tp *provider) TestKey(t *testing.T) {
t.Run("TestListSelf", tp.TestListSelf)
t.Run("TestRenameSelf", tp.TestRenameSelf)
t.Run("TestRemoveSelf", tp.TestRemoveSelf)
t.Run("TestGenerate", tp.TestGenerate)
t.Run("TestGenerateSize", tp.TestGenerateSize)
t.Run("TestGenerateType", tp.TestGenerateType)
t.Run("TestGenerateExisting", tp.TestGenerateExisting)
t.Run("TestList", tp.TestList)
t.Run("TestRename", tp.TestRename)
t.Run("TestRenameToSelf", tp.TestRenameToSelf)
t.Run("TestRenameToSelfForce", tp.TestRenameToSelfForce)
t.Run("TestRenameOverwriteNoForce", tp.TestRenameOverwriteNoForce)
t.Run("TestRenameOverwrite", tp.TestRenameOverwrite)
t.Run("TestRenameSameNameNoForce", tp.TestRenameSameNameNoForce)
t.Run("TestRenameSameName", tp.TestRenameSameName)
t.Run("TestRemove", tp.TestRemove)
}
func TestListSelf(t *testing.T) {
func (tp *provider) TestListSelf(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
return
}
self, err := api.Key().Self(ctx)
if err != nil {
t.Fatal(err)
}
keys, err := api.Key().List(ctx)
if err != nil {
t.Fatalf("failed to list keys: %s", err)
@ -48,14 +55,14 @@ func TestListSelf(t *testing.T) {
t.Errorf("expected the key to be called 'self', got '%s'", keys[0].Name())
}
if keys[0].Path().String() != "/ipns/"+testPeerID {
t.Errorf("expected the key to have path '/ipns/%s', got '%s'", testPeerID, keys[0].Path().String())
if keys[0].Path().String() != "/ipns/"+self.ID().Pretty() {
t.Errorf("expected the key to have path '/ipns/%s', got '%s'", self.ID().Pretty(), keys[0].Path().String())
}
}
func TestRenameSelf(t *testing.T) {
func (tp *provider) TestRenameSelf(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
return
@ -80,9 +87,9 @@ func TestRenameSelf(t *testing.T) {
}
}
func TestRemoveSelf(t *testing.T) {
func (tp *provider) TestRemoveSelf(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
return
@ -98,9 +105,9 @@ func TestRemoveSelf(t *testing.T) {
}
}
func TestGenerate(t *testing.T) {
func (tp *provider) TestGenerate(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -120,9 +127,9 @@ func TestGenerate(t *testing.T) {
}
}
func TestGenerateSize(t *testing.T) {
func (tp *provider) TestGenerateSize(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -142,11 +149,11 @@ func TestGenerateSize(t *testing.T) {
}
}
func TestGenerateType(t *testing.T) {
func (tp *provider) TestGenerateType(t *testing.T) {
ctx := context.Background()
t.Skip("disabled until libp2p/specs#111 is fixed")
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -167,9 +174,9 @@ func TestGenerateType(t *testing.T) {
}
}
func TestGenerateExisting(t *testing.T) {
func (tp *provider) TestGenerateExisting(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -199,9 +206,9 @@ func TestGenerateExisting(t *testing.T) {
}
}
func TestList(t *testing.T) {
func (tp *provider) TestList(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -244,9 +251,9 @@ func TestList(t *testing.T) {
}
}
func TestRename(t *testing.T) {
func (tp *provider) TestRename(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -272,9 +279,9 @@ func TestRename(t *testing.T) {
}
}
func TestRenameToSelf(t *testing.T) {
func (tp *provider) TestRenameToSelf(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -295,9 +302,9 @@ func TestRenameToSelf(t *testing.T) {
}
}
func TestRenameToSelfForce(t *testing.T) {
func (tp *provider) TestRenameToSelfForce(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -318,9 +325,9 @@ func TestRenameToSelfForce(t *testing.T) {
}
}
func TestRenameOverwriteNoForce(t *testing.T) {
func (tp *provider) TestRenameOverwriteNoForce(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -347,9 +354,9 @@ func TestRenameOverwriteNoForce(t *testing.T) {
}
}
func TestRenameOverwrite(t *testing.T) {
func (tp *provider) TestRenameOverwrite(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -385,9 +392,9 @@ func TestRenameOverwrite(t *testing.T) {
}
}
func TestRenameSameNameNoForce(t *testing.T) {
func (tp *provider) TestRenameSameNameNoForce(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -413,9 +420,9 @@ func TestRenameSameNameNoForce(t *testing.T) {
}
}
func TestRenameSameName(t *testing.T) {
func (tp *provider) TestRenameSameName(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -441,9 +448,9 @@ func TestRenameSameName(t *testing.T) {
}
}
func TestRemove(t *testing.T) {
func (tp *provider) TestRemove(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}

19
core/coreapi/interface/tests/name.go
View File

@ -15,9 +15,10 @@ import (
opt "github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestName(t *testing.T) {
t.Run("TestPublishResolve", TestPublishResolve)
t.Run("TestBasicPublishResolveKey", TestBasicPublishResolveKey)
func (tp *provider) TestName(t *testing.T) {
t.Run("TestPublishResolve", tp.TestPublishResolve)
t.Run("TestBasicPublishResolveKey", tp.TestBasicPublishResolveKey)
t.Run("TestBasicPublishResolveTimeout", tp.TestBasicPublishResolveTimeout)
}
var rnd = rand.New(rand.NewSource(0x62796532303137))
@ -34,10 +35,10 @@ func appendPath(p coreiface.Path, sub string) coreiface.Path {
return p
}
func TestPublishResolve(t *testing.T) {
func (tp *provider) TestPublishResolve(t *testing.T) {
ctx := context.Background()
init := func() (coreiface.CoreAPI, coreiface.Path) {
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
return nil, nil
@ -183,9 +184,9 @@ func TestPublishResolve(t *testing.T) {
})
}
func TestBasicPublishResolveKey(t *testing.T) {
func (tp *provider) TestBasicPublishResolveKey(t *testing.T) {
ctx := context.Background()
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
}
@ -224,11 +225,11 @@ func TestBasicPublishResolveKey(t *testing.T) {
}
}
func TestBasicPublishResolveTimeout(t *testing.T) {
func (tp *provider) TestBasicPublishResolveTimeout(t *testing.T) {
t.Skip("ValidTime doesn't appear to work at this time resolution")
ctx := context.Background()
apis, err := makeAPISwarm(ctx, true, 5)
apis, err := tp.MakeAPISwarm(ctx, true, 5)
if err != nil {
t.Fatal(err)
}

74
core/coreapi/interface/tests/object.go
View File

@ -12,24 +12,24 @@ import (
opt "github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestObject(t *testing.T) {
t.Run("TestNew", TestNew)
t.Run("TestObjectPut", TestObjectPut)
t.Run("TestObjectGet", TestObjectGet)
t.Run("TestObjectData", TestObjectData)
t.Run("TestObjectLinks", TestObjectLinks)
t.Run("TestObjectStat", TestObjectStat)
t.Run("TestObjectAddLink", TestObjectAddLink)
t.Run("TestObjectAddLinkCreate", TestObjectAddLinkCreate)
t.Run("TestObjectRmLink", TestObjectRmLink)
t.Run("TestObjectAddData", TestObjectAddData)
t.Run("TestObjectSetData", TestObjectSetData)
t.Run("TestDiffTest", TestDiffTest)
func (tp *provider) TestObject(t *testing.T) {
t.Run("TestNew", tp.TestNew)
t.Run("TestObjectPut", tp.TestObjectPut)
t.Run("TestObjectGet", tp.TestObjectGet)
t.Run("TestObjectData", tp.TestObjectData)
t.Run("TestObjectLinks", tp.TestObjectLinks)
t.Run("TestObjectStat", tp.TestObjectStat)
t.Run("TestObjectAddLink", tp.TestObjectAddLink)
t.Run("TestObjectAddLinkCreate", tp.TestObjectAddLinkCreate)
t.Run("TestObjectRmLink", tp.TestObjectRmLink)
t.Run("TestObjectAddData", tp.TestObjectAddData)
t.Run("TestObjectSetData", tp.TestObjectSetData)
t.Run("TestDiffTest", tp.TestDiffTest)
}
func TestNew(t *testing.T) {
func (tp *provider) TestNew(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -53,9 +53,9 @@ func TestNew(t *testing.T) {
}
}
func TestObjectPut(t *testing.T) {
func (tp *provider) TestObjectPut(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -93,9 +93,9 @@ func TestObjectPut(t *testing.T) {
}
}
func TestObjectGet(t *testing.T) {
func (tp *provider) TestObjectGet(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -115,9 +115,9 @@ func TestObjectGet(t *testing.T) {
}
}
func TestObjectData(t *testing.T) {
func (tp *provider) TestObjectData(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -142,9 +142,9 @@ func TestObjectData(t *testing.T) {
}
}
func TestObjectLinks(t *testing.T) {
func (tp *provider) TestObjectLinks(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -177,9 +177,9 @@ func TestObjectLinks(t *testing.T) {
}
}
func TestObjectStat(t *testing.T) {
func (tp *provider) TestObjectStat(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -224,9 +224,9 @@ func TestObjectStat(t *testing.T) {
}
}
func TestObjectAddLink(t *testing.T) {
func (tp *provider) TestObjectAddLink(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -264,9 +264,9 @@ func TestObjectAddLink(t *testing.T) {
}
}
func TestObjectAddLinkCreate(t *testing.T) {
func (tp *provider) TestObjectAddLinkCreate(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -312,9 +312,9 @@ func TestObjectAddLinkCreate(t *testing.T) {
}
}
func TestObjectRmLink(t *testing.T) {
func (tp *provider) TestObjectRmLink(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -344,9 +344,9 @@ func TestObjectRmLink(t *testing.T) {
}
}
func TestObjectAddData(t *testing.T) {
func (tp *provider) TestObjectAddData(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -373,9 +373,9 @@ func TestObjectAddData(t *testing.T) {
}
}
func TestObjectSetData(t *testing.T) {
func (tp *provider) TestObjectSetData(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -402,9 +402,9 @@ func TestObjectSetData(t *testing.T) {
}
}
func TestDiffTest(t *testing.T) {
func (tp *provider) TestDiffTest(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}

32
core/coreapi/interface/tests/path.go
View File

@ -9,17 +9,17 @@ import (
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestPath(t *testing.T) {
t.Run("TestMutablePath", TestMutablePath)
t.Run("TestPathRemainder", TestPathRemainder)
t.Run("TestEmptyPathRemainder", TestEmptyPathRemainder)
t.Run("TestInvalidPathRemainder", TestInvalidPathRemainder)
t.Run("TestPathRoot", TestPathRoot)
func (tp *provider) TestPath(t *testing.T) {
t.Run("TestMutablePath", tp.TestMutablePath)
t.Run("TestPathRemainder", tp.TestPathRemainder)
t.Run("TestEmptyPathRemainder", tp.TestEmptyPathRemainder)
t.Run("TestInvalidPathRemainder", tp.TestInvalidPathRemainder)
t.Run("TestPathRoot", tp.TestPathRoot)
}
func TestMutablePath(t *testing.T) {
func (tp *provider) TestMutablePath(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -44,9 +44,9 @@ func TestMutablePath(t *testing.T) {
}
}
func TestPathRemainder(t *testing.T) {
func (tp *provider) TestPathRemainder(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -71,9 +71,9 @@ func TestPathRemainder(t *testing.T) {
}
}
func TestEmptyPathRemainder(t *testing.T) {
func (tp *provider) TestEmptyPathRemainder(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -102,9 +102,9 @@ func TestEmptyPathRemainder(t *testing.T) {
}
}
func TestInvalidPathRemainder(t *testing.T) {
func (tp *provider) TestInvalidPathRemainder(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -125,9 +125,9 @@ func TestInvalidPathRemainder(t *testing.T) {
}
}
func TestPathRoot(t *testing.T) {
func (tp *provider) TestPathRoot(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}

20
core/coreapi/interface/tests/pin.go
View File

@ -8,15 +8,15 @@ import (
opt "github.com/ipfs/go-ipfs/core/coreapi/interface/options"
)
func TestPin(t *testing.T) {
t.Run("TestPinAdd", TestPinAdd)
t.Run("TestPinSimple", TestPinSimple)
t.Run("TestPinRecursive", TestPinRecursive)
func (tp *provider) TestPin(t *testing.T) {
t.Run("TestPinAdd", tp.TestPinAdd)
t.Run("TestPinSimple", tp.TestPinSimple)
t.Run("TestPinRecursive", tp.TestPinRecursive)
}
func TestPinAdd(t *testing.T) {
func (tp *provider) TestPinAdd(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -32,9 +32,9 @@ func TestPinAdd(t *testing.T) {
}
}
func TestPinSimple(t *testing.T) {
func (tp *provider) TestPinSimple(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -81,9 +81,9 @@ func TestPinSimple(t *testing.T) {
}
}
func TestPinRecursive(t *testing.T) {
func (tp *provider) TestPinRecursive(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}

8
core/coreapi/interface/tests/pubsub.go
View File

@ -7,15 +7,15 @@ import (
"time"
)
func TestPubSub(t *testing.T) {
t.Run("TestBasicPubSub", TestBasicPubSub)
func (tp *provider) TestPubSub(t *testing.T) {
t.Run("TestBasicPubSub", tp.TestBasicPubSub)
}
func TestBasicPubSub(t *testing.T) {
func (tp *provider) TestBasicPubSub(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
apis, err := makeAPISwarm(ctx, true, 2)
apis, err := tp.MakeAPISwarm(ctx, true, 2)
if err != nil {
t.Fatal(err)
}

70
core/coreapi/interface/tests/unixfs.go
View File

@ -23,22 +23,20 @@ import (
mh "gx/ipfs/QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW/go-multihash"
)
func TestUnixfs(t *testing.T) {
t.Run("TestAdd", TestAdd)
t.Run("TestAddPinned", TestAddPinned)
t.Run("TestAddHashOnly", TestAddHashOnly)
t.Run("TestGetEmptyFile", TestGetEmptyFile)
t.Run("TestGetDir", TestGetDir)
t.Run("TestGetNonUnixfs", TestGetNonUnixfs)
t.Run("TestLs", TestLs)
t.Run("TestEntriesExpired", TestEntriesExpired)
t.Run("TestLsEmptyDir", TestLsEmptyDir)
t.Run("TestLsNonUnixfs", TestLsNonUnixfs)
t.Run("TestAddCloses", TestAddCloses)
func (tp *provider) TestUnixfs(t *testing.T) {
t.Run("TestAdd", tp.TestAdd)
t.Run("TestAddPinned", tp.TestAddPinned)
t.Run("TestAddHashOnly", tp.TestAddHashOnly)
t.Run("TestGetEmptyFile", tp.TestGetEmptyFile)
t.Run("TestGetDir", tp.TestGetDir)
t.Run("TestGetNonUnixfs", tp.TestGetNonUnixfs)
t.Run("TestLs", tp.TestLs)
t.Run("TestEntriesExpired", tp.TestEntriesExpired)
t.Run("TestLsEmptyDir", tp.TestLsEmptyDir)
t.Run("TestLsNonUnixfs", tp.TestLsNonUnixfs)
t.Run("TestAddCloses", tp.TestAddCloses)
}
const testPeerID = "QmTFauExutTsy4XP6JbMFcw2Wa9645HJt2bTqL6qYDCKfe"
// `echo -n 'hello, world!' | ipfs add`
var hello = "/ipfs/QmQy2Dw4Wk7rdJKjThjYXzfFJNaRKRHhHP5gHHXroJMYxk"
var helloStr = "hello, world!"
@ -80,9 +78,9 @@ func wrapped(name string) func(f files.Node) files.Node {
}
}
func TestAdd(t *testing.T) {
func (tp *provider) TestAdd(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -537,9 +535,9 @@ func TestAdd(t *testing.T) {
}
}
func TestAddPinned(t *testing.T) {
func (tp *provider) TestAddPinned(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -559,9 +557,9 @@ func TestAddPinned(t *testing.T) {
}
}
func TestAddHashOnly(t *testing.T) {
func (tp *provider) TestAddHashOnly(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -584,9 +582,9 @@ func TestAddHashOnly(t *testing.T) {
}
}
func TestGetEmptyFile(t *testing.T) {
func (tp *provider) TestGetEmptyFile(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Fatal(err)
}
@ -616,9 +614,9 @@ func TestGetEmptyFile(t *testing.T) {
}
}
func TestGetDir(t *testing.T) {
func (tp *provider) TestGetDir(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -648,9 +646,9 @@ func TestGetDir(t *testing.T) {
}
}
func TestGetNonUnixfs(t *testing.T) {
func (tp *provider) TestGetNonUnixfs(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -667,9 +665,9 @@ func TestGetNonUnixfs(t *testing.T) {
}
}
func TestLs(t *testing.T) {
func (tp *provider) TestLs(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -703,9 +701,9 @@ func TestLs(t *testing.T) {
}
}
func TestEntriesExpired(t *testing.T) {
func (tp *provider) TestEntriesExpired(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -746,9 +744,9 @@ func TestEntriesExpired(t *testing.T) {
}
}
func TestLsEmptyDir(t *testing.T) {
func (tp *provider) TestLsEmptyDir(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -774,9 +772,9 @@ func TestLsEmptyDir(t *testing.T) {
}
// TODO(lgierth) this should test properly, with len(links) > 0
func TestLsNonUnixfs(t *testing.T) {
func (tp *provider) TestLsNonUnixfs(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}
@ -831,9 +829,9 @@ func (f *closeTestF) Close() error {
return nil
}
func TestAddCloses(t *testing.T) {
func (tp *provider) TestAddCloses(t *testing.T) {
ctx := context.Background()
api, err := makeAPI(ctx)
api, err := tp.makeAPI(ctx)
if err != nil {
t.Error(err)
}

108
core/coreapi/test/api_test.go
View File

@ -1,10 +1,114 @@
package test
import (
"context"
"encoding/base64"
"fmt"
"github.com/ipfs/go-ipfs/core/coreapi/interface/tests"
"testing"
"github.com/ipfs/go-ipfs/core"
"github.com/ipfs/go-ipfs/core/coreapi"
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
mock "github.com/ipfs/go-ipfs/core/mock"
"github.com/ipfs/go-ipfs/keystore"
"github.com/ipfs/go-ipfs/repo"
ci "gx/ipfs/QmNiJiXwWE3kRhZrC5ej3kSjWHm337pYfhjLGSCDNKJP2s/go-libp2p-crypto"
"gx/ipfs/QmRBaUEQEeFWywfrZJ64QgsmvcqgLSK3VbvGMR2NM2Edpf/go-libp2p/p2p/net/mock"
"gx/ipfs/QmY5Grm8pJdiSSVsYxx4uNRgweY72EmYwuSDbRnbFok3iY/go-libp2p-peer"
pstore "gx/ipfs/QmZ9zH2FnLcxv1xyzFeUpDUeo55xEhZQHgveZijcxr7TLj/go-libp2p-peerstore"
"gx/ipfs/QmcZfkbgwwwH5ZLTQRHkSQBDiDqd3skY2eU6MZRgWuXcse/go-ipfs-config"
"gx/ipfs/Qmf4xQhNomPNhrtZc67qSnfJSjxjXs9LWvknJtSXwimPrM/go-datastore"
syncds "gx/ipfs/Qmf4xQhNomPNhrtZc67qSnfJSjxjXs9LWvknJtSXwimPrM/go-datastore/sync"
)
func TestIface(t *testing.T) {
tests.TestApi(t)
const testPeerID = "QmTFauExutTsy4XP6JbMFcw2Wa9645HJt2bTqL6qYDCKfe"
type NodeProvider struct{}
func (NodeProvider) MakeAPISwarm(ctx context.Context, fullIdentity bool, n int) ([]coreiface.CoreAPI, error) {
mn := mocknet.New(ctx)
nodes := make([]*core.IpfsNode, n)
apis := make([]coreiface.CoreAPI, n)
for i := 0; i < n; i++ {
var ident config.Identity
if fullIdentity {
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
return nil, err
}
id, err := peer.IDFromPublicKey(pk)
if err != nil {
return nil, err
}
kbytes, err := sk.Bytes()
if err != nil {
return nil, err
}
ident = config.Identity{
PeerID: id.Pretty(),
PrivKey: base64.StdEncoding.EncodeToString(kbytes),
}
} else {
ident = config.Identity{
PeerID: testPeerID,
}
}
c := config.Config{}
c.Addresses.Swarm = []string{fmt.Sprintf("/ip4/127.0.%d.1/tcp/4001", i)}
c.Identity = ident
r := &repo.Mock{
C: c,
D: syncds.MutexWrap(datastore.NewMapDatastore()),
K: keystore.NewMemKeystore(),
}
node, err := core.NewNode(ctx, &core.BuildCfg{
Repo: r,
Host: mock.MockHostOption(mn),
Online: fullIdentity,
ExtraOpts: map[string]bool{
"pubsub": true,
},
})
if err != nil {
return nil, err
}
nodes[i] = node
apis[i], err = coreapi.NewCoreAPI(node)
if err != nil {
return nil, err
}
}
err := mn.LinkAll()
if err != nil {
return nil, err
}
bsinf := core.BootstrapConfigWithPeers(
[]pstore.PeerInfo{
nodes[0].Peerstore.PeerInfo(nodes[0].Identity),
},
)
for _, n := range nodes[1:] {
if err := n.Bootstrap(bsinf); err != nil {
return nil, err
}
}
return apis, nil
}
func TestIface(t *testing.T) {
tests.TestApi(&NodeProvider{})(t)
}