package zcash import ( "net" "os" "sync" "testing" "time" "github.com/btcsuite/btcd/peer" "github.com/btcsuite/btcd/wire" "github.com/btcsuite/btclog" "github.com/gtank/coredns-zcash/zcash/network" ) func TestMain(m *testing.M) { startMockLoop() exitCode := m.Run() os.Exit(exitCode) } func startMockLoop() { // Configure peer to act as a regtest node that offers no services. config, err := newSeederPeerConfig(network.Regtest, defaultPeerConfig) if err != nil { return } config.AllowSelfConns = true backendLogger := btclog.NewBackend(os.Stdout) mockPeerLogger := backendLogger.Logger("mockPeer") //mockPeerLogger.SetLevel(btclog.LevelTrace) peer.UseLogger(mockPeerLogger) config.Listeners.OnGetAddr = func(p *peer.Peer, msg *wire.MsgGetAddr) { cache := make([]*wire.NetAddress, 0, 1) addr := wire.NewNetAddressTimestamp( time.Now(), 0, net.ParseIP("127.0.0.1"), uint16(18233), ) addr2 := wire.NewNetAddressTimestamp( time.Now(), 0, net.ParseIP("127.0.0.1"), uint16(18344), ) cache = append(cache, addr, addr2) _, err := p.PushAddrMsg(cache) if err != nil { mockPeerLogger.Error(err) } } listenAddr := net.JoinHostPort("127.0.0.1", config.ChainParams.DefaultPort) listener, err := net.Listen("tcp", listenAddr) if err != nil { return } go func() { for { conn, err := listener.Accept() if err != nil { return } mockPeer := peer.NewInboundPeer(config) mockPeer.AssociateConnection(conn) } }() } func TestOutboundPeerSync(t *testing.T) { regSeeder, err := newTestSeeder(network.Regtest) if err != nil { t.Error(err) return } err = regSeeder.ConnectOnDefaultPort("127.0.0.1") if err != nil { t.Error(err) return } // Can we address that peer if we want to? p, err := regSeeder.GetPeer("127.0.0.1:18344") if err != nil { t.Error(err) return } if p.Connected() { regSeeder.DisconnectPeer("127.0.0.1:18344") } else { t.Error("Peer never connected") } // Can we STILL address a flushed peer? p, err = regSeeder.GetPeer("127.0.0.1:18344") if err != ErrNoSuchPeer { t.Error("Peer should have been cleared on disconnect") } } func TestOutboundPeerAsync(t *testing.T) { regSeeder, err := newTestSeeder(network.Regtest) if err != nil { t.Fatal(err) } var wg sync.WaitGroup for i := 0; i < 4; i++ { wg.Add(1) go func() { err := regSeeder.ConnectOnDefaultPort("127.0.0.1") if err != nil && err != ErrRepeatConnection { t.Error(err) } wg.Done() }() } wg.Wait() // Can we address that peer if we want to? p, err := regSeeder.GetPeer("127.0.0.1:18344") if err != nil { t.Error(err) return } if p.Connected() { // Shouldn't try to connect to a live peer again err := regSeeder.ConnectOnDefaultPort("127.0.0.1") if err != ErrRepeatConnection { t.Error("should have caught repeat connection attempt") } } else { t.Error("Peer never connected") } regSeeder.DisconnectAllPeers() } func TestRequestAddresses(t *testing.T) { regSeeder, err := newTestSeeder(network.Regtest) if err != nil { t.Error(err) return } err = regSeeder.ConnectOnDefaultPort("127.0.0.1") if err != nil { t.Error(err) return } regSeeder.RequestAddresses() regSeeder.WaitForAddresses(1) // TODO It isn't possible to test this wait on a local mock peer without // carving a path through absolutely all of the bad connection logic. }