func TestClient_Send(t *testing.T) { local := sda.NewLocalTest() defer local.CloseAll() // register service sda.RegisterNewService("BackForth", func(c *sda.Context, path string) sda.Service { return &simpleService{ ctx: c, } }) // create hosts hosts, el, _ := local.GenTree(4, true, true, false) client := sda.NewClient("BackForth") r := &simpleRequest{ ServerIdentities: el, Val: 10, } nm, err := client.Send(hosts[0].ServerIdentity, r) log.ErrFatal(err) assert.Equal(t, nm.MsgType, simpleResponseType) resp := nm.Msg.(simpleResponse) assert.Equal(t, resp.Val, 10) }
func TestServiceProtocolProcessMessage(t *testing.T) { ds := &DummyService{ link: make(chan bool), } var count int sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { if count == 0 { count++ // the client does not need a Service return &DummyService{link: make(chan bool)} } ds.c = c ds.path = path ds.Config = DummyConfig{ Send: true, } return ds }) // fake a client h2 := sda.NewLocalHost(2010) defer h2.Close() host := sda.NewLocalHost(2000) host.ListenAndBind() host.StartProcessMessages() log.Lvl1("Host created and listening") defer host.Close() // create the entityList and tree el := sda.NewRoster([]*network.ServerIdentity{host.ServerIdentity}) tree := el.GenerateBinaryTree() // give it to the service ds.fakeTree = tree // Send a request to the service b, err := network.MarshalRegisteredType(&DummyMsg{10}) log.ErrFatal(err) re := &sda.ClientRequest{ Service: sda.ServiceFactory.ServiceID("DummyService"), Data: b, } log.Lvl1("Client connecting to host") if _, err := h2.Connect(host.ServerIdentity); err != nil { t.Fatal(err) } log.Lvl1("Sending request to service...") if err := h2.SendRaw(host.ServerIdentity, re); err != nil { t.Fatal(err) } // wait for the link from the protocol waitOrFatalValue(ds.link, true, t) // now wait for the same link as the protocol should have sent a message to // himself ! waitOrFatalValue(ds.link, true, t) }
// Test if a request that makes the service create a new protocol works func TestServiceRequestNewProtocol(t *testing.T) { ds := &DummyService{ link: make(chan bool), } sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { ds.c = c ds.path = path return ds }) host := sda.NewLocalHost(2000) host.Listen() host.StartProcessMessages() log.Lvl1("Host created and listening") defer host.Close() // create the entityList and tree el := sda.NewRoster([]*network.ServerIdentity{host.ServerIdentity}) tree := el.GenerateBinaryTree() // give it to the service ds.fakeTree = tree // Send a request to the service b, err := network.MarshalRegisteredType(&DummyMsg{10}) log.ErrFatal(err) re := &sda.ClientRequest{ Service: sda.ServiceFactory.ServiceID("DummyService"), Data: b, } // fake a client h2 := sda.NewLocalHost(2010) defer h2.Close() log.Lvl1("Client connecting to host") if _, err := h2.Connect(host.ServerIdentity); err != nil { t.Fatal(err) } log.Lvl1("Sending request to service...") if err := h2.SendRaw(host.ServerIdentity, re); err != nil { t.Fatal(err) } // wait for the link from the waitOrFatalValue(ds.link, true, t) // Now RESEND the value so we instantiate using the SAME TREENODE log.Lvl1("Sending request AGAIN to service...") if err := h2.SendRaw(host.ServerIdentity, re); err != nil { t.Fatal(err) } // wait for the link from the // NOW expect false waitOrFatalValue(ds.link, false, t) }
func TestServiceNew(t *testing.T) { ds := &DummyService{ link: make(chan bool), } sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { ds.c = c ds.path = path ds.link <- true return ds }) go func() { h := sda.NewLocalHost(2000) h.Close() }() waitOrFatal(ds.link, t) }
func TestServiceProcessServiceMessage(t *testing.T) { ds1 := &DummyService{ link: make(chan bool), } ds2 := &DummyService{ link: make(chan bool), } var count int sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { var s *DummyService if count == 0 { s = ds1 } else { s = ds2 } s.c = c s.path = path return s }) // create two hosts h2 := sda.NewLocalHost(2010) defer h2.Close() h1 := sda.NewLocalHost(2000) h1.ListenAndBind() h1.StartProcessMessages() defer h1.Close() log.Lvl1("Host created and listening") // connect themselves log.Lvl1("Client connecting to host") if _, err := h2.Connect(h1.ServerIdentity); err != nil { t.Fatal(err) } // create request m, err := sda.CreateServiceMessage("DummyService", &DummyMsg{10}) assert.Nil(t, err) log.Lvl1("Sending request to service...") assert.Nil(t, h2.SendRaw(h1.ServerIdentity, m)) // wait for the link from the Service on host 1 waitOrFatalValue(ds1.link, true, t) }
func TestServiceProcessRequest(t *testing.T) { ds := &DummyService{ link: make(chan bool), } sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { ds.c = c ds.path = path return ds }) host := sda.NewLocalHost(2000) host.Listen() host.StartProcessMessages() log.Lvl1("Host created and listening") defer host.Close() // Send a request to the service re := &sda.ClientRequest{ Service: sda.ServiceFactory.ServiceID("DummyService"), Data: []byte("a"), } // fake a client h2 := sda.NewLocalHost(2010) defer h2.Close() log.Lvl1("Client connecting to host") if _, err := h2.Connect(host.ServerIdentity); err != nil { t.Fatal(err) } log.Lvl1("Sending request to service...") if err := h2.SendRaw(host.ServerIdentity, re); err != nil { t.Fatal(err) } // wait for the link select { case v := <-ds.link: if v { t.Fatal("was expecting false !") } case <-time.After(100 * time.Millisecond): t.Fatal("Too late") } }
func TestServiceBackForthProtocol(t *testing.T) { local := sda.NewLocalTest() defer local.CloseAll() // register service sda.RegisterNewService("BackForth", func(c *sda.Context, path string) sda.Service { return &simpleService{ ctx: c, } }) // create hosts hosts, el, _ := local.GenTree(4, true, true, false) // create client priv, pub := sda.PrivPub() client := network.NewSecureTCPHost(priv, network.NewServerIdentity(pub, "")) c, err := client.Open(hosts[0].ServerIdentity) assert.Nil(t, err) // create request r := &simpleRequest{ ServerIdentities: el, Val: 10, } buff, err := network.MarshalRegisteredType(r) assert.Nil(t, err) req := &sda.ClientRequest{ Service: sda.ServiceFactory.ServiceID("BackForth"), Data: buff, } assert.Nil(t, c.Send(context.TODO(), req)) nm, err := c.Receive(context.TODO()) assert.Nil(t, err) assert.Equal(t, nm.MsgType, simpleResponseType) resp := nm.Msg.(simpleResponse) assert.Equal(t, resp.Val, 10) }
func TestServiceChannels(t *testing.T) { defer log.AfterTest(t) sc1 := &ServiceChannels{} sc2 := &ServiceChannels{} var count int sda.RegisterNewService("ChannelsService", func(c *sda.Context, path string) sda.Service { var sc *ServiceChannels if count == 0 { sc = sc1 } else { sc = sc2 } count++ sc.ctx = c sc.path = path return sc }) h1, h2 := SetupTwoHosts(t, true) defer h1.Close() defer h2.Close() // Add tree + entitylist el := sda.NewRoster([]*network.ServerIdentity{h1.ServerIdentity, h2.ServerIdentity}) tree := el.GenerateBinaryTree() sc1.tree = *tree h1.AddRoster(el) h1.AddTree(tree) h1.StartProcessMessages() sc1.ProcessClientRequest(nil, nil) select { case msg := <-Incoming: if msg.I != 12 { t.Fatal("Child should receive 12") } case <-time.After(time.Second * 3): t.Fatal("Timeout") } }
func TestClient_Parallel(t *testing.T) { nbrNodes := 2 nbrParallel := 2 local := sda.NewLocalTest() defer local.CloseAll() // register service sda.RegisterNewService("BackForth", func(c *sda.Context, path string) sda.Service { return &simpleService{ ctx: c, } }) // create hosts hosts, el, _ := local.GenTree(nbrNodes, true, true, false) wg := sync.WaitGroup{} wg.Add(nbrParallel) for i := 0; i < nbrParallel; i++ { go func(i int) { log.Lvl1("Starting message", i) r := &simpleRequest{ ServerIdentities: el, Val: 10 * i, } client := sda.NewClient("BackForth") nm, err := client.Send(hosts[0].ServerIdentity, r) log.ErrFatal(err) assert.Equal(t, nm.MsgType, simpleResponseType) resp := nm.Msg.(simpleResponse) assert.Equal(t, resp.Val, 10*i) log.Lvl1("Done with message", i) wg.Done() }(i) } wg.Wait() }
// test for calling the NewProtocol method on a remote Service func TestServiceNewProtocol(t *testing.T) { ds1 := &DummyService{ link: make(chan bool), Config: DummyConfig{ Send: true, }, } ds2 := &DummyService{ link: make(chan bool), } var count int sda.RegisterNewService("DummyService", func(c *sda.Context, path string) sda.Service { var localDs *DummyService switch count { case 2: // the client does not need a Service return &DummyService{link: make(chan bool)} case 1: // children localDs = ds2 case 0: // root localDs = ds1 } localDs.c = c localDs.path = path count++ return localDs }) host := sda.NewLocalHost(2000) host.ListenAndBind() host.StartProcessMessages() log.Lvl1("Host created and listening") defer host.Close() host2 := sda.NewLocalHost(2002) host2.ListenAndBind() host2.StartProcessMessages() defer host2.Close() // create the entityList and tree el := sda.NewRoster([]*network.ServerIdentity{host.ServerIdentity, host2.ServerIdentity}) tree := el.GenerateBinaryTree() // give it to the service ds1.fakeTree = tree // Send a request to the service b, err := network.MarshalRegisteredType(&DummyMsg{10}) log.ErrFatal(err) re := &sda.ClientRequest{ Service: sda.ServiceFactory.ServiceID("DummyService"), Data: b, } // fake a client client := sda.NewLocalHost(2010) defer client.Close() log.Lvl1("Client connecting to host") if _, err := client.Connect(host.ServerIdentity); err != nil { t.Fatal(err) } log.Lvl1("Sending request to service...") if err := client.SendRaw(host.ServerIdentity, re); err != nil { t.Fatal(err) } // wait for the link from the protocol that Starts waitOrFatalValue(ds1.link, true, t) // now wait for the same link as the protocol should have sent a message to // himself ! waitOrFatalValue(ds1.link, true, t) // now wait for the SECOND LINK on the SECOND HOST that the SECOND SERVICE // should have started (ds2) in ProcessRequest waitOrFatalValue(ds2.link, true, t) }