func TestNilConnection(t *testing.T) {
var nc *nats.Conn
data := []byte("ok")
// Publish
if err := nc.Publish("foo", data); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.PublishMsg(nil); err == nil || err != nats.ErrInvalidMsg {
t.Fatalf("Expected ErrInvalidMsg error, got %v\n", err)
}
if err := nc.PublishMsg(&nats.Msg{}); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.PublishRequest("foo", "reply", data); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Subscribe
if _, err := nc.Subscribe("foo", nil); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.SubscribeSync("foo"); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.QueueSubscribe("foo", "bar", nil); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
ch := make(chan *nats.Msg)
if _, err := nc.ChanSubscribe("foo", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.ChanQueueSubscribe("foo", "bar", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if _, err := nc.QueueSubscribeSyncWithChan("foo", "bar", ch); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Flush
if err := nc.Flush(); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
if err := nc.FlushTimeout(time.Millisecond); err == nil || err != nats.ErrInvalidConnection {
t.Fatalf("Expected ErrInvalidConnection error, got %v\n", err)
}
// Nil Subscribers
var sub *nats.Subscription
if sub.Type() != nats.NilSubscription {
t.Fatalf("Got wrong type for nil subscription, %v\n", sub.Type())
}
if sub.IsValid() {
t.Fatalf("Expected IsValid() to return false")
}
if err := sub.Unsubscribe(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected Unsubscribe to return proper error, got %v\n", err)
}
if err := sub.AutoUnsubscribe(1); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.NextMsg(time.Millisecond); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.QueuedMsgs(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.Pending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.MaxPending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if err := sub.ClearMaxPending(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, _, err := sub.PendingLimits(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if err := sub.SetPendingLimits(1, 1); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.Delivered(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
if _, err := sub.Dropped(); err == nil || err != nats.ErrBadSubscription {
t.Fatalf("Expected ErrBadSubscription error, got %v\n", err)
}
}
// Unsubscribe is to unsubscribe to subject
func Unsubscribe(sub *nats.Subscription) {
// Unsubscribe
sub.Unsubscribe()
}
func TestSetPendingLimits(t *testing.T) {
s := RunDefaultServer()
defer s.Shutdown()
nc := NewDefaultConnection(t)
defer nc.Close()
payload := []byte("hello")
payloadLen := len(payload)
toSend := 100
var sub *nats.Subscription
// Check for invalid values
invalid := func() error {
if err := sub.SetPendingLimits(0, 1); err == nil {
return fmt.Errorf("Setting limit with 0 should fail")
}
if err := sub.SetPendingLimits(1, 0); err == nil {
return fmt.Errorf("Setting limit with 0 should fail")
}
return nil
}
// function to send messages
send := func(subject string, count int) {
for i := 0; i < count; i++ {
if err := nc.Publish(subject, payload); err != nil {
t.Fatalf("Unexpected error on publish: %v", err)
}
}
nc.Flush()
}
// Check pending vs expected values
var limitCount, limitBytes int
var expectedCount, expectedBytes int
checkPending := func() error {
lc, lb, err := sub.PendingLimits()
if err != nil {
return err
}
if lc != limitCount || lb != limitBytes {
return fmt.Errorf("Unexpected limits, expected %v msgs %v bytes, got %v msgs %v bytes",
limitCount, limitBytes, lc, lb)
}
msgs, bytes, err := sub.Pending()
if err != nil {
return fmt.Errorf("Unexpected error getting pending counts: %v", err)
}
if (msgs != expectedCount && msgs != expectedCount-1) ||
(bytes != expectedBytes && bytes != expectedBytes-payloadLen) {
return fmt.Errorf("Unexpected counts, expected %v msgs %v bytes, got %v msgs %v bytes",
expectedCount, expectedBytes, msgs, bytes)
}
return nil
}
recv := make(chan bool)
block := make(chan bool)
cb := func(m *nats.Msg) {
recv <- true
<-block
m.Sub.Unsubscribe()
}
subj := "foo"
sub, err := nc.Subscribe(subj, cb)
if err != nil {
t.Fatalf("Unexpected error on subscribe: %v", err)
}
defer sub.Unsubscribe()
if err := invalid(); err != nil {
t.Fatalf("%v", err)
}
// Check we apply limit only for size
limitCount = -1
limitBytes = (toSend / 2) * payloadLen
if err := sub.SetPendingLimits(limitCount, limitBytes); err != nil {
t.Fatalf("Unexpected error setting limits: %v", err)
}
// Send messages
send(subj, toSend)
// Wait for message to be received
if err := Wait(recv); err != nil {
t.Fatal("Did not get our message")
}
expectedBytes = limitBytes
expectedCount = limitBytes / payloadLen
if err := checkPending(); err != nil {
t.Fatalf("%v", err)
}
// Release callback
block <- true
subj = "bar"
sub, err = nc.Subscribe(subj, cb)
if err != nil {
t.Fatalf("Unexpected error on subscribe: %v", err)
}
defer sub.Unsubscribe()
// Check we apply limit only for count
limitCount = toSend / 4
limitBytes = -1
if err := sub.SetPendingLimits(limitCount, limitBytes); err != nil {
t.Fatalf("Unexpected error setting limits: %v", err)
}
// Send messages
send(subj, toSend)
// Wait for message to be received
if err := Wait(recv); err != nil {
t.Fatal("Did not get our message")
}
expectedCount = limitCount
expectedBytes = limitCount * payloadLen
if err := checkPending(); err != nil {
t.Fatalf("%v", err)
}
// Release callback
block <- true
subj = "baz"
sub, err = nc.SubscribeSync(subj)
if err != nil {
t.Fatalf("Unexpected error on subscribe: %v", err)
}
defer sub.Unsubscribe()
if err := invalid(); err != nil {
t.Fatalf("%v", err)
}
// Check we apply limit only for size
limitCount = -1
limitBytes = (toSend / 2) * payloadLen
if err := sub.SetPendingLimits(limitCount, limitBytes); err != nil {
t.Fatalf("Unexpected error setting limits: %v", err)
}
// Send messages
send(subj, toSend)
expectedBytes = limitBytes
expectedCount = limitBytes / payloadLen
if err := checkPending(); err != nil {
t.Fatalf("%v", err)
}
sub.Unsubscribe()
nc.Flush()
subj = "boz"
sub, err = nc.SubscribeSync(subj)
if err != nil {
t.Fatalf("Unexpected error on subscribe: %v", err)
}
defer sub.Unsubscribe()
// Check we apply limit only for count
limitCount = toSend / 4
limitBytes = -1
if err := sub.SetPendingLimits(limitCount, limitBytes); err != nil {
t.Fatalf("Unexpected error setting limits: %v", err)
}
// Send messages
send(subj, toSend)
expectedCount = limitCount
expectedBytes = limitCount * payloadLen
if err := checkPending(); err != nil {
t.Fatalf("%v", err)
}
sub.Unsubscribe()
nc.Flush()
}
func TestChanSubscriberPendingLimits(t *testing.T) {
s := RunDefaultServer()
defer s.Shutdown()
nc := NewDefaultConnection(t)
defer nc.Close()
// There was a defect that prevented to receive more than
// the default pending message limit. Trying to send more
// than this limit.
total := nats.DefaultSubPendingMsgsLimit + 100
for typeSubs := 0; typeSubs < 3; typeSubs++ {
func() {
// Create our own channel.
ch := make(chan *nats.Msg, total)
var err error
var sub *nats.Subscription
switch typeSubs {
case 0:
sub, err = nc.ChanSubscribe("foo", ch)
case 1:
sub, err = nc.ChanQueueSubscribe("foo", "bar", ch)
case 2:
sub, err = nc.QueueSubscribeSyncWithChan("foo", "bar", ch)
}
if err != nil {
t.Fatalf("Unexpected error on subscribe: %v", err)
}
defer sub.Unsubscribe()
// Send some messages to ourselves.
go func() {
for i := 0; i < total; i++ {
if err := nc.Publish("foo", []byte("Hello")); err != nil {
t.Fatalf("Unexpected error on publish: %v", err)
}
}
}()
received := 0
tm := time.NewTimer(5 * time.Second)
defer tm.Stop()
chk := func(ok bool) {
if !ok {
t.Fatalf("Got an error reading from channel")
} else {
received++
}
}
// Go ahead and receive
for {
select {
case _, ok := <-ch:
chk(ok)
case <-tm.C:
t.Fatalf("Timed out waiting on messages")
}
if received >= total {
return
}
}
}()
}
}