github.com/etsc3259/etsc@v0.0.0-20190109113336-a9c2c10f9c95/swarm/network/stream/streamer_test.go (about) 1 // Copyright 2018 The go-etsc Authors 2 // This file is part of the go-etsc library. 3 // 4 // The go-etsc library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-etsc library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-etsc library. If not, see <http://www.gnu.org/licenses/>. 16 17 package stream 18 19 import ( 20 "bytes" 21 "context" 22 "errors" 23 "strconv" 24 "testing" 25 "time" 26 27 "github.com/ETSC3259/etsc/crypto/sha3" 28 p2ptest "github.com/ETSC3259/etsc/p2p/testing" 29 ) 30 31 func TestStreamerSubscribe(t *testing.T) { 32 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 33 defer teardown() 34 if err != nil { 35 t.Fatal(err) 36 } 37 38 stream := NewStream("foo", "", true) 39 err = streamer.Subscribe(tester.Nodes[0].ID(), stream, NewRange(0, 0), Top) 40 if err == nil || err.Error() != "stream foo not registered" { 41 t.Fatalf("Expected error %v, got %v", "stream foo not registered", err) 42 } 43 } 44 45 func TestStreamerRequestSubscription(t *testing.T) { 46 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 47 defer teardown() 48 if err != nil { 49 t.Fatal(err) 50 } 51 52 stream := NewStream("foo", "", false) 53 err = streamer.RequestSubscription(tester.Nodes[0].ID(), stream, &Range{}, Top) 54 if err == nil || err.Error() != "stream foo not registered" { 55 t.Fatalf("Expected error %v, got %v", "stream foo not registered", err) 56 } 57 } 58 59 var ( 60 hash0 = sha3.Sum256([]byte{0}) 61 hash1 = sha3.Sum256([]byte{1}) 62 hash2 = sha3.Sum256([]byte{2}) 63 hashesTmp = append(hash0[:], hash1[:]...) 64 hashes = append(hashesTmp, hash2[:]...) 65 corruptHashes = append(hashes[:40]) 66 ) 67 68 type testClient struct { 69 t string 70 wait0 chan bool 71 wait2 chan bool 72 batchDone chan bool 73 receivedHashes map[string][]byte 74 } 75 76 func newTestClient(t string) *testClient { 77 return &testClient{ 78 t: t, 79 wait0: make(chan bool), 80 wait2: make(chan bool), 81 batchDone: make(chan bool), 82 receivedHashes: make(map[string][]byte), 83 } 84 } 85 86 func (self *testClient) NeedData(ctx context.Context, hash []byte) func(context.Context) error { 87 self.receivedHashes[string(hash)] = hash 88 if bytes.Equal(hash, hash0[:]) { 89 return func(context.Context) error { 90 <-self.wait0 91 return nil 92 } 93 } else if bytes.Equal(hash, hash2[:]) { 94 return func(context.Context) error { 95 <-self.wait2 96 return nil 97 } 98 } 99 return nil 100 } 101 102 func (self *testClient) BatchDone(Stream, uint64, []byte, []byte) func() (*TakeoverProof, error) { 103 close(self.batchDone) 104 return nil 105 } 106 107 func (self *testClient) Close() {} 108 109 type testServer struct { 110 t string 111 sessionIndex uint64 112 } 113 114 func newTestServer(t string, sessionIndex uint64) *testServer { 115 return &testServer{ 116 t: t, 117 sessionIndex: sessionIndex, 118 } 119 } 120 121 func (s *testServer) SessionIndex() (uint64, error) { 122 return s.sessionIndex, nil 123 } 124 125 func (self *testServer) SetNextBatch(from uint64, to uint64) ([]byte, uint64, uint64, *HandoverProof, error) { 126 return make([]byte, HashSize), from + 1, to + 1, nil, nil 127 } 128 129 func (self *testServer) GetData(context.Context, []byte) ([]byte, error) { 130 return nil, nil 131 } 132 133 func (self *testServer) Close() { 134 } 135 136 func TestStreamerDownstreamSubscribeUnsubscribeMsgExchange(t *testing.T) { 137 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 138 defer teardown() 139 if err != nil { 140 t.Fatal(err) 141 } 142 143 streamer.RegisterClientFunc("foo", func(p *Peer, t string, live bool) (Client, error) { 144 return newTestClient(t), nil 145 }) 146 147 node := tester.Nodes[0] 148 149 stream := NewStream("foo", "", true) 150 err = streamer.Subscribe(node.ID(), stream, NewRange(5, 8), Top) 151 if err != nil { 152 t.Fatalf("Expected no error, got %v", err) 153 } 154 155 err = tester.TestExchanges( 156 p2ptest.Exchange{ 157 Label: "Subscribe message", 158 Expects: []p2ptest.Expect{ 159 { 160 Code: 4, 161 Msg: &SubscribeMsg{ 162 Stream: stream, 163 History: NewRange(5, 8), 164 Priority: Top, 165 }, 166 Peer: node.ID(), 167 }, 168 }, 169 }, 170 // trigger OfferedHashesMsg to actually create the client 171 p2ptest.Exchange{ 172 Label: "OfferedHashes message", 173 Triggers: []p2ptest.Trigger{ 174 { 175 Code: 1, 176 Msg: &OfferedHashesMsg{ 177 HandoverProof: &HandoverProof{ 178 Handover: &Handover{}, 179 }, 180 Hashes: hashes, 181 From: 5, 182 To: 8, 183 Stream: stream, 184 }, 185 Peer: node.ID(), 186 }, 187 }, 188 Expects: []p2ptest.Expect{ 189 { 190 Code: 2, 191 Msg: &WantedHashesMsg{ 192 Stream: stream, 193 Want: []byte{5}, 194 From: 9, 195 To: 0, 196 }, 197 Peer: node.ID(), 198 }, 199 }, 200 }, 201 ) 202 if err != nil { 203 t.Fatal(err) 204 } 205 206 err = streamer.Unsubscribe(node.ID(), stream) 207 if err != nil { 208 t.Fatalf("Expected no error, got %v", err) 209 } 210 211 err = tester.TestExchanges(p2ptest.Exchange{ 212 Label: "Unsubscribe message", 213 Expects: []p2ptest.Expect{ 214 { 215 Code: 0, 216 Msg: &UnsubscribeMsg{ 217 Stream: stream, 218 }, 219 Peer: node.ID(), 220 }, 221 }, 222 }) 223 224 if err != nil { 225 t.Fatal(err) 226 } 227 } 228 229 func TestStreamerUpstreamSubscribeUnsubscribeMsgExchange(t *testing.T) { 230 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 231 defer teardown() 232 if err != nil { 233 t.Fatal(err) 234 } 235 236 stream := NewStream("foo", "", false) 237 238 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 239 return newTestServer(t, 10), nil 240 }) 241 242 node := tester.Nodes[0] 243 244 err = tester.TestExchanges(p2ptest.Exchange{ 245 Label: "Subscribe message", 246 Triggers: []p2ptest.Trigger{ 247 { 248 Code: 4, 249 Msg: &SubscribeMsg{ 250 Stream: stream, 251 History: NewRange(5, 8), 252 Priority: Top, 253 }, 254 Peer: node.ID(), 255 }, 256 }, 257 Expects: []p2ptest.Expect{ 258 { 259 Code: 1, 260 Msg: &OfferedHashesMsg{ 261 Stream: stream, 262 HandoverProof: &HandoverProof{ 263 Handover: &Handover{}, 264 }, 265 Hashes: make([]byte, HashSize), 266 From: 6, 267 To: 9, 268 }, 269 Peer: node.ID(), 270 }, 271 }, 272 }) 273 274 if err != nil { 275 t.Fatal(err) 276 } 277 278 err = tester.TestExchanges(p2ptest.Exchange{ 279 Label: "unsubscribe message", 280 Triggers: []p2ptest.Trigger{ 281 { 282 Code: 0, 283 Msg: &UnsubscribeMsg{ 284 Stream: stream, 285 }, 286 Peer: node.ID(), 287 }, 288 }, 289 }) 290 291 if err != nil { 292 t.Fatal(err) 293 } 294 } 295 296 func TestStreamerUpstreamSubscribeUnsubscribeMsgExchangeLive(t *testing.T) { 297 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 298 defer teardown() 299 if err != nil { 300 t.Fatal(err) 301 } 302 303 stream := NewStream("foo", "", true) 304 305 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 306 return newTestServer(t, 0), nil 307 }) 308 309 node := tester.Nodes[0] 310 311 err = tester.TestExchanges(p2ptest.Exchange{ 312 Label: "Subscribe message", 313 Triggers: []p2ptest.Trigger{ 314 { 315 Code: 4, 316 Msg: &SubscribeMsg{ 317 Stream: stream, 318 Priority: Top, 319 }, 320 Peer: node.ID(), 321 }, 322 }, 323 Expects: []p2ptest.Expect{ 324 { 325 Code: 1, 326 Msg: &OfferedHashesMsg{ 327 Stream: stream, 328 HandoverProof: &HandoverProof{ 329 Handover: &Handover{}, 330 }, 331 Hashes: make([]byte, HashSize), 332 From: 1, 333 To: 0, 334 }, 335 Peer: node.ID(), 336 }, 337 }, 338 }) 339 340 if err != nil { 341 t.Fatal(err) 342 } 343 344 err = tester.TestExchanges(p2ptest.Exchange{ 345 Label: "unsubscribe message", 346 Triggers: []p2ptest.Trigger{ 347 { 348 Code: 0, 349 Msg: &UnsubscribeMsg{ 350 Stream: stream, 351 }, 352 Peer: node.ID(), 353 }, 354 }, 355 }) 356 357 if err != nil { 358 t.Fatal(err) 359 } 360 } 361 362 func TestStreamerUpstreamSubscribeErrorMsgExchange(t *testing.T) { 363 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 364 defer teardown() 365 if err != nil { 366 t.Fatal(err) 367 } 368 369 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 370 return newTestServer(t, 0), nil 371 }) 372 373 stream := NewStream("bar", "", true) 374 375 node := tester.Nodes[0] 376 377 err = tester.TestExchanges(p2ptest.Exchange{ 378 Label: "Subscribe message", 379 Triggers: []p2ptest.Trigger{ 380 { 381 Code: 4, 382 Msg: &SubscribeMsg{ 383 Stream: stream, 384 History: NewRange(5, 8), 385 Priority: Top, 386 }, 387 Peer: node.ID(), 388 }, 389 }, 390 Expects: []p2ptest.Expect{ 391 { 392 Code: 7, 393 Msg: &SubscribeErrorMsg{ 394 Error: "stream bar not registered", 395 }, 396 Peer: node.ID(), 397 }, 398 }, 399 }) 400 401 if err != nil { 402 t.Fatal(err) 403 } 404 } 405 406 func TestStreamerUpstreamSubscribeLiveAndHistory(t *testing.T) { 407 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 408 defer teardown() 409 if err != nil { 410 t.Fatal(err) 411 } 412 413 stream := NewStream("foo", "", true) 414 415 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 416 return newTestServer(t, 10), nil 417 }) 418 419 node := tester.Nodes[0] 420 421 err = tester.TestExchanges(p2ptest.Exchange{ 422 Label: "Subscribe message", 423 Triggers: []p2ptest.Trigger{ 424 { 425 Code: 4, 426 Msg: &SubscribeMsg{ 427 Stream: stream, 428 History: NewRange(5, 8), 429 Priority: Top, 430 }, 431 Peer: node.ID(), 432 }, 433 }, 434 Expects: []p2ptest.Expect{ 435 { 436 Code: 1, 437 Msg: &OfferedHashesMsg{ 438 Stream: NewStream("foo", "", false), 439 HandoverProof: &HandoverProof{ 440 Handover: &Handover{}, 441 }, 442 Hashes: make([]byte, HashSize), 443 From: 6, 444 To: 9, 445 }, 446 Peer: node.ID(), 447 }, 448 { 449 Code: 1, 450 Msg: &OfferedHashesMsg{ 451 Stream: stream, 452 HandoverProof: &HandoverProof{ 453 Handover: &Handover{}, 454 }, 455 From: 11, 456 To: 0, 457 Hashes: make([]byte, HashSize), 458 }, 459 Peer: node.ID(), 460 }, 461 }, 462 }) 463 464 if err != nil { 465 t.Fatal(err) 466 } 467 } 468 469 func TestStreamerDownstreamCorruptHashesMsgExchange(t *testing.T) { 470 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 471 defer teardown() 472 if err != nil { 473 t.Fatal(err) 474 } 475 476 stream := NewStream("foo", "", true) 477 478 var tc *testClient 479 480 streamer.RegisterClientFunc("foo", func(p *Peer, t string, live bool) (Client, error) { 481 tc = newTestClient(t) 482 return tc, nil 483 }) 484 485 node := tester.Nodes[0] 486 487 err = streamer.Subscribe(node.ID(), stream, NewRange(5, 8), Top) 488 if err != nil { 489 t.Fatalf("Expected no error, got %v", err) 490 } 491 492 err = tester.TestExchanges(p2ptest.Exchange{ 493 Label: "Subscribe message", 494 Expects: []p2ptest.Expect{ 495 { 496 Code: 4, 497 Msg: &SubscribeMsg{ 498 Stream: stream, 499 History: NewRange(5, 8), 500 Priority: Top, 501 }, 502 Peer: node.ID(), 503 }, 504 }, 505 }, 506 p2ptest.Exchange{ 507 Label: "Corrupt offered hash message", 508 Triggers: []p2ptest.Trigger{ 509 { 510 Code: 1, 511 Msg: &OfferedHashesMsg{ 512 HandoverProof: &HandoverProof{ 513 Handover: &Handover{}, 514 }, 515 Hashes: corruptHashes, 516 From: 5, 517 To: 8, 518 Stream: stream, 519 }, 520 Peer: node.ID(), 521 }, 522 }, 523 }) 524 if err != nil { 525 t.Fatal(err) 526 } 527 528 expectedError := errors.New("Message handler error: (msg code 1): error invalid hashes length (len: 40)") 529 if err := tester.TestDisconnected(&p2ptest.Disconnect{Peer: node.ID(), Error: expectedError}); err != nil { 530 t.Fatal(err) 531 } 532 } 533 534 func TestStreamerDownstreamOfferedHashesMsgExchange(t *testing.T) { 535 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 536 defer teardown() 537 if err != nil { 538 t.Fatal(err) 539 } 540 541 stream := NewStream("foo", "", true) 542 543 var tc *testClient 544 545 streamer.RegisterClientFunc("foo", func(p *Peer, t string, live bool) (Client, error) { 546 tc = newTestClient(t) 547 return tc, nil 548 }) 549 550 node := tester.Nodes[0] 551 552 err = streamer.Subscribe(node.ID(), stream, NewRange(5, 8), Top) 553 if err != nil { 554 t.Fatalf("Expected no error, got %v", err) 555 } 556 557 err = tester.TestExchanges(p2ptest.Exchange{ 558 Label: "Subscribe message", 559 Expects: []p2ptest.Expect{ 560 { 561 Code: 4, 562 Msg: &SubscribeMsg{ 563 Stream: stream, 564 History: NewRange(5, 8), 565 Priority: Top, 566 }, 567 Peer: node.ID(), 568 }, 569 }, 570 }, 571 p2ptest.Exchange{ 572 Label: "WantedHashes message", 573 Triggers: []p2ptest.Trigger{ 574 { 575 Code: 1, 576 Msg: &OfferedHashesMsg{ 577 HandoverProof: &HandoverProof{ 578 Handover: &Handover{}, 579 }, 580 Hashes: hashes, 581 From: 5, 582 To: 8, 583 Stream: stream, 584 }, 585 Peer: node.ID(), 586 }, 587 }, 588 Expects: []p2ptest.Expect{ 589 { 590 Code: 2, 591 Msg: &WantedHashesMsg{ 592 Stream: stream, 593 Want: []byte{5}, 594 From: 9, 595 To: 0, 596 }, 597 Peer: node.ID(), 598 }, 599 }, 600 }) 601 if err != nil { 602 t.Fatal(err) 603 } 604 605 if len(tc.receivedHashes) != 3 { 606 t.Fatalf("Expected number of received hashes %v, got %v", 3, len(tc.receivedHashes)) 607 } 608 609 close(tc.wait0) 610 611 timeout := time.NewTimer(100 * time.Millisecond) 612 defer timeout.Stop() 613 614 select { 615 case <-tc.batchDone: 616 t.Fatal("batch done early") 617 case <-timeout.C: 618 } 619 620 close(tc.wait2) 621 622 timeout2 := time.NewTimer(10000 * time.Millisecond) 623 defer timeout2.Stop() 624 625 select { 626 case <-tc.batchDone: 627 case <-timeout2.C: 628 t.Fatal("timeout waiting batchdone call") 629 } 630 631 } 632 633 func TestStreamerRequestSubscriptionQuitMsgExchange(t *testing.T) { 634 tester, streamer, _, teardown, err := newStreamerTester(t, nil) 635 defer teardown() 636 if err != nil { 637 t.Fatal(err) 638 } 639 640 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 641 return newTestServer(t, 10), nil 642 }) 643 644 node := tester.Nodes[0] 645 646 stream := NewStream("foo", "", true) 647 err = streamer.RequestSubscription(node.ID(), stream, NewRange(5, 8), Top) 648 if err != nil { 649 t.Fatalf("Expected no error, got %v", err) 650 } 651 652 err = tester.TestExchanges( 653 p2ptest.Exchange{ 654 Label: "RequestSubscription message", 655 Expects: []p2ptest.Expect{ 656 { 657 Code: 8, 658 Msg: &RequestSubscriptionMsg{ 659 Stream: stream, 660 History: NewRange(5, 8), 661 Priority: Top, 662 }, 663 Peer: node.ID(), 664 }, 665 }, 666 }, 667 p2ptest.Exchange{ 668 Label: "Subscribe message", 669 Triggers: []p2ptest.Trigger{ 670 { 671 Code: 4, 672 Msg: &SubscribeMsg{ 673 Stream: stream, 674 History: NewRange(5, 8), 675 Priority: Top, 676 }, 677 Peer: node.ID(), 678 }, 679 }, 680 Expects: []p2ptest.Expect{ 681 { 682 Code: 1, 683 Msg: &OfferedHashesMsg{ 684 Stream: NewStream("foo", "", false), 685 HandoverProof: &HandoverProof{ 686 Handover: &Handover{}, 687 }, 688 Hashes: make([]byte, HashSize), 689 From: 6, 690 To: 9, 691 }, 692 Peer: node.ID(), 693 }, 694 { 695 Code: 1, 696 Msg: &OfferedHashesMsg{ 697 Stream: stream, 698 HandoverProof: &HandoverProof{ 699 Handover: &Handover{}, 700 }, 701 From: 11, 702 To: 0, 703 Hashes: make([]byte, HashSize), 704 }, 705 Peer: node.ID(), 706 }, 707 }, 708 }, 709 ) 710 if err != nil { 711 t.Fatal(err) 712 } 713 714 err = streamer.Quit(node.ID(), stream) 715 if err != nil { 716 t.Fatalf("Expected no error, got %v", err) 717 } 718 719 err = tester.TestExchanges(p2ptest.Exchange{ 720 Label: "Quit message", 721 Expects: []p2ptest.Expect{ 722 { 723 Code: 9, 724 Msg: &QuitMsg{ 725 Stream: stream, 726 }, 727 Peer: node.ID(), 728 }, 729 }, 730 }) 731 732 if err != nil { 733 t.Fatal(err) 734 } 735 736 historyStream := getscistoryStream(stream) 737 738 err = streamer.Quit(node.ID(), historyStream) 739 if err != nil { 740 t.Fatalf("Expected no error, got %v", err) 741 } 742 743 err = tester.TestExchanges(p2ptest.Exchange{ 744 Label: "Quit message", 745 Expects: []p2ptest.Expect{ 746 { 747 Code: 9, 748 Msg: &QuitMsg{ 749 Stream: historyStream, 750 }, 751 Peer: node.ID(), 752 }, 753 }, 754 }) 755 756 if err != nil { 757 t.Fatal(err) 758 } 759 } 760 761 // TestMaxPeerServersWithUnsubscribe creates a registry with a limited 762 // number of stream servers, and performs a test with subscriptions and 763 // unsubscriptions, checking if unsubscriptions will remove streams, 764 // leaving place for new streams. 765 func TestMaxPeerServersWithUnsubscribe(t *testing.T) { 766 var maxPeerServers = 6 767 tester, streamer, _, teardown, err := newStreamerTester(t, &RegistryOptions{ 768 Retrieval: RetrievalDisabled, 769 Syncing: SyncingDisabled, 770 MaxPeerServers: maxPeerServers, 771 }) 772 defer teardown() 773 if err != nil { 774 t.Fatal(err) 775 } 776 777 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 778 return newTestServer(t, 0), nil 779 }) 780 781 node := tester.Nodes[0] 782 783 for i := 0; i < maxPeerServers+10; i++ { 784 stream := NewStream("foo", strconv.Itoa(i), true) 785 786 err = tester.TestExchanges(p2ptest.Exchange{ 787 Label: "Subscribe message", 788 Triggers: []p2ptest.Trigger{ 789 { 790 Code: 4, 791 Msg: &SubscribeMsg{ 792 Stream: stream, 793 Priority: Top, 794 }, 795 Peer: node.ID(), 796 }, 797 }, 798 Expects: []p2ptest.Expect{ 799 { 800 Code: 1, 801 Msg: &OfferedHashesMsg{ 802 Stream: stream, 803 HandoverProof: &HandoverProof{ 804 Handover: &Handover{}, 805 }, 806 Hashes: make([]byte, HashSize), 807 From: 1, 808 To: 0, 809 }, 810 Peer: node.ID(), 811 }, 812 }, 813 }) 814 815 if err != nil { 816 t.Fatal(err) 817 } 818 819 err = tester.TestExchanges(p2ptest.Exchange{ 820 Label: "unsubscribe message", 821 Triggers: []p2ptest.Trigger{ 822 { 823 Code: 0, 824 Msg: &UnsubscribeMsg{ 825 Stream: stream, 826 }, 827 Peer: node.ID(), 828 }, 829 }, 830 }) 831 832 if err != nil { 833 t.Fatal(err) 834 } 835 } 836 } 837 838 // TestMaxPeerServersWithoutUnsubscribe creates a registry with a limited 839 // number of stream servers, and performs subscriptions to detect subscriptions 840 // error message exchange. 841 func TestMaxPeerServersWithoutUnsubscribe(t *testing.T) { 842 var maxPeerServers = 6 843 tester, streamer, _, teardown, err := newStreamerTester(t, &RegistryOptions{ 844 MaxPeerServers: maxPeerServers, 845 }) 846 defer teardown() 847 if err != nil { 848 t.Fatal(err) 849 } 850 851 streamer.RegisterServerFunc("foo", func(p *Peer, t string, live bool) (Server, error) { 852 return newTestServer(t, 0), nil 853 }) 854 855 node := tester.Nodes[0] 856 857 for i := 0; i < maxPeerServers+10; i++ { 858 stream := NewStream("foo", strconv.Itoa(i), true) 859 860 if i >= maxPeerServers { 861 err = tester.TestExchanges(p2ptest.Exchange{ 862 Label: "Subscribe message", 863 Triggers: []p2ptest.Trigger{ 864 { 865 Code: 4, 866 Msg: &SubscribeMsg{ 867 Stream: stream, 868 Priority: Top, 869 }, 870 Peer: node.ID(), 871 }, 872 }, 873 Expects: []p2ptest.Expect{ 874 { 875 Code: 7, 876 Msg: &SubscribeErrorMsg{ 877 Error: ErrMaxPeerServers.Error(), 878 }, 879 Peer: node.ID(), 880 }, 881 }, 882 }) 883 884 if err != nil { 885 t.Fatal(err) 886 } 887 continue 888 } 889 890 err = tester.TestExchanges(p2ptest.Exchange{ 891 Label: "Subscribe message", 892 Triggers: []p2ptest.Trigger{ 893 { 894 Code: 4, 895 Msg: &SubscribeMsg{ 896 Stream: stream, 897 Priority: Top, 898 }, 899 Peer: node.ID(), 900 }, 901 }, 902 Expects: []p2ptest.Expect{ 903 { 904 Code: 1, 905 Msg: &OfferedHashesMsg{ 906 Stream: stream, 907 HandoverProof: &HandoverProof{ 908 Handover: &Handover{}, 909 }, 910 Hashes: make([]byte, HashSize), 911 From: 1, 912 To: 0, 913 }, 914 Peer: node.ID(), 915 }, 916 }, 917 }) 918 919 if err != nil { 920 t.Fatal(err) 921 } 922 } 923 }