package ipfscluster import ( "context" "errors" "mime/multipart" "os" "path/filepath" "sync" "testing" "time" "github.com/ipfs-cluster/ipfs-cluster/adder/sharding" "github.com/ipfs-cluster/ipfs-cluster/allocator/balanced" "github.com/ipfs-cluster/ipfs-cluster/api" "github.com/ipfs-cluster/ipfs-cluster/config" "github.com/ipfs-cluster/ipfs-cluster/informer/numpin" "github.com/ipfs-cluster/ipfs-cluster/monitor/pubsubmon" "github.com/ipfs-cluster/ipfs-cluster/pintracker/stateless" "github.com/ipfs-cluster/ipfs-cluster/state" "github.com/ipfs-cluster/ipfs-cluster/test" "github.com/ipfs-cluster/ipfs-cluster/version" gopath "github.com/ipfs/go-path" peer "github.com/libp2p/go-libp2p-core/peer" rpc "github.com/libp2p/go-libp2p-gorpc" ) type mockComponent struct { rpcClient *rpc.Client } func (c *mockComponent) Shutdown(ctx context.Context) error { return nil } func (c *mockComponent) SetClient(client *rpc.Client) { c.rpcClient = client } type mockAPI struct { mockComponent } type mockProxy struct { mockComponent } type mockConnector struct { mockComponent pins sync.Map blocks sync.Map } func (ipfs *mockConnector) ID(ctx context.Context) (api.IPFSID, error) { return api.IPFSID{ ID: test.PeerID1, }, nil } func (ipfs *mockConnector) Pin(ctx context.Context, pin api.Pin) error { if pin.Cid == test.ErrorCid { return errors.New("trying to pin ErrorCid") } ipfs.pins.Store(pin.Cid, pin.MaxDepth) return nil } func (ipfs *mockConnector) Unpin(ctx context.Context, c api.Cid) error { ipfs.pins.Delete(c) return nil } func (ipfs *mockConnector) PinLsCid(ctx context.Context, pin api.Pin) (api.IPFSPinStatus, error) { dI, ok := ipfs.pins.Load(pin.Cid) if !ok { return api.IPFSPinStatusUnpinned, nil } depth := dI.(api.PinDepth) if depth == 0 { return api.IPFSPinStatusDirect, nil } return api.IPFSPinStatusRecursive, nil } func (ipfs *mockConnector) PinLs(ctx context.Context, in []string, out chan<- api.IPFSPinInfo) error { defer close(out) var st api.IPFSPinStatus ipfs.pins.Range(func(k, v interface{}) bool { switch v.(api.PinDepth) { case 0: st = api.IPFSPinStatusDirect default: st = api.IPFSPinStatusRecursive } c := k.(api.Cid) out <- api.IPFSPinInfo{Cid: api.Cid(c), Type: st} return true }) return nil } func (ipfs *mockConnector) SwarmPeers(ctx context.Context) ([]peer.ID, error) { return []peer.ID{test.PeerID4, test.PeerID5}, nil } func (ipfs *mockConnector) RepoStat(ctx context.Context) (api.IPFSRepoStat, error) { return api.IPFSRepoStat{RepoSize: 100, StorageMax: 1000}, nil } func (ipfs *mockConnector) RepoGC(ctx context.Context) (api.RepoGC, error) { return api.RepoGC{ Keys: []api.IPFSRepoGC{ { Key: test.Cid1, }, }, }, nil } func (ipfs *mockConnector) Resolve(ctx context.Context, path string) (api.Cid, error) { _, err := gopath.ParsePath(path) if err != nil { return api.CidUndef, err } return test.CidResolved, nil } func (ipfs *mockConnector) ConnectSwarms(ctx context.Context) error { return nil } func (ipfs *mockConnector) ConfigKey(keypath string) (interface{}, error) { return nil, nil } func (ipfs *mockConnector) BlockStream(ctx context.Context, in <-chan api.NodeWithMeta) error { for n := range in { ipfs.blocks.Store(n.Cid.String(), n.Data) } return nil } func (ipfs *mockConnector) BlockGet(ctx context.Context, c api.Cid) ([]byte, error) { d, ok := ipfs.blocks.Load(c.String()) if !ok { return nil, errors.New("block not found") } return d.([]byte), nil } type mockTracer struct { mockComponent } func testingCluster(t *testing.T) (*Cluster, *mockAPI, *mockConnector, PinTracker) { ident, clusterCfg, _, _, _, badgerCfg, levelDBCfg, raftCfg, crdtCfg, statelesstrackerCfg, psmonCfg, _, _, _ := testingConfigs() ctx := context.Background() host, pubsub, dht := createHost(t, ident.PrivateKey, clusterCfg.Secret, clusterCfg.ListenAddr) folder := filepath.Join(testsFolder, host.ID().Pretty()) cleanState() clusterCfg.SetBaseDir(folder) raftCfg.DataFolder = folder badgerCfg.Folder = filepath.Join(folder, "badger") levelDBCfg.Folder = filepath.Join(folder, "leveldb") api := &mockAPI{} proxy := &mockProxy{} ipfs := &mockConnector{} tracer := &mockTracer{} store := makeStore(t, badgerCfg, levelDBCfg) cons := makeConsensus(t, store, host, pubsub, dht, raftCfg, false, crdtCfg) tracker := stateless.New(statelesstrackerCfg, ident.ID, clusterCfg.Peername, cons.State) var peersF func(context.Context) ([]peer.ID, error) if consensus == "raft" { peersF = cons.Peers } psmonCfg.CheckInterval = 2 * time.Second mon, err := pubsubmon.New(ctx, psmonCfg, pubsub, peersF) if err != nil { t.Fatal(err) } alloc, err := balanced.New(&balanced.Config{ AllocateBy: []string{"numpin"}, }) if err != nil { t.Fatal(err) } numpinCfg := &numpin.Config{} numpinCfg.Default() inf, _ := numpin.NewInformer(numpinCfg) ReadyTimeout = raftCfg.WaitForLeaderTimeout + 1*time.Second cl, err := NewCluster( ctx, host, dht, clusterCfg, store, cons, []API{api, proxy}, ipfs, tracker, mon, alloc, []Informer{inf}, tracer, ) if err != nil { t.Fatal("cannot create cluster:", err) } <-cl.Ready() return cl, api, ipfs, tracker } func cleanState() { os.RemoveAll(testsFolder) } func TestClusterShutdown(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) err := cl.Shutdown(ctx) if err != nil { t.Error("cluster shutdown failed:", err) } cl.Shutdown(ctx) cl, _, _, _ = testingCluster(t) err = cl.Shutdown(ctx) if err != nil { t.Error("cluster shutdown failed:", err) } } func TestClusterStateSync(t *testing.T) { ctx := context.Background() cleanState() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 _, err := cl.Pin(ctx, c, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } err = cl.StateSync(ctx) if err != nil { t.Fatal("sync after pinning should have worked:", err) } // Modify state on the side so the sync does not // happen on an empty slide st, err := cl.consensus.State(ctx) if err != nil { t.Fatal(err) } st.(state.State).Rm(ctx, c) err = cl.StateSync(ctx) if err != nil { t.Fatal("sync with recover should have worked:", err) } } func TestClusterID(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) id := cl.ID(ctx) if len(id.Addresses) == 0 { t.Error("expected more addresses") } if id.ID == "" { t.Error("expected a cluster ID") } if id.Version != version.Version.String() { t.Error("version should match current version") } //if id.PublicKey == nil { // t.Error("publicKey should not be empty") //} } func TestClusterPin(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 res, err := cl.Pin(ctx, c, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } if res.Type != api.DataType { t.Error("unexpected pin type") } switch consensus { case "crdt": return case "raft": // test an error case cl.consensus.Shutdown(ctx) opts := api.PinOptions{ ReplicationFactorMax: 1, ReplicationFactorMin: 1, } _, err = cl.Pin(ctx, c, opts) if err == nil { t.Error("expected an error but things worked") } } } func TestPinExpired(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 _, err := cl.Pin(ctx, c, api.PinOptions{ ExpireAt: time.Now(), }) if err == nil { t.Fatal("pin should have errored") } } func TestClusterPinPath(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) pin, err := cl.PinPath(ctx, test.PathIPFS2, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } if !pin.Cid.Equals(test.CidResolved) { t.Error("expected a different cid, found", pin.Cid.String()) } // test an error case _, err = cl.PinPath(ctx, test.InvalidPath1, api.PinOptions{}) if err == nil { t.Error("expected an error but things worked") } } func TestAddFile(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) sth := test.NewShardingTestHelper() defer sth.Clean(t) t.Run("local", func(t *testing.T) { params := api.DefaultAddParams() params.Shard = false params.Name = "testlocal" mfr, closer := sth.GetTreeMultiReader(t) defer closer.Close() r := multipart.NewReader(mfr, mfr.Boundary()) c, err := cl.AddFile(context.Background(), r, params) if err != nil { t.Fatal(err) } if c.String() != test.ShardingDirBalancedRootCID { t.Fatal("unexpected root CID for local add") } pinDelay() pin := cl.StatusLocal(ctx, c) if pin.Error != "" { t.Fatal(pin.Error) } if pin.Status != api.TrackerStatusPinned { t.Error("cid should be pinned") } cl.Unpin(ctx, c) // unpin so we can pin the shard in next test pinDelay() }) t.Run("shard", func(t *testing.T) { params := api.DefaultAddParams() params.Shard = true params.Name = "testshard" mfr, closer := sth.GetTreeMultiReader(t) defer closer.Close() r := multipart.NewReader(mfr, mfr.Boundary()) c, err := cl.AddFile(context.Background(), r, params) if err != nil { t.Fatal(err) } if c.String() != test.ShardingDirBalancedRootCID { t.Fatal("unexpected root CID for local add") } pinDelay() // We know that this produces 14 shards. sharding.VerifyShards(t, c, cl, cl.ipfs, 14) }) } func TestUnpinShard(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) sth := test.NewShardingTestHelper() defer sth.Clean(t) params := api.DefaultAddParams() params.Shard = true params.Name = "testshard" mfr, closer := sth.GetTreeMultiReader(t) defer closer.Close() r := multipart.NewReader(mfr, mfr.Boundary()) root, err := cl.AddFile(context.Background(), r, params) if err != nil { t.Fatal(err) } pinDelay() // We know that this produces 14 shards. sharding.VerifyShards(t, root, cl, cl.ipfs, 14) // skipping errors, VerifyShards has checked pinnedCids := []api.Cid{} pinnedCids = append(pinnedCids, root) metaPin, _ := cl.PinGet(ctx, root) cDag, _ := cl.PinGet(ctx, *metaPin.Reference) pinnedCids = append(pinnedCids, cDag.Cid) cDagBlock, _ := cl.ipfs.BlockGet(ctx, cDag.Cid) cDagNode, _ := sharding.CborDataToNode(cDagBlock, "cbor") for _, l := range cDagNode.Links() { pinnedCids = append(pinnedCids, api.NewCid(l.Cid)) } t.Run("unpin clusterdag should fail", func(t *testing.T) { _, err := cl.Unpin(ctx, cDag.Cid) if err == nil { t.Fatal("should not allow unpinning the cluster DAG directly") } t.Log(err) }) t.Run("unpin shard should fail", func(t *testing.T) { _, err := cl.Unpin(ctx, api.NewCid(cDagNode.Links()[0].Cid)) if err == nil { t.Fatal("should not allow unpinning shards directly") } t.Log(err) }) t.Run("normal unpin", func(t *testing.T) { res, err := cl.Unpin(ctx, root) if err != nil { t.Fatal(err) } if res.Type != api.MetaType { t.Fatal("unexpected root pin type") } pinDelay() for _, c := range pinnedCids { st := cl.StatusLocal(ctx, c) if st.Status != api.TrackerStatusUnpinned { t.Errorf("%s should have been unpinned but is %s", c, st.Status) } st2, err := cl.ipfs.PinLsCid(context.Background(), api.PinCid(c)) if err != nil { t.Fatal(err) } if st2 != api.IPFSPinStatusUnpinned { t.Errorf("%s should have been unpinned in ipfs but is %d", c, st2) } } }) } // func singleShardedPin(t *testing.T, cl *Cluster) { // cShard, _ := cid.Decode(test.ShardCid) // cCdag, _ := cid.Decode(test.CdagCid) // cMeta, _ := cid.Decode(test.MetaRootCid) // pinMeta(t, cl, []api.NewCid(cShard), cCdag, cMeta) // } // func pinMeta(t *testing.T, cl *Cluster, shardCids []api.Cid, cCdag, cMeta api.Cid) { // for _, cShard := range shardCids { // shardPin := api.Pin{ // Cid: cShard, // Type: api.ShardType, // MaxDepth: 1, // PinOptions: api.PinOptions{ // ReplicationFactorMin: -1, // ReplicationFactorMax: -1, // }, // } // err := cl.Pin(shardPin) // if err != nil { // t.Fatal("shard pin should have worked:", err) // } // } // parents := cid.NewSet() // parents.Add(cMeta) // cdagPin := api.Pin{ // Cid: cCdag, // Type: api.ClusterDAGType, // MaxDepth: 0, // PinOptions: api.PinOptions{ // ReplicationFactorMin: -1, // ReplicationFactorMax: -1, // }, // } // err := cl.Pin(cdagPin) // if err != nil { // t.Fatal("pin should have worked:", err) // } // metaPin := api.Pin{ // Cid: cMeta, // Type: api.MetaType, // Clusterdag: cCdag, // } // err = cl.Pin(metaPin) // if err != nil { // t.Fatal("pin should have worked:", err) // } // } // func TestClusterPinMeta(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // singleShardedPin(t, cl) // } // func TestClusterUnpinShardFail(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // singleShardedPin(t, cl) // // verify pins // if len(cl.Pins()) != 3 { // t.Fatal("should have 3 pins") // } // // Unpinning metadata should fail // cShard, _ := cid.Decode(test.ShardCid) // cCdag, _ := cid.Decode(test.CdagCid) // err := cl.Unpin(cShard) // if err == nil { // t.Error("should error when unpinning shard") // } // err = cl.Unpin(cCdag) // if err == nil { // t.Error("should error when unpinning cluster dag") // } // } // func TestClusterUnpinMeta(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // singleShardedPin(t, cl) // // verify pins // if len(cl.Pins()) != 3 { // t.Fatal("should have 3 pins") // } // // Unpinning from root should work // cMeta, _ := cid.Decode(test.MetaRootCid) // err := cl.Unpin(cMeta) // if err != nil { // t.Error(err) // } // } // func pinTwoParentsOneShard(t *testing.T, cl *Cluster) { // singleShardedPin(t, cl) // cShard, _ := cid.Decode(test.ShardCid) // cShard2, _ := cid.Decode(test.ShardCid2) // cCdag2, _ := cid.Decode(test.CdagCid2) // cMeta2, _ := cid.Decode(test.MetaRootCid2) // pinMeta(t, cl, []api.Cid{cShard, cShard2}, cCdag2, cMeta2) // shardPin, err := cl.PinGet(cShard) // if err != nil { // t.Fatal("pin should be in state") // } // if shardPin.Parents.Len() != 2 { // t.Fatal("unexpected parent set in shared shard") // } // shardPin2, err := cl.PinGet(cShard2) // if shardPin2.Parents.Len() != 1 { // t.Fatal("unexpected parent set in unshared shard") // } // if err != nil { // t.Fatal("pin should be in state") // } // } // func TestClusterPinShardTwoParents(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // pinTwoParentsOneShard(t, cl) // cShard, _ := cid.Decode(test.ShardCid) // shardPin, err := cl.PinGet(cShard) // if err != nil { // t.Fatal("double pinned shard should be pinned") // } // if shardPin.Parents == nil || shardPin.Parents.Len() != 2 { // t.Fatal("double pinned shard should have two parents") // } // } // func TestClusterUnpinShardSecondParent(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // pinTwoParentsOneShard(t, cl) // if len(cl.Pins()) != 6 { // t.Fatal("should have 6 pins") // } // cMeta2, _ := cid.Decode(test.MetaRootCid2) // err := cl.Unpin(cMeta2) // if err != nil { // t.Error(err) // } // pinDelay() // if len(cl.Pins()) != 3 { // t.Fatal("should have 3 pins") // } // cShard, _ := cid.Decode(test.ShardCid) // cCdag, _ := cid.Decode(test.CdagCid) // shardPin, err := cl.PinGet(cShard) // if err != nil { // t.Fatal("double pinned shard node should still be pinned") // } // if shardPin.Parents == nil || shardPin.Parents.Len() != 1 || // !shardPin.Parents.Has(cCdag) { // t.Fatalf("shard node should have single original parent %v", shardPin.Parents.Keys()) // } // } // func TestClusterUnpinShardFirstParent(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // pinTwoParentsOneShard(t, cl) // if len(cl.Pins()) != 6 { // t.Fatal("should have 6 pins") // } // cMeta, _ := cid.Decode(test.MetaRootCid) // err := cl.Unpin(cMeta) // if err != nil { // t.Error(err) // } // if len(cl.Pins()) != 4 { // t.Fatal("should have 4 pins") // } // cShard, _ := cid.Decode(test.ShardCid) // cShard2, _ := cid.Decode(test.ShardCid2) // cCdag2, _ := cid.Decode(test.CdagCid2) // shardPin, err := cl.PinGet(cShard) // if err != nil { // t.Fatal("double pinned shard node should still be pinned") // } // if shardPin.Parents == nil || shardPin.Parents.Len() != 1 || // !shardPin.Parents.Has(cCdag2) { // t.Fatal("shard node should have single original parent") // } // _, err = cl.PinGet(cShard2) // if err != nil { // t.Fatal("other shard shoud still be pinned too") // } // } // func TestClusterPinTwoMethodsFail(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // // First pin normally then sharding pin fails // c, _ := cid.Decode(test.MetaRootCid) // err := cl.Pin(api.PinCid(c)) // if err != nil { // t.Fatal("pin should have worked:", err) // } // cCdag, _ := cid.Decode(test.CdagCid) // cMeta, _ := cid.Decode(test.MetaRootCid) // metaPin := api.Pin{ // Cid: cMeta, // Type: api.MetaType, // Clusterdag: cCdag, // } // err = cl.Pin(metaPin) // if err == nil { // t.Fatal("pin should have failed:", err) // } // err = cl.Unpin(c) // if err != nil { // t.Fatal("unpin should have worked:", err) // } // singleShardedPin(t, cl) // err = cl.Pin(api.PinCid(c)) // if err == nil { // t.Fatal("pin should have failed:", err) // } // } // func TestClusterRePinShard(t *testing.T) { // cl, _, _, _ := testingCluster(t) // defer cleanState() // defer cl.Shutdown() // cCdag, _ := cid.Decode(test.CdagCid) // cShard, _ := cid.Decode(test.ShardCid) // shardPin := api.Pin{ // Cid: cShard, // Type: api.ShardType, // ReplicationFactorMin: -1, // ReplicationFactorMax: -1, // Recursive: true, // } // err := cl.Pin(shardPin) // if err != nil { // t.Fatal("shard pin should have worked:", err) // } // parents := cid.NewSet() // parents.Add(cCdag) // shardPin.Parents = parents // err = cl.Pin(shardPin) // if err != nil { // t.Fatal("repinning shard pin with different parents should have worked:", err) // } // shardPin.ReplicationFactorMin = 3 // shardPin.ReplicationFactorMax = 5 // err = cl.Pin(shardPin) // if err == nil { // t.Fatal("repinning shard pin with different repl factors should have failed:", err) // } // } func TestClusterPins(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 _, err := cl.Pin(ctx, c, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } pinDelay() pins, err := cl.pinsSlice(ctx) if err != nil { t.Fatal(err) } if len(pins) != 1 { t.Fatal("pin should be part of the state") } if !pins[0].Cid.Equals(c) || pins[0].ReplicationFactorMin != -1 || pins[0].ReplicationFactorMax != -1 { t.Error("the Pin does not look as expected") } } func TestClusterPinGet(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 _, err := cl.Pin(ctx, c, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } pin, err := cl.PinGet(ctx, c) if err != nil { t.Fatal(err) } if !pin.Cid.Equals(c) || pin.ReplicationFactorMin != -1 || pin.ReplicationFactorMax != -1 { t.Error("the Pin does not look as expected") } _, err = cl.PinGet(ctx, test.Cid2) if err == nil { t.Fatal("expected an error") } } func TestClusterUnpin(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) c := test.Cid1 // Unpin should error without pin being committed to state _, err := cl.Unpin(ctx, c) if err == nil { t.Error("unpin should have failed") } // Unpin after pin should succeed _, err = cl.Pin(ctx, c, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } res, err := cl.Unpin(ctx, c) if err != nil { t.Error("unpin should have worked:", err) } if res.Type != api.DataType { t.Error("unexpected pin type returned") } // test another error case cl.consensus.Shutdown(ctx) _, err = cl.Unpin(ctx, c) if err == nil { t.Error("expected an error but things worked") } } func TestClusterUnpinPath(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) // Unpin should error without pin being committed to state _, err := cl.UnpinPath(ctx, test.PathIPFS2) if err == nil { t.Error("unpin with path should have failed") } // Unpin after pin should succeed pin, err := cl.PinPath(ctx, test.PathIPFS2, api.PinOptions{}) if err != nil { t.Fatal("pin with path should have worked:", err) } if !pin.Cid.Equals(test.CidResolved) { t.Error("expected a different cid, found", pin.Cid.String()) } pin, err = cl.UnpinPath(ctx, test.PathIPFS2) if err != nil { t.Error("unpin with path should have worked:", err) } if !pin.Cid.Equals(test.CidResolved) { t.Error("expected a different cid, found", pin.Cid.String()) } } func TestClusterPeers(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) out := make(chan api.ID, 10) cl.Peers(ctx, out) if len(out) != 1 { t.Fatal("expected 1 peer") } ident := &config.Identity{} err := ident.LoadJSON(testingIdentity) if err != nil { t.Fatal(err) } p := <-out if p.ID != ident.ID { t.Error("bad member") } } func TestVersion(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) if cl.Version() != version.Version.String() { t.Error("bad Version()") } } func TestClusterRecoverAllLocal(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) _, err := cl.Pin(ctx, test.ErrorCid, api.PinOptions{}) if err != nil { t.Fatal("pin should have worked:", err) } pinDelay() out := make(chan api.PinInfo, 10) go func() { err := cl.RecoverAllLocal(ctx, out) if err != nil { t.Error("did not expect an error") } }() recov := collectPinInfos(t, out) if len(recov) != 1 { t.Fatalf("there should be one pin recovered, got = %d", len(recov)) } // Recovery will fail, but the pin appearing in the response is good enough to know it was requeued. } func TestClusterRepoGC(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) gRepoGC, err := cl.RepoGC(ctx) if err != nil { t.Fatal("gc should have worked:", err) } if gRepoGC.PeerMap == nil { t.Fatal("expected a non-nil peer map") } if len(gRepoGC.PeerMap) != 1 { t.Error("expected repo gc information for one peer") } for _, repoGC := range gRepoGC.PeerMap { testRepoGC(t, repoGC) } } func TestClusterRepoGCLocal(t *testing.T) { ctx := context.Background() cl, _, _, _ := testingCluster(t) defer cleanState() defer cl.Shutdown(ctx) repoGC, err := cl.RepoGCLocal(ctx) if err != nil { t.Fatal("gc should have worked:", err) } testRepoGC(t, repoGC) } func testRepoGC(t *testing.T, repoGC api.RepoGC) { if repoGC.Peer == "" { t.Error("expected a cluster ID") } if repoGC.Error != "" { t.Error("did not expect any error") } if repoGC.Keys == nil { t.Fatal("expected a non-nil array of IPFSRepoGC") } if len(repoGC.Keys) == 0 { t.Fatal("expected at least one key, but found none") } if !repoGC.Keys[0].Key.Equals(test.Cid1) { t.Errorf("expected a different cid, expected: %s, found: %s", test.Cid1, repoGC.Keys[0].Key) } }