func TestAuth(t *testing.T) {
opts := gnatsd.DefaultTestOptions
opts.Port = 8232
s := RunServerWithOptions(opts)
// Auth is pluggable, so need to set here..
auth := &auth.Plain{
Username: "******",
Password: "******",
}
s.SetAuthMethod(auth)
defer s.Shutdown()
_, err := nats.Connect("nats://*****:*****@localhost:8232")
if err != nil {
t.Fatal("Should have connected successfully")
}
nc.Close()
}
func BenchmarkPublishSpeedViaChan(b *testing.B) {
b.StopTimer()
s := RunDefaultServer()
defer s.Shutdown()
nc, err := nats.Connect(nats.DefaultURL)
if err != nil {
b.Fatalf("Could not connect: %v\n", err)
}
ec, err := nats.NewEncodedConn(nc, nats.DEFAULT_ENCODER)
defer ec.Close()
ch := make(chan int32, 1024)
if err := ec.BindSendChan("foo", ch); err != nil {
b.Fatalf("Failed to bind to a send channel: %v\n", err)
}
b.StartTimer()
num := int32(22)
for i := 0; i < b.N; i++ {
ch <- num
}
// Make sure they are all processed.
nc.Flush()
b.StopTimer()
}
func NewConnection(t tLogger, port int) *nats.Conn {
url := fmt.Sprintf("nats://localhost:%d", port)
nc, err := nats.Connect(url)
if err != nil {
t.Fatalf("Failed to create default connection: %v\n", err)
return nil
}
return nc
}
func TestServerSecureConnections(t *testing.T) {
t.Skip("Moved to gnatsd, waiting on TLS support")
securePort := uint(2288)
// secureServer := startServer(t, securePort, "--ssl")
// defer secureServer.stopServer()
secureUrl := fmt.Sprintf("nats://localhost:%d/", securePort)
// Make sure this succeeds
nc, err := nats.SecureConnect(secureUrl)
if err != nil {
t.Fatal("Failed to create secure (TLS) connection", err)
}
omsg := []byte("Hello World")
received := 0
nc.Subscribe("foo", func(m *nats.Msg) {
received += 1
if !bytes.Equal(m.Data, omsg) {
t.Fatal("Message received does not match")
}
})
err = nc.Publish("foo", omsg)
if err != nil {
t.Fatal("Failed to publish on secure (TLS) connection", err)
}
nc.Flush()
nc.Close()
// Test flag mismatch
// Wanted but not available..
nc, err = nats.SecureConnect(nats.DefaultURL)
if err == nil || nc != nil || err != nats.ErrSecureConnWanted {
t.Fatalf("Should have failed to create connection: %v", err)
}
// Server required, but not requested.
nc, err = nats.Connect(secureUrl)
if err == nil || nc != nil || err != nats.ErrSecureConnRequired {
t.Fatal("Should have failed to create secure (TLS) connection")
}
}
func TestErrOnConnectAndDeadlock(t *testing.T) {
// We will hand run a fake server that will timeout and not return a proper
// INFO proto. This is to test that we do not deadlock. Issue #18
l, e := net.Listen("tcp", ":0")
if e != nil {
t.Fatal("Could not listen on an ephemeral port")
}
tl := l.(*net.TCPListener)
addr := tl.Addr().(*net.TCPAddr)
go func() {
conn, err := l.Accept()
if err != nil {
t.Fatalf("Error accepting client connection: %v\n", err)
}
defer conn.Close()
// Send back a mal-formed INFO.
conn.Write([]byte("INFOZ \r\n"))
}()
// Used to synchronize
ch := make(chan bool)
go func() {
natsUrl := fmt.Sprintf("nats://localhost:%d/", addr.Port)
_, err := nats.Connect(natsUrl)
if err == nil {
t.Fatal("Expected bad INFO err, got none")
}
ch <- true
}()
// Setup a timer to watch for deadlock
select {
case <-ch:
break
case <-time.After(time.Second):
t.Fatalf("Connect took too long, deadlock?")
}
}