예제 #1
0
func TestClientMessage(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	// empty message
	err = c.message([]byte{})
	assert.Equal(t, ErrInvalidMessage, err)

	// malformed message
	err = c.message([]byte("wroooong"))
	assert.NotEqual(t, nil, err)

	var cmds []clientCommand

	nonConnectFirstCmd := clientCommand{
		Method: "subscribe",
		Params: []byte("{}"),
	}

	cmds = append(cmds, nonConnectFirstCmd)
	cmdBytes, err := json.Marshal(cmds)
	assert.Equal(t, nil, err)
	err = c.message(cmdBytes)
	assert.Equal(t, ErrUnauthorized, err)
}
예제 #2
0
func TestNamespaceKey(t *testing.T) {
	app := testApp()
	assert.Equal(t, NamespaceKey("ns"), app.namespaceKey("ns:channel"))
	assert.Equal(t, NamespaceKey(""), app.namespaceKey("channel"))
	assert.Equal(t, NamespaceKey("ns"), app.namespaceKey("ns:channel:opa"))
	assert.Equal(t, NamespaceKey("ns"), app.namespaceKey("ns::channel"))
}
예제 #3
0
func TestToFloat64(t *testing.T) {
	var eight interface{} = 8
	assert.Equal(t, ToFloat64(8), 8.00)
	assert.Equal(t, ToFloat64(8.31), 8.31)
	assert.Equal(t, ToFloat64("8.31"), 8.31)
	assert.Equal(t, ToFloat64(eight), 8.0)
}
예제 #4
0
func TestIndirectPointers(t *testing.T) {
	x := 13
	y := &x
	z := &y

	assert.Equal(t, ToInt(y), 13)
	assert.Equal(t, ToInt(z), 13)
}
예제 #5
0
func TestProjectByKey(t *testing.T) {
	app := testApp()
	p, found := app.projectByKey("nonexistent")
	assert.Equal(t, found, false)
	p, found = app.projectByKey("test1")
	assert.Equal(t, found, true)
	assert.Equal(t, p.Name, ProjectKey("test1"))
}
예제 #6
0
func TestLevels(t *testing.T) {
	SetStdoutThreshold(LevelError)
	assert.Equal(t, outputThreshold, LevelError)
	SetLogThreshold(LevelCritical)
	assert.Equal(t, logThreshold, LevelCritical)
	assert.NotEqual(t, outputThreshold, LevelCritical)
	SetStdoutThreshold(LevelWarn)
	assert.Equal(t, outputThreshold, LevelWarn)
}
예제 #7
0
func TestGetProjectByKey(t *testing.T) {
	s := getTestStructure()

	_, found := s.projectByKey("test3")
	assert.Equal(t, false, found, "found project that does not exist")

	_, found = s.projectByKey("test2")
	assert.Equal(t, true, found)
}
예제 #8
0
func TestMemoryPresenceHub(t *testing.T) {
	h := newMemoryPresenceHub()
	assert.Equal(t, 0, len(h.presence))

	testCh1 := ChannelID("channel1")
	testCh2 := ChannelID("channel2")

	uid := ConnID("uid")

	info := ClientInfo{
		User:   "******",
		Client: "client",
	}

	h.add(testCh1, uid, info)
	assert.Equal(t, 1, len(h.presence))
	h.add(testCh2, uid, info)
	assert.Equal(t, 2, len(h.presence))
	h.remove(testCh1, uid)
	// remove non existing must not fail
	err := h.remove(testCh1, uid)
	assert.Equal(t, nil, err)
	assert.Equal(t, 1, len(h.presence))
	p, err := h.get(testCh1)
	assert.Equal(t, nil, err)
	assert.Equal(t, 0, len(p))
	p, err = h.get(testCh2)
	assert.Equal(t, nil, err)
	assert.Equal(t, 1, len(p))
}
예제 #9
0
func TestStringQueueResize(t *testing.T) {
	q := New()
	assert.Equal(t, 0, q.Len())
	assert.Equal(t, initialCapacity, q.Cap())
	assert.Equal(t, false, q.Closed())

	i := 0
	for i < initialCapacity {
		q.Add(strconv.Itoa(i))
		i++
	}
	assert.Equal(t, initialCapacity, q.Cap())
	q.Add("resize here")
	assert.Equal(t, initialCapacity*2, q.Cap())
	q.Remove()
	// back to initial capacity
	assert.Equal(t, initialCapacity, q.Cap())

	q.Add("new resize here")
	assert.Equal(t, initialCapacity*2, q.Cap())
	q.Add("one more item, no resize must happen")
	assert.Equal(t, initialCapacity*2, q.Cap())

	assert.Equal(t, initialCapacity+2, q.Len())
}
예제 #10
0
func TestAPIPresence(t *testing.T) {
	app := testApp()
	p, _ := app.projectByKey("test1")

	cmd := &presenceApiCommand{
		Channel: "channel",
	}
	resp, err := app.presenceCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}
예제 #11
0
func TestAPIHistory(t *testing.T) {
	app := testApp()
	p, _ := app.projectByKey("test1")

	cmd := &historyApiCommand{
		Channel: "channel",
	}
	resp, err := app.historyCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}
예제 #12
0
func TestAPIDisconnect(t *testing.T) {
	app := testApp()
	p, _ := app.projectByKey("test1")

	cmd := &disconnectApiCommand{
		User: "******",
	}
	resp, err := app.disconnectCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}
예제 #13
0
func TestAPIPublish(t *testing.T) {
	app := testApp()
	p, _ := app.projectByKey("test1")

	cmd := &publishApiCommand{
		Channel: "channel",
		Data:    []byte("null"),
	}
	resp, err := app.publishCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}
예제 #14
0
func TestAdminHub(t *testing.T) {
	h := newAdminHub()
	c := newTestUserCC()
	err := h.add(c)
	assert.Equal(t, err, nil)
	assert.Equal(t, len(h.connections), 1)
	err = h.broadcast("message")
	assert.Equal(t, err, nil)
	err = h.remove(c)
	assert.Equal(t, err, nil)
	assert.Equal(t, len(h.connections), 0)
}
예제 #15
0
func TestInfoHandler(t *testing.T) {
	app := testApp()
	r := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/info/", nil)
	app.InfoHandler(r, req)
	body, _ := ioutil.ReadAll(r.Body)
	assert.Equal(t, true, strings.Contains(string(body), "nodes"))
	assert.Equal(t, true, strings.Contains(string(body), "node_name"))
	assert.Equal(t, true, strings.Contains(string(body), "version"))
	assert.Equal(t, true, strings.Contains(string(body), "structure"))
	assert.Equal(t, true, strings.Contains(string(body), "engine"))
}
예제 #16
0
func TestClientRefresh(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	cmds := []clientCommand{testConnectCmd(timestamp), testSubscribeCmd("test")}
	err = c.handleCommands(cmds)
	assert.Equal(t, nil, err)

	cmds = []clientCommand{testRefreshCmd(timestamp)}
	err = c.handleCommands(cmds)
	assert.Equal(t, nil, err)
}
예제 #17
0
func TestClientPing(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	cmds := []clientCommand{testConnectCmd(timestamp)}
	err = c.handleCommands(cmds)
	assert.Equal(t, nil, err)

	resp, err := c.handleCmd(testPingCmd())
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}
예제 #18
0
func TestDefaultMux(t *testing.T) {
	app := testApp()
	mux := DefaultMux(app, "", "path/to/web", "sockjs url")
	server := httptest.NewServer(mux)
	defer server.Close()
	resp, err := http.Get(server.URL + "/connection/info")
	assert.Equal(t, nil, err)
	assert.Equal(t, http.StatusOK, resp.StatusCode)

	app.Shutdown()
	resp, err = http.Get(server.URL + "/connection/info")
	assert.Equal(t, nil, err)
	assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
}
예제 #19
0
func TestSingleObjectMessage(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	nonConnectFirstCmd := clientCommand{
		Method: "subscribe",
		Params: []byte("{}"),
	}

	cmdBytes, err := json.Marshal(nonConnectFirstCmd)
	assert.Equal(t, nil, err)
	err = c.message(cmdBytes)
	assert.Equal(t, ErrUnauthorized, err)
}
예제 #20
0
func TestGetChannelOptions(t *testing.T) {
	s := getTestStructure()

	_, err := s.channelOpts("wrong_project_key", "test")
	assert.Equal(t, ErrProjectNotFound, err)

	_, err = s.channelOpts("test1", "test")
	assert.Equal(t, nil, err)

	_, err = s.channelOpts("test1", "")
	assert.Equal(t, nil, err)

	_, err = s.channelOpts("test1", "wrongnamespacekey")
	assert.Equal(t, ErrNamespaceNotFound, err)
}
예제 #21
0
func TestShutdown(t *testing.T) {
	h := newClientHub()
	c := newTestUserCC()
	h.add(c)
	assert.Equal(t, len(h.users), 1)
	h.shutdown()
}
예제 #22
0
func TestRawWsHandler(t *testing.T) {
	app := testApp()
	mux := DefaultMux(app, "", "path/to/web", "sockjs url")
	server := httptest.NewServer(mux)
	defer server.Close()
	url := "ws" + server.URL[4:]
	conn, resp, err := websocket.DefaultDialer.Dial(url+"/connection/websocket", nil)
	conn.Close()
	assert.Equal(t, nil, err)
	assert.NotEqual(t, nil, conn)
	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	app.Shutdown()
	_, resp, err = websocket.DefaultDialer.Dial(url+"/connection/websocket", nil)
	assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
}
예제 #23
0
func TestAdminAuthToken(t *testing.T) {
	app := testApp()
	// first without secret set
	token, err := app.adminAuthToken()
	assert.Equal(t, nil, err)
	assert.True(t, len(token) > 0)
	err = app.checkAdminAuthToken("")
	assert.Equal(t, ErrUnauthorized, err)
	err = app.checkAdminAuthToken(token)
	assert.Equal(t, ErrUnauthorized, err)
	// now with secret set
	app.config.WebSecret = "test"
	token, err = app.adminAuthToken()
	assert.Equal(t, nil, err)
	err = app.checkAdminAuthToken(token)
	assert.Equal(t, nil, err)
}
예제 #24
0
func TestControlMessages(t *testing.T) {
	app := testApp()
	app.Run()
	// command from this node
	cmd := testPingControlCmd(app.uid)
	err := app.controlMsg(cmd)
	assert.Equal(t, nil, err)
	cmd = testPingControlCmd("another_node")
	err = app.controlMsg(cmd)
	assert.Equal(t, nil, err)
	err = app.controlMsg(testWrongControlCmd("another node"))
	assert.Equal(t, ErrInvalidMessage, err)
	err = app.controlMsg(testUnsubscribeControlCmd("another node"))
	assert.Equal(t, nil, err)
	err = app.controlMsg(testDisconnectControlCmd("another node"))
	assert.Equal(t, nil, err)
}
예제 #25
0
func TestSubHub(t *testing.T) {
	h := newClientHub()
	c := newTestUserCC()
	h.addSub("test1", c)
	h.addSub("test2", c)
	assert.Equal(t, 2, h.nChannels())
	channels := []string{}
	for _, ch := range h.channels() {
		channels = append(channels, string(ch))
	}
	assert.Equal(t, stringInSlice("test1", channels), true)
	assert.Equal(t, stringInSlice("test2", channels), true)
	err := h.broadcast("test1", "message")
	assert.Equal(t, err, nil)
	h.removeSub("test1", c)
	h.removeSub("test2", c)
	assert.Equal(t, len(h.subs), 0)
}
예제 #26
0
func TestClientSubscribePrivate(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	cmds := []clientCommand{testConnectCmd(timestamp)}
	_ = c.handleCommands(cmds)

	resp, err := c.handleCmd(testSubscribeCmd("$test"))
	assert.Equal(t, nil, err)
	assert.Equal(t, ErrPermissionDenied, resp.err)

	resp, err = c.handleCmd(testSubscribePrivateCmd("$test", c.UID))
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)

}
예제 #27
0
func TestMemoryEngine(t *testing.T) {
	e := testMemoryEngine()
	assert.NotEqual(t, nil, e.historyHub)
	assert.NotEqual(t, nil, e.presenceHub)
	assert.NotEqual(t, e.name(), "")
	assert.Equal(t, nil, e.publish(ChannelID("channel"), []byte("{}")))
	assert.Equal(t, nil, e.subscribe(ChannelID("channel")))
	assert.Equal(t, nil, e.unsubscribe(ChannelID("channel")))
	assert.Equal(t, nil, e.addPresence(ChannelID("channel"), "uid", ClientInfo{}))
	p, err := e.presence(ChannelID("channel"))
	assert.Equal(t, nil, err)
	assert.Equal(t, 1, len(p))
	assert.Equal(t, nil, e.addHistory(ChannelID("channel"), Message{}, 1, 1))
	h, err := e.history(ChannelID("channel"))
	assert.Equal(t, nil, err)
	assert.Equal(t, 1, len(h))
	err = e.removePresence(ChannelID("channel"), "uid")
	assert.Equal(t, nil, err)
}
예제 #28
0
func TestAdminWebsocketHandler(t *testing.T) {
	app := testApp()
	mux := DefaultMux(app, "", "path/to/web", "sockjs url")
	server := httptest.NewServer(mux)
	defer server.Close()
	url := "ws" + server.URL[4:]
	conn, resp, err := websocket.DefaultDialer.Dial(url+"/socket", nil)
	data := map[string]interface{}{
		"method": "ping",
		"params": map[string]string{},
	}
	conn.WriteJSON(data)
	var response interface{}
	conn.ReadJSON(&response)
	conn.Close()
	assert.Equal(t, nil, err)
	assert.NotEqual(t, nil, conn)
	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)
}
예제 #29
0
func TestClientConnect(t *testing.T) {
	app := testApp()
	c, err := newClient(app, &testSession{})
	assert.Equal(t, nil, err)

	var cmd clientCommand
	var cmds []clientCommand

	cmd = clientCommand{
		Method: "connect",
		Params: []byte("{}"),
	}
	cmds = []clientCommand{cmd}
	err = c.handleCommands(cmds)
	assert.Equal(t, ErrProjectNotFound, err)

	cmd = clientCommand{
		Method: "connect",
		Params: []byte(`{"project": "test1"}`),
	}
	cmds = []clientCommand{cmd}
	err = c.handleCommands(cmds)
	assert.Equal(t, ErrInvalidToken, err)

	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	cmds = []clientCommand{testConnectCmd(timestamp)}
	err = c.handleCommands(cmds)
	assert.Equal(t, nil, err)
	assert.Equal(t, true, c.authenticated)
	ts, err := strconv.Atoi(timestamp)
	assert.Equal(t, int64(ts), c.timestamp)

	clientInfo := c.info(Channel(""))
	assert.Equal(t, UserID("user1"), clientInfo.User)

	assert.Equal(t, 1, len(app.clients.conns))

	err = c.clean()
	assert.Equal(t, nil, err)

	assert.Equal(t, 0, len(app.clients.conns))
}
예제 #30
0
func TestAPIUnsubscribe(t *testing.T) {
	app := testApp()
	p, _ := app.projectByKey("test1")

	cmd := &unsubscribeApiCommand{
		User:    "******",
		Channel: "channel",
	}
	resp, err := app.unsubcribeCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)

	// unsubscribe from all channels
	cmd = &unsubscribeApiCommand{
		User:    "******",
		Channel: "",
	}
	resp, err = app.unsubcribeCmd(p, cmd)
	assert.Equal(t, nil, err)
	assert.Equal(t, nil, resp.err)
}