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 TestGCMConnector_GetErrorMessageFromGcm(t *testing.T) {
ctrl, finish := testutil.NewMockCtrl(t)
defer finish()
// defer testutil.EnableDebugForMethod()()
a := assert.New(t)
routerMock := NewMockRouter(ctrl)
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(route *server.Route) {
a.Equal("/gcm/broadcast", string(route.Path))
a.Equal("gcm_connector", route.UserID)
a.Equal("gcm_connector", route.ApplicationID)
})
// expect the route unsubscribed from removeSubscription
routerMock.EXPECT().Unsubscribe(gomock.Any()).Do(func(route *server.Route) {
a.Equal("/path", string(route.Path))
a.Equal("id", route.ApplicationID)
})
// expect the route subscribe with the new canonicalId from replaceSubscriptionWithCanonicalID
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(route *server.Route) {
a.Equal("/path", string(route.Path))
a.Equal("marvin", route.UserID)
a.Equal("gcmCanonicalID", route.ApplicationID)
})
kvStore := store.NewMemoryKVStore()
routerMock.EXPECT().KVStore().Return(kvStore, nil)
gcm, err := NewGCMConnector(routerMock, "/gcm/", "testApi", 1)
a.Nil(err)
err = gcm.Start()
a.Nil(err)
done := make(chan bool, 1)
mockSender := testutil.CreateGcmSender(
testutil.CreateRoundTripperWithJsonResponse(http.StatusOK, testutil.ErrorResponseMessageJSON, done))
gcm.Sender = mockSender
// put a dummy gcm message with minimum information
msg := &server.MessageForRoute{
Message: &protocol.Message{
ID: uint64(4),
Body: []byte("{id:id}"),
Time: 1405544146,
Path: "/gcm/marvin/gcm124/subscribe/stuff"},
Route: &server.Route{
ApplicationID: "id",
Path: "/path",
UserID: "marvin"}}
gcm.routerC <- msg
// expect that the Http Server gives us a malformed message
<-done
//wait before closing the gcm connector
time.Sleep(50 * time.Millisecond)
err = gcm.Stop()
a.NoError(err)
}
func TestGcmConnector_StartWithMessageSending(t *testing.T) {
ctrl, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
routerMock := NewMockRouter(ctrl)
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(route *server.Route) {
a.Equal("/gcm/broadcast", string(route.Path))
a.Equal("gcm_connector", route.UserID)
a.Equal("gcm_connector", route.ApplicationID)
})
kvStore := store.NewMemoryKVStore()
routerMock.EXPECT().KVStore().Return(kvStore, nil)
gcm, err := NewGCMConnector(routerMock, "/gcm/", "testApi", 1)
a.Nil(err)
err = gcm.Start()
a.Nil(err)
done := make(chan bool, 1)
mockSender := testutil.CreateGcmSender(
testutil.CreateRoundTripperWithJsonResponse(http.StatusOK, testutil.CorrectGcmResponseMessageJSON, done))
gcm.Sender = mockSender
// put a broadcast message with no recipients and expect to be dropped by
broadcastMsgWithNoRecipients := &server.MessageForRoute{
Message: &protocol.Message{
ID: uint64(4),
Body: []byte("{id:id}"),
Time: 1405544146,
Path: "/gcm/broadcast"}}
gcm.routerC <- broadcastMsgWithNoRecipients
time.Sleep(50 * time.Millisecond)
// expect that the HTTP Dummy Server to not handle any requests
// put a dummy gcm message with minimum information
msgWithNoRecipients := &server.MessageForRoute{
Message: &protocol.Message{
ID: uint64(4),
Body: []byte("{id:id}"),
Time: 1405544146,
Path: "/gcm/marvin/gcm124/subscribe/stuff"},
Route: &server.Route{ApplicationID: "id"}}
gcm.routerC <- msgWithNoRecipients
// expect that the Http Server to give us a malformed message
<-done
//wait a little to Stop the GcmConnector
time.Sleep(50 * time.Millisecond)
err = gcm.Stop()
a.NoError(err)
}
func TestGCMConnector_BroadcastMessage(t *testing.T) {
ctrl, finish := testutil.NewMockCtrl(t)
defer finish()
a := assert.New(t)
routerMock := NewMockRouter(ctrl)
kvStore := store.NewMemoryKVStore()
routerMock.EXPECT().KVStore().Return(kvStore, nil)
routerMock.EXPECT().Subscribe(gomock.Any()).Do(func(route *server.Route) {
a.Equal("/notifications", string(route.Path))
a.Equal("marvin", route.UserID)
a.Equal("gcmId123", route.ApplicationID)
})
gcm, err := NewGCMConnector(routerMock, "/gcm/", "testApi", 1)
a.Nil(err)
url, _ := url.Parse("http://localhost/gcm/marvin/gcmId123/subscribe/notifications")
// and a http context
req := &http.Request{URL: url, Method: "POST"}
w := httptest.NewRecorder()
// when: I POST a message
gcm.ServeHTTP(w, req)
// then
a.Equal("registered: /notifications\n", string(w.Body.Bytes()))
done := make(chan bool, 1)
mockSender := testutil.CreateGcmSender(
testutil.CreateRoundTripperWithJsonResponse(http.StatusOK, testutil.CorrectGcmResponseMessageJSON, done))
gcm.Sender = mockSender
// put a broadcast message with no recipients and expect to be dropped by
broadcastMessage := &server.MessageForRoute{
Message: &protocol.Message{
ID: uint64(4),
Body: []byte("{id:id}"),
Time: 1405544146,
Path: "/gcm/broadcast"}}
gcm.broadcastMessage(broadcastMessage)
// wait for the message to be processed by http server
<-done
//wait before closing the gcm connector
time.Sleep(50 * time.Millisecond)
err = gcm.Stop()
a.Nil(err)
}
func throughputSend(b *testing.B, nWorkers int, sampleSend func(c client.Client) error) float64 {
//testutil.EnableDebugForMethod()
fmt.Printf("b.N=%v\n", b.N)
defer testutil.ResetDefaultRegistryHealthCheck()
a := assert.New(b)
dir, errTempDir := ioutil.TempDir("", "guble_benchmarking_gcm_test")
defer func() {
errRemove := os.RemoveAll(dir)
if errRemove != nil {
log.WithFields(log.Fields{
"module": "testing",
"err": errRemove,
}).Error("Could not remove directory")
}
}()
a.NoError(errTempDir)
*config.HttpListen = "localhost:0"
*config.KVS = "memory"
*config.MS = "file"
*config.StoragePath = dir
*config.GCM.Enabled = true
*config.GCM.APIKey = "WILL BE OVERWRITTEN"
*config.GCM.Workers = nWorkers
service := StartService()
log.WithFields(log.Fields{
"module": "testing",
}).Debug("Overwriting the GCM Sender with a MocK")
gcmConnector, ok := service.Modules()[4].(*gcm.GCMConnector)
a.True(ok, "Modules[4] should be of type GCMConnector")
gcmConnector.Sender = testutil.CreateGcmSender(
testutil.CreateRoundTripperWithJsonResponse(http.StatusOK, testutil.CorrectGcmResponseMessageJSON, nil))
gomaxprocs := runtime.GOMAXPROCS(0)
clients := make([]client.Client, 0, gomaxprocs)
for clientID := 0; clientID < gomaxprocs; clientID++ {
location := "ws://" + service.WebServer().GetAddr() + "/stream/user/" + strconv.Itoa(clientID)
client, err := client.Open(location, "http://localhost/", 1000, true)
a.NoError(err)
clients = append(clients, client)
}
// create a topic
url := fmt.Sprintf("http://%s/gcm/0/gcmId0/subscribe/topic", service.WebServer().GetAddr())
response, errPost := http.Post(url, "text/plain", bytes.NewBufferString(""))
a.NoError(errPost)
a.Equal(response.StatusCode, 200)
body, errReadAll := ioutil.ReadAll(response.Body)
a.NoError(errReadAll)
a.Equal("registered: /topic\n", string(body))
log.WithFields(log.Fields{
"module": "testing",
}).Debug("Overwriting the GCM Sender with a MocK")
start := time.Now()
b.ResetTimer()
log.WithFields(log.Fields{
"module": "testing",
}).Debug("Sending multiple messages from each client in separate goroutines")
var wg sync.WaitGroup
wg.Add(gomaxprocs)
for _, c := range clients {
go func(c client.Client) {
defer wg.Done()
for i := 0; i < b.N; i++ {
a.NoError(sampleSend(c))
}
}(c)
}
wg.Wait()
// stop service (and wait for all the messages to be processed during the given grace period)
err := service.Stop()
a.Nil(err)
end := time.Now()
b.StopTimer()
return float64(b.N*gomaxprocs) / end.Sub(start).Seconds()
}
