github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/les/peer_test.go (about) 1 package les 2 3 import ( 4 "math/big" 5 "testing" 6 7 "github.com/ethereum/go-ethereum/common" 8 "github.com/ethereum/go-ethereum/common/mclock" 9 "github.com/ethereum/go-ethereum/les/flowcontrol" 10 "github.com/ethereum/go-ethereum/p2p" 11 "github.com/ethereum/go-ethereum/rlp" 12 ) 13 14 const ( 15 test_networkid = 10 16 protocol_version = 2123 17 ) 18 19 var ( 20 hash = common.HexToHash("some string") 21 genesis = common.HexToHash("genesis hash") 22 headNum = uint64(1234) 23 td = big.NewInt(123) 24 ) 25 26 //ulc connects to trusted peer and send announceType=announceTypeSigned 27 func TestPeerHandshakeSetAnnounceTypeToAnnounceTypeSignedForTrustedPeer(t *testing.T) { 28 id := newNodeID(t).ID() 29 30 //peer to connect(on ulc side) 31 p := peer{ 32 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 33 version: protocol_version, 34 isTrusted: true, 35 rw: &rwStub{ 36 WriteHook: func(recvList keyValueList) { 37 //checking that ulc sends to peer allowedRequests=onlyAnnounceRequests and announceType = announceTypeSigned 38 recv, _ := recvList.decode() 39 var reqType uint64 40 41 err := recv.get("announceType", &reqType) 42 if err != nil { 43 t.Fatal(err) 44 } 45 46 if reqType != announceTypeSigned { 47 t.Fatal("Expected announceTypeSigned") 48 } 49 }, 50 ReadHook: func(l keyValueList) keyValueList { 51 l = l.add("serveHeaders", nil) 52 l = l.add("serveChainSince", uint64(0)) 53 l = l.add("serveStateSince", uint64(0)) 54 l = l.add("txRelay", nil) 55 l = l.add("flowControl/BL", uint64(0)) 56 l = l.add("flowControl/MRR", uint64(0)) 57 l = l.add("flowControl/MRC", RequestCostList{}) 58 59 return l 60 }, 61 }, 62 network: test_networkid, 63 } 64 65 err := p.Handshake(td, hash, headNum, genesis, nil) 66 if err != nil { 67 t.Fatalf("Handshake error: %s", err) 68 } 69 70 if p.announceType != announceTypeSigned { 71 t.Fatal("Incorrect announceType") 72 } 73 } 74 75 func TestPeerHandshakeAnnounceTypeSignedForTrustedPeersPeerNotInTrusted(t *testing.T) { 76 id := newNodeID(t).ID() 77 p := peer{ 78 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 79 version: protocol_version, 80 rw: &rwStub{ 81 WriteHook: func(recvList keyValueList) { 82 //checking that ulc sends to peer allowedRequests=noRequests and announceType != announceTypeSigned 83 recv, _ := recvList.decode() 84 var reqType uint64 85 86 err := recv.get("announceType", &reqType) 87 if err != nil { 88 t.Fatal(err) 89 } 90 91 if reqType == announceTypeSigned { 92 t.Fatal("Expected not announceTypeSigned") 93 } 94 }, 95 ReadHook: func(l keyValueList) keyValueList { 96 l = l.add("serveHeaders", nil) 97 l = l.add("serveChainSince", uint64(0)) 98 l = l.add("serveStateSince", uint64(0)) 99 l = l.add("txRelay", nil) 100 l = l.add("flowControl/BL", uint64(0)) 101 l = l.add("flowControl/MRR", uint64(0)) 102 l = l.add("flowControl/MRC", RequestCostList{}) 103 104 return l 105 }, 106 }, 107 network: test_networkid, 108 } 109 110 err := p.Handshake(td, hash, headNum, genesis, nil) 111 if err != nil { 112 t.Fatal(err) 113 } 114 if p.announceType == announceTypeSigned { 115 t.Fatal("Incorrect announceType") 116 } 117 } 118 119 func TestPeerHandshakeDefaultAllRequests(t *testing.T) { 120 id := newNodeID(t).ID() 121 122 s := generateLesServer() 123 124 p := peer{ 125 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 126 version: protocol_version, 127 rw: &rwStub{ 128 ReadHook: func(l keyValueList) keyValueList { 129 l = l.add("announceType", uint64(announceTypeSigned)) 130 l = l.add("allowedRequests", uint64(0)) 131 132 return l 133 }, 134 }, 135 network: test_networkid, 136 } 137 138 err := p.Handshake(td, hash, headNum, genesis, s) 139 if err != nil { 140 t.Fatal(err) 141 } 142 143 if p.isOnlyAnnounce { 144 t.Fatal("Incorrect announceType") 145 } 146 } 147 148 func TestPeerHandshakeServerSendOnlyAnnounceRequestsHeaders(t *testing.T) { 149 id := newNodeID(t).ID() 150 151 s := generateLesServer() 152 s.onlyAnnounce = true 153 154 p := peer{ 155 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 156 version: protocol_version, 157 rw: &rwStub{ 158 ReadHook: func(l keyValueList) keyValueList { 159 l = l.add("announceType", uint64(announceTypeSigned)) 160 161 return l 162 }, 163 WriteHook: func(l keyValueList) { 164 for _, v := range l { 165 if v.Key == "serveHeaders" || 166 v.Key == "serveChainSince" || 167 v.Key == "serveStateSince" || 168 v.Key == "txRelay" { 169 t.Fatalf("%v exists", v.Key) 170 } 171 } 172 }, 173 }, 174 network: test_networkid, 175 } 176 177 err := p.Handshake(td, hash, headNum, genesis, s) 178 if err != nil { 179 t.Fatal(err) 180 } 181 } 182 func TestPeerHandshakeClientReceiveOnlyAnnounceRequestsHeaders(t *testing.T) { 183 id := newNodeID(t).ID() 184 185 p := peer{ 186 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 187 version: protocol_version, 188 rw: &rwStub{ 189 ReadHook: func(l keyValueList) keyValueList { 190 l = l.add("flowControl/BL", uint64(0)) 191 l = l.add("flowControl/MRR", uint64(0)) 192 l = l.add("flowControl/MRC", RequestCostList{}) 193 194 l = l.add("announceType", uint64(announceTypeSigned)) 195 196 return l 197 }, 198 }, 199 network: test_networkid, 200 isTrusted: true, 201 } 202 203 err := p.Handshake(td, hash, headNum, genesis, nil) 204 if err != nil { 205 t.Fatal(err) 206 } 207 208 if !p.isOnlyAnnounce { 209 t.Fatal("isOnlyAnnounce must be true") 210 } 211 } 212 213 func TestPeerHandshakeClientReturnErrorOnUselessPeer(t *testing.T) { 214 id := newNodeID(t).ID() 215 216 p := peer{ 217 Peer: p2p.NewPeer(id, "test peer", []p2p.Cap{}), 218 version: protocol_version, 219 rw: &rwStub{ 220 ReadHook: func(l keyValueList) keyValueList { 221 l = l.add("flowControl/BL", uint64(0)) 222 l = l.add("flowControl/MRR", uint64(0)) 223 l = l.add("flowControl/MRC", RequestCostList{}) 224 225 l = l.add("announceType", uint64(announceTypeSigned)) 226 227 return l 228 }, 229 }, 230 network: test_networkid, 231 } 232 233 err := p.Handshake(td, hash, headNum, genesis, nil) 234 if err == nil { 235 t.FailNow() 236 } 237 } 238 239 func generateLesServer() *LesServer { 240 s := &LesServer{ 241 defParams: flowcontrol.ServerParams{ 242 BufLimit: uint64(300000000), 243 MinRecharge: uint64(50000), 244 }, 245 fcManager: flowcontrol.NewClientManager(nil, &mclock.System{}), 246 } 247 return s 248 } 249 250 type rwStub struct { 251 ReadHook func(l keyValueList) keyValueList 252 WriteHook func(l keyValueList) 253 } 254 255 func (s *rwStub) ReadMsg() (p2p.Msg, error) { 256 payload := keyValueList{} 257 payload = payload.add("protocolVersion", uint64(protocol_version)) 258 payload = payload.add("networkId", uint64(test_networkid)) 259 payload = payload.add("headTd", td) 260 payload = payload.add("headHash", hash) 261 payload = payload.add("headNum", headNum) 262 payload = payload.add("genesisHash", genesis) 263 264 if s.ReadHook != nil { 265 payload = s.ReadHook(payload) 266 } 267 268 size, p, err := rlp.EncodeToReader(payload) 269 if err != nil { 270 return p2p.Msg{}, err 271 } 272 273 return p2p.Msg{ 274 Size: uint32(size), 275 Payload: p, 276 }, nil 277 } 278 279 func (s *rwStub) WriteMsg(m p2p.Msg) error { 280 recvList := keyValueList{} 281 if err := m.Decode(&recvList); err != nil { 282 return err 283 } 284 285 if s.WriteHook != nil { 286 s.WriteHook(recvList) 287 } 288 289 return nil 290 }