spox-mod_spox 0.3.1 → 0.3.2

data/tests/handlers/tc_Ping.rb

@@ -10,31 +10,44 @@ class TestPingHandler < Test::Unit::TestCase
                  :w_server => ':not.configured PING :test',
                  :bad => 'PING fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Ping')
+        require 'mod_spox/handlers/Ping'
+        @handler = ModSpox::Handlers::Ping.new({})
     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)
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:wo_server]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_result(m)
+        assert_equal(m.raw_content, @test[:wo_server])
+        assert_equal('not.configured', m.server)
+        assert_equal('not.configured', m.string)
+    end
+    
+    def test_direct
+        m = @handler.process(@test[:w_server])
+        check_result(m)
+        assert_equal(m.raw_content, @test[:w_server])
+        assert_equal('not.configured', m.server)
+        assert_equal('test', m.string)
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     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])
+    def check_result(result)
         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

@@ -9,20 +9,40 @@ class TestPongHandler < Test::Unit::TestCase
                  :good => ':swiftco.wa.us.dal.net PONG swiftco.wa.us.dal.net :FOO',
                  :bad => ':bad PONG fail'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Pong')
+        require 'mod_spox/handlers/Pong'
+        @handler = ModSpox::Handlers::Pong.new({})
     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)
+    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::Pong, 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

@@ -11,11 +11,39 @@ class TestPrivmsgHandler < Test::Unit::TestCase
                  :nick_to_channel_addressed => ':spox!~spox@host PRIVMSG #m :mod_spox: foobar',
                  :bad => ':fubared PRIVMSG fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Privmsg')
+        require 'mod_spox/handlers/Privmsg'
+        @handler = ModSpox::Handlers::Privmsg.new({})
     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])
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:nick_to_channel]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_nick2chan(m)
+    end
+    
+    def test_nick
+        check_nick2nick(@handler.process(@test[:nick_to_nick]))
+    end
+    
+    def test_chan_ad
+        check_nick2chanad(@handler.process(@test[:nick_to_channel_addressed]))
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
+    end
+
+    def check_nick2chan(result)
         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)
@@ -35,9 +63,7 @@ class TestPrivmsgHandler < Test::Unit::TestCase
         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])
+    def check_nick2chanad(result)
         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)
@@ -57,9 +83,7 @@ class TestPrivmsgHandler < Test::Unit::TestCase
         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])
+    def check_nick2nick(result)
         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)
@@ -78,8 +102,4 @@ class TestPrivmsgHandler < Test::Unit::TestCase
         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

@@ -10,31 +10,44 @@ class TestQuitHandler < Test::Unit::TestCase
                  :wo_message => ':spox!~spox@host QUIT :',
                  :bad => ':not.configured QUIT fail whale'
                 }
+        @queue = Queue.new
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Quit')
+        require 'mod_spox/handlers/Quit'
+        @handler = ModSpox::Handlers::Quit.new({})
     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)
+    def gather(m)
+        @queue << m
+    end
+    
+    def test_indirect
+        @bot.factory << @test[:wo_message]
+        sleep(0.1)
+        assert_equal(1, @queue.size)
+        m = @queue.pop
+        check_result(m)
+        assert_equal(@test[:wo_message], m.raw_content)
+        assert_equal('', m.message)
+    end
+    
+    def test_direct
+        m = @handler.process(@test[:w_message])
+        check_result(m)
+        assert_equal('Ping timeout', m.message)
+        assert_equal(@test[:w_message], m.raw_content)
+    end
+    
+    def test_unexpected
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     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])
+    def check_result(result)
         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

@@ -15,9 +15,11 @@ class TestWhoHandler < Test::Unit::TestCase
         @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)
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Who')
         @nicks = ['pizza_', 'pizza__', 'spox', 'mod_spox']
         @ops = ['pizza_', 'spox', 'mod_spox']
+        require 'mod_spox/handlers/Who'
+        @handler = ModSpox::Handlers::Who.new({})
     end
     
     def gather(m)
@@ -43,8 +45,11 @@ class TestWhoHandler < Test::Unit::TestCase
             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)}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     end
+
 end

data/tests/handlers/tc_Whois.rb

@@ -16,13 +16,15 @@ class TestWhoHandler < Test::Unit::TestCase
         @test[:good] << ':swiftco.wa.us.dal.net 317 spox spox 176 1242140666 :seconds idle, signon time'
         @test[:good] << ':swiftco.wa.us.dal.net 318 spox spox :End of /WHOIS list.'
         @queue = Queue.new
-        @bot.pipeline.hook(self, :gather, :Incoming_Whois)
+        @bot.pipeline.hook(self, :gather, 'ModSpox::Messages::Incoming::Whois')
         @voice = ['#ruby', '#!php']
         @ops = ['#php', '#mod_spox']
         nick = ModSpox::Models::Nick.find_or_create(:nick => 'spox')
         nick.auth.services = true
         nick.auth.save
         @con = Time.at(1242140666)
+        require 'mod_spox/handlers/Whois'
+        @handler = ModSpox::Handlers::Whois.new({})
     end
     
     def gather(m)
@@ -54,8 +56,10 @@ class TestWhoHandler < Test::Unit::TestCase
         assert_equal('myhost.com', m.nick.host)
         assert_equal('spox', m.nick.real_name)
     end
-
+    
     def test_unexpected
-        assert_raise(ModSpox::Exceptions::GeneralException){@bot.factory.handlers[@bot.factory.find_key(@test[:bad].dup)].process(@test[:bad].dup)}
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            @handler.process(@test[:bad])
+        end
     end
 end

data/tests/lib/tc_BotConfig.rb

@@ -0,0 +1,35 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestBotConfig < Test::Unit::TestCase
+
+    def setup
+        h = BotHolder.instance
+        @testdir = '/home/testing'
+        ModSpox.mod_spox_path = @testdir
+        ModSpox::BotConfig.populate(false) # don't try and create directory
+    end
+
+    def test_valid
+        gemname, gem = Gem.source_index.find{|name, spec| spec.name == 'mod_spox' && spec.version.version = ModSpox.botversion}
+        path = gem.full_gem_path
+        assert_equal(path, ModSpox::BotConfig[:basepath])
+        assert_equal("#{path}/lib/mod_spox", ModSpox::BotConfig[:libpath])
+        assert_equal("#{path}/data/mod_spox", ModSpox::BotConfig[:datapath])
+        assert_equal("#{path}/data/mod_spox/plugins", ModSpox::BotConfig[:pluginpath])
+        assert_equal("#{path}/data/mod_spox/extras", ModSpox::BotConfig[:pluginextraspath])
+        assert_equal("#{@testdir}/.mod_spox", ModSpox::BotConfig[:userpath])
+        assert_equal("#{@testdir}/.mod_spox/plugins", ModSpox::BotConfig[:userpluginpath])
+        assert_equal("#{@testdir}/.mod_spox/config", ModSpox::BotConfig[:userconfigpath])
+    end
+
+    def test_invalid
+        assert_raise(ModSpox::Exceptions::UnknownKey){ ModSpox::BotConfig[:fubar] }
+        assert_raise(ModSpox::Exceptions::UnknownKey){ ModSpox::BotConfig[0] }
+        assert_raise(ModSpox::Exceptions::UnknownKey){ ModSpox::BotConfig['fail'] }
+        # assert_raise(ArgumentError){ ModSpox::BotConfig[nil] } i don't even know how to remove the to_s method
+    end
+
+    def test_configured
+        assert(!ModSpox::BotConfig.configured?)
+    end
+end

data/tests/lib/tc_Helpers.rb

@@ -0,0 +1,139 @@
+require "#{File.dirname(__FILE__)}/../BotHolder.rb"
+
+class TestHelpers < Test::Unit::TestCase
+    def setup
+        h = BotHolder.instance
+        ModSpox::Models::Server.find_or_create(:host => 'some.irc.server.com')
+    end
+    def test_format_seconds
+        inc = {:year => 60 * 60 * 24 * 365,
+               :month => 60 * 60 * 24 * 31,
+               :week => 60 * 60 * 24 * 7,
+               :day => 60 * 60 * 24,
+               :hour => 60 * 60,
+               :minute => 60,
+               :second => 1}
+        100.times do |i|
+            time = rand(i)
+            otime = time
+            formatted = []
+            inc.each_pair do |name, value|
+                val = (time / value).to_i
+                if(val > 0)
+                    time = time - (val * value)
+                    formatted << "#{val} #{val == 1 ? name : "#{name}s"}"
+                end
+            end
+            formatted = formatted.empty? ? '0 seconds' : formatted.join(' ')
+            assert_equal(ModSpox::Helpers.format_seconds(otime), formatted)
+        end
+    end
+    
+    def test_format_size
+        inc = {"byte" => 1024**0,       # 1024^0
+               "Kilobyte" => 1024**1,   # 1024^1
+               "Megabyte" => 1024**2,   # 1024^2
+               "Gigabyte" => 1024**3,   # 1024^3
+               "Terabyte" => 1024**4,   # 1024^4
+               "Petabyte" => 1024**5,   # 1024^5
+               "Exabyte" => 1024**6,    # 1024^6
+               "Zettabyte" => 1024**7,  # 1024^7
+               "Yottabyte" => 1024**8   # 1024^8
+              }
+        100.times do |i|
+            val = i**rand(i)
+            formatted = nil
+            inc.each_pair do |name, value|
+                v = val / value.to_f
+                if(v.to_i > 0)
+                    formatted = ("%.3f" % v) + " #{name}#{v == 1 ? '' : 's'}"
+                end
+            end
+            formatted = '0 bytes' if formatted.nil?
+            assert_equal(formatted, ModSpox::Helpers.format_size(val))
+        end
+    end
+    
+     def test_safe_exec
+         assert_raise(IOError) do
+             ModSpox::Helpers.safe_exec('echo test', 10, 1)
+         end
+         assert_raise(Timeout::Error) do
+             ModSpox::Helpers.safe_exec('while [ true ]; do true; done;', 1)
+         end
+         assert_equal("test\n", ModSpox::Helpers.safe_exec('echo test'))
+     end
+
+     def test_tinyurl
+         assert_equal('http://tinyurl.com/1c2', ModSpox::Helpers.tinyurl('http://www.google.com'))
+         assert_equal('Error', ModSpox::Helpers.tinyurl(''))
+     end
+
+     def test_find_model
+         assert_kind_of(ModSpox::Models::Nick, ModSpox::Helpers.find_model('nick'))
+         assert_kind_of(ModSpox::Models::Channel, ModSpox::Helpers.find_model('#channel'))
+         assert_kind_of(ModSpox::Models::Server, ModSpox::Helpers.find_model('some.irc.server.com'))
+         assert_equal('not.a.real.server', ModSpox::Helpers.find_model('not.a.real.server'))
+         assert_kind_of(String, '*!*@some.host')
+     end
+    
+    def test_convert_entities
+        assert_equal('<p>', ModSpox::Helpers.convert_entities('&lt;p&gt;'))
+        assert_equal('hi there', ModSpox::Helpers.convert_entities('hi there'))
+    end
+    
+    def test_load_message
+        ModSpox::Helpers.load_message(:internal, :TimerAdd)
+        assert(ModSpox::Messages::Internal::TimerAdd)
+        assert_raise(ArgumentError){ ModSpox::Helpers.load_message(:foobar, :fee) }
+        assert_raise(LoadError){ ModSpox::Helpers.load_message(:internal, :fail) }
+    end
+     
+     def test_type_of?
+        ModSpox::Helpers.load_message(:internal, :HaltBot)
+        m = ModSpox::Messages::Internal::HaltBot.new
+        assert(ModSpox::Helpers.type_of?(m, Object))
+        assert(ModSpox::Helpers.type_of?(m, ModSpox))
+        assert(ModSpox::Helpers.type_of?(m, ModSpox::Messages))
+        assert(ModSpox::Helpers.type_of?(m, ModSpox::Messages::Internal))
+        assert(ModSpox::Helpers.type_of?(m, ModSpox::Messages::Internal::HaltBot))
+        assert(ModSpox::Helpers.type_of?(m, :ModSpox_Messages_Internal_HaltBot, true))
+        assert(ModSpox::Helpers.type_of?(m, :Internal_HaltBot, true))
+        assert(ModSpox::Helpers.type_of?(m, :Internal, true))
+        assert(!ModSpox::Helpers.type_of?(m, String))
+     end
+     
+    def test_find_const
+        ModSpox::Helpers.load_message(:internal, :HaltBot)
+        assert(ModSpox::Messages::Internal::HaltBot)
+        assert_equal(ModSpox::Messages::Internal::HaltBot, ModSpox::Helpers.find_const('ModSpox::Messages::Internal::HaltBot'))
+        assert_equal(ModSpox::Messages::Internal::HaltBot, ModSpox::Helpers.find_const('Internal::HaltBot'))
+        assert_equal('Incoming::UnknownType', ModSpox::Helpers.find_const('Incoming::UnknownType'))
+    end
+    
+    # test partially lifted from the unit tests in the source
+    # provided by Ryan "pizza_" Flynn
+    # Class and tests found in: http://github.com/pizza/algodict
+
+    def test_random
+        assert_raise(ModSpox::Exceptions::GeneralException) do
+            100.times do
+                results = []
+                pool = (0..rand(1000)).to_a
+                ideal = ModSpox::Helpers::IdealHumanRandomIterator.new(pool)
+                (pool.size / 2).times do
+                    n = ideal.next()
+                    if(results.include?(n))
+                        raise Exception.new("Duplicated result")
+                    else
+                        results << n
+                    end
+                end
+            end
+            raise ModSpox::Exceptions::GeneralException.new("OK")
+        end
+        assert_raise(ArgumentError){ ModSpox::Helpers::IdealHumanRandomIterator.new(1) }
+        assert_nil(ModSpox::Helpers::IdealHumanRandomIterator.new([]).next)
+        assert_equal(0, ModSpox::Helpers::IdealHumanRandomIterator.new([0]).next)
+    end
+end