mirror of https://github.com/fluffle/goirc
117 lines
2.9 KiB
Go
117 lines
2.9 KiB
Go
package client
|
|
|
|
import (
|
|
"github.com/fluffle/goirc/logging"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func init() {
|
|
// We have Error level logging that is printed on socket shutdown
|
|
// which we don't care too much about when testing with a mock conn...
|
|
logging.SetLogLevel(logging.LogFatal)
|
|
}
|
|
|
|
func setUp(t *testing.T) (*mockNetConn, *Conn) {
|
|
c := New("test", "test", "Testing IRC")
|
|
c.State = t
|
|
|
|
// Assert some basic things about the initial state of the Conn struct
|
|
if c.Me.Nick != "test" ||
|
|
c.Me.Ident != "test" ||
|
|
c.Me.Name != "Testing IRC" ||
|
|
c.Me.Host != "" {
|
|
t.Errorf("Conn.Me not correctly initialised.")
|
|
}
|
|
if len(c.chans) != 0 {
|
|
t.Errorf("Some channels are already known:")
|
|
for _, ch := range c.chans {
|
|
t.Logf(ch.String())
|
|
}
|
|
}
|
|
if len(c.nicks) != 1 {
|
|
t.Errorf("Other Nicks than ourselves exist:")
|
|
for _, n := range c.nicks {
|
|
t.Logf(n.String())
|
|
}
|
|
}
|
|
|
|
m := MockNetConn(t)
|
|
c.sock = m
|
|
c.postConnect()
|
|
c.Flood = true // Tests can take a while otherwise
|
|
c.Connected = true
|
|
return m, c
|
|
}
|
|
|
|
func tearDown(m *mockNetConn, c *Conn) {
|
|
c.shutdown()
|
|
}
|
|
|
|
func TestShutdown(t *testing.T) {
|
|
_, c := setUp(t)
|
|
|
|
// Setup a mock event dispatcher to test correct triggering of "disconnected"
|
|
flag := false
|
|
c.Dispatcher = WasEventDispatched("disconnected", &flag)
|
|
|
|
// Call shutdown manually
|
|
c.shutdown()
|
|
|
|
// Verify that the connection no longer thinks it's connected
|
|
if c.Connected {
|
|
t.Errorf("Conn still thinks it's connected to the server.")
|
|
}
|
|
|
|
// Verify that the "disconnected" event fired correctly
|
|
if !flag {
|
|
t.Errorf("Calling Close() didn't result in dispatch of disconnected event.")
|
|
}
|
|
|
|
// TODO(fluffle): Try to work out a way of testing that the background
|
|
// goroutines were *actually* stopped? Test m a bit more?
|
|
}
|
|
|
|
// Practically the same as the above test, but shutdown is called implicitly
|
|
// by recv() getting an EOF from the mock connection.
|
|
func TestEOF(t *testing.T) {
|
|
m, c := setUp(t)
|
|
|
|
// Setup a mock event dispatcher to test correct triggering of "disconnected"
|
|
flag := false
|
|
c.Dispatcher = WasEventDispatched("disconnected", &flag)
|
|
|
|
// Simulate EOF from server
|
|
m.Close()
|
|
|
|
// Since things happen in different internal goroutines, we need to wait
|
|
// 1 ms should be enough :-)
|
|
time.Sleep(1e6)
|
|
|
|
// Verify that the connection no longer thinks it's connected
|
|
if c.Connected {
|
|
t.Errorf("Conn still thinks it's connected to the server.")
|
|
}
|
|
|
|
// Verify that the "disconnected" event fired correctly
|
|
if !flag {
|
|
t.Errorf("Calling Close() didn't result in dispatch of disconnected event.")
|
|
}
|
|
}
|
|
|
|
// Mock dispatcher to verify that events are triggered successfully
|
|
type mockDispatcher func(string, ...interface{})
|
|
|
|
func (d mockDispatcher) Dispatch(name string, ev ...interface{}) {
|
|
d(name, ev...)
|
|
}
|
|
|
|
func WasEventDispatched(name string, flag *bool) mockDispatcher {
|
|
return mockDispatcher(func(n string, ev ...interface{}) {
|
|
if n == strings.ToLower(name) {
|
|
*flag = true
|
|
}
|
|
})
|
|
}
|