func TestGobMarshalStruct(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewGobEncodedConn(t)
defer ec.Close()
ch := make(chan bool)
me := &person{Name: "derek", Age: 22, Address: "140 New Montgomery St"}
me.Children = make(map[string]*person)
me.Children["sam"] = &person{Name: "sam", Age: 19, Address: "140 New Montgomery St"}
me.Children["meg"] = &person{Name: "meg", Age: 17, Address: "140 New Montgomery St"}
me.Assets = make(map[string]uint)
me.Assets["house"] = 1000
me.Assets["car"] = 100
ec.Subscribe("gob_struct", func(p *person) {
if !reflect.DeepEqual(p, me) {
t.Fatalf("Did not receive the correct struct response")
}
ch <- true
})
ec.Publish("gob_struct", me)
if e := test.Wait(ch); e != nil {
t.Fatal("Did not receive the message")
}
}
func BenchmarkPublishGobStruct(b *testing.B) {
// stop benchmark for set-up
b.StopTimer()
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewGobEncodedConn(b)
defer ec.Close()
ch := make(chan bool)
me := &person{Name: "derek", Age: 22, Address: "140 New Montgomery St"}
me.Children = make(map[string]*person)
me.Children["sam"] = &person{Name: "sam", Age: 19, Address: "140 New Montgomery St"}
me.Children["meg"] = &person{Name: "meg", Age: 17, Address: "140 New Montgomery St"}
ec.Subscribe("gob_struct", func(p *person) {
if !reflect.DeepEqual(p, me) {
b.Fatalf("Did not receive the correct struct response")
}
ch <- true
})
// resume benchmark
b.StartTimer()
for n := 0; n < b.N; n++ {
ec.Publish("gob_struct", me)
if e := test.Wait(ch); e != nil {
b.Fatal("Did not receive the message")
}
}
}
func TestProtoNilRequest(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewProtoEncodedConn(t)
defer ec.Close()
testPerson := &pb.Person{Name: "Anatolii", Age: 25, Address: "Ukraine, Nikolaev"}
//Subscribe with empty interface shouldn't failed on empty message
ec.Subscribe("nil_test", func(_, reply string, _ interface{}) {
ec.Publish(reply, testPerson)
})
resp := new(pb.Person)
//Request with nil argument shouldn't failed with nil argument
err := ec.Request("nil_test", nil, resp, 100*time.Millisecond)
ec.Flush()
if err != nil {
t.Error("Fail to send empty message via encoded proto connection")
}
if !reflect.DeepEqual(testPerson, resp) {
t.Error("Fail to receive encoded response")
}
}
func TestFailedEncodedPublish(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewJsonEncodedConn(t)
defer ec.Close()
ch := make(chan bool)
err := ec.Publish("foo", ch)
if err == nil {
t.Fatal("Expected an error trying to publish a channel")
}
err = ec.PublishRequest("foo", "bar", ch)
if err == nil {
t.Fatal("Expected an error trying to publish a channel")
}
var cr chan bool
err = ec.Request("foo", ch, &cr, 1*time.Second)
if err == nil {
t.Fatal("Expected an error trying to publish a channel")
}
err = ec.LastError()
if err != nil {
t.Fatalf("Expected LastError to be nil: %q ", err)
}
}
func TestAsyncMarshalErr(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
testString := "Hello World!"
subject := "err_marshall"
ec.Subscribe(subject, func(subj, num int) {
// This will never get called.
})
ec.Conn.Opts.AsyncErrorCB = func(c *nats.Conn, s *nats.Subscription, err error) {
ch <- true
}
ec.Publish(subject, testString)
if e := test.Wait(ch); e != nil {
t.Fatalf("Did not receive the message: %s", e)
}
}
func TestProtoMarshalStruct(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewProtoEncodedConn(t)
defer ec.Close()
ch := make(chan bool)
me := &pb.Person{Name: "derek", Age: 22, Address: "140 New Montgomery St"}
me.Children = make(map[string]*pb.Person)
me.Children["sam"] = &pb.Person{Name: "sam", Age: 19, Address: "140 New Montgomery St"}
me.Children["meg"] = &pb.Person{Name: "meg", Age: 17, Address: "140 New Montgomery St"}
ec.Subscribe("protobuf_test", func(p *pb.Person) {
if !reflect.DeepEqual(p, me) {
t.Fatal("Did not receive the correct protobuf response")
}
ch <- true
})
ec.Publish("protobuf_test", me)
if e := test.Wait(ch); e != nil {
t.Fatal("Did not receive the message")
}
}
func TestRawMsgSubscribeCB(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
testString := "Hello World!"
oSubj := "cb_args"
oReply := "foobar"
ec.Subscribe(oSubj, func(m *nats.Msg) {
s := string(m.Data)
if s != testString {
t.Fatalf("Received test string of '%s', wanted '%s'\n", s, testString)
}
if m.Subject != oSubj {
t.Fatalf("Received subject of '%s', wanted '%s'\n", m.Subject, oSubj)
}
if m.Reply != oReply {
t.Fatalf("Received reply of '%s', wanted '%s'\n", m.Reply, oReply)
}
ch <- true
})
ec.PublishRequest(oSubj, oReply, testString)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
}
func TestExtendedSubscribeCB(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
testString := "Hello World!"
subject := "cb_args"
ec.Subscribe(subject, func(subj, s string) {
if s != testString {
t.Fatalf("Received test string of '%s', wanted '%s'\n", s, testString)
}
if subj != subject {
t.Fatalf("Received subject of '%s', wanted '%s'\n", subj, subject)
}
ch <- true
})
ec.Publish(subject, testString)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
}
func TestMarshalBool(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
expected := make(chan bool, 1)
ec.Subscribe("enc_bool", func(b bool) {
val := <-expected
if b != val {
t.Fatal("Boolean values did not match")
}
ch <- true
})
expected <- false
ec.Publish("enc_bool", false)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
expected <- true
ec.Publish("enc_bool", true)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
}
func TestConstructorErrs(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
c := test.NewConnection(t, TEST_PORT)
_, err := nats.NewEncodedConn(nil, "default")
if err == nil {
t.Fatal("Expected err for nil connection")
}
_, err = nats.NewEncodedConn(c, "foo22")
if err == nil {
t.Fatal("Expected err for bad encoder")
}
c.Close()
_, err = nats.NewEncodedConn(c, "default")
if err == nil {
t.Fatal("Expected err for closed connection")
}
}
func TestGobMarshalInt(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewGobEncodedConn(t)
defer ec.Close()
ch := make(chan bool)
testN := 22
ec.Subscribe("gob_int", func(n int) {
if n != testN {
t.Fatalf("Received test int of '%d', wanted '%d'\n", n, testN)
}
ch <- true
})
ec.Publish("gob_int", testN)
if e := test.Wait(ch); e != nil {
t.Fatal("Did not receive the message")
}
}
func TestGobMarshalString(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewGobEncodedConn(t)
defer ec.Close()
ch := make(chan bool)
testString := "Hello World!"
ec.Subscribe("gob_string", func(s string) {
if s != testString {
t.Fatalf("Received test string of '%s', wanted '%s'\n", s, testString)
}
ch <- true
})
ec.Publish("gob_string", testString)
if e := test.Wait(ch); e != nil {
t.Fatal("Did not receive the message")
}
}
func TestEncRequestReceivesMsg(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
expectedResp := "I can help!"
ec.Subscribe("help", func(subj, reply, req string) {
ec.Publish(reply, expectedResp)
})
var resp nats.Msg
err := ec.Request("help", "help me", &resp, 1*time.Second)
if err != nil {
t.Fatalf("Failed at receiving proper response: %v\n", err)
}
if string(resp.Data) != expectedResp {
t.Fatalf("Received reply '%s', wanted '%s'\n", string(resp.Data), expectedResp)
}
}
func TestMarshalInt(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
testN := 22
ec.Subscribe("enc_int", func(n int) {
if n != testN {
t.Fatalf("Received test number of %d, wanted %d\n", n, testN)
}
ch <- true
})
ec.Publish("enc_int", testN)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
}
func TestMarshalBytes(t *testing.T) {
s := test.RunServerOnPort(TEST_PORT)
defer s.Shutdown()
ec := NewEConn(t)
defer ec.Close()
ch := make(chan bool)
testBytes := []byte("Hello World!")
ec.Subscribe("enc_bytes", func(b []byte) {
if !bytes.Equal(b, testBytes) {
t.Fatalf("Received test bytes of '%s', wanted '%s'\n", b, testBytes)
}
ch <- true
})
ec.Publish("enc_bytes", testBytes)
if e := test.Wait(ch); e != nil {
if ec.LastError() != nil {
e = ec.LastError()
}
t.Fatalf("Did not receive the message: %s", e)
}
}