github.com/bcnmy/go-ethereum@v1.10.27/p2p/simulations/http_test.go (about)

     1  // Copyright 2017 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum 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-ethereum 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-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package simulations
    18  
    19  import (
    20  	"context"
    21  	"flag"
    22  	"fmt"
    23  	"math/rand"
    24  	"net/http/httptest"
    25  	"os"
    26  	"reflect"
    27  	"sync"
    28  	"sync/atomic"
    29  	"testing"
    30  	"time"
    31  
    32  	"github.com/ethereum/go-ethereum/event"
    33  	"github.com/ethereum/go-ethereum/log"
    34  	"github.com/ethereum/go-ethereum/node"
    35  	"github.com/ethereum/go-ethereum/p2p"
    36  	"github.com/ethereum/go-ethereum/p2p/enode"
    37  	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
    38  	"github.com/ethereum/go-ethereum/rpc"
    39  	"github.com/mattn/go-colorable"
    40  )
    41  
    42  func TestMain(m *testing.M) {
    43  	loglevel := flag.Int("loglevel", 2, "verbosity of logs")
    44  
    45  	flag.Parse()
    46  	log.PrintOrigins(true)
    47  	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(true))))
    48  	os.Exit(m.Run())
    49  }
    50  
    51  // testService implements the node.Service interface and provides protocols
    52  // and APIs which are useful for testing nodes in a simulation network
    53  type testService struct {
    54  	id enode.ID
    55  
    56  	// peerCount is incremented once a peer handshake has been performed
    57  	peerCount int64
    58  
    59  	peers    map[enode.ID]*testPeer
    60  	peersMtx sync.Mutex
    61  
    62  	// state stores []byte which is used to test creating and loading
    63  	// snapshots
    64  	state atomic.Value
    65  }
    66  
    67  func newTestService(ctx *adapters.ServiceContext, stack *node.Node) (node.Lifecycle, error) {
    68  	svc := &testService{
    69  		id:    ctx.Config.ID,
    70  		peers: make(map[enode.ID]*testPeer),
    71  	}
    72  	svc.state.Store(ctx.Snapshot)
    73  
    74  	stack.RegisterProtocols(svc.Protocols())
    75  	stack.RegisterAPIs(svc.APIs())
    76  	return svc, nil
    77  }
    78  
    79  type testPeer struct {
    80  	testReady chan struct{}
    81  	dumReady  chan struct{}
    82  }
    83  
    84  func (t *testService) peer(id enode.ID) *testPeer {
    85  	t.peersMtx.Lock()
    86  	defer t.peersMtx.Unlock()
    87  	if peer, ok := t.peers[id]; ok {
    88  		return peer
    89  	}
    90  	peer := &testPeer{
    91  		testReady: make(chan struct{}),
    92  		dumReady:  make(chan struct{}),
    93  	}
    94  	t.peers[id] = peer
    95  	return peer
    96  }
    97  
    98  func (t *testService) Protocols() []p2p.Protocol {
    99  	return []p2p.Protocol{
   100  		{
   101  			Name:    "test",
   102  			Version: 1,
   103  			Length:  3,
   104  			Run:     t.RunTest,
   105  		},
   106  		{
   107  			Name:    "dum",
   108  			Version: 1,
   109  			Length:  1,
   110  			Run:     t.RunDum,
   111  		},
   112  		{
   113  			Name:    "prb",
   114  			Version: 1,
   115  			Length:  1,
   116  			Run:     t.RunPrb,
   117  		},
   118  	}
   119  }
   120  
   121  func (t *testService) APIs() []rpc.API {
   122  	return []rpc.API{{
   123  		Namespace: "test",
   124  		Version:   "1.0",
   125  		Service: &TestAPI{
   126  			state:     &t.state,
   127  			peerCount: &t.peerCount,
   128  		},
   129  	}}
   130  }
   131  
   132  func (t *testService) Start() error {
   133  	return nil
   134  }
   135  
   136  func (t *testService) Stop() error {
   137  	return nil
   138  }
   139  
   140  // handshake performs a peer handshake by sending and expecting an empty
   141  // message with the given code
   142  func (t *testService) handshake(rw p2p.MsgReadWriter, code uint64) error {
   143  	errc := make(chan error, 2)
   144  	go func() { errc <- p2p.SendItems(rw, code) }()
   145  	go func() { errc <- p2p.ExpectMsg(rw, code, struct{}{}) }()
   146  	for i := 0; i < 2; i++ {
   147  		if err := <-errc; err != nil {
   148  			return err
   149  		}
   150  	}
   151  	return nil
   152  }
   153  
   154  func (t *testService) RunTest(p *p2p.Peer, rw p2p.MsgReadWriter) error {
   155  	peer := t.peer(p.ID())
   156  
   157  	// perform three handshakes with three different message codes,
   158  	// used to test message sending and filtering
   159  	if err := t.handshake(rw, 2); err != nil {
   160  		return err
   161  	}
   162  	if err := t.handshake(rw, 1); err != nil {
   163  		return err
   164  	}
   165  	if err := t.handshake(rw, 0); err != nil {
   166  		return err
   167  	}
   168  
   169  	// close the testReady channel so that other protocols can run
   170  	close(peer.testReady)
   171  
   172  	// track the peer
   173  	atomic.AddInt64(&t.peerCount, 1)
   174  	defer atomic.AddInt64(&t.peerCount, -1)
   175  
   176  	// block until the peer is dropped
   177  	for {
   178  		_, err := rw.ReadMsg()
   179  		if err != nil {
   180  			return err
   181  		}
   182  	}
   183  }
   184  
   185  func (t *testService) RunDum(p *p2p.Peer, rw p2p.MsgReadWriter) error {
   186  	peer := t.peer(p.ID())
   187  
   188  	// wait for the test protocol to perform its handshake
   189  	<-peer.testReady
   190  
   191  	// perform a handshake
   192  	if err := t.handshake(rw, 0); err != nil {
   193  		return err
   194  	}
   195  
   196  	// close the dumReady channel so that other protocols can run
   197  	close(peer.dumReady)
   198  
   199  	// block until the peer is dropped
   200  	for {
   201  		_, err := rw.ReadMsg()
   202  		if err != nil {
   203  			return err
   204  		}
   205  	}
   206  }
   207  func (t *testService) RunPrb(p *p2p.Peer, rw p2p.MsgReadWriter) error {
   208  	peer := t.peer(p.ID())
   209  
   210  	// wait for the dum protocol to perform its handshake
   211  	<-peer.dumReady
   212  
   213  	// perform a handshake
   214  	if err := t.handshake(rw, 0); err != nil {
   215  		return err
   216  	}
   217  
   218  	// block until the peer is dropped
   219  	for {
   220  		_, err := rw.ReadMsg()
   221  		if err != nil {
   222  			return err
   223  		}
   224  	}
   225  }
   226  
   227  func (t *testService) Snapshot() ([]byte, error) {
   228  	return t.state.Load().([]byte), nil
   229  }
   230  
   231  // TestAPI provides a test API to:
   232  // * get the peer count
   233  // * get and set an arbitrary state byte slice
   234  // * get and increment a counter
   235  // * subscribe to counter increment events
   236  type TestAPI struct {
   237  	state     *atomic.Value
   238  	peerCount *int64
   239  	counter   int64
   240  	feed      event.Feed
   241  }
   242  
   243  func (t *TestAPI) PeerCount() int64 {
   244  	return atomic.LoadInt64(t.peerCount)
   245  }
   246  
   247  func (t *TestAPI) Get() int64 {
   248  	return atomic.LoadInt64(&t.counter)
   249  }
   250  
   251  func (t *TestAPI) Add(delta int64) {
   252  	atomic.AddInt64(&t.counter, delta)
   253  	t.feed.Send(delta)
   254  }
   255  
   256  func (t *TestAPI) GetState() []byte {
   257  	return t.state.Load().([]byte)
   258  }
   259  
   260  func (t *TestAPI) SetState(state []byte) {
   261  	t.state.Store(state)
   262  }
   263  
   264  func (t *TestAPI) Events(ctx context.Context) (*rpc.Subscription, error) {
   265  	notifier, supported := rpc.NotifierFromContext(ctx)
   266  	if !supported {
   267  		return nil, rpc.ErrNotificationsUnsupported
   268  	}
   269  
   270  	rpcSub := notifier.CreateSubscription()
   271  
   272  	go func() {
   273  		events := make(chan int64)
   274  		sub := t.feed.Subscribe(events)
   275  		defer sub.Unsubscribe()
   276  
   277  		for {
   278  			select {
   279  			case event := <-events:
   280  				notifier.Notify(rpcSub.ID, event)
   281  			case <-sub.Err():
   282  				return
   283  			case <-rpcSub.Err():
   284  				return
   285  			case <-notifier.Closed():
   286  				return
   287  			}
   288  		}
   289  	}()
   290  
   291  	return rpcSub, nil
   292  }
   293  
   294  var testServices = adapters.LifecycleConstructors{
   295  	"test": newTestService,
   296  }
   297  
   298  func testHTTPServer(t *testing.T) (*Network, *httptest.Server) {
   299  	t.Helper()
   300  	adapter := adapters.NewSimAdapter(testServices)
   301  	network := NewNetwork(adapter, &NetworkConfig{
   302  		DefaultService: "test",
   303  	})
   304  	return network, httptest.NewServer(NewServer(network))
   305  }
   306  
   307  // TestHTTPNetwork tests interacting with a simulation network using the HTTP
   308  // API
   309  func TestHTTPNetwork(t *testing.T) {
   310  	// start the server
   311  	network, s := testHTTPServer(t)
   312  	defer s.Close()
   313  
   314  	// subscribe to events so we can check them later
   315  	client := NewClient(s.URL)
   316  	events := make(chan *Event, 100)
   317  	var opts SubscribeOpts
   318  	sub, err := client.SubscribeNetwork(events, opts)
   319  	if err != nil {
   320  		t.Fatalf("error subscribing to network events: %s", err)
   321  	}
   322  	defer sub.Unsubscribe()
   323  
   324  	// check we can retrieve details about the network
   325  	gotNetwork, err := client.GetNetwork()
   326  	if err != nil {
   327  		t.Fatalf("error getting network: %s", err)
   328  	}
   329  	if gotNetwork.ID != network.ID {
   330  		t.Fatalf("expected network to have ID %q, got %q", network.ID, gotNetwork.ID)
   331  	}
   332  
   333  	// start a simulation network
   334  	nodeIDs := startTestNetwork(t, client)
   335  
   336  	// check we got all the events
   337  	x := &expectEvents{t, events, sub}
   338  	x.expect(
   339  		x.nodeEvent(nodeIDs[0], false),
   340  		x.nodeEvent(nodeIDs[1], false),
   341  		x.nodeEvent(nodeIDs[0], true),
   342  		x.nodeEvent(nodeIDs[1], true),
   343  		x.connEvent(nodeIDs[0], nodeIDs[1], false),
   344  		x.connEvent(nodeIDs[0], nodeIDs[1], true),
   345  	)
   346  
   347  	// reconnect the stream and check we get the current nodes and conns
   348  	events = make(chan *Event, 100)
   349  	opts.Current = true
   350  	sub, err = client.SubscribeNetwork(events, opts)
   351  	if err != nil {
   352  		t.Fatalf("error subscribing to network events: %s", err)
   353  	}
   354  	defer sub.Unsubscribe()
   355  	x = &expectEvents{t, events, sub}
   356  	x.expect(
   357  		x.nodeEvent(nodeIDs[0], true),
   358  		x.nodeEvent(nodeIDs[1], true),
   359  		x.connEvent(nodeIDs[0], nodeIDs[1], true),
   360  	)
   361  }
   362  
   363  func startTestNetwork(t *testing.T, client *Client) []string {
   364  	// create two nodes
   365  	nodeCount := 2
   366  	nodeIDs := make([]string, nodeCount)
   367  	for i := 0; i < nodeCount; i++ {
   368  		config := adapters.RandomNodeConfig()
   369  		node, err := client.CreateNode(config)
   370  		if err != nil {
   371  			t.Fatalf("error creating node: %s", err)
   372  		}
   373  		nodeIDs[i] = node.ID
   374  	}
   375  
   376  	// check both nodes exist
   377  	nodes, err := client.GetNodes()
   378  	if err != nil {
   379  		t.Fatalf("error getting nodes: %s", err)
   380  	}
   381  	if len(nodes) != nodeCount {
   382  		t.Fatalf("expected %d nodes, got %d", nodeCount, len(nodes))
   383  	}
   384  	for i, nodeID := range nodeIDs {
   385  		if nodes[i].ID != nodeID {
   386  			t.Fatalf("expected node %d to have ID %q, got %q", i, nodeID, nodes[i].ID)
   387  		}
   388  		node, err := client.GetNode(nodeID)
   389  		if err != nil {
   390  			t.Fatalf("error getting node %d: %s", i, err)
   391  		}
   392  		if node.ID != nodeID {
   393  			t.Fatalf("expected node %d to have ID %q, got %q", i, nodeID, node.ID)
   394  		}
   395  	}
   396  
   397  	// start both nodes
   398  	for _, nodeID := range nodeIDs {
   399  		if err := client.StartNode(nodeID); err != nil {
   400  			t.Fatalf("error starting node %q: %s", nodeID, err)
   401  		}
   402  	}
   403  
   404  	// connect the nodes
   405  	for i := 0; i < nodeCount-1; i++ {
   406  		peerId := i + 1
   407  		if i == nodeCount-1 {
   408  			peerId = 0
   409  		}
   410  		if err := client.ConnectNode(nodeIDs[i], nodeIDs[peerId]); err != nil {
   411  			t.Fatalf("error connecting nodes: %s", err)
   412  		}
   413  	}
   414  
   415  	return nodeIDs
   416  }
   417  
   418  type expectEvents struct {
   419  	*testing.T
   420  
   421  	events chan *Event
   422  	sub    event.Subscription
   423  }
   424  
   425  func (t *expectEvents) nodeEvent(id string, up bool) *Event {
   426  	config := &adapters.NodeConfig{ID: enode.HexID(id)}
   427  	return &Event{Type: EventTypeNode, Node: newNode(nil, config, up)}
   428  }
   429  
   430  func (t *expectEvents) connEvent(one, other string, up bool) *Event {
   431  	return &Event{
   432  		Type: EventTypeConn,
   433  		Conn: &Conn{
   434  			One:   enode.HexID(one),
   435  			Other: enode.HexID(other),
   436  			Up:    up,
   437  		},
   438  	}
   439  }
   440  
   441  func (t *expectEvents) expectMsgs(expected map[MsgFilter]int) {
   442  	actual := make(map[MsgFilter]int)
   443  	timeout := time.After(10 * time.Second)
   444  loop:
   445  	for {
   446  		select {
   447  		case event := <-t.events:
   448  			t.Logf("received %s event: %v", event.Type, event)
   449  
   450  			if event.Type != EventTypeMsg || event.Msg.Received {
   451  				continue loop
   452  			}
   453  			if event.Msg == nil {
   454  				t.Fatal("expected event.Msg to be set")
   455  			}
   456  			filter := MsgFilter{
   457  				Proto: event.Msg.Protocol,
   458  				Code:  int64(event.Msg.Code),
   459  			}
   460  			actual[filter]++
   461  			if actual[filter] > expected[filter] {
   462  				t.Fatalf("received too many msgs for filter: %v", filter)
   463  			}
   464  			if reflect.DeepEqual(actual, expected) {
   465  				return
   466  			}
   467  
   468  		case err := <-t.sub.Err():
   469  			t.Fatalf("network stream closed unexpectedly: %s", err)
   470  
   471  		case <-timeout:
   472  			t.Fatal("timed out waiting for expected events")
   473  		}
   474  	}
   475  }
   476  
   477  func (t *expectEvents) expect(events ...*Event) {
   478  	t.Helper()
   479  	timeout := time.After(10 * time.Second)
   480  	i := 0
   481  	for {
   482  		select {
   483  		case event := <-t.events:
   484  			t.Logf("received %s event: %v", event.Type, event)
   485  
   486  			expected := events[i]
   487  			if event.Type != expected.Type {
   488  				t.Fatalf("expected event %d to have type %q, got %q", i, expected.Type, event.Type)
   489  			}
   490  
   491  			switch expected.Type {
   492  			case EventTypeNode:
   493  				if event.Node == nil {
   494  					t.Fatal("expected event.Node to be set")
   495  				}
   496  				if event.Node.ID() != expected.Node.ID() {
   497  					t.Fatalf("expected node event %d to have id %q, got %q", i, expected.Node.ID().TerminalString(), event.Node.ID().TerminalString())
   498  				}
   499  				if event.Node.Up() != expected.Node.Up() {
   500  					t.Fatalf("expected node event %d to have up=%t, got up=%t", i, expected.Node.Up(), event.Node.Up())
   501  				}
   502  
   503  			case EventTypeConn:
   504  				if event.Conn == nil {
   505  					t.Fatal("expected event.Conn to be set")
   506  				}
   507  				if event.Conn.One != expected.Conn.One {
   508  					t.Fatalf("expected conn event %d to have one=%q, got one=%q", i, expected.Conn.One.TerminalString(), event.Conn.One.TerminalString())
   509  				}
   510  				if event.Conn.Other != expected.Conn.Other {
   511  					t.Fatalf("expected conn event %d to have other=%q, got other=%q", i, expected.Conn.Other.TerminalString(), event.Conn.Other.TerminalString())
   512  				}
   513  				if event.Conn.Up != expected.Conn.Up {
   514  					t.Fatalf("expected conn event %d to have up=%t, got up=%t", i, expected.Conn.Up, event.Conn.Up)
   515  				}
   516  			}
   517  
   518  			i++
   519  			if i == len(events) {
   520  				return
   521  			}
   522  
   523  		case err := <-t.sub.Err():
   524  			t.Fatalf("network stream closed unexpectedly: %s", err)
   525  
   526  		case <-timeout:
   527  			t.Fatal("timed out waiting for expected events")
   528  		}
   529  	}
   530  }
   531  
   532  // TestHTTPNodeRPC tests calling RPC methods on nodes via the HTTP API
   533  func TestHTTPNodeRPC(t *testing.T) {
   534  	// start the server
   535  	_, s := testHTTPServer(t)
   536  	defer s.Close()
   537  
   538  	// start a node in the network
   539  	client := NewClient(s.URL)
   540  
   541  	config := adapters.RandomNodeConfig()
   542  	node, err := client.CreateNode(config)
   543  	if err != nil {
   544  		t.Fatalf("error creating node: %s", err)
   545  	}
   546  	if err := client.StartNode(node.ID); err != nil {
   547  		t.Fatalf("error starting node: %s", err)
   548  	}
   549  
   550  	// create two RPC clients
   551  	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
   552  	defer cancel()
   553  	rpcClient1, err := client.RPCClient(ctx, node.ID)
   554  	if err != nil {
   555  		t.Fatalf("error getting node RPC client: %s", err)
   556  	}
   557  	rpcClient2, err := client.RPCClient(ctx, node.ID)
   558  	if err != nil {
   559  		t.Fatalf("error getting node RPC client: %s", err)
   560  	}
   561  
   562  	// subscribe to events using client 1
   563  	events := make(chan int64, 1)
   564  	sub, err := rpcClient1.Subscribe(ctx, "test", events, "events")
   565  	if err != nil {
   566  		t.Fatalf("error subscribing to events: %s", err)
   567  	}
   568  	defer sub.Unsubscribe()
   569  
   570  	// call some RPC methods using client 2
   571  	if err := rpcClient2.CallContext(ctx, nil, "test_add", 10); err != nil {
   572  		t.Fatalf("error calling RPC method: %s", err)
   573  	}
   574  	var result int64
   575  	if err := rpcClient2.CallContext(ctx, &result, "test_get"); err != nil {
   576  		t.Fatalf("error calling RPC method: %s", err)
   577  	}
   578  	if result != 10 {
   579  		t.Fatalf("expected result to be 10, got %d", result)
   580  	}
   581  
   582  	// check we got an event from client 1
   583  	select {
   584  	case event := <-events:
   585  		if event != 10 {
   586  			t.Fatalf("expected event to be 10, got %d", event)
   587  		}
   588  	case <-ctx.Done():
   589  		t.Fatal(ctx.Err())
   590  	}
   591  }
   592  
   593  // TestHTTPSnapshot tests creating and loading network snapshots
   594  func TestHTTPSnapshot(t *testing.T) {
   595  	// start the server
   596  	network, s := testHTTPServer(t)
   597  	defer s.Close()
   598  
   599  	var eventsDone = make(chan struct{})
   600  	count := 1
   601  	eventsDoneChan := make(chan *Event)
   602  	eventSub := network.Events().Subscribe(eventsDoneChan)
   603  	go func() {
   604  		defer eventSub.Unsubscribe()
   605  		for event := range eventsDoneChan {
   606  			if event.Type == EventTypeConn && !event.Control {
   607  				count--
   608  				if count == 0 {
   609  					eventsDone <- struct{}{}
   610  					return
   611  				}
   612  			}
   613  		}
   614  	}()
   615  
   616  	// create a two-node network
   617  	client := NewClient(s.URL)
   618  	nodeCount := 2
   619  	nodes := make([]*p2p.NodeInfo, nodeCount)
   620  	for i := 0; i < nodeCount; i++ {
   621  		config := adapters.RandomNodeConfig()
   622  		node, err := client.CreateNode(config)
   623  		if err != nil {
   624  			t.Fatalf("error creating node: %s", err)
   625  		}
   626  		if err := client.StartNode(node.ID); err != nil {
   627  			t.Fatalf("error starting node: %s", err)
   628  		}
   629  		nodes[i] = node
   630  	}
   631  	if err := client.ConnectNode(nodes[0].ID, nodes[1].ID); err != nil {
   632  		t.Fatalf("error connecting nodes: %s", err)
   633  	}
   634  
   635  	// store some state in the test services
   636  	states := make([]string, nodeCount)
   637  	for i, node := range nodes {
   638  		rpc, err := client.RPCClient(context.Background(), node.ID)
   639  		if err != nil {
   640  			t.Fatalf("error getting RPC client: %s", err)
   641  		}
   642  		defer rpc.Close()
   643  		state := fmt.Sprintf("%x", rand.Int())
   644  		if err := rpc.Call(nil, "test_setState", []byte(state)); err != nil {
   645  			t.Fatalf("error setting service state: %s", err)
   646  		}
   647  		states[i] = state
   648  	}
   649  	<-eventsDone
   650  	// create a snapshot
   651  	snap, err := client.CreateSnapshot()
   652  	if err != nil {
   653  		t.Fatalf("error creating snapshot: %s", err)
   654  	}
   655  	for i, state := range states {
   656  		gotState := snap.Nodes[i].Snapshots["test"]
   657  		if string(gotState) != state {
   658  			t.Fatalf("expected snapshot state %q, got %q", state, gotState)
   659  		}
   660  	}
   661  
   662  	// create another network
   663  	network2, s := testHTTPServer(t)
   664  	defer s.Close()
   665  	client = NewClient(s.URL)
   666  	count = 1
   667  	eventSub = network2.Events().Subscribe(eventsDoneChan)
   668  	go func() {
   669  		defer eventSub.Unsubscribe()
   670  		for event := range eventsDoneChan {
   671  			if event.Type == EventTypeConn && !event.Control {
   672  				count--
   673  				if count == 0 {
   674  					eventsDone <- struct{}{}
   675  					return
   676  				}
   677  			}
   678  		}
   679  	}()
   680  
   681  	// subscribe to events so we can check them later
   682  	events := make(chan *Event, 100)
   683  	var opts SubscribeOpts
   684  	sub, err := client.SubscribeNetwork(events, opts)
   685  	if err != nil {
   686  		t.Fatalf("error subscribing to network events: %s", err)
   687  	}
   688  	defer sub.Unsubscribe()
   689  
   690  	// load the snapshot
   691  	if err := client.LoadSnapshot(snap); err != nil {
   692  		t.Fatalf("error loading snapshot: %s", err)
   693  	}
   694  	<-eventsDone
   695  
   696  	// check the nodes and connection exists
   697  	net, err := client.GetNetwork()
   698  	if err != nil {
   699  		t.Fatalf("error getting network: %s", err)
   700  	}
   701  	if len(net.Nodes) != nodeCount {
   702  		t.Fatalf("expected network to have %d nodes, got %d", nodeCount, len(net.Nodes))
   703  	}
   704  	for i, node := range nodes {
   705  		id := net.Nodes[i].ID().String()
   706  		if id != node.ID {
   707  			t.Fatalf("expected node %d to have ID %s, got %s", i, node.ID, id)
   708  		}
   709  	}
   710  	if len(net.Conns) != 1 {
   711  		t.Fatalf("expected network to have 1 connection, got %d", len(net.Conns))
   712  	}
   713  	conn := net.Conns[0]
   714  	if conn.One.String() != nodes[0].ID {
   715  		t.Fatalf("expected connection to have one=%q, got one=%q", nodes[0].ID, conn.One)
   716  	}
   717  	if conn.Other.String() != nodes[1].ID {
   718  		t.Fatalf("expected connection to have other=%q, got other=%q", nodes[1].ID, conn.Other)
   719  	}
   720  	if !conn.Up {
   721  		t.Fatal("should be up")
   722  	}
   723  
   724  	// check the node states were restored
   725  	for i, node := range nodes {
   726  		rpc, err := client.RPCClient(context.Background(), node.ID)
   727  		if err != nil {
   728  			t.Fatalf("error getting RPC client: %s", err)
   729  		}
   730  		defer rpc.Close()
   731  		var state []byte
   732  		if err := rpc.Call(&state, "test_getState"); err != nil {
   733  			t.Fatalf("error getting service state: %s", err)
   734  		}
   735  		if string(state) != states[i] {
   736  			t.Fatalf("expected snapshot state %q, got %q", states[i], state)
   737  		}
   738  	}
   739  
   740  	// check we got all the events
   741  	x := &expectEvents{t, events, sub}
   742  	x.expect(
   743  		x.nodeEvent(nodes[0].ID, false),
   744  		x.nodeEvent(nodes[0].ID, true),
   745  		x.nodeEvent(nodes[1].ID, false),
   746  		x.nodeEvent(nodes[1].ID, true),
   747  		x.connEvent(nodes[0].ID, nodes[1].ID, false),
   748  		x.connEvent(nodes[0].ID, nodes[1].ID, true),
   749  	)
   750  }
   751  
   752  // TestMsgFilterPassMultiple tests streaming message events using a filter
   753  // with multiple protocols
   754  func TestMsgFilterPassMultiple(t *testing.T) {
   755  	// start the server
   756  	_, s := testHTTPServer(t)
   757  	defer s.Close()
   758  
   759  	// subscribe to events with a message filter
   760  	client := NewClient(s.URL)
   761  	events := make(chan *Event, 10)
   762  	opts := SubscribeOpts{
   763  		Filter: "prb:0-test:0",
   764  	}
   765  	sub, err := client.SubscribeNetwork(events, opts)
   766  	if err != nil {
   767  		t.Fatalf("error subscribing to network events: %s", err)
   768  	}
   769  	defer sub.Unsubscribe()
   770  
   771  	// start a simulation network
   772  	startTestNetwork(t, client)
   773  
   774  	// check we got the expected events
   775  	x := &expectEvents{t, events, sub}
   776  	x.expectMsgs(map[MsgFilter]int{
   777  		{"test", 0}: 2,
   778  		{"prb", 0}:  2,
   779  	})
   780  }
   781  
   782  // TestMsgFilterPassWildcard tests streaming message events using a filter
   783  // with a code wildcard
   784  func TestMsgFilterPassWildcard(t *testing.T) {
   785  	// start the server
   786  	_, s := testHTTPServer(t)
   787  	defer s.Close()
   788  
   789  	// subscribe to events with a message filter
   790  	client := NewClient(s.URL)
   791  	events := make(chan *Event, 10)
   792  	opts := SubscribeOpts{
   793  		Filter: "prb:0,2-test:*",
   794  	}
   795  	sub, err := client.SubscribeNetwork(events, opts)
   796  	if err != nil {
   797  		t.Fatalf("error subscribing to network events: %s", err)
   798  	}
   799  	defer sub.Unsubscribe()
   800  
   801  	// start a simulation network
   802  	startTestNetwork(t, client)
   803  
   804  	// check we got the expected events
   805  	x := &expectEvents{t, events, sub}
   806  	x.expectMsgs(map[MsgFilter]int{
   807  		{"test", 2}: 2,
   808  		{"test", 1}: 2,
   809  		{"test", 0}: 2,
   810  		{"prb", 0}:  2,
   811  	})
   812  }
   813  
   814  // TestMsgFilterPassSingle tests streaming message events using a filter
   815  // with a single protocol and code
   816  func TestMsgFilterPassSingle(t *testing.T) {
   817  	// start the server
   818  	_, s := testHTTPServer(t)
   819  	defer s.Close()
   820  
   821  	// subscribe to events with a message filter
   822  	client := NewClient(s.URL)
   823  	events := make(chan *Event, 10)
   824  	opts := SubscribeOpts{
   825  		Filter: "dum:0",
   826  	}
   827  	sub, err := client.SubscribeNetwork(events, opts)
   828  	if err != nil {
   829  		t.Fatalf("error subscribing to network events: %s", err)
   830  	}
   831  	defer sub.Unsubscribe()
   832  
   833  	// start a simulation network
   834  	startTestNetwork(t, client)
   835  
   836  	// check we got the expected events
   837  	x := &expectEvents{t, events, sub}
   838  	x.expectMsgs(map[MsgFilter]int{
   839  		{"dum", 0}: 2,
   840  	})
   841  }
   842  
   843  // TestMsgFilterPassSingle tests streaming message events using an invalid
   844  // filter
   845  func TestMsgFilterFailBadParams(t *testing.T) {
   846  	// start the server
   847  	_, s := testHTTPServer(t)
   848  	defer s.Close()
   849  
   850  	client := NewClient(s.URL)
   851  	events := make(chan *Event, 10)
   852  	opts := SubscribeOpts{
   853  		Filter: "foo:",
   854  	}
   855  	_, err := client.SubscribeNetwork(events, opts)
   856  	if err == nil {
   857  		t.Fatalf("expected event subscription to fail but succeeded!")
   858  	}
   859  
   860  	opts.Filter = "bzz:aa"
   861  	_, err = client.SubscribeNetwork(events, opts)
   862  	if err == nil {
   863  		t.Fatalf("expected event subscription to fail but succeeded!")
   864  	}
   865  
   866  	opts.Filter = "invalid"
   867  	_, err = client.SubscribeNetwork(events, opts)
   868  	if err == nil {
   869  		t.Fatalf("expected event subscription to fail but succeeded!")
   870  	}
   871  }