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")
}
}
