tests compile
Juan Batiz-Benet committed
Sep 17, 2014 at 10:30 UTC
29322a24da1a37e9daaac7a2f1f3ff4b68bb9c57
2 files changed
+145
-141
routing/dht/dht_test.go
+35
-46
@@ -3,11 +3,16 @@ package dht
3
import (
4
"testing"
5
6
+ context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
7
+
8
ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
9
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
10
+
11
ci "github.com/jbenet/go-ipfs/crypto"
12
spipe "github.com/jbenet/go-ipfs/crypto/spipe"
10
- swarm "github.com/jbenet/go-ipfs/net/swarm"
13
+ inet "github.com/jbenet/go-ipfs/net"
14
+ mux "github.com/jbenet/go-ipfs/net/mux"
15
+ netservice "github.com/jbenet/go-ipfs/net/service"
16
peer "github.com/jbenet/go-ipfs/peer"
17
u "github.com/jbenet/go-ipfs/util"
18
@@ -16,6 +21,30 @@ import (
21
"time"
22
)
23
24
+func setupDHT(t *testing.T, p *peer.Peer) *IpfsDHT {
25
+ ctx := context.TODO()
26
+
27
+ peerstore := peer.NewPeerstore()
28
+
29
+ ctx, _ = context.WithCancel(ctx)
30
+ dhts := netservice.NewService(nil) // nil handler for now, need to patch it
31
+ if err := dhts.Start(ctx); err != nil {
32
+ t.Fatal(err)
33
+ }
34
+
35
+ net, err := inet.NewIpfsNetwork(context.TODO(), p, &mux.ProtocolMap{
36
+ mux.ProtocolID_Routing: dhts,
37
+ })
38
+ if err != nil {
39
+ t.Fatal(err)
40
+ }
41
+
42
+ d := NewDHT(p, peerstore, net, dhts, ds.NewMapDatastore())
43
+ dhts.Handler = d
44
+ d.Start()
45
+ return d
46
+}
47
+
48
func setupDHTS(n int, t *testing.T) ([]*ma.Multiaddr, []*peer.Peer, []*IpfsDHT) {
49
var addrs []*ma.Multiaddr
50
for i := 0; i < 4; i++ {
@@ -46,14 +75,7 @@ func setupDHTS(n int, t *testing.T) ([]*ma.Multiaddr, []*peer.Peer, []*IpfsDHT)
75
76
var dhts []*IpfsDHT
77
for i := 0; i < 4; i++ {
49
- net := swarm.NewSwarm(peers[i])
50
- err := net.Listen()
51
- if err != nil {
52
- t.Fatal(err)
53
- }
54
- d := NewDHT(peers[i], net, ds.NewMapDatastore())
55
- dhts = append(dhts, d)
56
- d.Start()
78
+ dhts[i] = setupDHT(t, peers[i])
79
}
80
81
return addrs, peers, dhts
@@ -91,19 +113,8 @@ func TestPing(t *testing.T) {
113
peerA := makePeer(addrA)
114
peerB := makePeer(addrB)
115
94
- neta := swarm.NewSwarm(peerA)
95
- err = neta.Listen()
96
- if err != nil {
97
- t.Fatal(err)
98
- }
99
- dhtA := NewDHT(peerA, neta, ds.NewMapDatastore())
100
-
101
- netb := swarm.NewSwarm(peerB)
102
- err = netb.Listen()
103
- if err != nil {
104
- t.Fatal(err)
105
- }
106
- dhtB := NewDHT(peerB, netb, ds.NewMapDatastore())
116
+ dhtA := setupDHT(t, peerA)
117
+ dhtB := setupDHT(t, peerB)
118
119
dhtA.Start()
120
dhtB.Start()
@@ -136,36 +147,14 @@ func TestValueGetSet(t *testing.T) {
147
peerA := makePeer(addrA)
148
peerB := makePeer(addrB)
149
139
- neta := swarm.NewSwarm(peerA)
140
- err = neta.Listen()
141
- if err != nil {
142
- t.Fatal(err)
143
- }
144
- dhtA := NewDHT(peerA, neta, ds.NewMapDatastore())
145
-
146
- netb := swarm.NewSwarm(peerB)
147
- err = netb.Listen()
148
- if err != nil {
149
- t.Fatal(err)
150
- }
151
- dhtB := NewDHT(peerB, netb, ds.NewMapDatastore())
150
+ dhtA := setupDHT(t, peerA)
151
+ dhtB := setupDHT(t, peerB)
152
153
dhtA.Start()
154
dhtB.Start()
155
defer dhtA.Halt()
156
defer dhtB.Halt()
157
158
- errsa := dhtA.network.GetErrChan()
159
- errsb := dhtB.network.GetErrChan()
160
- go func() {
161
- select {
162
- case err := <-errsa:
163
- t.Fatal(err)
164
- case err := <-errsb:
165
- t.Fatal(err)
166
- }
167
- }()
168
-
158
_, err = dhtA.Connect(addrB)
159
if err != nil {
160
t.Fatal(err)
routing/dht/ext_test.go
+110
-95
@@ -5,11 +5,13 @@ import (
5
6
crand "crypto/rand"
7
8
+ context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
9
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto"
10
11
ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
12
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
12
- swarm "github.com/jbenet/go-ipfs/net/swarm"
13
+ msg "github.com/jbenet/go-ipfs/net/message"
14
+ mux "github.com/jbenet/go-ipfs/net/mux"
15
peer "github.com/jbenet/go-ipfs/peer"
16
u "github.com/jbenet/go-ipfs/util"
17
@@ -18,79 +20,84 @@ import (
20
21
// fauxNet is a standin for a swarm.Network in order to more easily recreate
22
// different testing scenarios
21
-type fauxNet struct {
22
- Chan *swarm.Chan
23
+type fauxSender struct {
24
handlers []mesHandleFunc
24
-
25
- swarm.Network
25
}
26
28
-// mesHandleFunc is a function that takes in outgoing messages
29
-// and can respond to them, simulating other peers on the network.
30
-// returning nil will chose not to respond and pass the message onto the
31
-// next registered handler
32
-type mesHandleFunc func(*swarm.Message) *swarm.Message
27
+func (f *fauxSender) SendRequest(ctx context.Context, m msg.NetMessage) (msg.NetMessage, error) {
28
34
-func newFauxNet() *fauxNet {
35
- fn := new(fauxNet)
36
- fn.Chan = swarm.NewChan(8)
29
+ for _, h := range f.handlers {
30
+ reply := h(m)
31
+ if reply != nil {
32
+ return reply, nil
33
+ }
34
+ }
35
38
- return fn
36
+ return nil, nil
37
}
38
41
-// Instead of 'Listening' Start up a goroutine that will check
42
-// all outgoing messages against registered message handlers,
43
-// and reply if needed
44
-func (f *fauxNet) Listen() error {
45
- go func() {
46
- for {
47
- select {
48
- case in := <-f.Chan.Outgoing:
49
- for _, h := range f.handlers {
50
- reply := h(in)
51
- if reply != nil {
52
- f.Chan.Incoming <- reply
53
- break
54
- }
55
- }
56
- }
39
+func (f *fauxSender) SendMessage(ctx context.Context, m msg.NetMessage) error {
40
+ for _, h := range f.handlers {
41
+ reply := h(m)
42
+ if reply != nil {
43
+ return nil
44
}
58
- }()
45
+ }
46
return nil
47
}
48
62
-func (f *fauxNet) AddHandler(fn func(*swarm.Message) *swarm.Message) {
63
- f.handlers = append(f.handlers, fn)
49
+// fauxNet is a standin for a swarm.Network in order to more easily recreate
50
+// different testing scenarios
51
+type fauxNet struct {
52
+ handlers []mesHandleFunc
53
}
54
66
-func (f *fauxNet) Send(mes *swarm.Message) {
67
- f.Chan.Outgoing <- mes
55
+// mesHandleFunc is a function that takes in outgoing messages
56
+// and can respond to them, simulating other peers on the network.
57
+// returning nil will chose not to respond and pass the message onto the
58
+// next registered handler
59
+type mesHandleFunc func(msg.NetMessage) msg.NetMessage
60
+
61
+func (f *fauxNet) AddHandler(fn func(msg.NetMessage) msg.NetMessage) {
62
+ f.handlers = append(f.handlers, fn)
63
}
64
70
-func (f *fauxNet) GetErrChan() chan error {
71
- return f.Chan.Errors
65
+// DialPeer attempts to establish a connection to a given peer
66
+func (f *fauxNet) DialPeer(*peer.Peer) error {
67
+ return nil
68
}
69
74
-func (f *fauxNet) GetChannel(t swarm.PBWrapper_MessageType) *swarm.Chan {
75
- return f.Chan
70
+// ClosePeer connection to peer
71
+func (f *fauxNet) ClosePeer(*peer.Peer) error {
72
+ return nil
73
}
74
78
-func (f *fauxNet) Connect(addr *ma.Multiaddr) (*peer.Peer, error) {
79
- return nil, nil
75
+// IsConnected returns whether a connection to given peer exists.
76
+func (f *fauxNet) IsConnected(*peer.Peer) (bool, error) {
77
+ return true, nil
78
}
79
82
-func (f *fauxNet) GetConnection(id peer.ID, addr *ma.Multiaddr) (*peer.Peer, error) {
83
- return &peer.Peer{ID: id, Addresses: []*ma.Multiaddr{addr}}, nil
80
+// GetProtocols returns the protocols registered in the network.
81
+func (f *fauxNet) GetProtocols() *mux.ProtocolMap { return nil }
82
+
83
+// SendMessage sends given Message out
84
+func (f *fauxNet) SendMessage(msg.NetMessage) error {
85
+ return nil
86
}
87
88
+// Close terminates all network operation
89
+func (f *fauxNet) Close() error { return nil }
90
+
91
func TestGetFailures(t *testing.T) {
87
- fn := newFauxNet()
88
- fn.Listen()
92
+ ctx := context.Background()
93
+ fn := &fauxNet{}
94
+ fs := &fauxSender{}
95
96
+ peerstore := peer.NewPeerstore()
97
local := new(peer.Peer)
98
local.ID = peer.ID("test_peer")
99
93
- d := NewDHT(local, fn, ds.NewMapDatastore())
100
+ d := NewDHT(local, peerstore, fn, fs, ds.NewMapDatastore())
101
102
other := &peer.Peer{ID: peer.ID("other_peer")}
103
@@ -109,20 +116,18 @@ func TestGetFailures(t *testing.T) {
116
}
117
118
// Reply with failures to every message
112
- fn.AddHandler(func(mes *swarm.Message) *swarm.Message {
113
- pmes := new(PBDHTMessage)
114
- err := proto.Unmarshal(mes.Data, pmes)
119
+ fn.AddHandler(func(mes msg.NetMessage) msg.NetMessage {
120
+ pmes := new(Message)
121
+ err := proto.Unmarshal(mes.Data(), pmes)
122
if err != nil {
123
t.Fatal(err)
124
}
125
119
- resp := Message{
120
- Type: pmes.GetType(),
121
- ID: pmes.GetId(),
122
- Response: true,
123
- Success: false,
126
+ resp := &Message{
127
+ Type: pmes.Type,
128
}
125
- return swarm.NewMessage(mes.Peer, resp.ToProtobuf())
129
+ m, err := msg.FromObject(mes.Peer(), resp)
130
+ return m
131
})
132
133
// This one should fail with NotFound
@@ -137,27 +142,34 @@ func TestGetFailures(t *testing.T) {
142
143
success := make(chan struct{})
144
fn.handlers = nil
140
- fn.AddHandler(func(mes *swarm.Message) *swarm.Message {
141
- resp := new(PBDHTMessage)
142
- err := proto.Unmarshal(mes.Data, resp)
145
+ fn.AddHandler(func(mes msg.NetMessage) msg.NetMessage {
146
+ resp := new(Message)
147
+ err := proto.Unmarshal(mes.Data(), resp)
148
if err != nil {
149
t.Fatal(err)
150
}
146
- if resp.GetSuccess() {
147
- t.Fatal("Get returned success when it shouldnt have.")
148
- }
151
success <- struct{}{}
152
return nil
153
})
154
155
// Now we test this DHT's handleGetValue failure
156
+ typ := Message_GET_VALUE
157
+ str := "hello"
158
req := Message{
155
- Type: PBDHTMessage_GET_VALUE,
156
- Key: "hello",
157
- ID: swarm.GenerateMessageID(),
159
+ Type: &typ,
160
+ Key: &str,
161
Value: []byte{0},
162
}
160
- fn.Chan.Incoming <- swarm.NewMessage(other, req.ToProtobuf())
163
+
164
+ mes, err := msg.FromObject(other, &req)
165
+ if err != nil {
166
+ t.Error(err)
167
+ }
168
+
169
+ mes, err = fs.SendRequest(ctx, mes)
170
+ if err != nil {
171
+ t.Error(err)
172
+ }
173
174
<-success
175
}
@@ -172,13 +184,14 @@ func _randPeer() *peer.Peer {
184
}
185
186
func TestNotFound(t *testing.T) {
175
- fn := newFauxNet()
176
- fn.Listen()
187
+ fn := &fauxNet{}
188
+ fs := &fauxSender{}
189
190
local := new(peer.Peer)
191
local.ID = peer.ID("test_peer")
192
+ peerstore := peer.NewPeerstore()
193
181
- d := NewDHT(local, fn, ds.NewMapDatastore())
194
+ d := NewDHT(local, peerstore, fn, fs, ds.NewMapDatastore())
195
d.Start()
196
197
var ps []*peer.Peer
@@ -188,26 +201,27 @@ func TestNotFound(t *testing.T) {
201
}
202
203
// Reply with random peers to every message
191
- fn.AddHandler(func(mes *swarm.Message) *swarm.Message {
192
- pmes := new(PBDHTMessage)
193
- err := proto.Unmarshal(mes.Data, pmes)
204
+ fn.AddHandler(func(mes msg.NetMessage) msg.NetMessage {
205
+ pmes := new(Message)
206
+ err := proto.Unmarshal(mes.Data(), pmes)
207
if err != nil {
208
t.Fatal(err)
209
}
210
211
switch pmes.GetType() {
199
- case PBDHTMessage_GET_VALUE:
200
- resp := Message{
201
- Type: pmes.GetType(),
202
- ID: pmes.GetId(),
203
- Response: true,
204
- Success: false,
205
- }
212
+ case Message_GET_VALUE:
213
+ resp := &Message{Type: pmes.Type}
214
215
+ peers := []*peer.Peer{}
216
for i := 0; i < 7; i++ {
208
- resp.Peers = append(resp.Peers, _randPeer())
217
+ peers = append(peers, _randPeer())
218
+ }
219
+ resp.CloserPeers = peersToPBPeers(peers)
220
+ mes, err := msg.FromObject(mes.Peer(), resp)
221
+ if err != nil {
222
+ t.Error(err)
223
}
210
- return swarm.NewMessage(mes.Peer, resp.ToProtobuf())
224
+ return mes
225
default:
226
panic("Shouldnt recieve this.")
227
}
@@ -233,13 +247,13 @@ func TestNotFound(t *testing.T) {
247
// a GET rpc and nobody has the value
248
func TestLessThanKResponses(t *testing.T) {
249
u.Debug = false
236
- fn := newFauxNet()
237
- fn.Listen()
238
-
250
+ fn := &fauxNet{}
251
+ fs := &fauxSender{}
252
+ peerstore := peer.NewPeerstore()
253
local := new(peer.Peer)
254
local.ID = peer.ID("test_peer")
255
242
- d := NewDHT(local, fn, ds.NewMapDatastore())
256
+ d := NewDHT(local, peerstore, fn, fs, ds.NewMapDatastore())
257
d.Start()
258
259
var ps []*peer.Peer
@@ -250,24 +264,25 @@ func TestLessThanKResponses(t *testing.T) {
264
other := _randPeer()
265
266
// Reply with random peers to every message
253
- fn.AddHandler(func(mes *swarm.Message) *swarm.Message {
254
- pmes := new(PBDHTMessage)
255
- err := proto.Unmarshal(mes.Data, pmes)
267
+ fn.AddHandler(func(mes msg.NetMessage) msg.NetMessage {
268
+ pmes := new(Message)
269
+ err := proto.Unmarshal(mes.Data(), pmes)
270
if err != nil {
271
t.Fatal(err)
272
}
273
274
switch pmes.GetType() {
261
- case PBDHTMessage_GET_VALUE:
262
- resp := Message{
263
- Type: pmes.GetType(),
264
- ID: pmes.GetId(),
265
- Response: true,
266
- Success: false,
267
- Peers: []*peer.Peer{other},
275
+ case Message_GET_VALUE:
276
+ resp := &Message{
277
+ Type: pmes.Type,
278
+ CloserPeers: peersToPBPeers([]*peer.Peer{other}),
279
}
280
270
- return swarm.NewMessage(mes.Peer, resp.ToProtobuf())
281
+ mes, err := msg.FromObject(mes.Peer(), resp)
282
+ if err != nil {
283
+ t.Error(err)
284
+ }
285
+ return mes
286
default:
287
panic("Shouldnt recieve this.")
288
}