Exemplo n.º 1
0
// Test the handler for 311 / RPL_WHOISUSER
func Test311(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// Create user1, who we know little about
	nick1 := state.NewNick("user1", s.log)

	// Send a 311 reply
	s.st.EXPECT().GetNick("user1").Return(nick1)
	c.h_311(parseLine(":irc.server.org 311 test user1 ident1 host1.com * :name"))

	// Verify we now know more about user1
	if nick1.Ident != "ident1" ||
		nick1.Host != "host1.com" ||
		nick1.Name != "name" {
		t.Errorf("WHOIS info of user1 not set correctly.")
	}

	// Check error paths -- send a 311 for an unknown nick
	gomock.InOrder(
		s.st.EXPECT().GetNick("user2").Return(nil),
		s.log.EXPECT().Warn("irc.311(): received WHOIS info for unknown nick %s",
			"user2"),
	)
	c.h_311(parseLine(":irc.server.org 311 test user2 ident2 host2.com * :dongs"))
}
Exemplo n.º 2
0
// Test the handler for 671 (unreal specific)
func Test671(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// Create user1, who should not be secure
	nick1 := state.NewNick("user1", s.log)
	if nick1.Modes.SSL {
		t.Errorf("Test nick user1 is already using SSL?")
	}

	// Send a 671 reply
	s.st.EXPECT().GetNick("user1").Return(nick1)
	c.h_671(parseLine(":irc.server.org 671 test user1 :some ignored text"))

	// Ensure user1 is now known to be on an SSL connection
	if !nick1.Modes.SSL {
		t.Errorf("Test nick user1 not using SSL?")
	}

	// Check error paths -- send a 671 for an unknown nick
	gomock.InOrder(
		s.st.EXPECT().GetNick("user2").Return(nil),
		s.log.EXPECT().Warn("irc.671(): received WHOIS SSL info for unknown "+
			"nick %s", "user2"),
	)
	c.h_671(parseLine(":irc.server.org 671 test user2 :some ignored text"))
}
Exemplo n.º 3
0
func Client(nick, ident, name string,
	r event.EventRegistry, l logging.Logger) *Conn {
	if r == nil || l == nil {
		return nil
	}
	conn := &Conn{
		ER:        r,
		ED:        r,
		l:         l,
		st:        false,
		in:        make(chan *Line, 32),
		out:       make(chan string, 32),
		cSend:     make(chan bool),
		cLoop:     make(chan bool),
		cPing:     make(chan bool),
		SSL:       false,
		SSLConfig: nil,
		PingFreq:  3 * time.Minute,
		Flood:     false,
		NewNick:   func(s string) string { return s + "_" },
		badness:   0,
		lastsent:  time.Now(),
		Websock:   nil,
	}
	conn.addIntHandlers()
	conn.Me = state.NewNick(nick, l)
	conn.Me.Ident = ident
	conn.Me.Name = name

	conn.initialise()
	return conn
}
Exemplo n.º 4
0
// Test the handler for KICK messages
// (this is very similar to the PART message test)
func TestKICK(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// We need some valid and associated nicks / channels to KICK.
	chan1 := state.NewChannel("#test1", s.log)
	nick1 := state.NewNick("user1", s.log)

	// KICK should dissociate a nick from a channel.
	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test1").Return(chan1),
		s.st.EXPECT().GetNick("user1").Return(nick1),
		s.st.EXPECT().Dissociate(chan1, nick1),
	)
	c.h_KICK(parseLine(":[email protected] KICK #test1 user1 :Bye!"))
}
Exemplo n.º 5
0
// Test the handler for PART messages
func TestPART(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// We need some valid and associated nicks / channels to PART with.
	chan1 := state.NewChannel("#test1", s.log)
	nick1 := state.NewNick("user1", s.log)

	// PART should dissociate a nick from a channel.
	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test1").Return(chan1),
		s.st.EXPECT().GetNick("user1").Return(nick1),
		s.st.EXPECT().Dissociate(chan1, nick1),
	)
	c.h_PART(parseLine(":[email protected] PART #test1 :Bye!"))
}
Exemplo n.º 6
0
// Test the handler for MODE messages
func TestMODE(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	chan1 := state.NewChannel("#test1", s.log)
	nick1 := state.NewNick("user1", s.log)

	// Send a channel mode line. Inconveniently, Channel and Nick objects
	// aren't mockable with gomock as they're not interface types (and I
	// don't want them to be, writing accessors for struct fields sucks).
	// This makes testing whether ParseModes is called correctly harder.
	s.st.EXPECT().GetChannel("#test1").Return(chan1)
	c.h_MODE(parseLine(":[email protected] MODE #test1 +sk somekey"))
	if !chan1.Modes.Secret || chan1.Modes.Key != "somekey" {
		t.Errorf("Channel.ParseModes() not called correctly.")
	}

	// Send a nick mode line, returning Me
	gomock.InOrder(
		s.st.EXPECT().GetChannel("test").Return(nil),
		s.st.EXPECT().GetNick("test").Return(c.Me),
	)
	c.h_MODE(parseLine(":[email protected] MODE test +i"))
	if !c.Me.Modes.Invisible {
		t.Errorf("Nick.ParseModes() not called correctly.")
	}

	// Check error paths
	gomock.InOrder(
		// send a valid user mode that's not us
		s.st.EXPECT().GetChannel("user1").Return(nil),
		s.st.EXPECT().GetNick("user1").Return(nick1),
		s.log.EXPECT().Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s",
			"+w", "user1"),
		// Send a random mode for an unknown channel
		s.st.EXPECT().GetChannel("#test2").Return(nil),
		s.st.EXPECT().GetNick("#test2").Return(nil),
		s.log.EXPECT().Warn("irc.MODE(): not sure what to do with MODE %s",
			"#test2 +is"),
	)
	c.h_MODE(parseLine(":[email protected] MODE user1 +w"))
	c.h_MODE(parseLine(":[email protected] MODE #test2 +is"))
}
Exemplo n.º 7
0
// Test the handler for 352 / RPL_WHOREPLY
func Test352(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// Create user1, who we know little about
	nick1 := state.NewNick("user1", s.log)

	// Send a 352 reply
	s.st.EXPECT().GetNick("user1").Return(nick1)
	c.h_352(parseLine(":irc.server.org 352 test #test1 ident1 host1.com irc.server.org user1 G :0 name"))

	// Verify we now know more about user1
	if nick1.Ident != "ident1" ||
		nick1.Host != "host1.com" ||
		nick1.Name != "name" ||
		nick1.Modes.Invisible ||
		nick1.Modes.Oper {
		t.Errorf("WHO info of user1 not set correctly.")
	}

	// Check that modes are set correctly from WHOREPLY
	s.st.EXPECT().GetNick("user1").Return(nick1)
	c.h_352(parseLine(":irc.server.org 352 test #test1 ident1 host1.com irc.server.org user1 H* :0 name"))

	if !nick1.Modes.Invisible || !nick1.Modes.Oper {
		t.Errorf("WHO modes of user1 not set correctly.")
	}

	// Check error paths -- send a 352 for an unknown nick
	gomock.InOrder(
		s.st.EXPECT().GetNick("user2").Return(nil),
		s.log.EXPECT().Warn("irc.352(): received WHO reply for unknown nick %s",
			"user2"),
	)
	c.h_352(parseLine(":irc.server.org 352 test #test2 ident2 host2.com irc.server.org user2 G :0 fooo"))
}
Exemplo n.º 8
0
// Test the handler for 353 / RPL_NAMREPLY
func Test353(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// Create #test1, whose user list we're mostly unfamiliar with
	chan1 := state.NewChannel("#test1", s.log)

	// Create maps for testing -- this is what the mock ST calls will return
	nicks := make(map[string]*state.Nick)
	privs := make(map[string]*state.ChanPrivs)

	nicks["test"] = c.Me
	privs["test"] = new(state.ChanPrivs)

	for _, n := range []string{"user1", "user2", "voice", "halfop",
		"op", "admin", "owner"} {
		nicks[n] = state.NewNick(n, s.log)
		privs[n] = new(state.ChanPrivs)
	}

	// 353 handler is called twice, so GetChannel will be called twice
	s.st.EXPECT().GetChannel("#test1").Return(chan1).Times(2)
	gomock.InOrder(
		// "test" is Me, i am known, and already on the channel
		s.st.EXPECT().GetNick("test").Return(c.Me),
		s.st.EXPECT().IsOn("#test1", "test").Return(privs["test"], true),
		// user1 is known, but not on the channel, so should be associated
		s.st.EXPECT().GetNick("user1").Return(nicks["user1"]),
		s.st.EXPECT().IsOn("#test1", "user1").Return(nil, false),
		s.st.EXPECT().Associate(chan1, nicks["user1"]).Return(privs["user1"]),
	)
	for _, n := range []string{"user2", "voice", "halfop", "op", "admin", "owner"} {
		gomock.InOrder(
			s.st.EXPECT().GetNick(n).Return(nil),
			s.st.EXPECT().NewNick(n).Return(nicks[n]),
			s.st.EXPECT().IsOn("#test1", n).Return(nil, false),
			s.st.EXPECT().Associate(chan1, nicks[n]).Return(privs[n]),
		)
	}

	// Send a couple of names replies (complete with trailing space)
	c.h_353(parseLine(":irc.server.org 353 test = #test1 :test @user1 user2 +voice "))
	c.h_353(parseLine(":irc.server.org 353 test = #test1 :%halfop @op &admin ~owner "))

	if p := privs["user2"]; p.Voice || p.HalfOp || p.Op || p.Admin || p.Owner {
		t.Errorf("353 handler incorrectly set modes on nick.")
	}

	if !privs["user1"].Op || !privs["voice"].Voice || !privs["halfop"].HalfOp ||
		!privs["op"].Op || !privs["admin"].Admin || !privs["owner"].Owner {
		t.Errorf("353 handler failed to set correct modes for nicks.")
	}

	// Check unknown channel causes a warning
	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test2").Return(nil),
		s.log.EXPECT().Warn("irc.353(): received NAMES list for unknown "+
			"channel %s", "#test2"),
	)
	c.h_353(parseLine(":irc.server.org 353 test = #test2 :test ~user3"))
}
Exemplo n.º 9
0
// Test the handler for JOIN messages
func TestJOIN(t *testing.T) {
	c, s := setUp(t)
	defer s.tearDown()

	// The state tracker should be creating a new channel in this first test
	chan1 := state.NewChannel("#test1", s.log)

	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test1").Return(nil),
		s.st.EXPECT().GetNick("test").Return(c.Me),
		s.st.EXPECT().NewChannel("#test1").Return(chan1),
		s.st.EXPECT().Associate(chan1, c.Me),
	)

	// Use #test1 to test expected behaviour
	// Call handler with JOIN by test to #test1
	c.h_JOIN(parseLine(":[email protected] JOIN :#test1"))

	// Verify that the MODE and WHO commands are sent correctly
	s.nc.Expect("MODE #test1")
	s.nc.Expect("WHO #test1")

	// In this second test, we should be creating a new nick
	nick1 := state.NewNick("user1", s.log)

	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test1").Return(chan1),
		s.st.EXPECT().GetNick("user1").Return(nil),
		s.st.EXPECT().NewNick("user1").Return(nick1),
		s.st.EXPECT().Associate(chan1, nick1),
	)

	// OK, now #test1 exists, JOIN another user we don't know about
	c.h_JOIN(parseLine(":[email protected] JOIN :#test1"))

	// Verify that the WHO command is sent correctly
	s.nc.Expect("WHO user1")

	// In this third test, we'll be pretending we know about the nick already.
	nick2 := state.NewNick("user2", c.l)
	gomock.InOrder(
		s.st.EXPECT().GetChannel("#test1").Return(chan1),
		s.st.EXPECT().GetNick("user2").Return(nick2),
		s.st.EXPECT().Associate(chan1, nick2),
	)
	c.h_JOIN(parseLine(":[email protected] JOIN :#test1"))

	// Test error paths
	gomock.InOrder(
		// unknown channel, unknown nick
		s.st.EXPECT().GetChannel("#test2").Return(nil),
		s.st.EXPECT().GetNick("blah").Return(nil),
		s.log.EXPECT().Warn("irc.JOIN(): JOIN to unknown channel %s "+
			"received from (non-me) nick %s", "#test2", "blah"),
		// unknown channel, known nick that isn't Me.
		s.st.EXPECT().GetChannel("#test2").Return(nil),
		s.st.EXPECT().GetNick("user2").Return(nick2),
		s.log.EXPECT().Warn("irc.JOIN(): JOIN to unknown channel %s "+
			"received from (non-me) nick %s", "#test2", "user2"),
	)
	c.h_JOIN(parseLine(":[email protected] JOIN :#test2"))
	c.h_JOIN(parseLine(":[email protected] JOIN :#test2"))
}