try to fix ban peer bug (#273)

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

diff --git a/p2p/switch_test.go b/p2p/switch_test.go
index d3566bc..7b162c2 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 (
@@ -126,7 +126,7 @@ func initSwitchFunc(sw *Switch) *Switch {
 
 //Test connect self.
 func TestFiltersOutItself(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -135,15 +135,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()
@@ -160,7 +171,7 @@ func TestFiltersOutItself(t *testing.T) {
 }
 
 func TestDialBannedPeer(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -169,30 +180,44 @@ 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)
        }
 }
 
 func TestDuplicateOutBoundPeer(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -201,15 +226,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()
 
@@ -223,7 +264,7 @@ func TestDuplicateOutBoundPeer(t *testing.T) {
 }
 
 func TestDuplicateInBoundPeer(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -232,15 +273,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)
@@ -258,7 +307,7 @@ func TestDuplicateInBoundPeer(t *testing.T) {
 }
 
 func TestAddInboundPeer(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -267,17 +316,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 {
@@ -286,8 +341,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()
@@ -297,8 +354,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)
@@ -310,7 +370,7 @@ func TestAddInboundPeer(t *testing.T) {
 }
 
 func TestStopPeer(t *testing.T) {
-       t.Skip("skipping test")
+       t.Skip("due to fail on mac")
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
                t.Fatal(err)
@@ -319,18 +379,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)
@@ -338,8 +403,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()