From f3c49069c059d6a10dcd015e5b4b3c32fa547a9d Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Wed, 31 Dec 2014 13:17:46 +0000 Subject: [PATCH] The great state tracker privatisation 3/3: tracker. --- state/tracker.go | 254 +++++++++++++++++++--------- state/tracker_test.go | 381 +++++++++++++++++++++++++++++------------- 2 files changed, 442 insertions(+), 193 deletions(-) diff --git a/state/tracker.go b/state/tracker.go index b666dfd..686fedc 100644 --- a/state/tracker.go +++ b/state/tracker.go @@ -2,6 +2,8 @@ package state import ( "github.com/fluffle/goirc/logging" + + "sync" ) // The state manager interface @@ -9,18 +11,22 @@ type Tracker interface { // Nick methods NewNick(nick string) *Nick GetNick(nick string) *Nick - ReNick(old, neu string) - DelNick(nick string) + ReNick(old, neu string) *Nick + DelNick(nick string) *Nick + NickInfo(nick, ident, host, name string) *Nick + NickModes(nick, modestr string) *Nick // Channel methods NewChannel(channel string) *Channel GetChannel(channel string) *Channel - DelChannel(channel string) + DelChannel(channel string) *Channel + Topic(channel, topic string) *Channel + ChannelModes(channel, modestr string, modeargs ...string) *Channel // Information about ME! Me() *Nick // And the tracking operations IsOn(channel, nick string) (*ChanPrivs, bool) - Associate(channel *Channel, nick *Nick) *ChanPrivs - Dissociate(channel *Channel, nick *Nick) + Associate(channel, nick string) *ChanPrivs + Dissociate(channel, nick string) Wipe() // The state tracker can output a debugging string String() string @@ -29,26 +35,34 @@ type Tracker interface { // ... and a struct to implement it ... type stateTracker struct { // Map of channels we're on - chans map[string]*Channel + chans map[string]*channel // Map of nicks we know about - nicks map[string]*Nick + nicks map[string]*nick // We need to keep state on who we are :-) - me *Nick + me *nick + + // And we need to protect against data races *cough*. + mu sync.Mutex } +var _ Tracker = (*stateTracker)(nil) + // ... and a constructor to make it ... func NewTracker(mynick string) *stateTracker { st := &stateTracker{ - chans: make(map[string]*Channel), - nicks: make(map[string]*Nick), + chans: make(map[string]*channel), + nicks: make(map[string]*nick), } - st.me = st.NewNick(mynick) + st.me = newNick(mynick) + st.nicks[mynick] = st.me return st } // ... and a method to wipe the state clean. func (st *stateTracker) Wipe() { + st.mu.Lock() + defer st.mu.Unlock() // Deleting all the channels implicitly deletes every nick but me. for _, ch := range st.chans { st.delChannel(ch) @@ -59,67 +73,84 @@ func (st *stateTracker) Wipe() { * tracker methods to create/look up nicks/channels \******************************************************************************/ -// Creates a new Nick, initialises it, and stores it so it +// Creates a new nick, initialises it, and stores it so it // can be properly tracked for state management purposes. func (st *stateTracker) NewNick(n string) *Nick { + if n == "" { + logging.Warn("Tracker.NewNick(): Not tracking empty nick.") + return nil + } + st.mu.Lock() + defer st.mu.Unlock() if _, ok := st.nicks[n]; ok { logging.Warn("Tracker.NewNick(): %s already tracked.", n) return nil } - st.nicks[n] = NewNick(n) - return st.nicks[n] + st.nicks[n] = newNick(n) + return st.nicks[n].Nick() } -// Returns a Nick for the nick n, if we're tracking it. +// Returns a nick for the nick n, if we're tracking it. func (st *stateTracker) GetNick(n string) *Nick { + st.mu.Lock() + defer st.mu.Unlock() if nk, ok := st.nicks[n]; ok { - return nk + return nk.Nick() } return nil } -// Signals to the tracker that a Nick should be tracked +// Signals to the tracker that a nick should be tracked // under a "neu" nick rather than the old one. -func (st *stateTracker) ReNick(old, neu string) { - if nk, ok := st.nicks[old]; ok { - if _, ok := st.nicks[neu]; !ok { - nk.Nick = neu - delete(st.nicks, old) - st.nicks[neu] = nk - for ch, _ := range nk.chans { - // We also need to update the lookup maps of all the channels - // the nick is on, to keep things in sync. - delete(ch.lookup, old) - ch.lookup[neu] = nk - } - } else { - logging.Warn("Tracker.ReNick(): %s already exists.", neu) - } - } else { +func (st *stateTracker) ReNick(old, neu string) *Nick { + st.mu.Lock() + defer st.mu.Unlock() + nk, ok := st.nicks[old] + if !ok { logging.Warn("Tracker.ReNick(): %s not tracked.", old) + return nil } + if _, ok := st.nicks[neu]; ok { + logging.Warn("Tracker.ReNick(): %s already exists.", neu) + return nil + } + + nk.nick = neu + delete(st.nicks, old) + st.nicks[neu] = nk + for ch, _ := range nk.chans { + // We also need to update the lookup maps of all the channels + // the nick is on, to keep things in sync. + delete(ch.lookup, old) + ch.lookup[neu] = nk + } + return nk.Nick() } -// Removes a Nick from being tracked. -func (st *stateTracker) DelNick(n string) { +// Removes a nick from being tracked. +func (st *stateTracker) DelNick(n string) *Nick { + st.mu.Lock() + defer st.mu.Unlock() if nk, ok := st.nicks[n]; ok { - if nk != st.me { - st.delNick(nk) - } else { + if nk == st.me { logging.Warn("Tracker.DelNick(): won't delete myself.") + return nil } - } else { - logging.Warn("Tracker.DelNick(): %s not tracked.", n) + st.delNick(nk) + return nk.Nick() } + logging.Warn("Tracker.DelNick(): %s not tracked.", n) + return nil } -func (st *stateTracker) delNick(nk *Nick) { +func (st *stateTracker) delNick(nk *nick) { + // st.mu lock held by DelNick, DelChannel or Wipe if nk == st.me { // Shouldn't get here => internal state tracking code is fubar. logging.Error("Tracker.DelNick(): TRYING TO DELETE ME :-(") return } - delete(st.nicks, nk.Nick) + delete(st.nicks, nk.nick) for ch, _ := range nk.chans { nk.delChannel(ch) ch.delNick(nk) @@ -127,41 +158,79 @@ func (st *stateTracker) delNick(nk *Nick) { // Deleting a nick from tracking shouldn't empty any channels as // *we* should be on the channel with them to be tracking them. logging.Error("Tracker.delNick(): deleting nick %s emptied "+ - "channel %s, this shouldn't happen!", nk.Nick, ch.Name) + "channel %s, this shouldn't happen!", nk.nick, ch.name) } } } +// Sets ident, host and "real" name for the nick. +func (st *stateTracker) NickInfo(n, ident, host, name string) *Nick { + st.mu.Lock() + defer st.mu.Unlock() + nk, ok := st.nicks[n] + if !ok { + return nil + } + nk.ident = ident + nk.host = host + nk.name = name + return nk.Nick() +} + +// Sets user modes for the nick. +func (st *stateTracker) NickModes(n, modes string) *Nick { + st.mu.Lock() + defer st.mu.Unlock() + nk, ok := st.nicks[n] + if !ok { + return nil + } + nk.parseModes(modes) + return nk.Nick() +} + // Creates a new Channel, initialises it, and stores it so it // can be properly tracked for state management purposes. func (st *stateTracker) NewChannel(c string) *Channel { + if c == "" { + logging.Warn("Tracker.NewChannel(): Not tracking empty channel.") + return nil + } + st.mu.Lock() + defer st.mu.Unlock() if _, ok := st.chans[c]; ok { logging.Warn("Tracker.NewChannel(): %s already tracked.", c) return nil } - st.chans[c] = NewChannel(c) - return st.chans[c] + st.chans[c] = newChannel(c) + return st.chans[c].Channel() } // Returns a Channel for the channel c, if we're tracking it. func (st *stateTracker) GetChannel(c string) *Channel { + st.mu.Lock() + defer st.mu.Unlock() if ch, ok := st.chans[c]; ok { - return ch + return ch.Channel() } return nil } // Removes a Channel from being tracked. -func (st *stateTracker) DelChannel(c string) { +func (st *stateTracker) DelChannel(c string) *Channel { + st.mu.Lock() + defer st.mu.Unlock() if ch, ok := st.chans[c]; ok { st.delChannel(ch) - } else { - logging.Warn("Tracker.DelChannel(): %s not tracked.", c) + return ch.Channel() } + logging.Warn("Tracker.DelChannel(): %s not tracked.", c) + return nil } -func (st *stateTracker) delChannel(ch *Channel) { - delete(st.chans, ch.Name) +func (st *stateTracker) delChannel(ch *channel) { + // st.mu lock held by DelChannel or Wipe + delete(st.chans, ch.name) for nk, _ := range ch.nicks { ch.delNick(nk) nk.delChannel(ch) @@ -172,67 +241,98 @@ func (st *stateTracker) delChannel(ch *Channel) { } } +// Sets the topic of a channel. +func (st *stateTracker) Topic(c, topic string) *Channel { + st.mu.Lock() + defer st.mu.Unlock() + ch, ok := st.chans[c] + if !ok { + return nil + } + ch.topic = topic + return ch.Channel() +} + +// Sets modes for a channel, including privileges like +o. +func (st *stateTracker) ChannelModes(c, modes string, args ...string) *Channel { + st.mu.Lock() + defer st.mu.Unlock() + ch, ok := st.chans[c] + if !ok { + return nil + } + ch.parseModes(modes, args...) + return ch.Channel() +} + // Returns the Nick the state tracker thinks is Me. func (st *stateTracker) Me() *Nick { - return st.me + return st.me.Nick() } // Returns true if both the channel c and the nick n are tracked // and the nick is associated with the channel. func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) { - nk := st.GetNick(n) - ch := st.GetChannel(c) - if nk != nil && ch != nil { - return nk.IsOn(ch) + st.mu.Lock() + defer st.mu.Unlock() + nk, nok := st.nicks[n] + ch, cok := st.chans[c] + if nok && cok { + return nk.isOn(ch) } return nil, false } // Associates an already known nick with an already known channel. -func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { - if ch == nil || nk == nil { - logging.Error("Tracker.Associate(): passed nil values :-(") - return nil - } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { +func (st *stateTracker) Associate(c, n string) *ChanPrivs { + st.mu.Lock() + defer st.mu.Unlock() + nk, nok := st.nicks[n] + ch, cok := st.chans[c] + + if !cok { // 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. logging.Error("Tracker.Associate(): channel %s not found in "+ - "(or differs from) internal state.", ch.Name) + "internal state.", c) return nil - } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { + } else if !nok { logging.Error("Tracker.Associate(): nick %s not found in "+ - "(or differs from) internal state.", nk.Nick) + "internal state.", n) return nil - } else if _, ok := nk.IsOn(ch); ok { + } else if _, ok := nk.isOn(ch); ok { logging.Warn("Tracker.Associate(): %s already on %s.", - nk.Nick, ch.Name) + nk, ch) return nil } cp := new(ChanPrivs) ch.addNick(nk, cp) nk.addChannel(ch, cp) - return cp + return cp.Copy() } // Dissociates an already known nick from an already known channel. // Does some tidying up to stop tracking nicks we're no longer on // any common channels with, and channels we're no longer on. -func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) { - if ch == nil || nk == nil { - logging.Error("Tracker.Dissociate(): passed nil values :-(") - } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { +func (st *stateTracker) Dissociate(c, n string) { + st.mu.Lock() + defer st.mu.Unlock() + nk, nok := st.nicks[n] + ch, cok := st.chans[c] + + if !cok { // 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. logging.Error("Tracker.Dissociate(): channel %s not found in "+ - "(or differs from) internal state.", ch.Name) - } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { + "internal state.", c) + } else if !nok { logging.Error("Tracker.Dissociate(): nick %s not found in "+ - "(or differs from) internal state.", nk.Nick) - } else if _, ok := nk.IsOn(ch); !ok { + "internal state.", n) + } else if _, ok := nk.isOn(ch); !ok { logging.Warn("Tracker.Dissociate(): %s not on %s.", - nk.Nick, ch.Name) + nk.nick, ch.name) } else if nk == st.me { // I'm leaving the channel for some reason, so it won't be tracked. st.delChannel(ch) @@ -248,6 +348,8 @@ func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) { } func (st *stateTracker) String() string { + st.mu.Lock() + defer st.mu.Unlock() str := "GoIRC Channels\n" str += "--------------\n\n" for _, ch := range st.chans { diff --git a/state/tracker_test.go b/state/tracker_test.go index 9ae2c19..165b5aa 100644 --- a/state/tracker_test.go +++ b/state/tracker_test.go @@ -2,6 +2,12 @@ package state import "testing" +// There is some awkwardness in these tests. Items retrieved directly from the +// state trackers internal maps are private and only have private, +// uncaptialised members. Items retrieved from state tracker public interface +// methods are public and only have public, capitalised members. Comparisons of +// the two are done on the basis of nick or channel name. + func TestSTNewTracker(t *testing.T) { st := NewTracker("mynick") @@ -11,7 +17,7 @@ func TestSTNewTracker(t *testing.T) { if len(st.chans) != 0 { t.Errorf("Channel list of new tracker is not empty.") } - if nk, ok := st.nicks["mynick"]; !ok || nk.Nick != "mynick" || nk != st.me { + if nk, ok := st.nicks["mynick"]; !ok || nk.nick != "mynick" || nk != st.me { t.Errorf("My nick not stored correctly in tracker.") } } @@ -23,20 +29,23 @@ func TestSTNewNick(t *testing.T) { 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 { + if n, ok := st.nicks["test1"]; !ok || !test1.Equals(n.Nick()) || len(st.nicks) != 2 { t.Errorf("Nick object stored incorrectly by NewNick.") } if fail := st.NewNick("test1"); fail != nil { t.Errorf("Creating duplicate nick did not produce nil return.") } + if fail := st.NewNick(""); fail != nil { + t.Errorf("Creating empty nick did not produce nil return.") + } } func TestSTGetNick(t *testing.T) { st := NewTracker("mynick") test1 := st.NewNick("test1") - if n := st.GetNick("test1"); n != test1 { + if n := st.GetNick("test1"); !test1.Equals(n) { t.Errorf("Incorrect nick returned by GetNick.") } if n := st.GetNick("test2"); n != nil { @@ -52,39 +61,53 @@ func TestSTReNick(t *testing.T) { test1 := st.NewNick("test1") // This channel is here to ensure that its lookup map gets updated - chan1 := st.NewChannel("#chan1") - st.Associate(chan1, test1) + st.NewChannel("#chan1") + st.Associate("#chan1", "test1") - st.ReNick("test1", "test2") + // We need to check out the manipulation of the internals. + n1 := st.nicks["test1"] + c1 := st.chans["#chan1"] + + test2 := st.ReNick("test1", "test2") if _, ok := st.nicks["test1"]; ok { t.Errorf("Nick test1 still exists after ReNick.") } - if n, ok := st.nicks["test2"]; !ok || n != test1 { + if n, ok := st.nicks["test2"]; !ok || n != n1 { t.Errorf("Nick test2 doesn't exist after ReNick.") } - if _, ok := chan1.lookup["test1"]; ok { + if _, ok := c1.lookup["test1"]; ok { t.Errorf("Channel #chan1 still knows about test1 after ReNick.") } - if n, ok := chan1.lookup["test2"]; !ok || n != test1 { + if n, ok := c1.lookup["test2"]; !ok || n != n1 { t.Errorf("Channel #chan1 doesn't know about test2 after ReNick.") } - if test1.Nick != "test2" { - t.Errorf("Nick test1 not changed correctly.") + if test1.Nick != "test1" { + t.Errorf("Nick test1 changed unexpectedly.") + } + if !test2.Equals(n1.Nick()) { + t.Errorf("Nick test2 did not change.") } if len(st.nicks) != 2 { t.Errorf("Nick list changed size during ReNick.") } + if len(c1.lookup) != 1 { + t.Errorf("Channel lookup list changed size during ReNick.") + } - test2 := st.NewNick("test1") - st.ReNick("test1", "test2") + st.NewNick("test1") + n2 := st.nicks["test1"] + fail := st.ReNick("test1", "test2") - if n, ok := st.nicks["test2"]; !ok || n != test1 { + if n, ok := st.nicks["test2"]; !ok || n != n1 { t.Errorf("Nick test2 overwritten/deleted by ReNick.") } - if n, ok := st.nicks["test1"]; !ok || n != test2 { + if n, ok := st.nicks["test1"]; !ok || n != n2 { t.Errorf("Nick test1 overwritten/deleted by ReNick.") } + if fail != nil { + t.Errorf("ReNick returned Nick on failure.") + } if len(st.nicks) != 3 { t.Errorf("Nick list changed size during ReNick.") } @@ -93,8 +116,8 @@ func TestSTReNick(t *testing.T) { func TestSTDelNick(t *testing.T) { st := NewTracker("mynick") - st.NewNick("test1") - st.DelNick("test1") + add := st.NewNick("test1") + del := st.DelNick("test1") if _, ok := st.nicks["test1"]; ok { t.Errorf("Nick test1 still exists after DelNick.") @@ -102,55 +125,106 @@ func TestSTDelNick(t *testing.T) { if len(st.nicks) != 1 { t.Errorf("Nick list still contains nicks after DelNick.") } + if !add.Equals(del) { + t.Errorf("DelNick returned different nick.") + } // 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") - st.DelNick("test2") - if len(st.nicks) != 2 { + st.NewNick("test1") + fail := st.DelNick("test2") + if fail != nil || len(st.nicks) != 2 { t.Errorf("Deleting unknown nick had unexpected side-effects.") } // Deleting my nick shouldn't work - st.DelNick("mynick") - if len(st.nicks) != 2 { + fail = st.DelNick("mynick") + if fail != nil || len(st.nicks) != 2 { t.Errorf("Deleting myself had unexpected side-effects.") } // 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. The mock logger should catch these. + // errors in other methods. // Create a new channel for testing purposes. - chan1 := st.NewChannel("#test1") + st.NewChannel("#test1") // Associate both "my" nick and test1 with the channel - st.Associate(chan1, st.me) - st.Associate(chan1, nick1) + st.Associate("#test1", "mynick") + st.Associate("#test1", "test1") + + // We need to check out the manipulation of the internals. + n1 := st.nicks["test1"] + c1 := st.chans["#test1"] // Test we have the expected starting state (at least vaguely) - if len(chan1.nicks) != 2 || len(st.nicks) != 2 || - len(st.me.chans) != 1 || len(nick1.chans) != 1 || len(st.chans) != 1 { + if len(c1.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 1 || len(n1.chans) != 1 || len(st.chans) != 1 { t.Errorf("Bad initial state for test DelNick() channel dissociation.") } + // Actual deletion tested above... st.DelNick("test1") - // Actual deletion tested above... - if len(chan1.nicks) != 1 || len(st.chans) != 1 || - len(st.me.chans) != 1 || len(nick1.chans) != 0 || len(st.chans) != 1 { + if len(c1.nicks) != 1 || len(st.nicks) != 1 || + len(st.me.chans) != 1 || len(n1.chans) != 0 || len(st.chans) != 1 { t.Errorf("Deleting nick didn't dissociate correctly from channels.") } - if _, ok := chan1.nicks[nick1]; ok { + if _, ok := c1.nicks[n1]; ok { t.Errorf("Nick not removed from channel's nick map.") } - if _, ok := chan1.lookup["test1"]; ok { + if _, ok := c1.lookup["test1"]; ok { t.Errorf("Nick not removed from channel's lookup map.") } } +func TestSTNickInfo(t *testing.T) { + st := NewTracker("mynick") + test1 := st.NewNick("test1") + test2 := st.NickInfo("test1", "foo", "bar", "baz") + test3 := st.GetNick("test1") + + if test1.Equals(test2) { + t.Errorf("NickInfo did not return modified nick.") + } + if !test3.Equals(test2) { + t.Errorf("Getting nick after NickInfo returned different nick.") + } + test1.Ident, test1.Host, test1.Name = "foo", "bar", "baz" + if !test1.Equals(test2) { + t.Errorf("NickInfo did not set nick info correctly.") + } + + if fail := st.NickInfo("test2", "foo", "bar", "baz"); fail != nil { + t.Errorf("NickInfo for nonexistent nick did not return nil.") + } +} + +func TestSTNickModes(t *testing.T) { + st := NewTracker("mynick") + test1 := st.NewNick("test1") + test2 := st.NickModes("test1", "+iB") + test3 := st.GetNick("test1") + + if test1.Equals(test2) { + t.Errorf("NickModes did not return modified nick.") + } + if !test3.Equals(test2) { + t.Errorf("Getting nick after NickModes returned different nick.") + } + test1.Modes.Invisible, test1.Modes.Bot = true, true + if !test1.Equals(test2) { + t.Errorf("NickModes did not set nick modes correctly.") + } + + if fail := st.NickModes("test2", "whatevs"); fail != nil { + t.Errorf("NickModes for nonexistent nick did not return nil.") + } +} + func TestSTNewChannel(t *testing.T) { st := NewTracker("mynick") @@ -163,13 +237,16 @@ func TestSTNewChannel(t *testing.T) { 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 { + if c, ok := st.chans["#test1"]; !ok || !test1.Equals(c.Channel()) || len(st.chans) != 1 { t.Errorf("Channel object stored incorrectly by NewChannel.") } if fail := st.NewChannel("#test1"); fail != nil { t.Errorf("Creating duplicate chan did not produce nil return.") } + if fail := st.NewChannel(""); fail != nil { + t.Errorf("Creating empty chan did not produce nil return.") + } } func TestSTGetChannel(t *testing.T) { @@ -177,7 +254,7 @@ func TestSTGetChannel(t *testing.T) { test1 := st.NewChannel("#test1") - if c := st.GetChannel("#test1"); c != test1 { + if c := st.GetChannel("#test1"); !test1.Equals(c) { t.Errorf("Incorrect Channel returned by GetChannel.") } if c := st.GetChannel("#test2"); c != nil { @@ -191,8 +268,8 @@ func TestSTGetChannel(t *testing.T) { func TestSTDelChannel(t *testing.T) { st := NewTracker("mynick") - st.NewChannel("#test1") - st.DelChannel("#test1") + add := st.NewChannel("#test1") + del := st.DelChannel("#test1") if _, ok := st.chans["#test1"]; ok { t.Errorf("Channel test1 still exists after DelChannel.") @@ -200,30 +277,38 @@ func TestSTDelChannel(t *testing.T) { if len(st.chans) != 0 { t.Errorf("Channel list still contains chans after DelChannel.") } + if !add.Equals(del) { + t.Errorf("DelChannel returned different channel.") + } - // 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") - st.DelChannel("#test2") - if len(st.chans) != 1 { + // Deleting unknown channel shouldn't work, but let's make sure we have a + // known channel first to catch any possible accidental removals. + st.NewChannel("#test1") + fail := st.DelChannel("#test2") + if fail != nil || 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 := st.NewChannel("#test2") - nick1 := st.NewNick("test1") + st.NewChannel("#test2") + st.NewNick("test1") // Associate both "my" nick and test1 with the channels - st.Associate(chan1, st.me) - st.Associate(chan1, nick1) - st.Associate(chan2, st.me) - st.Associate(chan2, nick1) + st.Associate("#test1", "mynick") + st.Associate("#test1", "test1") + st.Associate("#test2", "mynick") + st.Associate("#test2", "test1") + + // We need to check out the manipulation of the internals. + n1 := st.nicks["test1"] + c1 := st.chans["#test1"] + c2 := st.chans["#test2"] // Test we have the expected starting state (at least vaguely) - if len(chan1.nicks) != 2 || len(chan2.nicks) != 2 || len(st.nicks) != 2 || - len(st.me.chans) != 2 || len(nick1.chans) != 2 || len(st.chans) != 2 { + if len(c1.nicks) != 2 || len(c2.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 2 || len(n1.chans) != 2 || len(st.chans) != 2 { t.Errorf("Bad initial state for test DelChannel() nick dissociation.") } @@ -231,14 +316,14 @@ func TestSTDelChannel(t *testing.T) { // Test intermediate state. We're still on #test2 with test1, so test1 // shouldn't be deleted from state tracking itself just yet. - if len(chan1.nicks) != 0 || len(chan2.nicks) != 2 || len(st.nicks) != 2 || - len(st.me.chans) != 1 || len(nick1.chans) != 1 || len(st.chans) != 1 { + if len(c1.nicks) != 0 || len(c2.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 1 || len(n1.chans) != 1 || len(st.chans) != 1 { t.Errorf("Deleting channel didn't dissociate correctly from nicks.") } - if _, ok := nick1.chans[chan1]; ok { + if _, ok := n1.chans[c1]; ok { t.Errorf("Channel not removed from nick's chans map.") } - if _, ok := nick1.lookup["#test1"]; ok { + if _, ok := n1.lookup["#test1"]; ok { t.Errorf("Channel not removed from nick's lookup map.") } @@ -246,8 +331,8 @@ func TestSTDelChannel(t *testing.T) { // 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. - if len(chan1.nicks) != 0 || len(chan2.nicks) != 0 || len(st.nicks) != 1 || - len(st.me.chans) != 0 || len(nick1.chans) != 0 || len(st.chans) != 0 { + if len(c1.nicks) != 0 || len(c2.nicks) != 0 || len(st.nicks) != 1 || + len(st.me.chans) != 0 || len(n1.chans) != 0 || len(st.chans) != 0 { t.Errorf("Deleting last channel didn't dissociate correctly from nicks.") } if _, ok := st.nicks["test1"]; ok { @@ -258,17 +343,61 @@ func TestSTDelChannel(t *testing.T) { } } +func TestSTTopic(t *testing.T) { + st := NewTracker("mynick") + test1 := st.NewChannel("#test1") + test2 := st.Topic("#test1", "foo bar") + test3 := st.GetChannel("#test1") + + if test1.Equals(test2) { + t.Errorf("Topic did not return modified channel.") + } + if !test3.Equals(test2) { + t.Errorf("Getting channel after Topic returned different channel.") + } + test1.Topic = "foo bar" + if !test1.Equals(test2) { + t.Errorf("Topic did not set channel topic correctly.") + } + + if fail := st.Topic("#test2", "foo baz"); fail != nil { + t.Errorf("Topic for nonexistent channel did not return nil.") + } +} + +func TestSTChannelModes(t *testing.T) { + st := NewTracker("mynick") + test1 := st.NewChannel("#test1") + test2 := st.ChannelModes("#test1", "+sk", "foo") + test3 := st.GetChannel("#test1") + + if test1.Equals(test2) { + t.Errorf("ChannelModes did not return modified channel.") + } + if !test3.Equals(test2) { + t.Errorf("Getting channel after ChannelModes returned different channel.") + } + test1.Modes.Secret, test1.Modes.Key = true, "foo" + if !test1.Equals(test2) { + t.Errorf("ChannelModes did not set channel modes correctly.") + } + + if fail := st.ChannelModes("test2", "whatevs"); fail != nil { + t.Errorf("ChannelModes for nonexistent channel did not return nil.") + } +} + func TestSTIsOn(t *testing.T) { st := NewTracker("mynick") - nick1 := st.NewNick("test1") - chan1 := st.NewChannel("#test1") + st.NewNick("test1") + st.NewChannel("#test1") if priv, ok := st.IsOn("#test1", "test1"); ok || priv != nil { t.Errorf("test1 is not on #test1 (yet)") } - cp := st.Associate(chan1, nick1) - if priv, ok := st.IsOn("#test1", "test1"); !ok || priv != cp { + st.Associate("#test1", "test1") + if priv, ok := st.IsOn("#test1", "test1"); !ok || priv == nil { t.Errorf("test1 is on #test1 (now)") } } @@ -276,117 +405,135 @@ func TestSTIsOn(t *testing.T) { func TestSTAssociate(t *testing.T) { st := NewTracker("mynick") - nick1 := st.NewNick("test1") - chan1 := st.NewChannel("#test1") + st.NewNick("test1") + st.NewChannel("#test1") - cp := st.Associate(chan1, nick1) - if priv, ok := nick1.chans[chan1]; !ok || cp != priv { + // We need to check out the manipulation of the internals. + n1 := st.nicks["test1"] + c1 := st.chans["#test1"] + + st.Associate("#test1", "test1") + npriv, nok := n1.chans[c1] + cpriv, cok := c1.nicks[n1] + if !nok || !cok || npriv != cpriv { 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 - if st.Associate(nil, nick1) != nil { - t.Errorf("Associating nil *Channel did not return nil.") + if st.Associate("", "test1") != nil { + t.Errorf("Associating unknown channel did not return nil.") } - if st.Associate(chan1, nil) != nil { - t.Errorf("Associating nil *Nick did not return nil.") + if st.Associate("#test1", "") != nil { + t.Errorf("Associating unknown nick did not return nil.") } - if st.Associate(chan1, nick1) != nil { + if st.Associate("#test1", "test1") != 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 := NewTracker("mynick") - nick1 := st.NewNick("test1") - chan1 := st.NewChannel("#test1") - chan2 := st.NewChannel("#test2") + st.NewNick("test1") + st.NewChannel("#test1") + st.NewChannel("#test2") // Associate both "my" nick and test1 with the channels - st.Associate(chan1, st.me) - st.Associate(chan1, nick1) - st.Associate(chan2, st.me) - st.Associate(chan2, nick1) + st.Associate("#test1", "mynick") + st.Associate("#test1", "test1") + st.Associate("#test2", "mynick") + st.Associate("#test2", "test1") + + // We need to check out the manipulation of the internals. + n1 := st.nicks["test1"] + c1 := st.chans["#test1"] + c2 := st.chans["#test2"] // Check the initial state looks mostly like we expect it to. - if len(chan1.nicks) != 2 || len(chan2.nicks) != 2 || len(st.nicks) != 2 || - len(st.me.chans) != 2 || len(nick1.chans) != 2 || len(st.chans) != 2 { + if len(c1.nicks) != 2 || len(c2.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 2 || len(n1.chans) != 2 || len(st.chans) != 2 { t.Errorf("Initial state for dissociation tests looks odd.") } // First, test the case of me leaving #test2 - st.Dissociate(chan2, st.me) + st.Dissociate("#test2", "mynick") // This should have resulted in the complete deletion of the channel. - if len(chan1.nicks) != 2 || len(chan2.nicks) != 0 || len(st.nicks) != 2 || - len(st.me.chans) != 1 || len(nick1.chans) != 1 || len(st.chans) != 1 { + if len(c1.nicks) != 2 || len(c2.nicks) != 0 || len(st.nicks) != 2 || + len(st.me.chans) != 1 || len(n1.chans) != 1 || len(st.chans) != 1 { t.Errorf("Dissociating myself from channel didn't delete it correctly.") } + if st.GetChannel("#test2") != nil { + t.Errorf("Able to get channel after dissociating myself.") + } // Reassociating myself and test1 to #test2 shouldn't cause any errors. - chan2 = st.NewChannel("#test2") - st.Associate(chan2, st.me) - st.Associate(chan2, nick1) + st.NewChannel("#test2") + st.Associate("#test2", "mynick") + st.Associate("#test2", "test1") + + // c2 is out of date with the complete deletion of the channel + c2 = st.chans["#test2"] // Check state once moar. - if len(chan1.nicks) != 2 || len(chan2.nicks) != 2 || len(st.nicks) != 2 || - len(st.me.chans) != 2 || len(nick1.chans) != 2 || len(st.chans) != 2 { + if len(c1.nicks) != 2 || len(c2.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 2 || len(n1.chans) != 2 || len(st.chans) != 2 { t.Errorf("Reassociating to channel has produced unexpected state.") } // Now, lets dissociate test1 from #test1 then #test2. // This first one should only result in a change in associations. - st.Dissociate(chan1, nick1) + st.Dissociate("#test1", "test1") - 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 { + if len(c1.nicks) != 1 || len(c2.nicks) != 2 || len(st.nicks) != 2 || + len(st.me.chans) != 2 || len(n1.chans) != 1 || len(st.chans) != 2 { t.Errorf("Dissociating a nick from one channel went wrong.") } // This second one should also delete test1 // as it's no longer on any common channels with us - st.Dissociate(chan2, nick1) + st.Dissociate("#test2", "test1") - 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 { + if len(c1.nicks) != 1 || len(c2.nicks) != 1 || len(st.nicks) != 1 || + len(st.me.chans) != 2 || len(n1.chans) != 0 || len(st.chans) != 2 { t.Errorf("Dissociating a nick from it's last channel went wrong.") } + if st.GetNick("test1") != nil { + t.Errorf("Able to get nick after dissociating from all channels.") + } } func TestSTWipe(t *testing.T) { st := NewTracker("mynick") - nick1 := st.NewNick("test1") - nick2 := st.NewNick("test2") - nick3 := st.NewNick("test3") - - chan1 := st.NewChannel("#test1") - chan2 := st.NewChannel("#test2") - chan3 := st.NewChannel("#test3") + st.NewNick("test1") + st.NewNick("test2") + st.NewNick("test3") + st.NewChannel("#test1") + st.NewChannel("#test2") + st.NewChannel("#test3") // Some associations - st.Associate(chan1, st.me) - st.Associate(chan2, st.me) - st.Associate(chan3, st.me) + st.Associate("#test1", "mynick") + st.Associate("#test2", "mynick") + st.Associate("#test3", "mynick") - st.Associate(chan1, nick1) - st.Associate(chan2, nick2) - st.Associate(chan3, nick3) + st.Associate("#test1", "test1") + st.Associate("#test2", "test2") + st.Associate("#test3", "test3") - st.Associate(chan1, nick2) - st.Associate(chan2, nick3) + st.Associate("#test1", "test2") + st.Associate("#test2", "test3") - st.Associate(chan1, nick3) + st.Associate("#test1", "test3") + + // We need to check out the manipulation of the internals. + nick1 := st.nicks["test1"] + nick2 := st.nicks["test2"] + nick3 := st.nicks["test3"] + chan1 := st.chans["#test1"] + chan2 := st.chans["#test2"] + chan3 := st.chans["#test3"] // 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 {