func TestSubscribersIntegration(t *testing.T) { defer testutil.ResetDefaultRegistryHealthCheck() defer testutil.EnableDebugForMethod()() a := assert.New(t) s, cleanup := serviceSetUp(t) defer cleanup() subscribeMultipleClients(t, s, 4) a.Nil(nil) restClient := restclient.New(fmt.Sprintf("http://%s/api", s.WebServer().GetAddr())) content, err := restClient.GetSubscribers(testTopic) a.NoError(err) routeParams := make([]*Subscriber, 0) err = json.Unmarshal(content, &routeParams) a.Equal(4, len(routeParams), "Should have 4 subscribers") for i, rp := range routeParams { a.Equal(fmt.Sprintf("gcmId%d", i), rp.DeviceToken) a.Equal(fmt.Sprintf("user%d", i), rp.UserID) } a.NoError(err) }
func TestGCMConnector_Check(t *testing.T) { ctrl, finish := testutil.NewMockCtrl(t) defer finish() testutil.EnableDebugForMethod() assert := assert.New(t) routerMock := NewMockRouter(ctrl) routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(route *server.Route) { assert.Equal("/gcm/broadcast", string(route.Path)) assert.Equal("gcm_connector", route.UserID) assert.Equal("gcm_connector", route.ApplicationID) }) kvStore := store.NewMemoryKVStore() routerMock.EXPECT().KVStore().Return(kvStore, nil) gcm, err := NewGCMConnector(routerMock, "/gcm/", "testApi", 1) assert.Nil(err) err = gcm.Start() assert.Nil(err) done := make(chan bool, 1) mockSender := testutil.CreateGcmSender(testutil.CreateRoundTripperWithJsonResponse(http.StatusOK, testutil.CorrectGcmResponseMessageJSON, done)) gcm.Sender = mockSender err = gcm.Check() fmt.Println(err) done2 := make(chan bool, 1) mockSender2 := testutil.CreateGcmSender(testutil.CreateRoundTripperWithJsonResponse(http.StatusUnauthorized, "", done2)) gcm.Sender = mockSender2 err = gcm.Check() fmt.Println(err) }
func TestReadLastID(t *testing.T) { ctrl, finish := testutil.NewMockCtrl(t) defer finish() defer testutil.EnableDebugForMethod()() a := assert.New(t) mockSmsSender := NewMockSender(ctrl) kvStore := kvstore.NewMemoryKVStore() a.NotNil(kvStore) routerMock := NewMockRouter(testutil.MockCtrl) routerMock.EXPECT().KVStore().AnyTimes().Return(kvStore, nil) msgStore := dummystore.New(kvStore) routerMock.EXPECT().MessageStore().AnyTimes().Return(msgStore, nil) topic := "/sms" worker := 1 config := Config{ Workers: &worker, SMSTopic: &topic, Name: "test_gateway", Schema: SMSSchema, } gw, err := New(routerMock, mockSmsSender, config) a.NoError(err) gw.SetLastSentID(uint64(10)) gw.ReadLastID() a.Equal(uint64(10), gw.LastIDSent) }
func TestCluster_BroadcastStringAndMessageAndCheck(t *testing.T) { defer testutil.EnableDebugForMethod() a := assert.New(t) config1 := testConfig() node1, err := New(&config1) a.NoError(err, "No error should be raised when Creating the Cluster") node1.MessageHandler = DummyMessageHandler{} //start the cluster node 1 defer node1.Stop() err = node1.Start() a.NoError(err, "No error should be raised when starting node 1 of the Cluster") config2 := testConfigAnother() node2, err := New(&config2) a.NoError(err, "No error should be raised when Creating the Cluster") node2.MessageHandler = DummyMessageHandler{} //start the cluster node 2 defer node2.Stop() err = node2.Start() a.NoError(err, "No error should be raised when starting node 2 of the Cluster") // Send a String Message str := "TEST" err = node1.BroadcastString(&str) a.NoError(err, "No error should be raised when sending a string to Cluster") // and a protocol message pmsg := protocol.Message{ ID: 1, Path: "/stuff", UserID: "id", ApplicationID: "appId", Time: time.Now().Unix(), HeaderJSON: "{}", Body: []byte("test"), NodeID: 1} err = node1.BroadcastMessage(&pmsg) a.NoError(err, "No error should be raised when sending a protocol message to Cluster") err = node1.Check() a.NoError(err, "Health-check score of a Cluster with 2 nodes should be OK for node 1") err = node2.Check() a.NoError(err, "Health-check score of a Cluster with 2 nodes should be OK for node 2") }
// Server should return an 405 Method Not Allowed in case method request is not POST func TestServeHTTP_GetError(t *testing.T) { a := assert.New(t) defer testutil.EnableDebugForMethod()() api := NewRestMessageAPI(nil, "/api") url, _ := url.Parse("http://localhost/api/message/my/topic?userId=marvin&messageId=42") // and a http context req := &http.Request{ Method: http.MethodGet, URL: url, Body: ioutil.NopCloser(bytes.NewReader(testBytes)), Header: http.Header{}, } w := &httptest.ResponseRecorder{} // when: I POST a message api.ServeHTTP(w, req) a.Equal(http.StatusNotFound, w.Code) }
func Test_SendOneSms(t *testing.T) { ctrl, finish := testutil.NewMockCtrl(t) defer finish() defer testutil.EnableDebugForMethod()() a := assert.New(t) mockSmsSender := NewMockSender(ctrl) kvStore := kvstore.NewMemoryKVStore() a.NotNil(kvStore) routerMock := NewMockRouter(testutil.MockCtrl) routerMock.EXPECT().KVStore().AnyTimes().Return(kvStore, nil) msgStore := dummystore.New(kvStore) routerMock.EXPECT().MessageStore().AnyTimes().Return(msgStore, nil) topic := "/sms" worker := 1 config := Config{ Workers: &worker, SMSTopic: &topic, Name: "test_gateway", Schema: SMSSchema, } routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(r *router.Route) (*router.Route, error) { a.Equal(topic, string(r.Path)) return r, nil }) gw, err := New(routerMock, mockSmsSender, config) a.NoError(err) err = gw.Start() a.NoError(err) sms := NexmoSms{ To: "toNumber", From: "FromNUmber", Text: "body", } d, err := json.Marshal(&sms) a.NoError(err) msg := protocol.Message{ Path: protocol.Path(topic), ID: uint64(4), Body: d, } mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Return(nil) a.NotNil(gw.route) gw.route.Deliver(&msg) time.Sleep(100 * time.Millisecond) err = gw.Stop() a.NoError(err) err = gw.ReadLastID() a.NoError(err) time.Sleep(100 * time.Millisecond) }
func Test_Restart(t *testing.T) { ctrl, finish := testutil.NewMockCtrl(t) defer finish() defer testutil.EnableDebugForMethod()() a := assert.New(t) mockSmsSender := NewMockSender(ctrl) kvStore := kvstore.NewMemoryKVStore() a.NotNil(kvStore) routerMock := NewMockRouter(testutil.MockCtrl) routerMock.EXPECT().KVStore().AnyTimes().Return(kvStore, nil) msgStore := NewMockMessageStore(ctrl) routerMock.EXPECT().MessageStore().AnyTimes().Return(msgStore, nil) topic := "/sms" worker := 1 config := Config{ Workers: &worker, SMSTopic: &topic, Name: "test_gateway", Schema: SMSSchema, } routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(r *router.Route) (*router.Route, error) { a.Equal(strings.Split(topic, "/")[1], r.Path.Partition()) return r, nil }).Times(2) gw, err := New(routerMock, mockSmsSender, config) a.NoError(err) err = gw.Start() a.NoError(err) sms := NexmoSms{ To: "toNumber", From: "FromNUmber", Text: "body", } d, err := json.Marshal(&sms) a.NoError(err) msg := protocol.Message{ Path: protocol.Path(topic), UserID: "samsa", ApplicationID: "sms", ID: uint64(4), Body: d, } //TODO MARIAN FIX THIS TEST //msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(0), nil) //msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(4), nil) //msgStore.EXPECT().MaxMessageID(gomock.Eq(gw.route.Path.Partition())).Return(uint64(4), nil) mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Times(1).Return(ErrNoSMSSent) //routerMock.EXPECT().Fetch(gomock.Any()).Do(func(r *store.FetchRequest) { // go func() { // // logger.WithField("r.Partition", r.Partition).Info("----") // // a.Equal(strings.Split(topic, "/")[1], r.Partition) // // r.StartC <- 1 // // r.MessageC <- &store.FetchedMessage{ID: uint64(4), Message: msg.Bytes()} // close(r.MessageC) // }() //}) doneC := make(chan bool) routerMock.EXPECT().Done().AnyTimes().Return(doneC) // //mockSmsSender.EXPECT().Send(gomock.Eq(&msg)).Return(nil) a.NotNil(gw.route) gw.route.Deliver(&msg) time.Sleep(100 * time.Millisecond) }
// Test synchronizing messages when a new node is func TestSynchronizerIntegration(t *testing.T) { testutil.SkipIfShort(t) defer testutil.EnableDebugForMethod()() a := assert.New(t) node1 := newTestClusterNode(t, testClusterNodeConfig{ HttpListen: "localhost:8094", NodeID: 1, NodePort: 11004, Remotes: "localhost:11004", }) a.NotNil(node1) defer node1.cleanup(true) time.Sleep(2 * time.Second) client1, err := node1.client("client1", 10, true) a.NoError(err) client1.Send(syncTopic, "nobody", "") client1.Send(syncTopic, "nobody", "") client1.Send(syncTopic, "nobody", "") time.Sleep(2 * time.Second) node2 := newTestClusterNode(t, testClusterNodeConfig{ HttpListen: "localhost:8095", NodeID: 2, NodePort: 11005, Remotes: "localhost:11004", }) a.NotNil(node2) defer node2.cleanup(true) client2, err := node2.client("client2", 10, true) a.NoError(err) cmd := &protocol.Cmd{ Name: protocol.CmdReceive, Arg: syncTopic + " -3", } doneC := make(chan struct{}) go func() { for { select { case m := <-client2.Messages(): log.WithField("m", m).Error("Message received from first cluster") case e := <-client2.Errors(): log.WithField("clientError", e).Error("Client error") case status := <-client2.StatusMessages(): log.WithField("status", status).Error("Client status messasge") case <-doneC: return } } }() log.Error(string(cmd.Bytes())) client2.WriteRawMessage(cmd.Bytes()) time.Sleep(10 * time.Second) close(doneC) }
func (params *benchParams) throughputAPNS() { defer testutil.EnableDebugForMethod()() _, finish := testutil.NewMockBenchmarkCtrl(params.B) defer finish() defer testutil.ResetDefaultRegistryHealthCheck() a := assert.New(params) dir, errTempDir := ioutil.TempDir("", "guble_benchmarking_apns_test") a.NoError(errTempDir) *Config.HttpListen = "localhost:0" *Config.KVS = "memory" *Config.MS = "file" *Config.StoragePath = dir *Config.APNS.Enabled = true *Config.APNS.AppTopic = "app.topic" *Config.APNS.Prefix = "/apns/" params.receiveC = make(chan bool) CreateModules = createModulesWebsocketAndMockAPNSPusher(params.receiveC, params.timeout) params.service = StartService() var apnsConn connector.ResponsiveConnector var ok bool for _, iface := range params.service.ModulesSortedByStartOrder() { apnsConn, ok = iface.(connector.ResponsiveConnector) if ok { break } } if apnsConn == nil { a.FailNow("There should be a module of type: APNS Connector") } urlFormat := fmt.Sprintf("http://%s/apns/apns-%%d/%%d/%%s", params.service.WebServer().GetAddr()) for i := 1; i <= params.subscriptions; i++ { // create APNS subscription response, errPost := http.Post( fmt.Sprintf(urlFormat, i, i, strings.TrimPrefix(testTopic, "/")), "text/plain", bytes.NewBufferString(""), ) a.NoError(errPost) a.Equal(response.StatusCode, 200) body, errReadAll := ioutil.ReadAll(response.Body) a.NoError(errReadAll) a.Equal("{\"subscribed\":\"/topic\"}", string(body)) } clients := params.createClients() // Report allocations also params.ReportAllocs() expectedMessagesNumber := params.N * params.clients * params.subscriptions logger.WithFields(log.Fields{ "expectedMessagesNumber": expectedMessagesNumber, "b.N": params.N, }).Info("Expecting messages") params.wg.Add(expectedMessagesNumber) // start the receive loop (a select on receiveC and doneC) params.doneC = make(chan struct{}) params.receiveLoop() params.ResetTimer() // send all messages, or fail on any error for _, cl := range clients { go func(cl client.Client) { for i := 0; i < params.N; i++ { err := params.sender(cl) if err != nil { a.FailNow("Message could not be sent") } params.sent++ } }(cl) } // wait to receive all messages params.wg.Wait() // stop timer after the actual test params.StopTimer() close(params.doneC) a.NoError(params.service.Stop()) params.service = nil close(params.receiveC) errRemove := os.RemoveAll(dir) if errRemove != nil { logger.WithError(errRemove).WithField("module", "testing").Error("Could not remove directory") } }