From 94724fdaf89a24657fcec372e359ebbe78e25fd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Thu, 20 Dec 2018 21:01:00 +0100 Subject: [PATCH] coreapi: Interface for external test providers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit License: MIT Signed-off-by: Łukasz Magiera --- core/coreapi/interface/tests/api.go | 138 +++++-------------------- core/coreapi/interface/tests/block.go | 38 +++---- core/coreapi/interface/tests/dag.go | 32 +++--- core/coreapi/interface/tests/dht.go | 20 ++-- core/coreapi/interface/tests/key.go | 105 ++++++++++--------- core/coreapi/interface/tests/name.go | 19 ++-- core/coreapi/interface/tests/object.go | 74 ++++++------- core/coreapi/interface/tests/path.go | 32 +++--- core/coreapi/interface/tests/pin.go | 20 ++-- core/coreapi/interface/tests/pubsub.go | 8 +- core/coreapi/interface/tests/unixfs.go | 70 ++++++------- core/coreapi/test/api_test.go | 108 ++++++++++++++++++- 12 files changed, 344 insertions(+), 320 deletions(-) diff --git a/core/coreapi/interface/tests/api.go b/core/coreapi/interface/tests/api.go index 8baa869dd..a4b0312f6 100644 --- a/core/coreapi/interface/tests/api.go +++ b/core/coreapi/interface/tests/api.go @@ -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) + } } diff --git a/core/coreapi/interface/tests/block.go b/core/coreapi/interface/tests/block.go index 07679a926..0ee968860 100644 --- a/core/coreapi/interface/tests/block.go +++ b/core/coreapi/interface/tests/block.go @@ -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) } diff --git a/core/coreapi/interface/tests/dag.go b/core/coreapi/interface/tests/dag.go index a75438ab1..f19216221 100644 --- a/core/coreapi/interface/tests/dag.go +++ b/core/coreapi/interface/tests/dag.go @@ -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) } diff --git a/core/coreapi/interface/tests/dht.go b/core/coreapi/interface/tests/dht.go index 429197f70..9269bc4c5 100644 --- a/core/coreapi/interface/tests/dht.go +++ b/core/coreapi/interface/tests/dht.go @@ -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) } diff --git a/core/coreapi/interface/tests/key.go b/core/coreapi/interface/tests/key.go index b08f56a4f..c2b892599 100644 --- a/core/coreapi/interface/tests/key.go +++ b/core/coreapi/interface/tests/key.go @@ -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) } diff --git a/core/coreapi/interface/tests/name.go b/core/coreapi/interface/tests/name.go index 154c1d444..ecb06ddde 100644 --- a/core/coreapi/interface/tests/name.go +++ b/core/coreapi/interface/tests/name.go @@ -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) } diff --git a/core/coreapi/interface/tests/object.go b/core/coreapi/interface/tests/object.go index 7d4243bca..349b4a8f5 100644 --- a/core/coreapi/interface/tests/object.go +++ b/core/coreapi/interface/tests/object.go @@ -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) } diff --git a/core/coreapi/interface/tests/path.go b/core/coreapi/interface/tests/path.go index efbacd29f..cb1246366 100644 --- a/core/coreapi/interface/tests/path.go +++ b/core/coreapi/interface/tests/path.go @@ -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) } diff --git a/core/coreapi/interface/tests/pin.go b/core/coreapi/interface/tests/pin.go index 344cd0db7..8c659ba35 100644 --- a/core/coreapi/interface/tests/pin.go +++ b/core/coreapi/interface/tests/pin.go @@ -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) } diff --git a/core/coreapi/interface/tests/pubsub.go b/core/coreapi/interface/tests/pubsub.go index 3ecd80274..3462b4755 100644 --- a/core/coreapi/interface/tests/pubsub.go +++ b/core/coreapi/interface/tests/pubsub.go @@ -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) } diff --git a/core/coreapi/interface/tests/unixfs.go b/core/coreapi/interface/tests/unixfs.go index 1ca0b282a..b31a55d4c 100644 --- a/core/coreapi/interface/tests/unixfs.go +++ b/core/coreapi/interface/tests/unixfs.go @@ -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) } diff --git a/core/coreapi/test/api_test.go b/core/coreapi/test/api_test.go index 983f4f065..f44716b7e 100644 --- a/core/coreapi/test/api_test.go +++ b/core/coreapi/test/api_test.go @@ -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) }