mirror of
https://github.com/fluffle/goirc
synced 2025-07-06 21:39:21 +00:00
Convert state tracker to use gomock logging for tests.
This commit is contained in:
Alex Bramley
parent
d0f0175d7f
commit
69d52270b6
4 changed files with 326 additions and 179 deletions
|
|
@ -2,16 +2,30 @@ package state
|
|||
|
||||
import (
|
||||
"github.com/fluffle/goirc/logging"
|
||||
"gomock.googlecode.com/hg/gomock"
|
||||
"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 TestSTNewTracker(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
st := NewTracker("mynick", l)
|
||||
m.ExpectNothing()
|
||||
|
||||
if st.l != l {
|
||||
if st.l != s.log {
|
||||
t.Errorf("State tracker's logger not set correctly.")
|
||||
}
|
||||
if len(st.nicks) != 1 {
|
||||
|
|
@ -26,31 +40,29 @@ func TestSTNewTracker(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSTNewNick(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
test1 := st.NewNick("test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
if test1 == nil || test1.Nick != "test1" || test1.l != l {
|
||||
if test1 == nil || test1.Nick != "test1" || test1.l != s.log {
|
||||
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.")
|
||||
}
|
||||
m.ExpectAt(logging.Warn, "StateTracker.NewNick(): test1 already tracked.")
|
||||
}
|
||||
|
||||
func TestSTGetNick(t *testing.T) {
|
||||
l, _ := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
test1 := NewNick("test1", l)
|
||||
st.nicks["test1"] = test1
|
||||
test1 := st.NewNick("test1")
|
||||
|
||||
if n := st.GetNick("test1"); n != test1 {
|
||||
t.Errorf("Incorrect nick returned by GetNick.")
|
||||
|
|
@ -64,20 +76,16 @@ func TestSTGetNick(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSTReNick(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
test1 := NewNick("test1", l)
|
||||
st.nicks["test1"] = test1
|
||||
test1 := st.NewNick("test1")
|
||||
|
||||
// This channel is here to ensure that its lookup map gets updated
|
||||
cp := new(ChanPrivs)
|
||||
chan1 := NewChannel("#chan1", l)
|
||||
test1.addChannel(chan1, cp)
|
||||
chan1.addNick(test1, cp)
|
||||
chan1 := st.NewChannel("#chan1")
|
||||
st.Associate(chan1, test1)
|
||||
|
||||
st.ReNick("test1", "test2")
|
||||
m.ExpectNothing()
|
||||
|
||||
if _, ok := st.nicks["test1"]; ok {
|
||||
t.Errorf("Nick test1 still exists after ReNick.")
|
||||
|
|
@ -98,11 +106,10 @@ func TestSTReNick(t *testing.T) {
|
|||
t.Errorf("Nick list changed size during ReNick.")
|
||||
}
|
||||
|
||||
test2 := NewNick("test1", l)
|
||||
st.nicks["test1"] = test2
|
||||
test2 := st.NewNick("test1")
|
||||
|
||||
s.log.EXPECT().Warn("StateTracker.ReNick(): %s already exists.", "test2")
|
||||
st.ReNick("test1", "test2")
|
||||
m.ExpectAt(logging.Warn, "StateTracker.ReNick(): test2 already exists.")
|
||||
|
||||
if n, ok := st.nicks["test2"]; !ok || n != test1 {
|
||||
t.Errorf("Nick test2 overwritten/deleted by ReNick.")
|
||||
|
|
@ -114,19 +121,16 @@ func TestSTReNick(t *testing.T) {
|
|||
t.Errorf("Nick list changed size during ReNick.")
|
||||
}
|
||||
|
||||
s.log.EXPECT().Warn("StateTracker.ReNick(): %s not tracked.", "test3")
|
||||
st.ReNick("test3", "test2")
|
||||
m.ExpectAt(logging.Warn, "StateTracker.ReNick(): test3 not tracked.")
|
||||
}
|
||||
|
||||
func TestSTDelNick(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
|
||||
nick1 := NewNick("test1", l)
|
||||
st.nicks["test1"] = nick1
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
st.NewNick("test1")
|
||||
st.DelNick("test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
if _, ok := st.nicks["test1"]; ok {
|
||||
t.Errorf("Nick test1 still exists after DelNick.")
|
||||
|
|
@ -135,18 +139,19 @@ func TestSTDelNick(t *testing.T) {
|
|||
t.Errorf("Nick list still contains nicks after DelNick.")
|
||||
}
|
||||
|
||||
st.nicks["test1"] = nick1
|
||||
// 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")
|
||||
m.ExpectAt(logging.Warn, "StateTracker.DelNick(): test2 not tracked.")
|
||||
|
||||
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")
|
||||
m.ExpectAt(logging.Warn, "StateTracker.DelNick(): won't delete myself.")
|
||||
|
||||
if len(st.nicks) != 2 {
|
||||
t.Errorf("Deleting myself had unexpected side-effects.")
|
||||
|
|
@ -155,19 +160,14 @@ func TestSTDelNick(t *testing.T) {
|
|||
// Test that deletion correctly dissociates nick from channels.
|
||||
// NOTE: the two error states in delNick (as opposed to DelNick)
|
||||
// are not tested for here, as they will only arise from programming
|
||||
// errors in other methods. Using m.CheckNothingWritten() while
|
||||
// testing these methods will catch those errors should they occur.
|
||||
// errors in other methods. The mock logger should catch these.
|
||||
|
||||
// Create a new channel for testing purposes
|
||||
chan1 := NewChannel("#test1", l)
|
||||
st.chans["#test1"] = chan1
|
||||
// Create a new channel for testing purposes.
|
||||
chan1 := st.NewChannel("#test1")
|
||||
|
||||
// Associate both "my" nick and test1 with the channel
|
||||
p := new(ChanPrivs)
|
||||
chan1.addNick(st.me, p)
|
||||
st.me.addChannel(chan1, p)
|
||||
chan1.addNick(nick1, p)
|
||||
nick1.addChannel(chan1, p)
|
||||
st.Associate(chan1, st.me)
|
||||
st.Associate(chan1, nick1)
|
||||
|
||||
// Test we have the expected starting state (at least vaguely)
|
||||
if len(chan1.nicks) != 2 || len(st.nicks) != 2 ||
|
||||
|
|
@ -176,7 +176,6 @@ func TestSTDelNick(t *testing.T) {
|
|||
}
|
||||
|
||||
st.DelNick("test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
// Actual deletion tested above...
|
||||
if len(chan1.nicks) != 1 || len(st.chans) != 1 ||
|
||||
|
|
@ -193,35 +192,33 @@ func TestSTDelNick(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSTNewChannel(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
if len(st.chans) != 0 {
|
||||
t.Errorf("Channel list of new tracker is non-zero length.")
|
||||
}
|
||||
|
||||
test1 := st.NewChannel("#test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
if test1 == nil || test1.Name != "#test1" || test1.l != l {
|
||||
if test1 == nil || test1.Name != "#test1" || test1.l != s.log {
|
||||
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.")
|
||||
}
|
||||
m.ExpectAt(logging.Warn, "StateTracker.NewChannel(): #test1 already tracked.")
|
||||
}
|
||||
|
||||
func TestSTGetChannel(t *testing.T) {
|
||||
l, _ := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
test1 := NewChannel("#test1", l)
|
||||
st.chans["#test1"] = test1
|
||||
test1 := st.NewChannel("#test1")
|
||||
|
||||
if c := st.GetChannel("#test1"); c != test1 {
|
||||
t.Errorf("Incorrect Channel returned by GetChannel.")
|
||||
|
|
@ -235,14 +232,11 @@ func TestSTGetChannel(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSTDelChannel(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
|
||||
chan1 := NewChannel("#test1", l)
|
||||
st.chans["#test1"] = chan1
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
st.NewChannel("#test1")
|
||||
st.DelChannel("#test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
if _, ok := st.chans["#test1"]; ok {
|
||||
t.Errorf("Channel test1 still exists after DelChannel.")
|
||||
|
|
@ -251,34 +245,28 @@ func TestSTDelChannel(t *testing.T) {
|
|||
t.Errorf("Channel list still contains chans after DelChannel.")
|
||||
}
|
||||
|
||||
st.chans["#test1"] = chan1
|
||||
// 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")
|
||||
m.ExpectAt(logging.Warn, "StateTracker.DelChannel(): #test2 not tracked.")
|
||||
|
||||
if len(st.chans) != 1 {
|
||||
t.Errorf("DelChannel had unexpected side-effects.")
|
||||
}
|
||||
|
||||
// Test that deletion correctly dissociates channel from tracked nicks.
|
||||
|
||||
// In order to test this thoroughly we need two channels (so that delNick()
|
||||
// is not called internally in delChannel() when len(nick1.chans) == 0.
|
||||
chan2 := NewChannel("#test2", l)
|
||||
st.chans["#test2"] = chan2
|
||||
nick1 := NewNick("test1", l)
|
||||
st.nicks["test1"] = nick1
|
||||
chan2 := st.NewChannel("#test2")
|
||||
nick1 := st.NewNick("test1")
|
||||
|
||||
// Associate both "my" nick and test1 with the channels
|
||||
p := new(ChanPrivs)
|
||||
chan1.addNick(st.me, p)
|
||||
st.me.addChannel(chan1, p)
|
||||
chan1.addNick(nick1, p)
|
||||
nick1.addChannel(chan1, p)
|
||||
chan2.addNick(st.me, p)
|
||||
st.me.addChannel(chan2, p)
|
||||
chan2.addNick(nick1, p)
|
||||
nick1.addChannel(chan2, p)
|
||||
st.Associate(chan1, st.me)
|
||||
st.Associate(chan1, nick1)
|
||||
st.Associate(chan2, st.me)
|
||||
st.Associate(chan2, nick1)
|
||||
|
||||
// Test we have the expected starting state (at least vaguely)
|
||||
if len(chan1.nicks) != 2 || len(chan2.nicks) != 2 || len(st.nicks) != 2 ||
|
||||
|
|
@ -287,7 +275,6 @@ func TestSTDelChannel(t *testing.T) {
|
|||
}
|
||||
|
||||
st.DelChannel("#test1")
|
||||
m.ExpectNothing()
|
||||
|
||||
// Test intermediate state. We're still on #test2 with test1, so test1
|
||||
// shouldn't be deleted from state tracking itself just yet.
|
||||
|
|
@ -295,7 +282,6 @@ func TestSTDelChannel(t *testing.T) {
|
|||
len(st.me.chans) != 1 || len(nick1.chans) != 1 || len(st.chans) != 1 {
|
||||
t.Errorf("Deleting channel didn't dissociate correctly from nicks.")
|
||||
}
|
||||
|
||||
if _, ok := nick1.chans[chan1]; ok {
|
||||
t.Errorf("Channel not removed from nick's chans map.")
|
||||
}
|
||||
|
|
@ -304,7 +290,6 @@ func TestSTDelChannel(t *testing.T) {
|
|||
}
|
||||
|
||||
st.DelChannel("#test2")
|
||||
m.ExpectNothing()
|
||||
|
||||
// Test final state. Deleting #test2 means that we're no longer on any
|
||||
// common channels with test1, and thus it should be removed from tracking.
|
||||
|
|
@ -312,7 +297,6 @@ func TestSTDelChannel(t *testing.T) {
|
|||
len(st.me.chans) != 0 || len(nick1.chans) != 0 || len(st.chans) != 0 {
|
||||
t.Errorf("Deleting last channel didn't dissociate correctly from nicks.")
|
||||
}
|
||||
|
||||
if _, ok := st.nicks["test1"]; ok {
|
||||
t.Errorf("Nick not deleted correctly when on no channels.")
|
||||
}
|
||||
|
|
@ -322,63 +306,63 @@ func TestSTDelChannel(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSTIsOn(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
nick1 := NewNick("test1", l)
|
||||
st.nicks["test1"] = nick1
|
||||
chan1 := NewChannel("#test1", l)
|
||||
st.chans["#test1"] = chan1
|
||||
nick1 := st.NewNick("test1")
|
||||
chan1 := st.NewChannel("#test1")
|
||||
|
||||
if priv, ok := st.IsOn("#test1", "test1"); ok || priv != nil {
|
||||
t.Errorf("test1 is not on #test1 (yet)")
|
||||
}
|
||||
cp := new(ChanPrivs)
|
||||
chan1.addNick(nick1, cp)
|
||||
nick1.addChannel(chan1, cp)
|
||||
cp := st.Associate(chan1, nick1)
|
||||
if priv, ok := st.IsOn("#test1", "test1"); !ok || priv != cp {
|
||||
t.Errorf("test1 is on #test1 (now)")
|
||||
}
|
||||
m.ExpectNothing()
|
||||
}
|
||||
|
||||
func TestSTAssociate(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
nick1 := st.NewNick("test1")
|
||||
chan1 := st.NewChannel("#test1")
|
||||
|
||||
cp := st.Associate(chan1, nick1)
|
||||
m.ExpectNothing()
|
||||
if priv, ok := st.IsOn("#test1", "test1"); !ok || cp != priv {
|
||||
if priv, ok := nick1.chans[chan1]; !ok || cp != priv {
|
||||
t.Errorf("#test1 was not associated with test1.")
|
||||
}
|
||||
if priv, ok := chan1.nicks[nick1]; !ok || cp != priv {
|
||||
t.Errorf("test1 was not associated with #test1.")
|
||||
}
|
||||
|
||||
// Test error cases
|
||||
s.log.EXPECT().Error("StateTracker.Associate(): passed nil values :-(")
|
||||
st.Associate(nil, nick1)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Associate(): passed nil values :-(")
|
||||
|
||||
s.log.EXPECT().Error("StateTracker.Associate(): passed nil values :-(")
|
||||
st.Associate(chan1, nil)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Associate(): passed nil values :-(")
|
||||
|
||||
s.log.EXPECT().Warn("StateTracker.Associate(): %s already on %s.",
|
||||
"test1", "#test1")
|
||||
st.Associate(chan1, nick1)
|
||||
m.ExpectAt(logging.Warn, "StateTracker.Associate(): test1 already on #test1.")
|
||||
|
||||
nick2 := NewNick("test2", l)
|
||||
// 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)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Associate(): nick test2 not found "+
|
||||
"in (or differs from) internal state.")
|
||||
|
||||
chan2 := NewChannel("#test2", l)
|
||||
// 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)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Associate(): channel #test2 not "+
|
||||
"found in (or differs from) internal state.")
|
||||
}
|
||||
|
||||
func TestSTDissociate(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
nick1 := st.NewNick("test1")
|
||||
chan1 := st.NewChannel("#test1")
|
||||
|
|
@ -398,7 +382,6 @@ func TestSTDissociate(t *testing.T) {
|
|||
|
||||
// First, test the case of me leaving #test2
|
||||
st.Dissociate(chan2, st.me)
|
||||
m.ExpectNothing()
|
||||
|
||||
// This should have resulted in the complete deletion of the channel.
|
||||
if len(chan1.nicks) != 2 || len(chan2.nicks) != 0 || len(st.nicks) != 2 ||
|
||||
|
|
@ -410,7 +393,6 @@ func TestSTDissociate(t *testing.T) {
|
|||
chan2 = st.NewChannel("#test2")
|
||||
st.Associate(chan2, st.me)
|
||||
st.Associate(chan2, nick1)
|
||||
m.ExpectNothing()
|
||||
|
||||
// Check state once moar.
|
||||
if len(chan1.nicks) != 2 || len(chan2.nicks) != 2 || len(st.nicks) != 2 ||
|
||||
|
|
@ -421,7 +403,6 @@ func TestSTDissociate(t *testing.T) {
|
|||
// Now, lets dissociate test1 from #test1 then #test2.
|
||||
// This first one should only result in a change in associations.
|
||||
st.Dissociate(chan1, nick1)
|
||||
m.ExpectNothing()
|
||||
|
||||
if len(chan1.nicks) != 1 || len(chan2.nicks) != 2 || len(st.nicks) != 2 ||
|
||||
len(st.me.chans) != 2 || len(nick1.chans) != 1 || len(st.chans) != 2 {
|
||||
|
|
@ -431,7 +412,6 @@ func TestSTDissociate(t *testing.T) {
|
|||
// This second one should also delete test1
|
||||
// as it's no longer on any common channels with us
|
||||
st.Dissociate(chan2, nick1)
|
||||
m.ExpectNothing()
|
||||
|
||||
if len(chan1.nicks) != 1 || len(chan2.nicks) != 1 || len(st.nicks) != 1 ||
|
||||
len(st.me.chans) != 2 || len(nick1.chans) != 0 || len(st.chans) != 2 {
|
||||
|
|
@ -441,29 +421,32 @@ func TestSTDissociate(t *testing.T) {
|
|||
// 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)
|
||||
m.ExpectAt(logging.Warn, "StateTracker.Dissociate(): test1 not on #test1.")
|
||||
|
||||
s.log.EXPECT().Error("StateTracker.Dissociate(): passed nil values :-(")
|
||||
st.Dissociate(chan1, nil)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Dissociate(): passed nil values :-(")
|
||||
|
||||
s.log.EXPECT().Error("StateTracker.Dissociate(): passed nil values :-(")
|
||||
st.Dissociate(nil, nick1)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Dissociate(): passed nil values :-(")
|
||||
|
||||
nick3 := NewNick("test3", l)
|
||||
// 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)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Dissociate(): nick test3 not "+
|
||||
"found in (or differs from) internal state.")
|
||||
|
||||
chan3 := NewChannel("#test3", l)
|
||||
// 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)
|
||||
m.ExpectAt(logging.Error, "StateTracker.Dissociate(): channel #test3 not "+
|
||||
"found in (or differs from) internal state.")
|
||||
}
|
||||
|
||||
func TestSTWipe(t *testing.T) {
|
||||
l, m := logging.NewMock(t)
|
||||
st := NewTracker("mynick", l)
|
||||
st, s := setUp(t)
|
||||
defer s.tearDown()
|
||||
|
||||
nick1 := st.NewNick("test1")
|
||||
nick2 := st.NewNick("test2")
|
||||
|
|
@ -487,8 +470,6 @@ func TestSTWipe(t *testing.T) {
|
|||
|
||||
st.Associate(chan1, nick3)
|
||||
|
||||
m.ExpectNothing()
|
||||
|
||||
// Check the state we have at this point is what we would expect.
|
||||
if len(st.nicks) != 4 || len(st.chans) != 3 || len(st.me.chans) != 3 {
|
||||
t.Errorf("Tracker nick/channel lists wrong length before wipe.")
|
||||
|
|
@ -502,7 +483,6 @@ func TestSTWipe(t *testing.T) {
|
|||
|
||||
// Nuke *all* the state!
|
||||
st.Wipe()
|
||||
m.ExpectNothing()
|
||||
|
||||
// Check the state we have at this point is what we would expect.
|
||||
if len(st.nicks) != 1 || len(st.chans) != 0 || len(st.me.chans) != 0 {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue