go.dedis.ch/onet/v3@v3.2.11-0.20210930124529-e36530bca7ef/local_test.go (about)

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