func subscribeHandler(successChannel, errorChannel chan []byte) {
for {
select {
case response := <-successChannel:
fmt.Printf("Success response: %s", response)
case err := <-errorChannel:
fmt.Printf("Error response: %s", err)
case <-messaging.SubscribeTimeout():
fmt.Printf("Subscirbe request timeout")
}
}
}
func TestPubnubGrantSubscribeParallelUnsafe(t *testing.T) {
wg := sync.WaitGroup{}
pubnub := messaging.NewPubnub(PubKey, SubKey, SecKey, "", false, "")
for j := 0; j < numGrants; j++ {
wg.Add(1)
go func(j int) {
defer wg.Done()
callback, err := make(chan []byte), make(chan []byte)
go pubnub.GrantSubscribe(channel, true, true, ttl, authKey, callback, err)
select {
case <-callback:
case <-err:
case <-messaging.SubscribeTimeout():
}
}(j)
}
wg.Wait()
}
func TestWildcardSubscriptionMessage(t *testing.T) {
assert := assert.New(t)
stop, _ := NewVCRBoth("fixtures/wildcard/message", []string{"uuid"})
defer stop()
uuid := "UUID_SubscribeMajor"
major := "Channel_SubscribeMajor"
minor := "Channel_SubscribeMinor"
channel := fmt.Sprintf("%s.%s", major, minor)
wildcard := fmt.Sprintf("%s.*", major)
pubnubInstance := messaging.NewPubnub(PubKey, SubKey, "", "", false, uuid)
subscribeSuccessChannel := make(chan []byte)
subscribeErrorChannel := make(chan []byte)
successChannel := make(chan []byte)
errorChannel := make(chan []byte)
await := make(chan bool)
go pubnubInstance.Subscribe(wildcard, "",
subscribeSuccessChannel, false, subscribeErrorChannel)
ExpectConnectedEvent(t, wildcard, "", subscribeSuccessChannel,
subscribeErrorChannel)
go func() {
select {
case message := <-subscribeSuccessChannel:
var msg []interface{}
err := json.Unmarshal(message, &msg)
if err != nil {
assert.Fail(err.Error())
}
assert.Contains(string(message), "hey")
assert.Equal(channel, msg[2].(string))
assert.Equal(wildcard, msg[3].(string))
await <- true
case err := <-subscribeErrorChannel:
assert.Fail(string(err))
await <- false
case <-messaging.SubscribeTimeout():
assert.Fail("Subscribe timeout")
await <- false
}
}()
go pubnubInstance.Publish(channel, "hey", successChannel, errorChannel)
select {
case <-successChannel:
case err := <-errorChannel:
assert.Fail(string(err))
}
<-await
go pubnubInstance.Unsubscribe(wildcard, successChannel, errorChannel)
ExpectUnsubscribedEvent(t, wildcard, "", successChannel, errorChannel)
// pubnubInstance.CloseExistingConnection()
}