swarm: network simulation for swarm tests (#769)

* cmd/swarm: minor cli flag text adjustments

* cmd/swarm, swarm/storage, swarm: fix  mingw on windows test issues

* cmd/swarm: support for smoke tests on the production swarm cluster

* cmd/swarm/swarm-smoke: simplify cluster logic as per suggestion

* changed colour of landing page

* landing page reacts to enter keypress

* swarm/api/http: sticky footer for swarm landing page using flex

* swarm/api/http: sticky footer for error pages and fix for multiple choices

* swarm: propagate ctx to internal apis (#754)

* swarm/simnet: add basic node/service functions

* swarm/netsim: add buckets for global state and kademlia health check

* swarm/netsim: Use sync.Map as bucket and provide cleanup function for...

* swarm, swarm/netsim: adjust SwarmNetworkTest

* swarm/netsim: fix tests

* swarm: added visualization option to sim net redesign

* swarm/netsim: support multiple services per node

* swarm/netsim: remove redundant return statement

* swarm/netsim: add comments

* swarm: shutdown HTTP in Simulation.Close

* swarm: sim HTTP server timeout

* swarm/netsim: add more simulation methods and peer events examples

* swarm/netsim: add WaitKademlia example

* swarm/netsim: fix comments

* swarm/netsim: terminate peer events goroutines on simulation done

* swarm, swarm/netsim: naming updates

* swarm/netsim: return not healthy kademlias on WaitTillHealthy

* swarm: fix WaitTillHealthy call in testSwarmNetwork

* swarm/netsim: allow bucket to have any type for a key

* swarm: Added snapshots to new netsim

* swarm/netsim: add more tests for bucket

* swarm/netsim: move http related things into separate files

* swarm/netsim: add AddNodeWithService option

* swarm/netsim: add more tests and Start* methods

* swarm/netsim: add peer events and kademlia tests

* swarm/netsim: fix some tests flakiness

* swarm/netsim: improve random nodes selection, fix TestStartStop* tests

* swarm/netsim: remove time measurement from TestClose to avoid flakiness

* swarm/netsim: builder pattern for netsim HTTP server (#773)

* swarm/netsim: add connect related tests

* swarm/netsim: add comment for TestPeerEvents

* swarm: rename netsim package to network/simulation

1 files changed, 207 insertions, 0 deletions

diff --git a/swarm/network/simulation/simulation_test.go b/swarm/network/simulation/simulation_test.go
new file mode 100644
index 000000000..803e0499a
--- /dev/null
+++ b/swarm/network/simulation/simulation_test.go
@@ -0,0 +1,207 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package simulation
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+	"github.com/ethereum/go-ethereum/rpc"
+	colorable "github.com/mattn/go-colorable"
+)
+
+var (
+	loglevel = flag.Int("loglevel", 2, "verbosity of logs")
+)
+
+func init() {
+	flag.Parse()
+	log.PrintOrigins(true)
+	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(true))))
+}
+
+// TestRun tests if Run method calls RunFunc and if it handles context properly.
+func TestRun(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	defer sim.Close()
+
+	t.Run("call", func(t *testing.T) {
+		expect := "something"
+		var got string
+		r := sim.Run(context.Background(), func(ctx context.Context, sim *Simulation) error {
+			got = expect
+			return nil
+		})
+
+		if r.Error != nil {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+		if got != expect {
+			t.Errorf("expected %q, got %q", expect, got)
+		}
+	})
+
+	t.Run("cancelation", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		r := sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+			time.Sleep(100 * time.Millisecond)
+			return nil
+		})
+
+		if r.Error != context.DeadlineExceeded {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+	})
+
+	t.Run("context value and duration", func(t *testing.T) {
+		ctx := context.WithValue(context.Background(), "hey", "there")
+		sleep := 50 * time.Millisecond
+
+		r := sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+			if ctx.Value("hey") != "there" {
+				return errors.New("expected context value not passed")
+			}
+			time.Sleep(sleep)
+			return nil
+		})
+
+		if r.Error != nil {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+		if r.Duration < sleep {
+			t.Errorf("reported run duration less then expected: %s", r.Duration)
+		}
+	})
+}
+
+// TestClose tests are Close method triggers all close functions and are all nodes not up anymore.
+func TestClose(t *testing.T) {
+	var mu sync.Mutex
+	var cleanupCount int
+
+	sleep := 50 * time.Millisecond
+
+	sim := New(map[string]ServiceFunc{
+		"noop": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+			return newNoopService(), func() {
+				time.Sleep(sleep)
+				mu.Lock()
+				defer mu.Unlock()
+				cleanupCount++
+			}, nil
+		},
+	})
+
+	nodeCount := 30
+
+	_, err := sim.AddNodes(nodeCount)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var upNodeCount int
+	for _, n := range sim.Net.GetNodes() {
+		if n.Up {
+			upNodeCount++
+		}
+	}
+	if upNodeCount != nodeCount {
+		t.Errorf("all nodes should be up, insted only %v are up", upNodeCount)
+	}
+
+	sim.Close()
+
+	if cleanupCount != nodeCount {
+		t.Errorf("number of cleanups expected %v, got %v", nodeCount, cleanupCount)
+	}
+
+	upNodeCount = 0
+	for _, n := range sim.Net.GetNodes() {
+		if n.Up {
+			upNodeCount++
+		}
+	}
+	if upNodeCount != 0 {
+		t.Errorf("all nodes should be down, insted %v are up", upNodeCount)
+	}
+}
+
+// TestDone checks if Close method triggers the closing of done channel.
+func TestDone(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	sleep := 50 * time.Millisecond
+	timeout := 2 * time.Second
+
+	start := time.Now()
+	go func() {
+		time.Sleep(sleep)
+		sim.Close()
+	}()
+
+	select {
+	case <-time.After(timeout):
+		t.Error("done channel closing timmed out")
+	case <-sim.Done():
+		if d := time.Since(start); d < sleep {
+			t.Errorf("done channel closed sooner then expected: %s", d)
+		}
+	}
+}
+
+// a helper map for usual services that do not do anyting
+var noopServiceFuncMap = map[string]ServiceFunc{
+	"noop": noopServiceFunc,
+}
+
+// a helper function for most basic noop service
+func noopServiceFunc(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+	return newNoopService(), nil, nil
+}
+
+// noopService is the service that does not do anything
+// but implements node.Service interface.
+type noopService struct{}
+
+func newNoopService() node.Service {
+	return &noopService{}
+}
+
+func (t *noopService) Protocols() []p2p.Protocol {
+	return []p2p.Protocol{}
+}
+
+func (t *noopService) APIs() []rpc.API {
+	return []rpc.API{}
+}
+
+func (t *noopService) Start(server *p2p.Server) error {
+	return nil
+}
+
+func (t *noopService) Stop() error {
+	return nil
+}