spox-mod_spox 0.3.1

data/tests/BotHolder.rb

@@ -0,0 +1,24 @@
+['sequel', 'thread', 'etc', 'getoptlong', 'logger'].each{|f|require f}
+# lets get sequel setup like we want it #
+require 'sequel/extensions/migration'
+Sequel::Model.plugin :validation_helpers
+Sequel::Model.plugin :schema
+Sequel::Model.unrestrict_primary_key
+require 'mod_spox/Version'
+require 'mod_spox/Loader'
+require 'test/unit'
+require 'singleton'
+
+class BotHolder
+    include Singleton
+    attr_reader :bot
+    def initialize
+        ModSpox::Database.db = nil
+        ModSpox.initialize_bot(Sequel.sqlite('test.db'))
+        require 'mod_spox/Bot'
+        @bot = ModSpox::Bot.new
+        m = ModSpox::Models::Nick.find_or_create(:nick => 'mod_spox')
+        m.update(:botnick => true)
+    end
+
+end

data/tests/handlers/tc_BadNick.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestBadNickHandler < Test::Unit::TestCase
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {:good => 'fail', :bad => 'fail'}
+    end
+
+    def teardown
+        #nothing#
+    end
+
+    def test_expected
+        assert_kind_of(ModSpox::Messages::Incoming::BadNick, @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good]))
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Created.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestCreatedHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot    
+        @test = {
+                 :good => ':not.configured 003 spox :This server was created Tue Mar 24 2009 at 15:42:36 PDT',
+                 :bad => ':fubared 003 fail whale'
+                }
+    end
+
+    def test_expected
+        assert_equal('003', @bot.factory.find_key(@test[:good]))
+        assert_kind_of(ModSpox::Messages::Incoming::Created, @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good]))
+        assert_equal(@test[:good], @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good]).raw_content)
+        assert_kind_of(Time, @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good]).date)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Invite.rb

@@ -0,0 +1,50 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestInviteHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot    
+        @test = {
+                    :good => ':spox!~spox@host INVITE spex :#m',
+                    :bad => ':fail INVITE whale'
+                }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, :Incoming_Invite)
+    end
+    
+    def gather(m)
+        @queue << m
+    end
+
+    def test_direct
+        assert_equal(:INVITE, @bot.factory.find_key(@test[:good]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        check_result(result)
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:good]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_result(m)
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+    
+    private
+    
+    def check_result(m)
+        assert_kind_of(ModSpox::Messages::Incoming::Invite, m)
+        assert_kind_of(ModSpox::Models::Nick, m.source)
+        assert_kind_of(ModSpox::Models::Nick, m.target)
+        assert_kind_of(ModSpox::Models::Channel, m.channel)
+        assert_equal('spox', m.source.nick)
+        assert_equal('spex', m.target.nick)
+        assert_equal('#m', m.channel.name)
+        assert_equal(@test[:good], m.raw_content)
+    end
+end

data/tests/handlers/tc_Join.rb

@@ -0,0 +1,33 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestJoinHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot    
+        @test = {
+                 :good => ':mod_spox!~mod_spox@host JOIN :#m',
+                 :bad => ':fubared JOIN fail whale'
+                }
+    end
+
+    def test_expected
+        assert_equal(:JOIN, @bot.factory.find_key(@test[:good]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Join, result)
+        assert_equal(@test[:good], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_kind_of(ModSpox::Models::Nick, result.nick)
+        assert_equal('#m', result.channel.name)
+        assert_equal('mod_spox', result.nick.nick)
+        assert_equal('host', result.nick.host)
+        assert_equal('host', result.nick.address)
+        assert_equal('~mod_spox', result.nick.username)
+        assert_equal('mod_spox!~mod_spox@host', result.nick.source)
+        assert(result.nick.visible)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Kick.rb

@@ -0,0 +1,32 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestKickHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :good => ':spax!~spox@host KICK #m spox :foo',
+                 :bad => ':fubared KICK fail whale'
+                }
+    end
+
+    def test_expected
+        assert_equal(:KICK, @bot.factory.find_key(@test[:good]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Kick, result)
+        assert_equal(@test[:good], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('#m', result.channel.name)
+        assert_kind_of(ModSpox::Models::Nick, result.kickee)
+        assert_equal('spox', result.kickee.nick)
+        assert_kind_of(ModSpox::Models::Nick, result.kicker)
+        assert_equal('spax', result.kicker.nick)
+        assert_kind_of(String, result.reason)
+        assert_equal('foo', result.reason)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Mode.rb

@@ -0,0 +1,85 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestModeHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot    
+        @test = {
+                 :set_single => ':spax!~spox@host MODE #m +o spax',
+                 :set_double => ':spax!~spox@host MODE #m +oo spax spex',
+                 :set_channel => ':spax!~spox@host MODE #m +s',
+                 :set_self => ':mod_spox MODE mod_spox :+iw',
+                 :bad => ':fubared MODE fail whale'
+                }
+    end
+
+    def test_single
+        assert_equal(:MODE, @bot.factory.find_key(@test[:set_single]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:set_single])].process(@test[:set_single])
+        assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
+        assert_equal(@test[:set_single], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('#m', result.channel.name)
+        assert_kind_of(ModSpox::Models::Nick, result.target)
+        assert_equal('spax', result.target.nick)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spax', result.source.nick)
+        assert_kind_of(String, result.mode)
+        assert_equal('+o', result.mode)
+        assert(result.target.is_op?(result.channel))
+    end
+
+    def test_double
+        assert_equal(:MODE, @bot.factory.find_key(@test[:set_double]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:set_double])].process(@test[:set_double])
+        assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
+        assert_equal(@test[:set_double], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('#m', result.channel.name)
+        assert_kind_of(Array, result.target)
+        assert_equal('spax', result.target[0].nick)
+        assert_equal('spex', result.target[1].nick)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spax', result.source.nick)
+        assert_kind_of(String, result.mode)
+        assert_equal('+oo', result.mode)
+        assert(result.target[0].is_op?(result.channel))
+        assert(result.target[1].is_op?(result.channel))
+    end
+
+    def test_channel
+        assert_equal(:MODE, @bot.factory.find_key(@test[:set_channel]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:set_channel])].process(@test[:set_channel])
+        assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
+        assert_equal(@test[:set_channel], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('#m', result.channel.name)
+        assert_nil(result.target)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spax', result.source.nick)
+        assert_kind_of(String, result.mode)
+        assert_equal('+s', result.mode)
+        assert(result.channel.set?('s'))
+    end
+    
+    def test_self
+        assert_equal(:MODE, @bot.factory.find_key(@test[:set_self]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:set_self])].process(@test[:set_self])
+        assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
+        assert_equal(@test[:set_self], result.raw_content)
+        assert_nil(result.channel)
+        assert_kind_of(ModSpox::Models::Nick, result.target)
+        assert_equal('mod_spox', result.target.nick)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('mod_spox', result.source.nick)
+        assert_kind_of(String, result.mode)
+        assert_equal('+iw', result.mode)
+        assert(result.target.mode_set?('i'))
+        assert(result.target.mode_set?('w'))
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Names.rb

@@ -0,0 +1,35 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestNamesHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :names_start => ':swiftco.wa.us.dal.net 353 spox @ #mod_spox :@pizza_ pizza__ @mod_spox @spox +spex',
+                 :names_end => ':swiftco.wa.us.dal.net 366 spox #mod_spox :End of /NAMES list.',
+                 :bad => ':fubared 353 fail whale'
+                }
+    end
+
+    def test_expected
+        assert_equal('353', @bot.factory.find_key(@test[:names_start]))
+        assert_nil(@bot.factory.handlers[@bot.factory.find_key(@test[:names_start])].process(@test[:names_start]))
+        assert_equal('366', @bot.factory.find_key(@test[:names_end]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:names_end])].process(@test[:names_end])
+        assert_kind_of(ModSpox::Messages::Incoming::Names, result)
+        assert_equal('#mod_spox', result.channel.name)
+        assert_equal(5, result.nicks.size)
+        assert_equal(3, result.ops.size)
+        assert_equal(1, result.voiced.size)
+        assert(ModSpox::Models::Nick.find_or_create(:nick => 'mod_spox').is_op?(result.channel))
+        assert(ModSpox::Models::Nick.find_or_create(:nick => 'pizza_').is_op?(result.channel))
+        assert(ModSpox::Models::Nick.find_or_create(:nick => 'spox').is_op?(result.channel))
+        assert(!ModSpox::Models::Nick.find_or_create(:nick => 'pizza__').is_op?(result.channel))
+        assert(ModSpox::Models::Nick.find_or_create(:nick => 'spex').is_voice?(result.channel))
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Nick.rb

@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestNickHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :good => ':spox!~spox@some.random.host NICK :flock_of_deer',
+                 :bad => ':bad NICK fail'
+                }
+        @nick = ModSpox::Models::Nick.find_or_create(:nick => 'spox')
+    end
+
+    def test_simple
+        m = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Nick, m)
+        assert_equal(@test[:good], m.raw_content)
+        assert_kind_of(ModSpox::Models::Nick, m.new_nick)
+        assert_kind_of(ModSpox::Models::Nick, m.original_nick)
+        assert_equal('spox', m.original_nick.nick)
+        assert_equal('flock_of_deer', m.new_nick.nick)
+    end
+    
+    def test_info_move
+        @nick.address = 'some.random.host'
+        @nick.username = '~spox'
+        @nick.real_name = 'foobar'
+        @nick.save
+        m = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Nick, m)
+        assert_equal('spox', m.original_nick.nick)
+        assert_equal('flock_of_deer', m.new_nick.nick)
+        assert_equal('some.random.host', m.new_nick.address)
+        assert_equal('~spox', m.new_nick.username)
+        assert_equal('foobar', m.new_nick.real_name)
+    end
+    
+    def test_mode_move
+        c = ModSpox::Models::Channel.find_or_create(:name => '#test')
+        @nick.add_channel(c)
+        mode = ModSpox::Models::NickMode.find_or_create(:nick_id => @nick.pk, :channel_id => c.pk)
+        mode.set_mode('o')
+        m = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Nick, m)
+        assert_equal(0, m.original_nick.channels.size)
+        assert(m.new_nick.channels.size > 0)
+        assert(m.new_nick.channels.include?(c))
+        assert(m.new_nick.is_op?(c))
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Part.rb

@@ -0,0 +1,44 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestPartHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :w_message => ':mod_spox!~mod_spox@host PART #m :part message',
+                 :wo_message => ':mod_spox!~mod_spox@host PART #m :',
+                 :bad => ':bad PART fail'
+                }
+    end
+
+    def test_w_message
+        assert_equal(:PART, @bot.factory.find_key(@test[:w_message]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:w_message])].process(@test[:w_message])
+        assert_kind_of(ModSpox::Messages::Incoming::Part, result)
+        assert_equal(@test[:w_message], result.raw_content)
+        assert_kind_of(String, result.reason)
+        assert_kind_of(ModSpox::Models::Nick, result.nick)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('mod_spox', result.nick.nick)
+        assert_equal('#m', result.channel.name)
+        assert_equal('part message', result.reason)
+    end
+
+    def test_wo_message
+        assert_equal(:PART, @bot.factory.find_key(@test[:wo_message]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:wo_message])].process(@test[:wo_message])
+        assert_kind_of(ModSpox::Messages::Incoming::Part, result)
+        assert_equal(@test[:wo_message], result.raw_content)
+        assert_kind_of(String, result.reason)
+        assert_kind_of(ModSpox::Models::Nick, result.nick)
+        assert_kind_of(ModSpox::Models::Channel, result.channel)
+        assert_equal('mod_spox', result.nick.nick)
+        assert_equal('#m', result.channel.name)
+        assert(result.reason.empty?)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Ping.rb

@@ -0,0 +1,40 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestPingHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :wo_server => 'PING :not.configured',
+                 :w_server => ':not.configured PING :test',
+                 :bad => 'PING fail whale'
+                }
+    end
+
+    def test_wo_server
+        assert_equal(:PING, @bot.factory.find_key(@test[:wo_server]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:wo_server])].process(@test[:wo_server])
+        assert_kind_of(ModSpox::Messages::Incoming::Ping, result)
+        assert_equal(@test[:wo_server], result.raw_content)
+        assert_kind_of(String, result.string)
+        assert_kind_of(String, result.server)
+        assert_equal('not.configured', result.server)
+        assert_equal('not.configured', result.string)
+    end
+
+    def test_w_server
+        assert_equal(:PING, @bot.factory.find_key(@test[:w_server]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:w_server])].process(@test[:w_server])
+        assert_kind_of(ModSpox::Messages::Incoming::Ping, result)
+        assert_equal(@test[:w_server], result.raw_content)
+        assert_kind_of(String, result.string)
+        assert_kind_of(String, result.server)
+        assert_equal('not.configured', result.server)
+        assert_equal('test', result.string)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Pong.rb

@@ -0,0 +1,28 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestPongHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :good => ':swiftco.wa.us.dal.net PONG swiftco.wa.us.dal.net :FOO',
+                 :bad => ':bad PONG fail'
+                }
+    end
+
+    def test_expected
+        assert_equal(:PONG, @bot.factory.find_key(@test[:good]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        assert_kind_of(ModSpox::Messages::Incoming::Ping, result)
+        assert_equal(@test[:good], result.raw_content)
+        assert_kind_of(String, result.string)
+        assert_kind_of(String, result.server)
+        assert_equal('swiftco.wa.us.dal.net', result.server)
+        assert_equal('FOO', result.string)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Privmsg.rb

@@ -0,0 +1,85 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestPrivmsgHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :nick_to_channel => ':spox!~spox@host PRIVMSG #m :foobar',
+                 :nick_to_nick => ':spox!~spox@host PRIVMSG mod_spox :foobar',
+                 :nick_to_channel_addressed => ':spox!~spox@host PRIVMSG #m :mod_spox: foobar',
+                 :bad => ':fubared PRIVMSG fail whale'
+                }
+    end
+
+    def test_nick_to_channel
+        assert_equal(:PRIVMSG, @bot.factory.find_key(@test[:nick_to_channel]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:nick_to_channel])].process(@test[:nick_to_channel])
+        assert_kind_of(ModSpox::Messages::Incoming::Privmsg, result)
+        assert_equal(@test[:nick_to_channel], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.target)
+        assert_equal('#m', result.target.name)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spox', result.source.nick)
+        assert_kind_of(String, result.message)
+        assert_equal('foobar', result.message)
+        assert(!result.is_private?)
+        assert(result.is_public?)
+        assert(!result.addressed?)
+        assert(!result.is_action?)
+        assert(!result.is_colored?)
+        assert(!result.is_ctcp?)
+        assert(!result.is_dcc?)
+        assert_equal(result.message_nocolor, result.message)
+        assert_equal(result.target, result.replyto)
+    end
+
+    def test_nick_to_channel_addressed
+        assert_equal(:PRIVMSG, @bot.factory.find_key(@test[:nick_to_channel_addressed]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:nick_to_channel_addressed])].process(@test[:nick_to_channel_addressed])
+        assert_kind_of(ModSpox::Messages::Incoming::Privmsg, result)
+        assert_equal(@test[:nick_to_channel_addressed], result.raw_content)
+        assert_kind_of(ModSpox::Models::Channel, result.target)
+        assert_equal('#m', result.target.name)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spox', result.source.nick)
+        assert_kind_of(String, result.message)
+        assert_equal('mod_spox: foobar', result.message)
+        assert(!result.is_private?)
+        assert(result.is_public?)
+        assert(result.addressed?)
+        assert(!result.is_action?)
+        assert(!result.is_colored?)
+        assert(!result.is_ctcp?)
+        assert(!result.is_dcc?)
+        assert_equal(result.message_nocolor, result.message)
+        assert_equal(result.target, result.replyto)
+    end
+
+    def test_nick_to_nick
+        assert_equal(:PRIVMSG, @bot.factory.find_key(@test[:nick_to_nick]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:nick_to_nick])].process(@test[:nick_to_nick])
+        assert_kind_of(ModSpox::Messages::Incoming::Privmsg, result)
+        assert_equal(@test[:nick_to_nick], result.raw_content)
+        assert_kind_of(ModSpox::Models::Nick, result.target)
+        assert_equal('mod_spox', result.target.nick)
+        assert_kind_of(ModSpox::Models::Nick, result.source)
+        assert_equal('spox', result.source.nick)
+        assert_kind_of(String, result.message)
+        assert_equal('foobar', result.message)
+        assert(result.is_private?)
+        assert(!result.is_public?)
+        assert(result.addressed?)
+        assert(!result.is_action?)
+        assert(!result.is_colored?)
+        assert(!result.is_ctcp?)
+        assert(!result.is_dcc?)
+        assert_equal(result.message_nocolor, result.message)
+        assert_equal(result.source, result.replyto)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Quit.rb

@@ -0,0 +1,40 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestQuitHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                 :w_message => ':spox!~spox@host QUIT :Ping timeout',
+                 :wo_message => ':spox!~spox@host QUIT :',
+                 :bad => ':not.configured QUIT fail whale'
+                }
+    end
+
+    def test_wo_message
+        assert_equal(:QUIT, @bot.factory.find_key(@test[:wo_message]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:wo_message])].process(@test[:wo_message])
+        assert_kind_of(ModSpox::Messages::Incoming::Quit, result)
+        assert_equal(@test[:wo_message], result.raw_content)
+        assert_kind_of(ModSpox::Models::Nick, result.nick)
+        assert_equal('spox', result.nick.nick)
+        assert_kind_of(String, result.message)
+        assert_equal('', result.message)
+    end
+
+    def test_w_message
+        assert_equal(:QUIT, @bot.factory.find_key(@test[:w_message]))
+        result = @bot.factory.handlers[@bot.factory.find_key(@test[:w_message])].process(@test[:w_message])
+        assert_kind_of(ModSpox::Messages::Incoming::Quit, result)
+        assert_equal(@test[:w_message], result.raw_content)
+        assert_kind_of(ModSpox::Models::Nick, result.nick)
+        assert_equal('spox', result.nick.nick)
+        assert_kind_of(String, result.message)
+        assert_equal('Ping timeout', result.message)
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+    end
+end

data/tests/handlers/tc_Who.rb

@@ -0,0 +1,50 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestWhoHandler < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @bot = h.bot
+        @test = {
+                    :good => [],
+                    :bad => ':host 352 fail whale'
+                }
+        @test[:good] << ':host 352 spox #mod_spox ~pizza_ host.1 punch.va.us.dal.net pizza_ H@ :5 pizza_'
+        @test[:good] << ':host 352 spox #mod_spox ~pizza_ host.2 punch.va.us.dal.net pizza__ H :5 pizza_'
+        @test[:good] << ':host 352 spox #mod_spox ~mod_spox host.3 mozilla.se.eu.dal.net mod_spox H@ :6 mod_spox IRC bot'
+        @test[:good] << ':host 352 spox #mod_spox ~spox host.4 swiftco.wa.us.dal.net spox H@ :0 spox'
+        @test[:good] << ':host 315 spox #mod_spox :End of /WHO list.'
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, :Incoming_Who)
+        @nicks = ['pizza_', 'pizza__', 'spox', 'mod_spox']
+        @ops = ['pizza_', 'spox', 'mod_spox']
+    end
+    
+    def gather(m)
+        @queue << m
+    end
+
+    def test_expected
+        4.times{ @bot.factory << @test[:good].shift }
+        sleep(0.5) # wait for much longer than needed to check queue
+        assert_equal(0, @queue.size)
+        @bot.factory << @test[:good].shift
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        assert_kind_of(ModSpox::Messages::Incoming::Who, m)
+        assert_kind_of(ModSpox::Models::Channel, m.location)
+        assert_equal('#mod_spox', m.location.name)
+        assert_kind_of(Array, m.nicks)
+        assert_equal(4, m.nicks.size)
+        m.nicks.each do |nick|
+            assert(@nicks.include?(nick.nick))
+            assert(nick.channels.map{|c|c.name}.include?('#mod_spox'))
+            assert_equal(@ops.include?(nick.nick), nick.is_op?(m.location))
+        end
+    end
+
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad].dup)].process(@test[:bad].dup)}
+    end
+end