gopkg.in/dedis/onet.v2@v2.0.0-20181115163211-c8f3724038a7/local_test.go (about)

     1  package onet
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/stretchr/testify/require"
     8  	"gopkg.in/dedis/kyber.v2/suites"
     9  	"gopkg.in/dedis/onet.v2/log"
    10  	"gopkg.in/dedis/onet.v2/network"
    11  )
    12  
    13  var tSuite = suites.MustFind("Ed25519")
    14  
    15  const clientServiceName = "ClientService"
    16  
    17  var clientServiceID ServiceID
    18  
    19  func init() {
    20  	var err error
    21  	clientServiceID, err = RegisterNewService(clientServiceName, newClientService)
    22  	log.ErrFatal(err)
    23  }
    24  
    25  func Test_panicClose(t *testing.T) {
    26  	l := NewLocalTest(tSuite)
    27  	l.CloseAll()
    28  	require.Panics(t, func() { l.genLocalHosts(2) })
    29  }
    30  
    31  func Test_showPanic(t *testing.T) {
    32  	l := NewLocalTest(tSuite)
    33  	c := make(chan bool)
    34  	go func() {
    35  		<-c
    36  	}()
    37  	defer func() {
    38  		require.NotNil(t, recover())
    39  		c <- true
    40  	}()
    41  	defer l.CloseAll()
    42  	panic("this should be caught")
    43  }
    44  
    45  func Test_showFail(t *testing.T) {
    46  	t.Skip("I have no idea how I can have this test passing... It tests that CloseAll doesn't test goroutines when a test fails.")
    47  	l := NewLocalTest(tSuite)
    48  	c := make(chan bool)
    49  	go func() {
    50  		<-c
    51  	}()
    52  	defer l.CloseAll()
    53  	defer func() {
    54  		if !t.Failed() {
    55  			t.Fail()
    56  		}
    57  		c <- true
    58  	}()
    59  	l.T = t
    60  	require.Nil(t, "not nil")
    61  }
    62  
    63  func TestGenLocalHost(t *testing.T) {
    64  	l := NewLocalTest(tSuite)
    65  	hosts := l.genLocalHosts(2)
    66  	defer l.CloseAll()
    67  
    68  	log.Lvl4("Hosts are:", hosts[0].Address(), hosts[1].Address())
    69  	if hosts[0].Address() == hosts[1].Address() {
    70  		t.Fatal("Both addresses are equal")
    71  	}
    72  }
    73  
    74  func TestGenLocalHostAfter(t *testing.T) {
    75  	l := NewLocalTest(tSuite)
    76  	defer l.CloseAll()
    77  	hosts := l.genLocalHosts(2)
    78  	hosts2 := l.genLocalHosts(2)
    79  	require.NotEqual(t, hosts2[0].Address(), hosts[0].Address())
    80  }
    81  
    82  // This tests the client-connection in the case of a non-garbage-collected
    83  // client that stays in the service.
    84  func TestNewTCPTest(t *testing.T) {
    85  	l := NewTCPTest(tSuite)
    86  	_, el, _ := l.GenTree(3, true)
    87  	defer l.CloseAll()
    88  
    89  	c1 := NewClient(tSuite, clientServiceName)
    90  	err := c1.SendProtobuf(el.List[0], &SimpleMessage{}, nil)
    91  	log.ErrFatal(err)
    92  }
    93  
    94  // Tests whether TestClose is called in the service.
    95  func TestTestClose(t *testing.T) {
    96  	l := NewTCPTest(tSuite)
    97  	servers, _, _ := l.GenTree(1, true)
    98  	services := l.GetServices(servers, clientServiceID)
    99  	pingpong := make(chan bool, 1)
   100  	go func() {
   101  		pingpong <- true
   102  		for _, s := range services {
   103  			<-s.(*clientService).closed
   104  		}
   105  		pingpong <- true
   106  	}()
   107  	// Wait for the go-routine to be started
   108  	<-pingpong
   109  	l.CloseAll()
   110  	// Wait for all services to be clsoed
   111  	<-pingpong
   112  }
   113  
   114  func TestWaitDone(t *testing.T) {
   115  	l := NewTCPTest(tSuite)
   116  	servers, ro, _ := l.GenTree(1, true)
   117  	defer l.CloseAll()
   118  
   119  	services := l.GetServices(servers, clientServiceID)
   120  	service := services[0].(*clientService)
   121  	require.Nil(t, service.SendRaw(ro.List[0], &RawMessage{}))
   122  	<-service.click
   123  	select {
   124  	case <-service.click:
   125  		log.Fatal("service is already done")
   126  	default:
   127  	}
   128  	require.Nil(t, l.WaitDone(5*time.Second))
   129  	select {
   130  	case <-service.click:
   131  	default:
   132  		log.Fatal("service should be done by now")
   133  	}
   134  }
   135  
   136  type clientService struct {
   137  	*ServiceProcessor
   138  	cl     *Client
   139  	click  chan bool
   140  	closed chan bool
   141  }
   142  
   143  type SimpleMessage2 struct{}
   144  
   145  type RawMessage struct{}
   146  
   147  func (c *clientService) SimpleMessage(msg *SimpleMessage) (network.Message, error) {
   148  	log.Lvl3("Got request", msg)
   149  	c.cl.SendProtobuf(c.ServerIdentity(), &SimpleMessage2{}, nil)
   150  	return nil, nil
   151  }
   152  
   153  func (c *clientService) SimpleMessage2(msg *SimpleMessage2) (network.Message, error) {
   154  	log.Lvl3("Got request", msg)
   155  	return nil, nil
   156  }
   157  
   158  func (c *clientService) TestClose() {
   159  	c.closed <- true
   160  }
   161  
   162  func newClientService(c *Context) (Service, error) {
   163  	s := &clientService{
   164  		ServiceProcessor: NewServiceProcessor(c),
   165  		cl:               NewClient(c.server.Suite(), clientServiceName),
   166  		click:            make(chan bool, 1),
   167  		closed:           make(chan bool, 1),
   168  	}
   169  	log.ErrFatal(s.RegisterHandlers(s.SimpleMessage, s.SimpleMessage2))
   170  	s.RegisterProcessorFunc(network.RegisterMessage(RawMessage{}), func(arg1 *network.Envelope) {
   171  		s.click <- true
   172  		time.Sleep(100 * time.Millisecond)
   173  		s.click <- true
   174  	})
   175  
   176  	return s, nil
   177  }