2017-02-09 15:29:17 +00:00
|
|
|
package test
|
2016-12-23 18:35:37 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
"github.com/ipfs/ipfs-cluster/api"
|
|
|
|
|
2017-01-25 11:14:39 +00:00
|
|
|
rpc "github.com/hsanjuan/go-libp2p-gorpc"
|
2016-12-23 18:35:37 +00:00
|
|
|
cid "github.com/ipfs/go-cid"
|
2017-10-23 11:46:37 +00:00
|
|
|
host "github.com/libp2p/go-libp2p-host"
|
2016-12-23 18:35:37 +00:00
|
|
|
peer "github.com/libp2p/go-libp2p-peer"
|
|
|
|
)
|
|
|
|
|
2017-02-15 14:16:34 +00:00
|
|
|
// ErrBadCid is returned when using ErrorCid. Operations with that CID always
|
|
|
|
// fail.
|
2017-02-09 15:29:17 +00:00
|
|
|
var ErrBadCid = errors.New("this is an expected error when using ErrorCid")
|
2016-12-23 18:35:37 +00:00
|
|
|
|
|
|
|
type mockService struct{}
|
|
|
|
|
2017-02-09 15:29:17 +00:00
|
|
|
// NewMockRPCClient creates a mock ipfs-cluster RPC server and returns
|
|
|
|
// a client to it.
|
|
|
|
func NewMockRPCClient(t *testing.T) *rpc.Client {
|
2017-10-23 11:46:37 +00:00
|
|
|
return NewMockRPCClientWithHost(t, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewMockRPCClientWithHost returns a mock ipfs-cluster RPC server
|
|
|
|
// initialized with a given host.
|
|
|
|
func NewMockRPCClientWithHost(t *testing.T, h host.Host) *rpc.Client {
|
|
|
|
s := rpc.NewServer(h, "mock")
|
|
|
|
c := rpc.NewClientWithServer(h, "mock", s)
|
2016-12-23 18:35:37 +00:00
|
|
|
err := s.RegisterName("Cluster", &mockService{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
return c
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func (mock *mockService) Pin(in api.PinSerial, out *struct{}) error {
|
2017-02-09 15:29:17 +00:00
|
|
|
if in.Cid == ErrorCid {
|
|
|
|
return ErrBadCid
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func (mock *mockService) Unpin(in api.PinSerial, out *struct{}) error {
|
2017-02-09 15:29:17 +00:00
|
|
|
if in.Cid == ErrorCid {
|
|
|
|
return ErrBadCid
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-04-06 02:27:02 +00:00
|
|
|
func (mock *mockService) Pins(in struct{}, out *[]api.PinSerial) error {
|
2017-03-08 15:57:27 +00:00
|
|
|
*out = []api.PinSerial{
|
2017-02-13 15:46:53 +00:00
|
|
|
{
|
|
|
|
Cid: TestCid1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Cid: TestCid2,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Cid: TestCid3,
|
|
|
|
},
|
|
|
|
}
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-04-06 02:27:02 +00:00
|
|
|
func (mock *mockService) PinGet(in api.PinSerial, out *api.PinSerial) error {
|
|
|
|
if in.Cid == ErrorCid {
|
|
|
|
return errors.New("expected error when using ErrorCid")
|
|
|
|
}
|
|
|
|
*out = in
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) ID(in struct{}, out *api.IDSerial) error {
|
|
|
|
//_, pubkey, _ := crypto.GenerateKeyPair(
|
|
|
|
// DefaultConfigCrypto,
|
|
|
|
// DefaultConfigKeyLength)
|
2017-03-23 18:34:33 +00:00
|
|
|
*out = api.IDSerial{
|
|
|
|
ID: TestPeerID1.Pretty(),
|
2017-02-08 17:04:08 +00:00
|
|
|
//PublicKey: pubkey,
|
|
|
|
Version: "0.0.mock",
|
2017-03-23 18:34:33 +00:00
|
|
|
IPFS: api.IPFSIDSerial{
|
|
|
|
ID: TestPeerID1.Pretty(),
|
|
|
|
Addresses: api.MultiaddrsSerial{
|
|
|
|
api.MultiaddrSerial("/ip4/127.0.0.1/tcp/4001/ipfs/" + TestPeerID1.Pretty()),
|
|
|
|
},
|
2017-01-26 18:59:31 +00:00
|
|
|
},
|
2017-03-23 18:34:33 +00:00
|
|
|
}
|
2017-01-24 15:19:23 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) Version(in struct{}, out *api.Version) error {
|
2017-02-15 14:16:34 +00:00
|
|
|
*out = api.Version{
|
|
|
|
Version: "0.0.mock",
|
|
|
|
}
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) Peers(in struct{}, out *[]api.IDSerial) error {
|
|
|
|
id := api.IDSerial{}
|
2017-01-26 18:59:31 +00:00
|
|
|
mock.ID(in, &id)
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
*out = []api.IDSerial{id}
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) PeerAdd(in api.MultiaddrSerial, out *api.IDSerial) error {
|
|
|
|
id := api.IDSerial{}
|
2017-01-30 12:12:25 +00:00
|
|
|
mock.ID(struct{}{}, &id)
|
|
|
|
*out = id
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) PeerRemove(in peer.ID, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) StatusAll(in struct{}, out *[]api.GlobalPinInfoSerial) error {
|
2017-02-09 15:29:17 +00:00
|
|
|
c1, _ := cid.Decode(TestCid1)
|
|
|
|
c2, _ := cid.Decode(TestCid2)
|
|
|
|
c3, _ := cid.Decode(TestCid3)
|
2017-02-08 17:04:08 +00:00
|
|
|
*out = globalPinInfoSliceToSerial([]api.GlobalPinInfo{
|
2017-01-24 11:39:08 +00:00
|
|
|
{
|
2016-12-23 18:35:37 +00:00
|
|
|
Cid: c1,
|
2017-02-08 17:04:08 +00:00
|
|
|
PeerMap: map[peer.ID]api.PinInfo{
|
2017-02-09 15:29:17 +00:00
|
|
|
TestPeerID1: {
|
2017-02-08 17:04:08 +00:00
|
|
|
Cid: c1,
|
2017-02-09 15:29:17 +00:00
|
|
|
Peer: TestPeerID1,
|
2017-02-08 17:04:08 +00:00
|
|
|
Status: api.TrackerStatusPinned,
|
2016-12-23 18:35:37 +00:00
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2017-01-24 11:39:08 +00:00
|
|
|
{
|
2016-12-23 18:35:37 +00:00
|
|
|
Cid: c2,
|
2017-02-08 17:04:08 +00:00
|
|
|
PeerMap: map[peer.ID]api.PinInfo{
|
2017-02-09 15:29:17 +00:00
|
|
|
TestPeerID1: {
|
2017-02-08 17:04:08 +00:00
|
|
|
Cid: c2,
|
2017-02-09 15:29:17 +00:00
|
|
|
Peer: TestPeerID1,
|
2017-02-08 17:04:08 +00:00
|
|
|
Status: api.TrackerStatusPinning,
|
2016-12-23 18:35:37 +00:00
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2017-01-24 11:39:08 +00:00
|
|
|
{
|
2016-12-23 18:35:37 +00:00
|
|
|
Cid: c3,
|
2017-02-08 17:04:08 +00:00
|
|
|
PeerMap: map[peer.ID]api.PinInfo{
|
2017-02-09 15:29:17 +00:00
|
|
|
TestPeerID1: {
|
2017-02-08 17:04:08 +00:00
|
|
|
Cid: c3,
|
2017-02-09 15:29:17 +00:00
|
|
|
Peer: TestPeerID1,
|
2017-02-08 17:04:08 +00:00
|
|
|
Status: api.TrackerStatusPinError,
|
2016-12-23 18:35:37 +00:00
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2017-02-08 17:04:08 +00:00
|
|
|
})
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) StatusAllLocal(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
return mock.TrackerStatusAll(in, out)
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func (mock *mockService) Status(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
2017-02-09 15:29:17 +00:00
|
|
|
if in.Cid == ErrorCid {
|
|
|
|
return ErrBadCid
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
2017-02-09 15:29:17 +00:00
|
|
|
c1, _ := cid.Decode(TestCid1)
|
2017-02-08 17:04:08 +00:00
|
|
|
*out = api.GlobalPinInfo{
|
2016-12-23 18:35:37 +00:00
|
|
|
Cid: c1,
|
2017-02-08 17:04:08 +00:00
|
|
|
PeerMap: map[peer.ID]api.PinInfo{
|
2017-02-09 15:29:17 +00:00
|
|
|
TestPeerID1: {
|
2017-02-08 17:04:08 +00:00
|
|
|
Cid: c1,
|
2017-02-09 15:29:17 +00:00
|
|
|
Peer: TestPeerID1,
|
2017-02-08 17:04:08 +00:00
|
|
|
Status: api.TrackerStatusPinned,
|
2016-12-23 18:35:37 +00:00
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
},
|
2017-02-08 17:04:08 +00:00
|
|
|
}.ToSerial()
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) StatusLocal(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
return mock.TrackerStatus(in, out)
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) SyncAll(in struct{}, out *[]api.GlobalPinInfoSerial) error {
|
2017-01-25 18:38:23 +00:00
|
|
|
return mock.StatusAll(in, out)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) SyncAllLocal(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
return mock.StatusAllLocal(in, out)
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func (mock *mockService) Sync(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
2017-01-25 18:38:23 +00:00
|
|
|
return mock.Status(in, out)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
2017-01-23 11:08:04 +00:00
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) SyncLocal(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
return mock.StatusLocal(in, out)
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:04:08 +00:00
|
|
|
func (mock *mockService) StateSync(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
*out = make([]api.PinInfoSerial, 0, 0)
|
2017-01-23 11:08:04 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) RecoverAllLocal(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
return mock.TrackerRecoverAll(in, out)
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func (mock *mockService) Recover(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
2017-01-25 18:38:23 +00:00
|
|
|
return mock.Status(in, out)
|
|
|
|
}
|
|
|
|
|
2017-11-30 00:53:31 +00:00
|
|
|
func (mock *mockService) RecoverLocal(in api.PinSerial, out *api.PinInfoSerial) error {
|
2017-12-01 11:56:26 +00:00
|
|
|
return mock.TrackerRecover(in, out)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tracker methods */
|
|
|
|
|
|
|
|
func (mock *mockService) Track(in api.PinSerial, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) Untrack(in api.PinSerial, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) TrackerStatusAll(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
c1, _ := cid.Decode(TestCid1)
|
|
|
|
c3, _ := cid.Decode(TestCid3)
|
|
|
|
|
|
|
|
*out = pinInfoSliceToSerial([]api.PinInfo{
|
|
|
|
{
|
|
|
|
Cid: c1,
|
|
|
|
Peer: TestPeerID1,
|
|
|
|
Status: api.TrackerStatusPinned,
|
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Cid: c3,
|
|
|
|
Peer: TestPeerID1,
|
|
|
|
Status: api.TrackerStatusPinError,
|
|
|
|
TS: time.Now(),
|
|
|
|
},
|
|
|
|
})
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) TrackerStatus(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
if in.Cid == ErrorCid {
|
|
|
|
return ErrBadCid
|
|
|
|
}
|
|
|
|
c1, _ := cid.Decode(TestCid1)
|
|
|
|
|
2017-11-30 00:53:31 +00:00
|
|
|
*out = api.PinInfo{
|
2017-12-01 11:56:26 +00:00
|
|
|
Cid: c1,
|
|
|
|
Peer: TestPeerID2,
|
2017-11-30 00:53:31 +00:00
|
|
|
Status: api.TrackerStatusPinned,
|
|
|
|
TS: time.Now(),
|
|
|
|
}.ToSerial()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) TrackerRecoverAll(in struct{}, out *[]api.PinInfoSerial) error {
|
2017-11-30 00:53:31 +00:00
|
|
|
*out = make([]api.PinInfoSerial, 0, 0)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-01 11:56:26 +00:00
|
|
|
func (mock *mockService) TrackerRecover(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
in2 := in.ToPin()
|
|
|
|
*out = api.PinInfo{
|
|
|
|
Cid: in2.Cid,
|
|
|
|
Peer: TestPeerID1,
|
|
|
|
Status: api.TrackerStatusPinned,
|
|
|
|
TS: time.Now(),
|
|
|
|
}.ToSerial()
|
2017-01-23 11:08:04 +00:00
|
|
|
return nil
|
|
|
|
}
|
2017-02-13 15:46:53 +00:00
|
|
|
|
2017-03-14 15:10:45 +00:00
|
|
|
/* PeerManager methods */
|
|
|
|
|
2017-03-13 18:35:29 +00:00
|
|
|
func (mock *mockService) PeerManagerAddPeer(in api.MultiaddrSerial, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-03-14 15:10:45 +00:00
|
|
|
/* IPFSConnector methods */
|
|
|
|
|
|
|
|
func (mock *mockService) IPFSPin(in api.PinSerial, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) IPFSUnpin(in api.PinSerial, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) IPFSPinLsCid(in api.PinSerial, out *api.IPFSPinStatus) error {
|
|
|
|
if in.Cid == TestCid1 || in.Cid == TestCid3 {
|
|
|
|
*out = api.IPFSPinStatusRecursive
|
|
|
|
} else {
|
|
|
|
*out = api.IPFSPinStatusUnpinned
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) IPFSPinLs(in string, out *map[string]api.IPFSPinStatus) error {
|
|
|
|
m := map[string]api.IPFSPinStatus{
|
|
|
|
TestCid1: api.IPFSPinStatusRecursive,
|
|
|
|
TestCid3: api.IPFSPinStatusRecursive,
|
|
|
|
}
|
|
|
|
*out = m
|
2017-03-13 18:35:29 +00:00
|
|
|
return nil
|
|
|
|
}
|
2017-03-23 18:34:33 +00:00
|
|
|
|
2017-03-27 13:07:12 +00:00
|
|
|
func (mock *mockService) IPFSConnectSwarms(in struct{}, out *struct{}) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockService) IPFSConfigKey(in string, out *interface{}) error {
|
|
|
|
switch in {
|
|
|
|
case "Datastore/StorageMax":
|
|
|
|
*out = "100KB"
|
|
|
|
default:
|
|
|
|
return errors.New("configuration key not found")
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-26 13:47:03 +00:00
|
|
|
func (mock *mockService) IPFSRepoSize(in struct{}, out *uint64) error {
|
2017-03-27 13:07:12 +00:00
|
|
|
// since we have two pins. Assume each is 1KB.
|
|
|
|
*out = 2000
|
2017-03-23 18:34:33 +00:00
|
|
|
return nil
|
|
|
|
}
|
2017-08-04 19:35:30 +00:00
|
|
|
|
2017-10-26 13:47:03 +00:00
|
|
|
func (mock *mockService) IPFSFreeSpace(in struct{}, out *uint64) error {
|
2017-08-04 19:35:30 +00:00
|
|
|
// RepoSize is 2KB, StorageMax is 100KB
|
|
|
|
*out = 98000
|
|
|
|
return nil
|
|
|
|
}
|
2017-10-23 11:46:37 +00:00
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
func (mock *mockService) ConsensusAddPeer(in peer.ID, out *struct{}) error {
|
2017-10-23 11:46:37 +00:00
|
|
|
return errors.New("mock rpc cannot redirect")
|
|
|
|
}
|
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
func (mock *mockService) ConsensusRmPeer(in peer.ID, out *struct{}) error {
|
2017-10-23 11:46:37 +00:00
|
|
|
return errors.New("mock rpc cannot redirect")
|
|
|
|
}
|
2017-11-14 11:26:42 +00:00
|
|
|
|
|
|
|
func (mock *mockService) ConsensusPeers(in struct{}, out *[]peer.ID) error {
|
|
|
|
*out = []peer.ID{TestPeerID1, TestPeerID2, TestPeerID3}
|
|
|
|
return nil
|
|
|
|
}
|
2017-12-01 11:56:26 +00:00
|
|
|
|
|
|
|
// FIXME: dup from util.go
|
|
|
|
func globalPinInfoSliceToSerial(gpi []api.GlobalPinInfo) []api.GlobalPinInfoSerial {
|
|
|
|
gpis := make([]api.GlobalPinInfoSerial, len(gpi), len(gpi))
|
|
|
|
for i, v := range gpi {
|
|
|
|
gpis[i] = v.ToSerial()
|
|
|
|
}
|
|
|
|
return gpis
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: dup from util.go
|
|
|
|
func pinInfoSliceToSerial(pi []api.PinInfo) []api.PinInfoSerial {
|
|
|
|
pis := make([]api.PinInfoSerial, len(pi), len(pi))
|
|
|
|
for i, v := range pi {
|
|
|
|
pis[i] = v.ToSerial()
|
|
|
|
}
|
|
|
|
return pis
|
|
|
|
}
|