// PublishSimpleMessage publises a message on a pubnub channel and
// calls the parse method to validate the message subscription.
func PublishSimpleMessage(pubnubInstance *pubnubMessaging.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)
}
// PublishMessages calls the publish method of pubnubMessaging package numberOfMessages times
// and appends the count with the message to distinguish from the others.
//
// Parameters:
// pubnubInstance: a reference of *pubnubMessaging.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 *pubnubMessaging.Pubnub, channel string, t *testing.T, startMessagesFrom int, numberOfMessages int, message string) bool {
messagesReceived := 0
messageToSend := ""
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)
}
if messagesReceived == numberOfMessages {
return true
}
return false
}
// 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 *pubnubMessaging.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 *pubnubMessaging.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
}
}
}
}
}