// ParseSubscribeResponseAndCallUnsubscribe will parse the response on the go channel.
// It will check the subscribe connection status and when connected
// it will initiate the unsubscribe request.
func ParseSubscribeResponseAndCallUnsubscribe(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, message string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
message = "'" + channel + "' " + message
//messageAbort := "'" + channel + "' aborted"
//fmt.Printf("response:",response);
//fmt.Printf("message:", message);
if strings.Contains(response, message) {
returnUnsubscribeChannel := make(chan []byte)
errorChannel := make(chan []byte)
go pubnubInstance.Unsubscribe(channel, returnUnsubscribeChannel, errorChannel)
go ParseUnsubscribeResponse(returnUnsubscribeChannel, channel, "unsubscribed", responseChannel)
go ParseResponseDummy(errorChannel)
break
} /*else if (strings.Contains(response, messageAbort)){
responseChannel <- "Test unsubscribed: failed."
break
} else {
responseChannel <- "Test unsubscribed: failed."
break
}*/
}
}
}
func ParseSetUserStateResponseJSON(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, key1 string, val1 string, key2 string, val2 string, jsonString string, testName string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
//fmt.Println("Test JSON'" + testName + "':" +response)
jsonString = fmt.Sprintf("{\"%s\": \"%s\", \"%s\": \"%s\"}", key2, val2, key1, val1)
if strings.Contains(response, jsonString) {
errorChannel := make(chan []byte)
returnChannel2 := make(chan []byte)
time.Sleep(3 * time.Second)
go pubnubInstance.SetUserStateKeyVal(channel, key2, "", returnChannel2, errorChannel)
go ParseUserStateResponse(returnChannel2, channel, key1, val1, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
break
} else {
responseChannel <- "Test '" + testName + "': failed."
break
}
}
}
}
// PublishSimpleMessage publises a message on a pubnub channel and
// calls the parse method to validate the message subscription.
func PublishSimpleMessage(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, testName string, cipherKey string, responseChannel chan string) {
message := "Test message"
returnChannel := make(chan []byte)
errorChannel := make(chan []byte)
go pubnubInstance.Publish(channel, message, returnChannel, errorChannel)
go ParseSubscribeResponse(pubnubInstance, returnChannel, t, channel, "", testName, cipherKey, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
}
func populateGroup(pubnub *messaging.Pubnub, group, channels string) {
successChannel := make(chan []byte)
errorChannel := make(chan []byte)
pubnub.ChannelGroupAddChannel(group, channels, successChannel, errorChannel)
select {
case <-successChannel:
case <-errorChannel:
}
}
func CommonUserStateJSON(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, key1 string, val1 string, key2 string, val2 string, testName string) {
returnChannel := make(chan []byte)
errorChannel := make(chan []byte)
waitChannel := make(chan string)
responseChannel := make(chan string)
jsonString := fmt.Sprintf("{\"%s\": \"%s\",\"%s\": \"%s\"}", key1, val1, key2, val2)
time.Sleep(2 * time.Second)
go pubnubInstance.SetUserStateJSON(channel, jsonString, returnChannel, errorChannel)
go ParseSetUserStateResponseJSON(pubnubInstance, returnChannel, channel, key1, val1, key2, val2, jsonString, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
go WaitForCompletion(responseChannel, waitChannel)
ParseWaitResponse(waitChannel, t, testName)
}
func populateChannelGroup(pubnub *messaging.Pubnub, group, channels string) {
successChannel := make(chan []byte, 1)
errorChannel := make(chan []byte, 1)
pubnub.ChannelGroupAddChannel(group, channels, successChannel, errorChannel)
select {
case <-successChannel:
// fmt.Println("Group created")
case <-errorChannel:
fmt.Println("Channel group creation error")
case <-timeout():
fmt.Println("Channel group creation timeout")
}
}
func createChannelGroups(pubnub *messaging.Pubnub, groups []string) {
successChannel := make(chan []byte, 1)
errorChannel := make(chan []byte, 1)
for _, group := range groups {
// fmt.Println("Creating group", group)
pubnub.ChannelGroupAddChannel(group, "adsf", successChannel, errorChannel)
select {
case <-successChannel:
// fmt.Println("Group created")
case <-errorChannel:
fmt.Println("Channel group creation error")
case <-timeout():
fmt.Println("Channel group creation timeout")
}
}
}
func removeChannelGroups(pubnub *messaging.Pubnub, groups []string) {
successChannel := make(chan []byte, 1)
errorChannel := make(chan []byte, 1)
for _, group := range groups {
// fmt.Println("Removing group", group)
pubnub.ChannelGroupRemoveGroup(group, successChannel, errorChannel)
select {
case <-successChannel:
// fmt.Println("Group removed")
case <-errorChannel:
fmt.Println("Channel group removal error")
case <-timeout():
fmt.Println("Channel group removal timeout")
}
}
}
// PublishMessages calls the publish method of messaging package numberOfMessages times
// and appends the count with the message to distinguish from the others.
//
// Parameters:
// pubnubInstance: a reference of *messaging.Pubnub,
// channel: the pubnub channel to publish the messages,
// t: a reference to *testing.T,
// startMessagesFrom: the message identifer,
// numberOfMessages: number of messages to send,
// message: message to send.
//
// returns a bool if the publish of all messages is successful.
func PublishMessages(pubnubInstance *messaging.Pubnub, channel string, t *testing.T, startMessagesFrom int, numberOfMessages int, message string) bool {
messagesReceived := 0
messageToSend := ""
tOut := messaging.GetNonSubscribeTimeout()
messaging.SetNonSubscribeTimeout(30)
for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ {
messageToSend = message + strconv.Itoa(i)
returnPublishChannel := make(chan []byte)
errorChannel := make(chan []byte)
go pubnubInstance.Publish(channel, messageToSend, returnPublishChannel, errorChannel)
messagesReceived++
//time.Sleep(500 * time.Millisecond)
time.Sleep(1500 * time.Millisecond)
}
if messagesReceived == numberOfMessages {
return true
}
messaging.SetNonSubscribeTimeout(tOut)
return false
}
func ParseSetUserStateResponse(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, key string, val string, testName string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
//fmt.Println("Test '" + testName + "':" +response)
message := fmt.Sprintf("{\"%s\": \"%s\"}", key, val)
//fmt.Println("%s", message)
if strings.Contains(response, message) {
errorChannel := make(chan []byte)
returnChannel2 := make(chan []byte)
time.Sleep(3 * time.Second)
if testName == "SetGetUserState" {
go pubnubInstance.GetUserState(channel, returnChannel2, errorChannel)
} else if testName == "SetGetUserStateHereNow" {
go pubnubInstance.HereNow(channel, true, true, returnChannel2, errorChannel)
} else if testName == "SetGetUserStateGlobalHereNow" {
go pubnubInstance.GlobalHereNow(true, true, returnChannel2, errorChannel)
}
go ParseUserStateResponse(returnChannel2, channel, key, val, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
break
} else {
responseChannel <- "Test '" + testName + "': failed."
break
}
}
}
}
func (stock *Stock) UpdateValuesAndPublish(pubnub *messaging.Pubnub,
cycle chan bool) {
if stock.CurrentPrice == 0 {
stock.CurrentPrice = stock.InitialPrice
}
rand.Seed(int64(time.Now().Nanosecond()))
change := float64(rand.Intn(stock.Volatility)-stock.Volatility/2) / 100
stock.CurrentPrice = stock.CurrentPrice + float64(change)
delta := stock.CurrentPrice - stock.InitialPrice
percentage := Roundn((1-stock.InitialPrice/stock.CurrentPrice)*100, 2)
vol := Randn(stock.Volatility, 1000) * 10
streamMessage := StreamMessage{
Time: time.Now().Format(TIME_FORMAT),
Price: fmt.Sprintf("%.2f", stock.CurrentPrice),
Delta: fmt.Sprintf("%.2f", delta),
Percentage: fmt.Sprintf("%.2f", percentage),
Vol: vol}
if math.Abs(percentage) > float64(stock.MaxDelta)/100 {
stock.CurrentPrice = stock.InitialPrice
}
errorChannel := make(chan []byte)
successChannel := make(chan []byte)
done := make(chan bool)
go pubnub.Publish(stock.Name, streamMessage, successChannel, errorChannel)
go handleResponse(successChannel, errorChannel,
messaging.GetNonSubscribeTimeout(), done)
sleep := Randn(stock.MinTrade, stock.MaxTrade)
time.Sleep(time.Duration(sleep) * time.Microsecond)
cycle <- <-done
}
func ParseSubcribeResponseForUserState(pubnubInstance *messaging.Pubnub, t *testing.T, returnChannel chan []byte, channel string, key string, val string, testName string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
message := "'" + channel + "' connected"
messageReconn := "'" + channel + "' reconnected"
if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
time.Sleep(1 * time.Second)
errorChannel := make(chan []byte)
returnChannel2 := make(chan []byte)
go pubnubInstance.SetUserStateKeyVal(channel, key, val, returnChannel2, errorChannel)
go ParseSetUserStateResponse(pubnubInstance, returnChannel2, channel, key, val, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
}
break
}
}
}
// PublishMessages calls the publish method of messaging package numberOfMessages times
// and appends the count with the message to distinguish from the others.
//
// Parameters:
// pubnubInstance: a reference of *messaging.Pubnub,
// channel: the pubnub channel to publish the messages,
// t: a reference to *testing.T,
// startMessagesFrom: the message identifer,
// numberOfMessages: number of messages to send,
// message: message to send.
//
// returns a bool if the publish of all messages is successful.
func PublishMessages(pubnubInstance *messaging.Pubnub, channel string,
t *testing.T, startMessagesFrom int, numberOfMessages int,
message string, sleep func(int)) bool {
assert := assert.New(t)
messagesReceived := 0
messageToSend := ""
tOut := messaging.GetNonSubscribeTimeout()
messaging.SetNonSubscribeTimeout(30)
successChannel := make(chan []byte)
errorChannel := make(chan []byte)
for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ {
messageToSend = message + strconv.Itoa(i)
go pubnubInstance.Publish(channel, messageToSend, successChannel, errorChannel)
select {
case <-successChannel:
messagesReceived++
case err := <-errorChannel:
assert.Fail("Failed to get channel list", string(err))
case <-messaging.Timeout():
assert.Fail("WhereNow timeout")
}
}
sleep(3)
if messagesReceived == numberOfMessages {
return true
}
messaging.SetNonSubscribeTimeout(tOut)
return false
}
func CommonUserState(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, key string, val string, testName string) {
returnSubscribeChannel := make(chan []byte)
errorChannel := make(chan []byte)
waitChannel := make(chan string)
//returnChannel := make(chan []byte)
responseChannel := make(chan string)
go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel, false, errorChannel)
go ParseSubcribeResponseForUserState(pubnubInstance, t, returnSubscribeChannel, channel, key, val, testName, responseChannel)
go ParseResponseDummy(errorChannel)
//go ParseErrorResponse(errorChannel, responseChannel)
go WaitForCompletion(responseChannel, waitChannel)
ParseWaitResponse(waitChannel, t, testName)
go pubnubInstance.Unsubscribe(channel, returnSubscribeChannel, errorChannel)
pubnubInstance.CloseExistingConnection()
time.Sleep(2 * time.Second)
}
// ParseSubscribeMultiplexedResponse publishes 2 messages on 2 different channels and
// when both the channels are connected
// it reads the responseChannel for the 2 messages. If we get the same 2 messages as response
// the test is passed.
//
// parameters:
// pubnubInstance: an instace of *messaging.Pubnub,
// returnSubscribeChannel: the channel to read the subscribe response on.
// message1: first message to publish.
// message2: second message to publish.
// pubnubChannel1: pubnub Channel 1 to publish the first message.
// pubnubChannel2: pubnub Channel 2 to publish the second message.
// testName: test name.
// responseChannel: the channelto send a response back.
func ParseSubscribeMultiplexedResponse(pubnubInstance *messaging.Pubnub, returnSubscribeChannel chan []byte, message1 string, message2 string, pubnubChannel1 string, pubnubChannel2 string, testName string, responseChannel chan string) {
messageCount := 0
channelCount := 0
for {
value, ok := <-returnSubscribeChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
message := "' connected"
messageT1 := "'" + pubnubChannel1 + "' connected"
messageT2 := "'" + pubnubChannel2 + "' connected"
if strings.Contains(response, message) {
if strings.Contains(response, messageT1) {
channelCount++
}
if strings.Contains(response, messageT2) {
channelCount++
}
if channelCount >= 2 {
returnPublishChannel := make(chan []byte)
errorChannelPub := make(chan []byte)
go pubnubInstance.Publish(pubnubChannel1, message1, returnPublishChannel, errorChannelPub)
go ParseResponseDummy(returnPublishChannel)
go ParseResponseDummy(errorChannelPub)
returnPublishChannel2 := make(chan []byte)
errorChannelPub2 := make(chan []byte)
go pubnubInstance.Publish(pubnubChannel2, message2, returnPublishChannel2, errorChannelPub2)
go ParseResponseDummy(returnPublishChannel2)
go ParseResponseDummy(errorChannelPub2)
}
} else {
var s []interface{}
err := json.Unmarshal(value, &s)
if err == nil {
if len(s) > 2 {
if message, ok := s[0].([]interface{}); ok {
if messageT, ok2 := message[0].(string); ok2 {
if (len(message) > 0) && (messageT == message1) && (s[2].(string) == pubnubChannel1) {
messageCount++
}
if (len(message) > 0) && (messageT == message2) && (s[2].(string) == pubnubChannel2) {
messageCount++
}
}
}
}
}
if messageCount >= 2 {
responseChannel <- "Test '" + testName + "': passed."
break
}
}
}
}
}
// ParseSubscribeResponse reads the response from the go channel and unmarshal's it.
// It is used by multiple test cases and acts according to the testcase names.
// The idea is to parse each message in the response based on the type of message
// and test against the sent message. If both match the test case is successful.
// _publishSuccessMessage is defined in the common.go file.
func ParseSubscribeResponse(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, t *testing.T, channel string, message string, testName string, cipherKey string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
if string(value) != "[]" {
response := fmt.Sprintf("%s", value)
//fmt.Println("Response1:", response)
if (testName == "SubscriptionConnectedForComplex") || (testName == "SubscriptionConnectedForComplexWithCipher") {
message = "'" + channel + "' connected"
if strings.Contains(response, message) {
PublishComplexMessage(pubnubInstance, t, channel, publishSuccessMessage, cipherKey, responseChannel)
} else {
//fmt.Println("resp:", response)
if ParseSubscribeData(t, value, testName, cipherKey, responseChannel) {
responseChannel <- "Test '" + testName + "': passed."
} else {
responseChannel <- "Test '" + testName + "': failed."
}
break
}
} else if (testName == "SubscriptionConnectedForSimple") || (testName == "SubscriptionConnectedForSimpleWithCipher") {
message = "'" + channel + "' connected"
if strings.Contains(response, message) {
PublishSimpleMessage(pubnubInstance, t, channel, publishSuccessMessage, cipherKey, responseChannel)
} else {
if ParseSubscribeData(t, value, testName, cipherKey, responseChannel) {
responseChannel <- "Test '" + testName + "': passed."
} else {
responseChannel <- "Test '" + testName + "': failed."
}
break
}
} else if testName == "SubscriptionAlreadySubscribed" {
message = "'" + channel + "' connected"
if strings.Contains(response, message) {
returnSubscribeChannel2 := make(chan []byte)
errorChannel2 := make(chan []byte)
go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel2, false, errorChannel2)
go ParseSubscribeResponse(pubnubInstance, errorChannel2, t, channel, "already subscribed", "SubscriptionAlreadySubscribedResponse", "", responseChannel)
go ParseResponseDummy(returnSubscribeChannel2)
}
break
} else if testName == "SubscriptionAlreadySubscribedResponse" {
message = "'" + channel + "' already subscribed"
if strings.Contains(response, message) {
responseChannel <- "Test '" + testName + "': passed."
} else {
responseChannel <- "Test '" + testName + "': failed."
//t.Error("Test '" + testName + "': failed.");
}
break
} else if testName == "SubscriptionConnectStatus" {
message = "'" + channel + "' connected"
if strings.Contains(response, message) {
responseChannel <- "Test '" + testName + "': passed."
} else {
responseChannel <- "Test '" + testName + "': failed."
//t.Error("Test '" + testName + "': failed.");
}
break
}
}
}
}
// ParseSubscribeResponseForPresence will look for the connection status in the response
// received on the go channel.
func ParseSubscribeResponseForPresence(pubnubInstance *messaging.Pubnub, customUuid string, returnChannel chan []byte, channel string, testName string, responseChannel chan string) {
for {
value, ok := <-returnChannel
if !ok {
break
}
//response := fmt.Sprintf("%s", value)
//fmt.Println(response);
if string(value) != "[]" {
if (testName == "CustomUuid") || (testName == "HereNow") || (testName == "HereNowWithCipher") {
response := fmt.Sprintf("%s", value)
message := "'" + channel + "' connected"
messageReconn := "'" + channel + "' reconnected"
if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
errorChannel := make(chan []byte)
returnChannel := make(chan []byte)
time.Sleep(3 * time.Second)
go pubnubInstance.HereNow(channel, true, true, returnChannel, errorChannel)
go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
break
}
} else if testName == "WhereNow" {
response := fmt.Sprintf("%s", value)
message := "'" + channel + "' connected"
messageReconn := "'" + channel + "' reconnected"
if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
errorChannel := make(chan []byte)
returnChannel := make(chan []byte)
time.Sleep(3 * time.Second)
go pubnubInstance.WhereNow(customUuid, returnChannel, errorChannel)
go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
break
}
} else if testName == "GlobalHereNow" {
response := fmt.Sprintf("%s", value)
message := "'" + channel + "' connected"
messageReconn := "'" + channel + "' reconnected"
if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
errorChannel := make(chan []byte)
returnChannel := make(chan []byte)
time.Sleep(3 * time.Second)
go pubnubInstance.GlobalHereNow(true, false, returnChannel, errorChannel)
go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
go ParseErrorResponse(errorChannel, responseChannel)
break
}
} else {
response := fmt.Sprintf("%s", value)
message := "'" + channel + "' connected"
messageReconn := "'" + channel + "' reconnected"
//fmt.Println("Test3 '" + testName + "':" +response)
if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
errorChannel2 := make(chan []byte)
returnSubscribeChannel := make(chan []byte)
time.Sleep(1 * time.Second)
go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel, false, errorChannel2)
go ParseResponseDummy(returnSubscribeChannel)
go ParseResponseDummy(errorChannel2)
} else {
if testName == "Presence" {
data, _, returnedChannel, err2 := messaging.ParseJSON(value, "")
var occupants []struct {
Action string
Uuid string
Timestamp float64
Occupancy int
}
if err2 != nil {
responseChannel <- "Test '" + testName + "': failed. Message: 1 :" + err2.Error()
break
}
//fmt.Println("Test3 '" + testName + "':" +data)
err := json.Unmarshal([]byte(data), &occupants)
if err != nil {
//fmt.Println("err '" + testName + "':",err)
responseChannel <- "Test '" + testName + "': failed. Message: 2 :" + err.Error()
break
} else {
channelSubRepsonseReceived := false
for i := 0; i < len(occupants); i++ {
if (occupants[i].Action == "join") && occupants[i].Uuid == customUuid {
channelSubRepsonseReceived = true
break
}
}
if !channelSubRepsonseReceived {
responseChannel <- "Test '" + testName + "': failed. Message: err3"
break
}
if channel == returnedChannel {
responseChannel <- "Test '" + testName + "': passed."
break
} else {
responseChannel <- "Test '" + testName + "': failed. Message: err4"
break
}
}
}
}
}
}
}
}
// GetServerTime calls the GetTime method of the messaging, parses the response to get the
// value and return it.
func GetServerTime(pubnubInstance *messaging.Pubnub, t *testing.T, testName string) int64 {
returnTimeChannel := make(chan []byte)
errorChannel := make(chan []byte)
go pubnubInstance.GetTime(returnTimeChannel, errorChannel)
return ParseServerTimeResponse(returnTimeChannel, t, testName)
}