feat: init cross_tx keepers (#146)

[bytom/vapor.git] / p2p / switch_test.go

diff --git a/p2p/switch_test.go b/p2p/switch_test.go
index b1025a1..19c475e 100644 (file)
--- a/p2p/switch_test.go
+++ b/p2p/switch_test.go
@@ -8,12 +8,12 @@ import (
        "time"
 
        "github.com/davecgh/go-spew/spew"
-       "github.com/tendermint/go-crypto"
-
        cfg "github.com/vapor/config"
        dbm "github.com/vapor/database/leveldb"
        "github.com/vapor/errors"
        conn "github.com/vapor/p2p/connection"
+       "github.com/vapor/p2p/security"
+       "github.com/vapor/p2p/signlib"
 )
 
 var (
@@ -134,15 +134,26 @@ func TestFiltersOutItself(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
+       rmdirPath, err := ioutil.TempDir(".", "")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer os.RemoveAll(rmdirPath)
+
        // simulate s1 having a public key and creating a remote peer with the same key
        rpCfg := *testCfg
+       rpCfg.DBPath = rmdirPath
        rp := &remotePeer{PrivKey: s1.nodePrivKey, Config: &rpCfg}
        rp.Start()
        defer rp.Stop()
@@ -167,24 +178,38 @@ func TestDialBannedPeer(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
+       rmdirPath, err := ioutil.TempDir(".", "")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer os.RemoveAll(rmdirPath)
+
        rpCfg := *testCfg
-       rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: &rpCfg}
-       rp.Start()
-       defer rp.Stop()
-       s1.AddBannedPeer(rp.addr.IP.String())
-       if err := s1.DialPeerWithAddress(rp.addr); errors.Root(err) != ErrConnectBannedPeer {
+       rpCfg.DBPath = rmdirPath
+       remotePrivKey, err := signlib.NewPrivKey()
+       if err != nil {
                t.Fatal(err)
        }
 
-       s1.delBannedPeer(rp.addr.IP.String())
-       if err := s1.DialPeerWithAddress(rp.addr); err != nil {
+       rp := &remotePeer{PrivKey: remotePrivKey, Config: &rpCfg}
+       rp.Start()
+       defer rp.Stop()
+       for {
+               if ok := s1.security.IsBanned(rp.addr.IP.String(), security.LevelMsgIllegal, "test"); ok {
+                       break
+               }
+       }
+       if err := s1.DialPeerWithAddress(rp.addr); errors.Root(err) != security.ErrConnectBannedPeer {
                t.Fatal(err)
        }
 }
@@ -198,15 +223,31 @@ func TestDuplicateOutBoundPeer(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
+       rmdirPath, err := ioutil.TempDir(".", "")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer os.RemoveAll(rmdirPath)
+
        rpCfg := *testCfg
-       rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: &rpCfg}
+       rpCfg.DBPath = rmdirPath
+       remotePrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       rp := &remotePeer{PrivKey: remotePrivKey, Config: &rpCfg}
        rp.Start()
        defer rp.Stop()
 
@@ -228,15 +269,23 @@ func TestDuplicateInBoundPeer(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
        inpCfg := *testCfg
-       inp := &inboundPeer{PrivKey: crypto.GenPrivKeyEd25519(), config: &inpCfg}
+       inpPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
        addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
        if err != nil {
                t.Fatal(err)
@@ -262,17 +311,23 @@ func TestAddInboundPeer(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.MaxNumPeers = 2
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
        inpCfg := *testCfg
-       inpPrivKey := crypto.GenPrivKeyEd25519()
-       inpCfg.P2P.PrivateKey = inpPrivKey.String()
+       inpPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
        inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
        addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
        if err != nil {
@@ -281,8 +336,10 @@ func TestAddInboundPeer(t *testing.T) {
        go inp.dial(addr)
 
        rpCfg := *testCfg
-       rpPrivKey := crypto.GenPrivKeyEd25519()
-       rpCfg.P2P.PrivateKey = rpPrivKey.String()
+       rpPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        rp := &remotePeer{PrivKey: rpPrivKey, Config: &rpCfg}
        rp.Start()
        defer rp.Stop()
@@ -292,8 +349,11 @@ func TestAddInboundPeer(t *testing.T) {
        }
 
        inp2Cfg := *testCfg
-       inp2PrivKey := crypto.GenPrivKeyEd25519()
-       inp2Cfg.P2P.PrivateKey = inp2PrivKey.String()
+
+       inp2PrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        inp2 := &inboundPeer{PrivKey: inp2PrivKey, config: &inp2Cfg}
 
        go inp2.dial(addr)
@@ -313,18 +373,23 @@ func TestStopPeer(t *testing.T) {
 
        testDB := dbm.NewDB("testdb", "leveldb", dirPath)
        cfg := *testCfg
+       cfg.DBPath = dirPath
        cfg.P2P.MaxNumPeers = 2
        cfg.P2P.ListenAddress = "127.0.1.1:0"
-       swPrivKey := crypto.GenPrivKeyEd25519()
-       cfg.P2P.PrivateKey = swPrivKey.String()
+       swPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
        s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
        s1.Start()
        defer s1.Stop()
 
        inpCfg := *testCfg
-       inpPrivKey := crypto.GenPrivKeyEd25519()
-       inpCfg.P2P.PrivateKey = inpPrivKey.String()
-       inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
+       inp2PrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+       inp := &inboundPeer{PrivKey: inp2PrivKey, config: &inpCfg}
        addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
        if err != nil {
                t.Fatal(err)
@@ -332,8 +397,11 @@ func TestStopPeer(t *testing.T) {
        go inp.dial(addr)
 
        rpCfg := *testCfg
-       rpPrivKey := crypto.GenPrivKeyEd25519()
-       rpCfg.P2P.PrivateKey = rpPrivKey.String()
+       rpPrivKey, err := signlib.NewPrivKey()
+       if err != nil {
+               t.Fatal(err)
+       }
+
        rp := &remotePeer{PrivKey: rpPrivKey, Config: &rpCfg}
        rp.Start()
        defer rp.Stop()