spox-mod_spox 0.3.1 → 0.3.2

data/tests/BotHolder.rb

@@ -14,7 +14,13 @@ class BotHolder
     attr_reader :bot
     def initialize
         ModSpox::Database.db = nil
-        ModSpox.initialize_bot(Sequel.sqlite('test.db'))
+        begin
+            File.unlink('test.db') if File.exists?('test.db')
+            ModSpox.initialize_bot(Sequel.sqlite('test.db'))
+        rescue SQLite3::BusyException
+            ModSpox::Database.reconnect
+            retry
+        end
         require 'mod_spox/Bot'
         @bot = ModSpox::Bot.new
         m = ModSpox::Models::Nick.find_or_create(:nick => 'mod_spox')

data/tests/handlers/tc_Created.rb

@@ -4,21 +4,41 @@ class TestCreatedHandler < Test::Unit::TestCase
 
     def setup
         h = BotHolder.instance
-        @bot = h.bot    
+        @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'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Created')
+        require 'mod_spox/handlers/Created'
+        @handler = ModSpox::Handlers::Created.new({})
     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)
+    def gather(m)
+        @queue << m
     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_direct
+        check_result(@handler.process(@test[:good]))
+    end
+    
     def test_unexpected
-        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_result(m)
+        assert_kind_of(ModSpox::Messages::Incoming::Created, m)
+        assert_equal(m.raw_content, @test[:good])
     end
 end

data/tests/handlers/tc_Invite.rb

@@ -4,24 +4,20 @@ class TestInviteHandler < Test::Unit::TestCase
 
     def setup
         h = BotHolder.instance
-        @bot = h.bot    
+        @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)
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Invite')
+        require 'mod_spox/handlers/Invite'
+        @handler = ModSpox::Handlers::Invite.new({})
     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]
@@ -31,8 +27,14 @@ class TestInviteHandler < Test::Unit::TestCase
         check_result(m)
     end
     
+    def test_direct
+        check_result(@handler.process(@test[:good]))
+    end
+    
     def test_unexpected
-        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     end
     
     private

data/tests/handlers/tc_Join.rb

@@ -9,25 +9,45 @@ class TestJoinHandler < Test::Unit::TestCase
                  :good => ':mod_spox!~mod_spox@host JOIN :#m',
                  :bad => ':fubared JOIN fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Join')
+        require 'mod_spox/handlers/Join'
+        @handler = ModSpox::Handlers::Join.new({})
     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)
+    def gather(m)
+        @queue << m
     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_direct
+        check_result(@handler.process(@test[:good]))
+    end
+    
     def test_unexpected
-        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad])].process(@test[:bad])}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_result(m)
+        assert_kind_of(ModSpox::Messages::Incoming::Join, m)
+        assert_equal(m.raw_content, @test[:good])
+        assert_kind_of(ModSpox::Models::Channel, m.channel)
+        assert_kind_of(ModSpox::Models::Nick, m.nick)
+        assert_equal('#m', m.channel.name)
+        assert_equal('mod_spox', m.nick.nick)
+        assert_equal('host', m.nick.host)
+        assert_equal('host', m.nick.address)
+        assert_equal('~mod_spox', m.nick.username)
+        assert_equal('mod_spox!~mod_spox@host', m.nick.source)
+        assert(m.nick.visible)
     end
 end

data/tests/handlers/tc_Kick.rb

@@ -9,11 +9,35 @@ class TestKickHandler < Test::Unit::TestCase
                  :good => ':spax!~spox@host KICK #m spox :foo',
                  :bad => ':fubared KICK fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Kick')
+        require 'mod_spox/handlers/Kick'
+        @handler = ModSpox::Handlers::Kick.new({})
     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])
+    def gather(m)
+        @queue << m
+    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_direct
+        check_result(@handler.process(@test[:good]))
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_result(result)
         assert_kind_of(ModSpox::Messages::Incoming::Kick, result)
         assert_equal(@test[:good], result.raw_content)
         assert_kind_of(ModSpox::Models::Channel, result.channel)
@@ -26,7 +50,4 @@ class TestKickHandler < Test::Unit::TestCase
         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

@@ -12,11 +12,21 @@ class TestModeHandler < Test::Unit::TestCase
                  :set_self => ':mod_spox MODE mod_spox :+iw',
                  :bad => ':fubared MODE fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Mode')
+        require 'mod_spox/handlers/Mode'
+        @handler = ModSpox::Handlers::Mode.new({})
     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])
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:set_single]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        result = @queue.pop
         assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
         assert_equal(@test[:set_single], result.raw_content)
         assert_kind_of(ModSpox::Models::Channel, result.channel)
@@ -29,10 +39,9 @@ class TestModeHandler < Test::Unit::TestCase
         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])
+        result = @handler.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)
@@ -47,10 +56,9 @@ class TestModeHandler < Test::Unit::TestCase
         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])
+        result = @handler.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)
@@ -64,8 +72,7 @@ class TestModeHandler < Test::Unit::TestCase
     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])
+        result = @handler.process(@test[:set_self])
         assert_kind_of(ModSpox::Messages::Incoming::Mode, result)
         assert_equal(@test[:set_self], result.raw_content)
         assert_nil(result.channel)
@@ -78,8 +85,11 @@ class TestModeHandler < Test::Unit::TestCase
         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])}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     end
+
 end

data/tests/handlers/tc_Names.rb

@@ -10,13 +10,37 @@ class TestNamesHandler < Test::Unit::TestCase
                  :names_end => ':swiftco.wa.us.dal.net 366 spox #mod_spox :End of /NAMES list.',
                  :bad => ':fubared 353 fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Names')
+        require 'mod_spox/handlers/Names'
+        @handler = ModSpox::Handlers::Names.new({})
     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])
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:names_start]
+        @bot.factory << @test[:names_end]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_result(m)
+    end
+    
+    def test_direct
+        assert_nil(@handler.process(@test[:names_start]))
+        check_result(@handler.process(@test[:names_end]))
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_result(result)
         assert_kind_of(ModSpox::Messages::Incoming::Names, result)
         assert_equal('#mod_spox', result.channel.name)
         assert_equal(5, result.nicks.size)
@@ -28,8 +52,4 @@ class TestNamesHandler < Test::Unit::TestCase
         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

@@ -10,16 +10,42 @@ class TestNickHandler < Test::Unit::TestCase
                  :bad => ':bad NICK fail'
                 }
         @nick = ModSpox::Models::Nick.find_or_create(:nick => 'spox')
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Nick')
+        require 'mod_spox/handlers/Nick'
+        @handler = ModSpox::Handlers::Nick.new({})
     end
 
-    def test_simple
-        m = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+    def gather(m)
+        @queue << m
+    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_direct
+        check_result(@handler.process(@test[:good]))
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_result(m)
         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)
+        assert_equal(m.raw_content, @test[:good])
     end
     
     def test_info_move
@@ -27,7 +53,7 @@ class TestNickHandler < Test::Unit::TestCase
         @nick.username = '~spox'
         @nick.real_name = 'foobar'
         @nick.save
-        m = @bot.factory.handlers[@bot.factory.find_key(@test[:good])].process(@test[:good])
+        m = @handler.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)
@@ -41,15 +67,11 @@ class TestNickHandler < Test::Unit::TestCase
         @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])
+        m = @handler.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

@@ -10,35 +10,45 @@ class TestPartHandler < Test::Unit::TestCase
                  :wo_message => ':mod_spox!~mod_spox@host PART #m :',
                  :bad => ':bad PART fail'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Part')
+        require 'mod_spox/handlers/Part'
+        @handler = ModSpox::Handlers::Part.new({})
     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)
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:w_message]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_result(m)
+        assert_equal('part message', m.reason)
+        assert_equal(m.raw_content, @test[:w_message])
+    end
+    
+    def test_direct
+        m = @handler.process(@test[:wo_message])
+        check_result(m)
+        assert(m.reason.empty?)
+        assert_equal(m.raw_content, @test[:wo_message])
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     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])
+    def check_result(result)
         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