github.com/linapex/ethereum-go-chinese@v0.0.0-20190316121929-f8b7a73c3fa1/swarm/network/stream/lightnode_test.go (about)

     1  
     2  //<developer>
     3  //    <name>linapex 曹一峰</name>
     4  //    <email>linapex@163.com</email>
     5  //    <wx>superexc</wx>
     6  //    <qqgroup>128148617</qqgroup>
     7  //    <url>https://jsq.ink</url>
     8  //    <role>pku engineer</role>
     9  //    <date>2019-03-16 19:16:44</date>
    10  //</624450115519647744>
    11  
    12  package stream
    13  
    14  import (
    15  	"testing"
    16  
    17  	p2ptest "github.com/ethereum/go-ethereum/p2p/testing"
    18  )
    19  
    20  //此测试检查服务器的默认行为，即
    21  //当它提供检索请求时。
    22  func TestLigthnodeRetrieveRequestWithRetrieve(t *testing.T) {
    23  	registryOptions := &RegistryOptions{
    24  		Retrieval: RetrievalClientOnly,
    25  		Syncing:   SyncingDisabled,
    26  	}
    27  	tester, _, _, teardown, err := newStreamerTester(t, registryOptions)
    28  	defer teardown()
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  
    33  	node := tester.Nodes[0]
    34  
    35  	stream := NewStream(swarmChunkServerStreamName, "", false)
    36  
    37  	err = tester.TestExchanges(p2ptest.Exchange{
    38  		Label: "SubscribeMsg",
    39  		Triggers: []p2ptest.Trigger{
    40  			{
    41  				Code: 4,
    42  				Msg: &SubscribeMsg{
    43  					Stream: stream,
    44  				},
    45  				Peer: node.ID(),
    46  			},
    47  		},
    48  	})
    49  	if err != nil {
    50  		t.Fatalf("Got %v", err)
    51  	}
    52  
    53  	err = tester.TestDisconnected(&p2ptest.Disconnect{Peer: node.ID()})
    54  	if err == nil || err.Error() != "timed out waiting for peers to disconnect" {
    55  		t.Fatalf("Expected no disconnect, got %v", err)
    56  	}
    57  }
    58  
    59  //此测试在服务检索时检查服务器的lightnode行为
    60  //请求被禁用
    61  func TestLigthnodeRetrieveRequestWithoutRetrieve(t *testing.T) {
    62  	registryOptions := &RegistryOptions{
    63  		Retrieval: RetrievalDisabled,
    64  		Syncing:   SyncingDisabled,
    65  	}
    66  	tester, _, _, teardown, err := newStreamerTester(t, registryOptions)
    67  	defer teardown()
    68  	if err != nil {
    69  		t.Fatal(err)
    70  	}
    71  
    72  	node := tester.Nodes[0]
    73  
    74  	stream := NewStream(swarmChunkServerStreamName, "", false)
    75  
    76  	err = tester.TestExchanges(
    77  		p2ptest.Exchange{
    78  			Label: "SubscribeMsg",
    79  			Triggers: []p2ptest.Trigger{
    80  				{
    81  					Code: 4,
    82  					Msg: &SubscribeMsg{
    83  						Stream: stream,
    84  					},
    85  					Peer: node.ID(),
    86  				},
    87  			},
    88  			Expects: []p2ptest.Expect{
    89  				{
    90  					Code: 7,
    91  					Msg: &SubscribeErrorMsg{
    92  						Error: "stream RETRIEVE_REQUEST not registered",
    93  					},
    94  					Peer: node.ID(),
    95  				},
    96  			},
    97  		})
    98  	if err != nil {
    99  		t.Fatalf("Got %v", err)
   100  	}
   101  }
   102  
   103  //此测试检查服务器的默认行为，即
   104  //启用同步时。
   105  func TestLigthnodeRequestSubscriptionWithSync(t *testing.T) {
   106  	registryOptions := &RegistryOptions{
   107  		Retrieval: RetrievalDisabled,
   108  		Syncing:   SyncingRegisterOnly,
   109  	}
   110  	tester, _, _, teardown, err := newStreamerTester(t, registryOptions)
   111  	defer teardown()
   112  	if err != nil {
   113  		t.Fatal(err)
   114  	}
   115  
   116  	node := tester.Nodes[0]
   117  
   118  	syncStream := NewStream("SYNC", FormatSyncBinKey(1), false)
   119  
   120  	err = tester.TestExchanges(
   121  		p2ptest.Exchange{
   122  			Label: "RequestSubscription",
   123  			Triggers: []p2ptest.Trigger{
   124  				{
   125  					Code: 8,
   126  					Msg: &RequestSubscriptionMsg{
   127  						Stream: syncStream,
   128  					},
   129  					Peer: node.ID(),
   130  				},
   131  			},
   132  			Expects: []p2ptest.Expect{
   133  				{
   134  					Code: 4,
   135  					Msg: &SubscribeMsg{
   136  						Stream: syncStream,
   137  					},
   138  					Peer: node.ID(),
   139  				},
   140  			},
   141  		})
   142  
   143  	if err != nil {
   144  		t.Fatalf("Got %v", err)
   145  	}
   146  }
   147  
   148  //此测试检查服务器的lightnode行为，即
   149  //当同步被禁用时。
   150  func TestLigthnodeRequestSubscriptionWithoutSync(t *testing.T) {
   151  	registryOptions := &RegistryOptions{
   152  		Retrieval: RetrievalDisabled,
   153  		Syncing:   SyncingDisabled,
   154  	}
   155  	tester, _, _, teardown, err := newStreamerTester(t, registryOptions)
   156  	defer teardown()
   157  	if err != nil {
   158  		t.Fatal(err)
   159  	}
   160  
   161  	node := tester.Nodes[0]
   162  
   163  	syncStream := NewStream("SYNC", FormatSyncBinKey(1), false)
   164  
   165  	err = tester.TestExchanges(p2ptest.Exchange{
   166  		Label: "RequestSubscription",
   167  		Triggers: []p2ptest.Trigger{
   168  			{
   169  				Code: 8,
   170  				Msg: &RequestSubscriptionMsg{
   171  					Stream: syncStream,
   172  				},
   173  				Peer: node.ID(),
   174  			},
   175  		},
   176  		Expects: []p2ptest.Expect{
   177  			{
   178  				Code: 7,
   179  				Msg: &SubscribeErrorMsg{
   180  					Error: "stream SYNC not registered",
   181  				},
   182  				Peer: node.ID(),
   183  			},
   184  		},
   185  	}, p2ptest.Exchange{
   186  		Label: "RequestSubscription",
   187  		Triggers: []p2ptest.Trigger{
   188  			{
   189  				Code: 4,
   190  				Msg: &SubscribeMsg{
   191  					Stream: syncStream,
   192  				},
   193  				Peer: node.ID(),
   194  			},
   195  		},
   196  		Expects: []p2ptest.Expect{
   197  			{
   198  				Code: 7,
   199  				Msg: &SubscribeErrorMsg{
   200  					Error: "stream SYNC not registered",
   201  				},
   202  				Peer: node.ID(),
   203  			},
   204  		},
   205  	})
   206  
   207  	if err != nil {
   208  		t.Fatalf("Got %v", err)
   209  	}
   210  }
   211