2017-02-13 15:46:53 +00:00
|
|
|
package api
|
|
|
|
|
|
|
|
import (
|
2018-03-18 19:29:02 +00:00
|
|
|
"fmt"
|
2018-01-18 02:49:35 +00:00
|
|
|
"reflect"
|
2017-02-13 15:46:53 +00:00
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
cid "github.com/ipfs/go-cid"
|
|
|
|
peer "github.com/libp2p/go-libp2p-peer"
|
|
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
|
|
)
|
|
|
|
|
|
|
|
var testTime = time.Date(2017, 12, 31, 15, 45, 50, 0, time.UTC)
|
|
|
|
var testMAddr, _ = ma.NewMultiaddr("/ip4/1.2.3.4")
|
2017-12-07 22:59:24 +00:00
|
|
|
var testMAddr2, _ = ma.NewMultiaddr("/dns4/a.b.c.d")
|
|
|
|
var testMAddr3, _ = ma.NewMultiaddr("/ip4/127.0.0.1/tcp/8081/ws/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd")
|
2017-02-13 15:46:53 +00:00
|
|
|
var testCid1, _ = cid.Decode("QmP63DkAFEnDYNjDYBpyNDfttu1fvUw99x1brscPzpqmmq")
|
2018-03-18 19:29:02 +00:00
|
|
|
var testCid2, _ = cid.Decode("QmYCLpFCj9Av8NFjkQogvtXspnTDFWaizLpVFEijHTH4eV")
|
|
|
|
var testCid3, _ = cid.Decode("QmZmdA3UZKuHuy9FrWsxJ82q21nbEh97NUnxTzF5EHxZia")
|
|
|
|
var testCid4, _ = cid.Decode("QmZbNfi13Sb2WUDMjiW1ZNhnds5KDk6mJB5hP9B5h9m5CJ")
|
2017-02-13 15:46:53 +00:00
|
|
|
var testPeerID1, _ = peer.IDB58Decode("QmXZrtE5jQwXNqCJMfHUTQkvhQ4ZAnqMnmzFMJfLewuabc")
|
|
|
|
var testPeerID2, _ = peer.IDB58Decode("QmXZrtE5jQwXNqCJMfHUTQkvhQ4ZAnqMnmzFMJfLewuabd")
|
2018-01-18 02:49:35 +00:00
|
|
|
var testPeerID3, _ = peer.IDB58Decode("QmPGDFvBkgWhvzEK9qaTWrWurSwqXNmhnK3hgELPdZZNPa")
|
|
|
|
var testPeerID4, _ = peer.IDB58Decode("QmZ8naDy5mEz4GLuQwjWt9MPYqHTBbsm8tQBrNSjiq6zBc")
|
|
|
|
var testPeerID5, _ = peer.IDB58Decode("QmZVAo3wd8s5eTTy2kPYs34J9PvfxpKPuYsePPYGjgRRjg")
|
|
|
|
var testPeerID6, _ = peer.IDB58Decode("QmR8Vu6kZk7JvAN2rWVWgiduHatgBq2bb15Yyq8RRhYSbx")
|
2017-02-13 15:46:53 +00:00
|
|
|
|
|
|
|
func TestTrackerFromString(t *testing.T) {
|
2019-01-08 15:18:33 +00:00
|
|
|
testcases := []string{"cluster_error", "pin_error", "unpin_error", "pinned", "pinning", "unpinning", "unpinned", "remote"}
|
2017-02-13 15:46:53 +00:00
|
|
|
for i, tc := range testcases {
|
2019-01-08 15:18:33 +00:00
|
|
|
if TrackerStatusFromString(tc).String() != TrackerStatus(1<<uint(i+1)).String() {
|
2017-02-15 14:16:34 +00:00
|
|
|
t.Errorf("%s does not match TrackerStatus %d", tc, i)
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
}
|
2019-01-08 15:18:33 +00:00
|
|
|
|
|
|
|
if TrackerStatusFromString("") != TrackerStatusUndefined ||
|
|
|
|
TrackerStatusFromString("xyz") != TrackerStatusUndefined {
|
|
|
|
t.Error("expected tracker status undefined for bad strings")
|
|
|
|
}
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestIPFSPinStatusFromString(t *testing.T) {
|
|
|
|
testcases := []string{"direct", "recursive", "indirect"}
|
|
|
|
for i, tc := range testcases {
|
|
|
|
if IPFSPinStatusFromString(tc) != IPFSPinStatus(i+2) {
|
|
|
|
t.Errorf("%s does not match IPFSPinStatus %d", tc, i+2)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestGlobalPinInfoConv(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
t.Fatal("paniced")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
gpi := GlobalPinInfo{
|
|
|
|
Cid: testCid1,
|
|
|
|
PeerMap: map[peer.ID]PinInfo{
|
|
|
|
testPeerID1: {
|
|
|
|
Cid: testCid1,
|
|
|
|
Peer: testPeerID1,
|
|
|
|
Status: TrackerStatusPinned,
|
|
|
|
TS: testTime,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
newgpi := gpi.ToSerial().ToGlobalPinInfo()
|
|
|
|
if gpi.Cid.String() != newgpi.Cid.String() {
|
|
|
|
t.Error("mismatching CIDs")
|
|
|
|
}
|
|
|
|
if gpi.PeerMap[testPeerID1].Cid.String() != newgpi.PeerMap[testPeerID1].Cid.String() {
|
|
|
|
t.Error("mismatching PinInfo CIDs")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !gpi.PeerMap[testPeerID1].TS.Equal(newgpi.PeerMap[testPeerID1].TS) {
|
|
|
|
t.Error("bad time")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIDConv(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
t.Fatal("paniced")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
id := ID{
|
2017-11-10 17:23:38 +00:00
|
|
|
ID: testPeerID1,
|
|
|
|
Addresses: []ma.Multiaddr{testMAddr},
|
|
|
|
ClusterPeers: []peer.ID{testPeerID2},
|
2017-12-07 22:59:24 +00:00
|
|
|
ClusterPeersAddresses: []ma.Multiaddr{testMAddr2},
|
2017-11-10 17:23:38 +00:00
|
|
|
Version: "testv",
|
|
|
|
Commit: "ab",
|
|
|
|
RPCProtocolVersion: "testp",
|
|
|
|
Error: "teste",
|
2017-02-13 15:46:53 +00:00
|
|
|
IPFS: IPFSID{
|
|
|
|
ID: testPeerID2,
|
2017-12-07 22:59:24 +00:00
|
|
|
Addresses: []ma.Multiaddr{testMAddr3},
|
2017-02-13 15:46:53 +00:00
|
|
|
Error: "abc",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
newid := id.ToSerial().ToID()
|
|
|
|
|
|
|
|
if id.ID != newid.ID {
|
|
|
|
t.Error("mismatching Peer IDs")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !id.Addresses[0].Equal(newid.Addresses[0]) {
|
|
|
|
t.Error("mismatching addresses")
|
|
|
|
}
|
|
|
|
|
2017-11-10 17:23:38 +00:00
|
|
|
if id.ClusterPeers[0] != newid.ClusterPeers[0] {
|
2017-02-13 15:46:53 +00:00
|
|
|
t.Error("mismatching clusterPeers")
|
|
|
|
}
|
|
|
|
|
2017-11-10 17:23:38 +00:00
|
|
|
if !id.ClusterPeersAddresses[0].Equal(newid.ClusterPeersAddresses[0]) {
|
|
|
|
t.Error("mismatching clusterPeersAddresses")
|
|
|
|
}
|
|
|
|
|
2017-02-13 15:46:53 +00:00
|
|
|
if id.Version != newid.Version ||
|
|
|
|
id.Commit != newid.Commit ||
|
|
|
|
id.RPCProtocolVersion != newid.RPCProtocolVersion ||
|
|
|
|
id.Error != newid.Error {
|
|
|
|
t.Error("some field didn't survive")
|
|
|
|
}
|
|
|
|
|
|
|
|
if id.IPFS.ID != newid.IPFS.ID {
|
|
|
|
t.Error("ipfs daemon id mismatch")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !id.IPFS.Addresses[0].Equal(newid.IPFS.Addresses[0]) {
|
|
|
|
t.Error("mismatching addresses")
|
|
|
|
}
|
|
|
|
if id.IPFS.Error != newid.IPFS.Error {
|
|
|
|
t.Error("ipfs error mismatch")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-18 02:49:35 +00:00
|
|
|
func TestConnectGraphConv(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
t.Fatal("paniced")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
cg := ConnectGraph{
|
|
|
|
ClusterID: testPeerID1,
|
|
|
|
IPFSLinks: map[peer.ID][]peer.ID{
|
|
|
|
testPeerID4: []peer.ID{testPeerID5, testPeerID6},
|
|
|
|
testPeerID5: []peer.ID{testPeerID4, testPeerID6},
|
|
|
|
testPeerID6: []peer.ID{testPeerID4, testPeerID5},
|
|
|
|
},
|
|
|
|
ClusterLinks: map[peer.ID][]peer.ID{
|
|
|
|
testPeerID1: []peer.ID{testPeerID2, testPeerID3},
|
|
|
|
testPeerID2: []peer.ID{testPeerID1, testPeerID3},
|
|
|
|
testPeerID3: []peer.ID{testPeerID1, testPeerID2},
|
|
|
|
},
|
|
|
|
ClustertoIPFS: map[peer.ID]peer.ID{
|
|
|
|
testPeerID1: testPeerID4,
|
|
|
|
testPeerID2: testPeerID5,
|
|
|
|
testPeerID3: testPeerID6,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
cgNew := cg.ToSerial().ToConnectGraph()
|
|
|
|
if !reflect.DeepEqual(cg, cgNew) {
|
|
|
|
t.Fatal("The new connect graph should be equivalent to the old")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-13 15:46:53 +00:00
|
|
|
func TestMultiaddrConv(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
t.Fatal("paniced")
|
|
|
|
}
|
|
|
|
}()
|
2017-12-07 22:59:24 +00:00
|
|
|
addrs := []ma.Multiaddr{testMAddr2}
|
2017-02-13 15:46:53 +00:00
|
|
|
new := MultiaddrsToSerial(addrs).ToMultiaddrs()
|
|
|
|
if !addrs[0].Equal(new[0]) {
|
|
|
|
t.Error("mismatch")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
func TestPinConv(t *testing.T) {
|
2017-02-13 15:46:53 +00:00
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
t.Fatal("paniced")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
c := Pin{
|
2018-07-20 12:03:19 +00:00
|
|
|
Cid: testCid1,
|
|
|
|
Type: ClusterDAGType,
|
|
|
|
Allocations: []peer.ID{testPeerID1},
|
2018-07-23 13:56:46 +00:00
|
|
|
Reference: testCid2,
|
2018-07-20 12:03:19 +00:00
|
|
|
MaxDepth: -1,
|
|
|
|
PinOptions: PinOptions{
|
|
|
|
ReplicationFactorMax: -1,
|
|
|
|
ReplicationFactorMin: -1,
|
|
|
|
Name: "A test pin",
|
|
|
|
},
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
|
2017-03-08 15:57:27 +00:00
|
|
|
newc := c.ToSerial().ToPin()
|
2018-07-20 12:03:19 +00:00
|
|
|
if !c.Cid.Equals(newc.Cid) ||
|
2017-02-13 15:46:53 +00:00
|
|
|
c.Allocations[0] != newc.Allocations[0] ||
|
2018-01-12 17:04:46 +00:00
|
|
|
c.ReplicationFactorMin != newc.ReplicationFactorMin ||
|
2018-03-18 19:29:02 +00:00
|
|
|
c.ReplicationFactorMax != newc.ReplicationFactorMax ||
|
2018-07-20 12:03:19 +00:00
|
|
|
c.MaxDepth != newc.MaxDepth ||
|
2018-07-23 13:56:46 +00:00
|
|
|
!c.Reference.Equals(newc.Reference) ||
|
|
|
|
c.Name != newc.Name || c.Type != newc.Type {
|
2018-03-18 19:29:02 +00:00
|
|
|
|
2018-07-20 12:03:19 +00:00
|
|
|
fmt.Printf("c: %+v\ncnew: %+v\n", c, newc)
|
2018-03-18 19:29:02 +00:00
|
|
|
t.Fatal("mismatch")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !c.Equals(newc) {
|
|
|
|
t.Error("all pin fields are equal but Equals returns false")
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMetric(t *testing.T) {
|
|
|
|
m := Metric{
|
|
|
|
Name: "hello",
|
|
|
|
Value: "abc",
|
|
|
|
}
|
|
|
|
|
|
|
|
if !m.Expired() {
|
2017-03-14 15:10:45 +00:00
|
|
|
t.Error("metric should be expired")
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 06:50:03 +00:00
|
|
|
m.SetTTL(1 * time.Second)
|
2017-02-13 15:46:53 +00:00
|
|
|
if m.Expired() {
|
|
|
|
t.Error("metric should not be expired")
|
|
|
|
}
|
|
|
|
|
|
|
|
// let it expire
|
|
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
|
|
|
|
if !m.Expired() {
|
|
|
|
t.Error("metric should be expired")
|
|
|
|
}
|
|
|
|
|
2018-05-07 06:50:03 +00:00
|
|
|
m.SetTTL(30 * time.Second)
|
2017-02-13 15:46:53 +00:00
|
|
|
m.Valid = true
|
|
|
|
|
|
|
|
if m.Discard() {
|
|
|
|
t.Error("metric should be valid")
|
|
|
|
}
|
|
|
|
|
|
|
|
m.Valid = false
|
|
|
|
if !m.Discard() {
|
|
|
|
t.Error("metric should be invalid")
|
|
|
|
}
|
|
|
|
|
|
|
|
ttl := m.GetTTL()
|
|
|
|
if ttl > 30*time.Second || ttl < 29*time.Second {
|
|
|
|
t.Error("looks like a bad ttl")
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 02:00:38 +00:00
|
|
|
|
|
|
|
func BenchmarkPinSerial_ToPin(b *testing.B) {
|
|
|
|
pin := Pin{
|
|
|
|
Cid: testCid1,
|
|
|
|
Type: ClusterDAGType,
|
|
|
|
Allocations: []peer.ID{testPeerID1},
|
|
|
|
Reference: testCid2,
|
|
|
|
MaxDepth: -1,
|
|
|
|
PinOptions: PinOptions{
|
|
|
|
ReplicationFactorMax: -1,
|
|
|
|
ReplicationFactorMin: -1,
|
|
|
|
Name: "A test pin",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
pinS := pin.ToSerial()
|
|
|
|
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
pinS.ToPin()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkPinSerial_DecodeCid(b *testing.B) {
|
|
|
|
pin := Pin{
|
|
|
|
Cid: testCid1,
|
|
|
|
Type: ClusterDAGType,
|
|
|
|
Allocations: []peer.ID{testPeerID1},
|
|
|
|
Reference: testCid2,
|
|
|
|
MaxDepth: -1,
|
|
|
|
PinOptions: PinOptions{
|
|
|
|
ReplicationFactorMax: -1,
|
|
|
|
ReplicationFactorMin: -1,
|
|
|
|
Name: "A test pin",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
pinS := pin.ToSerial()
|
|
|
|
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
pinS.DecodeCid()
|
|
|
|
}
|
|
|
|
}
|