package p2p import ( "fmt" "io" "net" "testing" "time" ) type TestNetwork struct { connections map[string]*TestNetworkConnection dialer Dialer maxinbound int } func NewTestNetwork(maxinbound int) *TestNetwork { connections := make(map[string]*TestNetworkConnection) return &TestNetwork{ connections: connections, dialer: &TestDialer{connections}, maxinbound: maxinbound, } } func (self *TestNetwork) Dialer(addr net.Addr) (Dialer, error) { return self.dialer, nil } func (self *TestNetwork) Listener(addr net.Addr) (net.Listener, error) { return &TestListener{ connections: self.connections, addr: addr, max: self.maxinbound, close: make(chan struct{}), }, nil } func (self *TestNetwork) Start() error { return nil } func (self *TestNetwork) NewAddr(string, int) (addr net.Addr, err error) { return } func (self *TestNetwork) ParseAddr(string) (addr net.Addr, err error) { return } type TestAddr struct { name string } func (self *TestAddr) String() string { return self.name } func (*TestAddr) Network() string { return "test" } type TestDialer struct { connections map[string]*TestNetworkConnection } func (self *TestDialer) Dial(network string, addr string) (conn net.Conn, err error) { address := &TestAddr{addr} tconn := NewTestNetworkConnection(address) self.connections[addr] = tconn conn = net.Conn(tconn) return } type TestListener struct { connections map[string]*TestNetworkConnection addr net.Addr max int i int close chan struct{} } func (self *TestListener) Accept() (net.Conn, error) { self.i++ if self.i > self.max { <-self.close return nil, io.EOF } addr := &TestAddr{fmt.Sprintf("inboundpeer-%d", self.i)} tconn := NewTestNetworkConnection(addr) key := tconn.RemoteAddr().String() self.connections[key] = tconn fmt.Printf("accepted connection from: %v \n", addr) return tconn, nil } func (self *TestListener) Close() error { close(self.close) return nil } func (self *TestListener) Addr() net.Addr { return self.addr } type TestNetworkConnection struct { in chan []byte close chan struct{} current []byte Out [][]byte addr net.Addr } func NewTestNetworkConnection(addr net.Addr) *TestNetworkConnection { return &TestNetworkConnection{ in: make(chan []byte), close: make(chan struct{}), current: []byte{}, Out: [][]byte{}, addr: addr, } } func (self *TestNetworkConnection) In(latency time.Duration, packets ...[]byte) { time.Sleep(latency) for _, s := range packets { self.in <- s } } func (self *TestNetworkConnection) Read(buff []byte) (n int, err error) { if len(self.current) == 0 { var ok bool select { case self.current, ok = <-self.in: if !ok { return 0, io.EOF } case <-self.close: return 0, io.EOF } } length := len(self.current) if length > len(buff) { copy(buff[:], self.current[:len(buff)]) self.current = self.current[len(buff):] return len(buff), nil } else { copy(buff[:length], self.current[:]) self.current = []byte{} return length, io.EOF } } func (self *TestNetworkConnection) Write(buff []byte) (n int, err error) { self.Out = append(self.Out, buff) fmt.Printf("net write(%d): %x\n", len(self.Out), buff) return len(buff), nil } func (self *TestNetworkConnection) Close() error { close(self.close) return nil } func (self *TestNetworkConnection) LocalAddr() (addr net.Addr) { return } func (self *TestNetworkConnection) RemoteAddr() (addr net.Addr) { return self.addr } func (self *TestNetworkConnection) SetDeadline(t time.Time) (err error) { return } func (self *TestNetworkConnection) SetReadDeadline(t time.Time) (err error) { return } func (self *TestNetworkConnection) SetWriteDeadline(t time.Time) (err error) { return } func SetupTestServer(handlers Handlers) (network *TestNetwork, server *Server) { network = NewTestNetwork(1) addr := &TestAddr{"test:30303"} identity := NewSimpleClientIdentity("clientIdentifier", "version", "customIdentifier", "pubkey") maxPeers := 2 if handlers == nil { handlers = make(Handlers) } blackist := NewBlacklist() server = New(network, addr, identity, handlers, maxPeers, blackist) fmt.Println(server.identity.Pubkey()) return } func TestServerListener(t *testing.T) { t.SkipNow() network, server := SetupTestServer(nil) server.Start(true, false) time.Sleep(10 * time.Millisecond) server.Stop() peer1, ok := network.connections["inboundpeer-1"] if !ok { t.Error("not found inbound peer 1") } else { if len(peer1.Out) != 2 { t.Errorf("wrong number of writes to peer 1: got %d, want %d", len(peer1.Out), 2) } } } func TestServerDialer(t *testing.T) { network, server := SetupTestServer(nil) server.Start(false, true) server.peerConnect <- &TestAddr{"outboundpeer-1"} time.Sleep(10 * time.Millisecond) server.Stop() peer1, ok := network.connections["outboundpeer-1"] if !ok { t.Error("not found outbound peer 1") } else { if len(peer1.Out) != 2 { t.Errorf("wrong number of writes to peer 1: got %d, want %d", len(peer1.Out), 2) } } } // func TestServerBroadcast(t *testing.T) { // handlers := make(Handlers) // testProtocol := &TestProtocol{Msgs: []*Msg{}} // handlers["aaa"] = func(p *Peer) Protocol { return testProtocol } // network, server := SetupTestServer(handlers) // server.Start(true, true) // server.peerConnect <- &TestAddr{"outboundpeer-1"} // time.Sleep(10 * time.Millisecond) // msg := NewMsg(0) // server.Broadcast("", msg) // packet := Packet(0, 0) // time.Sleep(10 * time.Millisecond) // server.Stop() // peer1, ok := network.connections["outboundpeer-1"] // if !ok { // t.Error("not found outbound peer 1") // } else { // fmt.Printf("out: %v\n", peer1.Out) // if len(peer1.Out) != 3 { // t.Errorf("not enough messages sent to peer 1: %v ", len(peer1.Out)) // } else { // if bytes.Compare(peer1.Out[1], packet) != 0 { // t.Errorf("incorrect broadcast packet %v != %v", peer1.Out[1], packet) // } // } // } // peer2, ok := network.connections["inboundpeer-1"] // if !ok { // t.Error("not found inbound peer 2") // } else { // fmt.Printf("out: %v\n", peer2.Out) // if len(peer1.Out) != 3 { // t.Errorf("not enough messages sent to peer 2: %v ", len(peer2.Out)) // } else { // if bytes.Compare(peer2.Out[1], packet) != 0 { // t.Errorf("incorrect broadcast packet %v != %v", peer2.Out[1], packet) // } // } // } // } func TestServerPeersMessage(t *testing.T) { t.SkipNow() _, server := SetupTestServer(nil) server.Start(true, true) defer server.Stop() server.peerConnect <- &TestAddr{"outboundpeer-1"} time.Sleep(2000 * time.Millisecond) pl := server.encodedPeerList() if pl == nil { t.Errorf("expect non-nil peer list") } if c := server.PeerCount(); c != 2 { t.Errorf("expect 2 peers, got %v", c) } }