From 5bcf13080590b8f6404ad5c78b4752aa2e17e204 Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Wed, 23 Jan 2013 22:33:01 +0000 Subject: [PATCH] Remove embedded logger from state tracker. Hmmmm. --- state/channel.go | 18 +++--- state/channel_test.go | 57 +++-------------- state/nick.go | 10 ++- state/nick_test.go | 47 +++----------- state/tracker.go | 46 +++++++------- state/tracker_test.go | 139 ++++++++++-------------------------------- 6 files changed, 83 insertions(+), 234 deletions(-) diff --git a/state/channel.go b/state/channel.go index c87a00c..5067348 100644 --- a/state/channel.go +++ b/state/channel.go @@ -13,7 +13,6 @@ type Channel struct { Modes *ChanMode lookup map[string]*Nick nicks map[*Nick]*ChanPrivs - l logging.Logger } // A struct representing the modes of an IRC Channel @@ -97,13 +96,12 @@ func init() { * Channel methods for state management \******************************************************************************/ -func NewChannel(name string, l logging.Logger) *Channel { +func NewChannel(name string) *Channel { return &Channel{ Name: name, Modes: new(ChanMode), nicks: make(map[*Nick]*ChanPrivs), lookup: make(map[string]*Nick), - l: l, } } @@ -124,7 +122,7 @@ func (ch *Channel) addNick(nk *Nick, cp *ChanPrivs) { ch.nicks[nk] = cp ch.lookup[nk.Nick] = nk } else { - ch.l.Warn("Channel.addNick(): %s already on %s.", nk.Nick, ch.Name) + logging.Warn("Channel.addNick(): %s already on %s.", nk.Nick, ch.Name) } } @@ -134,7 +132,7 @@ func (ch *Channel) delNick(nk *Nick) { delete(ch.nicks, nk) delete(ch.lookup, nk.Nick) } else { - ch.l.Warn("Channel.delNick(): %s not on %s.", nk.Nick, ch.Name) + logging.Warn("Channel.delNick(): %s not on %s.", nk.Nick, ch.Name) } } @@ -176,7 +174,7 @@ func (ch *Channel) ParseModes(modes string, modeargs ...string) { } else if !modeop { ch.Modes.Key = "" } else { - ch.l.Warn("Channel.ParseModes(): not enough arguments to "+ + logging.Warn("Channel.ParseModes(): not enough arguments to "+ "process MODE %s %s%c", ch.Name, modestr, m) } case 'l': @@ -186,7 +184,7 @@ func (ch *Channel) ParseModes(modes string, modeargs ...string) { } else if !modeop { ch.Modes.Limit = 0 } else { - ch.l.Warn("Channel.ParseModes(): not enough arguments to "+ + logging.Warn("Channel.ParseModes(): not enough arguments to "+ "process MODE %s %s%c", ch.Name, modestr, m) } case 'q', 'a', 'o', 'h', 'v': @@ -207,15 +205,15 @@ func (ch *Channel) ParseModes(modes string, modeargs ...string) { } modeargs = modeargs[1:] } else { - ch.l.Warn("Channel.ParseModes(): untracked nick %s "+ + logging.Warn("Channel.ParseModes(): untracked nick %s "+ "received MODE on channel %s", modeargs[0], ch.Name) } } else { - ch.l.Warn("Channel.ParseModes(): not enough arguments to "+ + logging.Warn("Channel.ParseModes(): not enough arguments to "+ "process MODE %s %s%c", ch.Name, modestr, m) } default: - ch.l.Info("Channel.ParseModes(): unknown mode char %c", m) + logging.Info("Channel.ParseModes(): unknown mode char %c", m) } } } diff --git a/state/channel_test.go b/state/channel_test.go index 48c8124..f714044 100644 --- a/state/channel_test.go +++ b/state/channel_test.go @@ -5,12 +5,9 @@ import ( ) func TestNewChannel(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() + ch := NewChannel("#test1") - ch := NewChannel("#test1", s.log) - - if ch.Name != "#test1" || ch.l != s.log { + if ch.Name != "#test1" { t.Errorf("Channel not created correctly by NewChannel()") } if len(ch.nicks) != 0 || len(ch.lookup) != 0 { @@ -19,11 +16,8 @@ func TestNewChannel(t *testing.T) { } func TestAddNick(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - ch := NewChannel("#test1", s.log) - nk := NewNick("test1", s.log) + ch := NewChannel("#test1") + nk := NewNick("test1") cp := new(ChanPrivs) ch.addNick(nk, cp) @@ -37,25 +31,13 @@ func TestAddNick(t *testing.T) { if n, ok := ch.lookup["test1"]; !ok || n != nk { t.Errorf("Nick test1 not properly stored in lookup map.") } - - s.log.EXPECT().Warn("Channel.addNick(): %s already on %s.", - "test1", "#test1") - ch.addNick(nk, cp) } func TestDelNick(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - ch := NewChannel("#test1", s.log) - nk := NewNick("test1", s.log) + ch := NewChannel("#test1") + nk := NewNick("test1") cp := new(ChanPrivs) - // Testing the error state first is easier - s.log.EXPECT().Warn("Channel.delNick(): %s not on %s.", - "test1", "#test1") - ch.delNick(nk) - ch.addNick(nk, cp) ch.delNick(nk) if len(ch.nicks) != 0 || len(ch.lookup) != 0 { @@ -70,14 +52,11 @@ func TestDelNick(t *testing.T) { } func TestChannelParseModes(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - ch := NewChannel("#test1", s.log) + ch := NewChannel("#test1") md := ch.Modes // Channel modes can adjust channel privs too, so we need a Nick - nk := NewNick("test1", s.log) + nk := NewNick("test1") cp := new(ChanPrivs) ch.addNick(nk, cp) @@ -111,9 +90,7 @@ func TestChannelParseModes(t *testing.T) { t.Errorf("Limit for channel not set correctly") } - // enable limit incorrectly. see nick_test.go for why the byte() cast. - s.log.EXPECT().Warn("Channel.ParseModes(): not enough arguments to "+ - "process MODE %s %s%c", "#test1", "+", byte('l')) + // enable limit incorrectly ch.ParseModes("+l") if md.Limit != 256 { t.Errorf("Bad limit value caused limit to be unset.") @@ -137,8 +114,6 @@ func TestChannelParseModes(t *testing.T) { } // enable key incorrectly - s.log.EXPECT().Warn("Channel.ParseModes(): not enough arguments to "+ - "process MODE %s %s%c", "#test1", "+", byte('k')) ch.ParseModes("+k") if md.Key != "foobar" { t.Errorf("Bad key value caused key to be unset.") @@ -159,18 +134,8 @@ func TestChannelParseModes(t *testing.T) { t.Errorf("Channel privileges not flipped correctly by ParseModes.") } - s.log.EXPECT().Warn("Channel.ParseModes(): untracked nick %s "+ - "received MODE on channel %s", "test2", "#test1") - ch.ParseModes("+v", "test2") - - s.log.EXPECT().Warn("Channel.ParseModes(): not enough arguments to "+ - "process MODE %s %s%c", "#test1", "-", byte('v')) - ch.ParseModes("-v") - // Test a random mix of modes, just to be sure md.Limit = 256 - s.log.EXPECT().Warn("Channel.ParseModes(): not enough arguments to "+ - "process MODE %s %s%c", "#test1", "-", byte('h')) ch.ParseModes("+zpt-qsl+kv-h", "test1", "foobar", "test1") if !md.Private || md.Secret || !md.ProtectedTopic || !md.NoExternalMsg || @@ -184,8 +149,4 @@ func TestChannelParseModes(t *testing.T) { // NOTE: HalfOp not actually unset above thanks to deliberate error. t.Errorf("Channel privileges not flipped correctly by ParseModes (2).") } - - // Finally, check we get an info log for an unrecognised mode character - s.log.EXPECT().Info("Channel.ParseModes(): unknown mode char %c", byte('d')) - ch.ParseModes("+d") } diff --git a/state/nick.go b/state/nick.go index 725e698..96a0b48 100644 --- a/state/nick.go +++ b/state/nick.go @@ -11,7 +11,6 @@ type Nick struct { Modes *NickMode lookup map[string]*Channel chans map[*Channel]*ChanPrivs - l logging.Logger } // A struct representing the modes of an IRC Nick (User Modes) @@ -45,13 +44,12 @@ func init() { * Nick methods for state management \******************************************************************************/ -func NewNick(n string, l logging.Logger) *Nick { +func NewNick(n string) *Nick { return &Nick{ Nick: n, Modes: new(NickMode), chans: make(map[*Channel]*ChanPrivs), lookup: make(map[string]*Channel), - l: l, } } @@ -72,7 +70,7 @@ func (nk *Nick) addChannel(ch *Channel, cp *ChanPrivs) { nk.chans[ch] = cp nk.lookup[ch.Name] = ch } else { - nk.l.Warn("Nick.addChannel(): %s already on %s.", nk.Nick, ch.Name) + logging.Warn("Nick.addChannel(): %s already on %s.", nk.Nick, ch.Name) } } @@ -82,7 +80,7 @@ func (nk *Nick) delChannel(ch *Channel) { delete(nk.chans, ch) delete(nk.lookup, ch.Name) } else { - nk.l.Warn("Nick.delChannel(): %s not on %s.", nk.Nick, ch.Name) + logging.Warn("Nick.delChannel(): %s not on %s.", nk.Nick, ch.Name) } } @@ -108,7 +106,7 @@ func (nk *Nick) ParseModes(modes string) { case 'z': nk.Modes.SSL = modeop default: - nk.l.Info("Nick.ParseModes(): unknown mode char %c", m) + logging.Info("Nick.ParseModes(): unknown mode char %c", m) } } } diff --git a/state/nick_test.go b/state/nick_test.go index 283f908..c01ec1a 100644 --- a/state/nick_test.go +++ b/state/nick_test.go @@ -5,12 +5,9 @@ import ( ) func TestNewNick(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() + nk := NewNick("test1") - nk := NewNick("test1", s.log) - - if nk.Nick != "test1" || nk.l != s.log { + if nk.Nick != "test1" { t.Errorf("Nick not created correctly by NewNick()") } if len(nk.chans) != 0 || len(nk.lookup) != 0 { @@ -19,11 +16,8 @@ func TestNewNick(t *testing.T) { } func TestAddChannel(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - nk := NewNick("test1", s.log) - ch := NewChannel("#test1", s.log) + nk := NewNick("test1") + ch := NewChannel("#test1") cp := new(ChanPrivs) nk.addChannel(ch, cp) @@ -37,24 +31,13 @@ func TestAddChannel(t *testing.T) { if c, ok := nk.lookup["#test1"]; !ok || c != ch { t.Errorf("Channel #test1 not properly stored in lookup map.") } - - s.log.EXPECT().Warn("Nick.addChannel(): %s already on %s.", - "test1", "#test1") - nk.addChannel(ch, cp) } func TestDelChannel(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - nk := NewNick("test1", s.log) - ch := NewChannel("#test1", s.log) + nk := NewNick("test1") + ch := NewChannel("#test1") cp := new(ChanPrivs) - // Testing the error state first is easier - s.log.EXPECT().Warn("Nick.delChannel(): %s not on %s.", "test1", "#test1") - nk.delChannel(ch) - nk.addChannel(ch, cp) nk.delChannel(ch) if len(nk.chans) != 0 || len(nk.lookup) != 0 { @@ -69,10 +52,7 @@ func TestDelChannel(t *testing.T) { } func TestNickParseModes(t *testing.T) { - _, s := setUp(t) - defer s.tearDown() - - nk := NewNick("test1", s.log) + nk := NewNick("test1") md := nk.Modes // Modes should all be false for a new nick @@ -90,17 +70,4 @@ func TestNickParseModes(t *testing.T) { if !md.Invisible || md.Oper || !md.WallOps || md.HiddenHost || !md.SSL { t.Errorf("Modes not flipped correctly by ParseModes.") } - - // Check that passing an unknown mode char results in an info log - // The cast to byte here is needed to pass; gomock uses reflect.DeepEqual - // to examine argument equality, but 'd' (when not implicitly coerced to a - // uint8 by the type system) is an int, whereas string("+d")[1] is not. - // This type difference (despite the values being nominally the same) - // causes the test to fail with the following confusing error. - // - // no matching expected call: *logging.MockLogger.Info([Nick.ParseModes(): unknown mode char %c [100]]) - // missing call(s) to *logging.MockLogger.Info(is equal to Nick.ParseModes(): unknown mode char %c, is equal to [100]) - - s.log.EXPECT().Info("Nick.ParseModes(): unknown mode char %c", byte('d')) - nk.ParseModes("+d") } diff --git a/state/tracker.go b/state/tracker.go index d168b78..fb29cd2 100644 --- a/state/tracker.go +++ b/state/tracker.go @@ -35,17 +35,13 @@ type stateTracker struct { // We need to keep state on who we are :-) me *Nick - - // For great logging justice. - l logging.Logger } // ... and a constructor to make it ... -func NewTracker(mynick string, l logging.Logger) *stateTracker { +func NewTracker(mynick string) *stateTracker { st := &stateTracker{ chans: make(map[string]*Channel), nicks: make(map[string]*Nick), - l: l, } st.me = st.NewNick(mynick) return st @@ -67,10 +63,10 @@ func (st *stateTracker) Wipe() { // can be properly tracked for state management purposes. func (st *stateTracker) NewNick(n string) *Nick { if _, ok := st.nicks[n]; ok { - st.l.Warn("StateTracker.NewNick(): %s already tracked.", n) + logging.Warn("StateTracker.NewNick(): %s already tracked.", n) return nil } - st.nicks[n] = NewNick(n, st.l) + st.nicks[n] = NewNick(n) return st.nicks[n] } @@ -97,10 +93,10 @@ func (st *stateTracker) ReNick(old, neu string) { ch.lookup[neu] = nk } } else { - st.l.Warn("StateTracker.ReNick(): %s already exists.", neu) + logging.Warn("StateTracker.ReNick(): %s already exists.", neu) } } else { - st.l.Warn("StateTracker.ReNick(): %s not tracked.", old) + logging.Warn("StateTracker.ReNick(): %s not tracked.", old) } } @@ -110,17 +106,17 @@ func (st *stateTracker) DelNick(n string) { if nk != st.me { st.delNick(nk) } else { - st.l.Warn("StateTracker.DelNick(): won't delete myself.") + logging.Warn("StateTracker.DelNick(): won't delete myself.") } } else { - st.l.Warn("StateTracker.DelNick(): %s not tracked.", n) + logging.Warn("StateTracker.DelNick(): %s not tracked.", n) } } func (st *stateTracker) delNick(nk *Nick) { if nk == st.me { // Shouldn't get here => internal state tracking code is fubar. - st.l.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(") + logging.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(") return } delete(st.nicks, nk.Nick) @@ -130,7 +126,7 @@ func (st *stateTracker) delNick(nk *Nick) { if len(ch.nicks) == 0 { // Deleting a nick from tracking shouldn't empty any channels as // *we* should be on the channel with them to be tracking them. - st.l.Error("StateTracker.delNick(): deleting nick %s emptied "+ + logging.Error("StateTracker.delNick(): deleting nick %s emptied "+ "channel %s, this shouldn't happen!", nk.Nick, ch.Name) } } @@ -140,10 +136,10 @@ func (st *stateTracker) delNick(nk *Nick) { // can be properly tracked for state management purposes. func (st *stateTracker) NewChannel(c string) *Channel { if _, ok := st.chans[c]; ok { - st.l.Warn("StateTracker.NewChannel(): %s already tracked.", c) + logging.Warn("StateTracker.NewChannel(): %s already tracked.", c) return nil } - st.chans[c] = NewChannel(c, st.l) + st.chans[c] = NewChannel(c) return st.chans[c] } @@ -160,7 +156,7 @@ func (st *stateTracker) DelChannel(c string) { if ch, ok := st.chans[c]; ok { st.delChannel(ch) } else { - st.l.Warn("StateTracker.DelChannel(): %s not tracked.", c) + logging.Warn("StateTracker.DelChannel(): %s not tracked.", c) } } @@ -195,19 +191,21 @@ func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) { // Associates an already known nick with an already known channel. func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { if ch == nil || nk == nil { - st.l.Error("StateTracker.Associate(): passed nil values :-(") + logging.Error("StateTracker.Associate(): passed nil values :-(") return nil } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { // As we can implicitly delete both nicks and channels from being // tracked by dissociating one from the other, we should verify that // we're not being passed an old Nick or Channel. - st.l.Error("StateTracker.Associate(): channel %s not found in "+ + logging.Error("StateTracker.Associate(): channel %s not found in "+ "(or differs from) internal state.", ch.Name) + return nil } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { - st.l.Error("StateTracker.Associate(): nick %s not found in "+ + logging.Error("StateTracker.Associate(): nick %s not found in "+ "(or differs from) internal state.", nk.Nick) + return nil } else if _, ok := nk.IsOn(ch); ok { - st.l.Warn("StateTracker.Associate(): %s already on %s.", + logging.Warn("StateTracker.Associate(): %s already on %s.", nk.Nick, ch.Name) return nil } @@ -222,18 +220,18 @@ func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { // any common channels with, and channels we're no longer on. func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) { if ch == nil || nk == nil { - st.l.Error("StateTracker.Dissociate(): passed nil values :-(") + logging.Error("StateTracker.Dissociate(): passed nil values :-(") } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { // As we can implicitly delete both nicks and channels from being // tracked by dissociating one from the other, we should verify that // we're not being passed an old Nick or Channel. - st.l.Error("StateTracker.Dissociate(): channel %s not found in "+ + logging.Error("StateTracker.Dissociate(): channel %s not found in "+ "(or differs from) internal state.", ch.Name) } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { - st.l.Error("StateTracker.Dissociate(): nick %s not found in "+ + logging.Error("StateTracker.Dissociate(): nick %s not found in "+ "(or differs from) internal state.", nk.Nick) } else if _, ok := nk.IsOn(ch); !ok { - st.l.Warn("StateTracker.Dissociate(): %s not on %s.", + logging.Warn("StateTracker.Dissociate(): %s not on %s.", nk.Nick, ch.Name) } else if nk == st.me { // I'm leaving the channel for some reason, so it won't be tracked. diff --git a/state/tracker_test.go b/state/tracker_test.go index e68273d..e6f3584 100644 --- a/state/tracker_test.go +++ b/state/tracker_test.go @@ -1,33 +1,19 @@ package state import ( - "code.google.com/p/gomock/gomock" "github.com/fluffle/golog/logging" "testing" ) -type testState struct { - ctrl *gomock.Controller - log *logging.MockLogger -} - -func setUp(t *testing.T) (*stateTracker, *testState) { - ctrl := gomock.NewController(t) - log := logging.NewMockLogger(ctrl) - return NewTracker("mynick", log), &testState{ctrl, log} -} - -func (s *testState) tearDown() { - s.ctrl.Finish() +func init() { + // This is probably a dirty hack... + logging.InitFromFlags() + logging.SetLogLevel(logging.LogFatal) } func TestSTNewTracker(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") - if st.l != s.log { - t.Errorf("State tracker's logger not set correctly.") - } if len(st.nicks) != 1 { t.Errorf("Nick list of new tracker is not 1 (me!).") } @@ -40,28 +26,23 @@ func TestSTNewTracker(t *testing.T) { } func TestSTNewNick(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() - + st := NewTracker("mynick") test1 := st.NewNick("test1") - if test1 == nil || test1.Nick != "test1" || test1.l != s.log { + if test1 == nil || test1.Nick != "test1" { t.Errorf("Nick object created incorrectly by NewNick.") } if n, ok := st.nicks["test1"]; !ok || n != test1 || len(st.nicks) != 2 { t.Errorf("Nick object stored incorrectly by NewNick.") } - s.log.EXPECT().Warn("StateTracker.NewNick(): %s already tracked.", "test1") if fail := st.NewNick("test1"); fail != nil { t.Errorf("Creating duplicate nick did not produce nil return.") } } func TestSTGetNick(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() - + st := NewTracker("mynick") test1 := st.NewNick("test1") if n := st.GetNick("test1"); n != test1 { @@ -76,9 +57,7 @@ func TestSTGetNick(t *testing.T) { } func TestSTReNick(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() - + st := NewTracker("mynick") test1 := st.NewNick("test1") // This channel is here to ensure that its lookup map gets updated @@ -107,8 +86,6 @@ func TestSTReNick(t *testing.T) { } test2 := st.NewNick("test1") - - s.log.EXPECT().Warn("StateTracker.ReNick(): %s already exists.", "test2") st.ReNick("test1", "test2") if n, ok := st.nicks["test2"]; !ok || n != test1 { @@ -120,14 +97,10 @@ func TestSTReNick(t *testing.T) { if len(st.nicks) != 3 { t.Errorf("Nick list changed size during ReNick.") } - - s.log.EXPECT().Warn("StateTracker.ReNick(): %s not tracked.", "test3") - st.ReNick("test3", "test2") } func TestSTDelNick(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") st.NewNick("test1") st.DelNick("test1") @@ -142,17 +115,13 @@ func TestSTDelNick(t *testing.T) { // Deleting unknown nick shouldn't work, but let's make sure we have a // known nick first to catch any possible accidental removals. nick1 := st.NewNick("test1") - - s.log.EXPECT().Warn("StateTracker.DelNick(): %s not tracked.", "test2") st.DelNick("test2") if len(st.nicks) != 2 { t.Errorf("Deleting unknown nick had unexpected side-effects.") } // Deleting my nick shouldn't work - s.log.EXPECT().Warn("StateTracker.DelNick(): won't delete myself.") st.DelNick("mynick") - if len(st.nicks) != 2 { t.Errorf("Deleting myself had unexpected side-effects.") } @@ -192,8 +161,7 @@ func TestSTDelNick(t *testing.T) { } func TestSTNewChannel(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") if len(st.chans) != 0 { t.Errorf("Channel list of new tracker is non-zero length.") @@ -201,22 +169,20 @@ func TestSTNewChannel(t *testing.T) { test1 := st.NewChannel("#test1") - if test1 == nil || test1.Name != "#test1" || test1.l != s.log { + if test1 == nil || test1.Name != "#test1" { t.Errorf("Channel object created incorrectly by NewChannel.") } if c, ok := st.chans["#test1"]; !ok || c != test1 || len(st.chans) != 1 { t.Errorf("Channel object stored incorrectly by NewChannel.") } - s.log.EXPECT().Warn("StateTracker.NewChannel(): %s already tracked.", "#test1") if fail := st.NewChannel("#test1"); fail != nil { t.Errorf("Creating duplicate chan did not produce nil return.") } } func TestSTGetChannel(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") test1 := st.NewChannel("#test1") @@ -232,8 +198,7 @@ func TestSTGetChannel(t *testing.T) { } func TestSTDelChannel(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") st.NewChannel("#test1") st.DelChannel("#test1") @@ -248,10 +213,7 @@ func TestSTDelChannel(t *testing.T) { // Deleting unknown nick shouldn't work, but let's make sure we have a // known nick first to catch any possible accidental removals. chan1 := st.NewChannel("#test1") - - s.log.EXPECT().Warn("StateTracker.DelChannel(): %s not tracked.", "#test2") st.DelChannel("#test2") - if len(st.chans) != 1 { t.Errorf("DelChannel had unexpected side-effects.") } @@ -306,8 +268,7 @@ func TestSTDelChannel(t *testing.T) { } func TestSTIsOn(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") nick1 := st.NewNick("test1") chan1 := st.NewChannel("#test1") @@ -322,8 +283,7 @@ func TestSTIsOn(t *testing.T) { } func TestSTAssociate(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") nick1 := st.NewNick("test1") chan1 := st.NewChannel("#test1") @@ -337,32 +297,25 @@ func TestSTAssociate(t *testing.T) { } // Test error cases - s.log.EXPECT().Error("StateTracker.Associate(): passed nil values :-(") - st.Associate(nil, nick1) - - s.log.EXPECT().Error("StateTracker.Associate(): passed nil values :-(") - st.Associate(chan1, nil) - - s.log.EXPECT().Warn("StateTracker.Associate(): %s already on %s.", - "test1", "#test1") - st.Associate(chan1, nick1) - - // nick2 deliberately created directly here. - nick2 := NewNick("test2", s.log) - s.log.EXPECT().Error("StateTracker.Associate(): nick %s not found in "+ - "(or differs from) internal state.", "test2") - st.Associate(chan1, nick2) - - // chan2 deliberately created directly here. - chan2 := NewChannel("#test2", s.log) - s.log.EXPECT().Error("StateTracker.Associate(): channel %s not found in "+ - "(or differs from) internal state.", "#test2") - st.Associate(chan2, nick1) + if st.Associate(nil, nick1) != nil { + t.Errorf("Associating nil *Channel did not return nil.") + } + if st.Associate(chan1, nil) != nil { + t.Errorf("Associating nil *Nick did not return nil.") + } + if st.Associate(chan1, nick1) != nil { + t.Errorf("Associating already-associated things did not return nil.") + } + if st.Associate(chan1, NewNick("test2")) != nil { + t.Errorf("Associating unknown *Nick did not return nil.") + } + if st.Associate(NewChannel("#test2"), nick1) != nil { + t.Errorf("Associating unknown *Channel did not return nil.") + } } func TestSTDissociate(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") nick1 := st.NewNick("test1") chan1 := st.NewChannel("#test1") @@ -417,36 +370,10 @@ func TestSTDissociate(t *testing.T) { len(st.me.chans) != 2 || len(nick1.chans) != 0 || len(st.chans) != 2 { t.Errorf("Dissociating a nick from it's last channel went wrong.") } - - // Check error cases - // test1 was deleted above, so "re-track" it for this test. - nick1 = st.NewNick("test1") - s.log.EXPECT().Warn("StateTracker.Dissociate(): %s not on %s.", - "test1", "#test1") - st.Dissociate(chan1, nick1) - - s.log.EXPECT().Error("StateTracker.Dissociate(): passed nil values :-(") - st.Dissociate(chan1, nil) - - s.log.EXPECT().Error("StateTracker.Dissociate(): passed nil values :-(") - st.Dissociate(nil, nick1) - - // nick3 deliberately created directly here. - nick3 := NewNick("test3", s.log) - s.log.EXPECT().Error("StateTracker.Dissociate(): nick %s not found in "+ - "(or differs from) internal state.", "test3") - st.Dissociate(chan1, nick3) - - // chan3 deliberately created directly here. - chan3 := NewChannel("#test3", s.log) - s.log.EXPECT().Error("StateTracker.Dissociate(): channel %s not found in "+ - "(or differs from) internal state.", "#test3") - st.Dissociate(chan3, nick1) } func TestSTWipe(t *testing.T) { - st, s := setUp(t) - defer s.tearDown() + st := NewTracker("mynick") nick1 := st.NewNick("test1") nick2 := st.NewNick("test2")