jabbot 0.1.2 → 0.2.0

data/lib/jabbot/version.rb

@@ -0,0 +1,3 @@
+module Jabbot
+  VERSION = '0.2.0'
+end

data/test/helper.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'fileutils'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'jabbot'
+
+module Test::Unit::Assertions
+  def assert_hashes_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.all? { |k| expected[k] == actual[k] }
+    end
+  end
+
+  def assert_hashes_not_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.any? { |k| expected[k] != actual[k] }
+    end
+  end
+end
+
+TEST_DIR = File.join(File.dirname(__FILE__), *%w[.])
+
+def testpath(path)
+  File.join(TEST_DIR, path)
+end
+
+# test/spec/mini 3
+# http://gist.github.com/25455
+# chris@ozmm.org
+# file:lib/test/spec/mini.rb
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+end
+
+Message = Struct.new(:user, :text, :time)
+def mock_message(user, text)
+  Message.new(user, text, Time.now)
+end

data/test/test_bot.rb

@@ -1,20 +1,20 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'helper'
 require 'fileutils'
 
-class TestBot < Test::Unit::TestCase
-  should "not raise errors when initialized" do
+context "Bot" do
+  test "raise no exceptions when initialized" do
     assert_nothing_raised do
       Jabbot::Bot.new Jabbot::Config.new
     end
   end
 
-  should "raise errors when initialized without config file" do
+  test "raise exception when initialized without config file" do
     assert_raise SystemExit do
       Jabbot::Bot.new
     end
   end
 
-  should "not raise error on initialize when config file exists" do
+  test "raise no exception on initialize when config file exists" do
     if File.exists?("config")
       FileUtils.rm("config/bot.yml")
     else
@@ -30,17 +30,17 @@ class TestBot < Test::Unit::TestCase
     FileUtils.rm_rf("config")
   end
 
-  should "provide configuration settings as methods" do
+  test "provide configuration settings as methods" do
     bot = Jabbot::Bot.new Jabbot::Config.new(:login => "jabbot")
     assert_equal "jabbot", bot.login
   end
 
-  should "return logger instance" do
+  test "return logger instance" do
     bot = Jabbot::Bot.new(Jabbot::Config.default << Jabbot::Config.new)
     assert bot.log.is_a?(Logger)
   end
 
-  should "respect configured log level" do
+  test "respect configured log level" do
     bot = Jabbot::Bot.new(Jabbot::Config.new(:log_level => "info"))
     assert_equal Logger::INFO, bot.log.level
 
@@ -49,38 +49,8 @@ class TestBot < Test::Unit::TestCase
   end
 end
 
-class TestBotMacros < Test::Unit::TestCase
-  should "provide configure macro" do
-    assert respond_to?(:configure)
-  end
-
-  should "yield configuration" do
-    Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
-
-    conf = nil
-    assert_nothing_raised { configure { |c| conf = c } }
-    assert conf.is_a?(Jabbot::Config)
-  end
-
-   should "add handler" do
-     Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
-
-     handler = add_handler(:message, ":command", :from => :cjno)
-     assert handler.is_a?(Jabbot::Handler), handler.class
-   end
-
-  should "provide client macro" do
-    assert respond_to?(:client)
-  end
-
-  should "provide user macro" do
-    assert respond_to?(:user)
-  end
-end
-
-class TestBotHandlers < Test::Unit::TestCase
-
-  should "include handlers" do
+context "Handler DSL" do
+  test "include handlers" do
     bot = Jabbot::Bot.new(Jabbot::Config.new)
 
     assert_not_nil bot.handlers
@@ -91,7 +61,7 @@ class TestBotHandlers < Test::Unit::TestCase
     assert_not_nil bot.handlers[:subject]
   end
 
-  should "add handler" do
+  test "add handler" do
     bot = Jabbot::Bot.new(Jabbot::Config.new)
     bot.add_handler :message, Jabbot::Handler.new
     assert_equal 1, bot.handlers[:message].length

data/test/test_config.rb

@@ -1,44 +1,44 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'helper'
 require 'stringio'
 
-class TestConfig < Test::Unit::TestCase
-  should "default configuration be a hash" do
+context "Config" do
+  test "default configuration be a hash" do
     assert_not_nil Jabbot::Config::DEFAULT
     assert Jabbot::Config::DEFAULT.is_a?(Hash)
   end
 
-  should "initialize with no options" do
+  test "initialize with no options" do
     assert_hashes_equal({}, Jabbot::Config.new.settings)
   end
 
-  should "return config from add" do
+  test "return config from add" do
     config = Jabbot::Config.new
     assert_equal config, config.add(Jabbot::Config.new)
   end
 
-  should "alias add to <<" do
+  test "alias add to <<" do
     config = Jabbot::Config.new
     assert config.respond_to?(:<<)
     assert config << Jabbot::Config.new
   end
 
-  should "mirror method_missing as config getters" do
+  test "mirror method_missing as config getters" do
     config = Jabbot::Config.default << Jabbot::Config.new
     assert_equal Jabbot::Config::DEFAULT[:password], config.password
     assert_equal Jabbot::Config::DEFAULT[:login], config.login
   end
 
-  should "mirror missing methods as config setters" do
+  test "mirror missing methods as config setters" do
     config = Jabbot::Config.default << Jabbot::Config.new
     assert_equal Jabbot::Config::DEFAULT[:login], config.login
 
     val = "jabbot"
-    config.login = val+'!' 
+    config.login = val+'!'
     assert_not_equal Jabbot::Config::DEFAULT[:login], config.login
     assert_equal val+'!', config.login
   end
 
-  should "not override default hash" do
+  test "not override default hash" do
     config = Jabbot::Config.default
     hash = Jabbot::Config::DEFAULT
 
@@ -49,7 +49,7 @@ class TestConfig < Test::Unit::TestCase
     assert_hashes_equal hash, Jabbot::Config::DEFAULT
   end
 
-  should "return merged configuration from to_hash" do
+  test "return merged configuration from to_hash" do
     config = Jabbot::Config.new
     config.login = "jabbot"
     config.password = "secret"
@@ -64,16 +64,16 @@ class TestConfig < Test::Unit::TestCase
   end
 end
 
-class TestFileConfig < Test::Unit::TestCase
-  should "subclass config for file config" do
+context "FileConfig" do
+  test "subclass config for file config" do
     assert Jabbot::FileConfig.new(StringIO.new).is_a?(Jabbot::Config)
   end
 
-  should "read settings from stream" do
+  test "read settings from stream" do
     config = Jabbot::FileConfig.new(StringIO.new <<-YAML)
-login: jabbot
-password: secret
-    YAML
+  login: jabbot
+  password: secret
+      YAML
 
     assert_equal "jabbot", config.login
     assert_equal "secret", config.password

data/test/test_handler.rb

@@ -1,156 +1,154 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'helper'
 
-class TestHandler < Test::Unit::TestCase
-  context "pattern writer" do
-    should "abort on empty values" do
-      handler = Jabbot::Handler.new
+context "Handler" do
+  test "abort on empty values" do
+    handler = Jabbot::Handler.new
 
-      handler.pattern = nil
-      assert_nil handler.instance_eval { @options[:pattern] }
-      assert_nil handler.instance_eval { @options[:tokens] }
+    handler.pattern = nil
+    assert_nil handler.instance_eval { @options[:pattern] }
+    assert_nil handler.instance_eval { @options[:tokens] }
 
-      handler.pattern = ""
-      assert_nil handler.instance_eval { @options[:pattern] }
-      assert_nil handler.instance_eval { @options[:tokens] }
-    end
+    handler.pattern = ""
+    assert_nil handler.instance_eval { @options[:pattern] }
+    assert_nil handler.instance_eval { @options[:tokens] }
+  end
 
-    should "turn regular pattern into regex" do
-      handler = Jabbot::Handler.new
-      handler.pattern = "command"
+  test "turn regular pattern into regex" do
+    handler = Jabbot::Handler.new
+    handler.pattern = "command"
 
-      assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
-      assert_equal 0, handler.instance_eval { @options[:tokens] }.length
-    end
+    assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
+    assert_equal 0, handler.instance_eval { @options[:tokens] }.length
+  end
 
-    should "convert single named switch to regex" do
-      handler = Jabbot::Handler.new
-      handler.pattern = ":command"
+  test "convert single named switch to regex" do
+    handler = Jabbot::Handler.new
+    handler.pattern = ":command"
 
-      assert_equal(/([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
-      assert_equal 1, handler.instance_eval { @options[:tokens] }.length
-      assert_equal :command, handler.instance_eval { @options[:tokens].first }
-    end
+    assert_equal(/([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+    assert_equal 1, handler.instance_eval { @options[:tokens] }.length
+    assert_equal :command, handler.instance_eval { @options[:tokens].first }
+  end
 
-    should "convert several named switches to regexen" do
-      handler = Jabbot::Handler.new
-      handler.pattern = ":command fixed_word :subcommand"
+  test "convert several named switches to regexen" do
+    handler = Jabbot::Handler.new
+    handler.pattern = ":command fixed_word :subcommand"
 
-      assert_equal(/([^\s]+) fixed_word ([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
-      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
-      assert_equal :command, handler.instance_eval { @options[:tokens].first }
-      assert_equal :subcommand, handler.instance_eval { @options[:tokens][1] }
-    end
+    assert_equal(/([^\s]+) fixed_word ([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+    assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+    assert_equal :command, handler.instance_eval { @options[:tokens].first }
+    assert_equal :subcommand, handler.instance_eval { @options[:tokens][1] }
+  end
 
-    should "convert several named switches to regexen specified by options" do
-      handler = Jabbot::Handler.new(":time :hour", :hour => /\d\d/)
+  test "convert several named switches to regexen specified by options" do
+    handler = Jabbot::Handler.new(":time :hour", :hour => /\d\d/)
 
-      assert_equal(/([^\s]+) ((?-mix:\d\d))(\s.+)?/, handler.instance_eval { @options[:pattern] })
-      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
-      assert_equal :time, handler.instance_eval { @options[:tokens].first }
-      assert_equal :hour, handler.instance_eval { @options[:tokens][1] }
-    end
+    assert_equal(/([^\s]+) ((?-mix:\d\d))(\s.+)?/, handler.instance_eval { @options[:pattern] })
+    assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+    assert_equal :time, handler.instance_eval { @options[:tokens].first }
+    assert_equal :hour, handler.instance_eval { @options[:tokens][1] }
   end
 
-  should "recognize empty pattern" do
+  test "recognize empty pattern" do
     handler = Jabbot::Handler.new
-    message = message "cjno", "A jabber message"
+    message = mock_message "cjno", "A jabber message"
 
     assert handler.recognize?(message)
   end
 
-  should "recognize empty pattern and allowed user" do
+  test "recognize empty pattern and allowed user" do
     handler = Jabbot::Handler.new "", :from => "cjno"
-    message = message "cjno", "A jabber message"
+    message = mock_message "cjno", "A jabber message"
     assert handler.recognize?(message)
 
     handler = Jabbot::Handler.new "", :from => ["cjno", "irbno"]
     assert handler.recognize?(message)
   end
 
-  should "not recognize empty pattern and disallowed user" do
+  test "not recognize empty pattern and disallowed user" do
     handler = Jabbot::Handler.new "", :from => "irbno"
-    message = message "cjno", "A jabber message"
+    message = mock_message "cjno", "A jabber message"
     assert !handler.recognize?(message)
 
     handler = Jabbot::Handler.new "", :from => ["irbno", "satan"]
     assert !handler.recognize?(message)
   end
 
-  should "recognize fixed pattern and no user" do
+  test "recognize fixed pattern and no user" do
     handler = Jabbot::Handler.new "time"
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  should "recognize dynamic pattern and no user" do
+  test "recognize dynamic pattern and no user" do
     handler = Jabbot::Handler.new "time :city :country"
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  should "not recognize dynamic pattern and no user" do
+  test "not recognize dynamic pattern and no user" do
     handler = Jabbot::Handler.new "time :city :country"
-    message = message "cjno", "oslo norway what is the time?"
+    message = mock_message "cjno", "oslo norway what is the time?"
     assert !handler.recognize?(message)
   end
 
-  should "recognize fixed pattern and user" do
+  test "recognize fixed pattern and user" do
     handler = Jabbot::Handler.new "time", :from => ["cjno", "irbno"]
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  should "recognize dynamic pattern and user" do
+  test "recognize dynamic pattern and user" do
     handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  should "not recognize dynamic pattern and user" do
+  test "not recognize dynamic pattern and user" do
     handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
-    message = message "dude", "time oslo norway"
+    message = mock_message "dude", "time oslo norway"
     assert !handler.recognize?(message)
   end
 
-  should "recognize symbol users" do
+  test "recognize symbol users" do
     handler = Jabbot::Handler.new "time :city :country", :from => [:cjno, :irbno]
-    message = message "dude", "time oslo norway"
+    message = mock_message "dude", "time oslo norway"
     assert !handler.recognize?(message)
 
-    message = message("cjno", "time oslo norway")
+    message = mock_message("cjno", "time oslo norway")
     assert handler.recognize?(message)
   end
 
-  should "recognize messages from allowed users" do
+  test "recognize messages from allowed users" do
     handler = Jabbot::Handler.new :from => [:cjno, :irbno]
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
-  
-  should "not recognize messages from unallowed users with capital screen names" do
+
+  test "not recognize messages from unallowed users with capital screen names" do
     handler = Jabbot::Handler.new :from => [:cjno, :irbno]
-    message = message "Cjno", "time oslo norway"
+    message = mock_message "Cjno", "time oslo norway"
     assert !handler.recognize?(message)
   end
 
-  should "accept options as only argument" do
+  test "accept options as only argument" do
     handler = Jabbot::Handler.new :from => :cjno
     assert_equal(['cjno'], handler.instance_eval { @options[:from] })
     assert_nil handler.instance_eval { @options[:pattern] }
   end
 
-  should "provide parameters in params hash" do
+  test "provide parameters in params hash" do
     handler = Jabbot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
       assert_equal "oslo", params[:city]
       assert_equal "norway", params[:country]
     end
 
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
     handler.dispatch(message)
   end
 
-  should "call constructor block from handle" do
+  test "call constructor block from handle" do
     handler = Jabbot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
       raise "Boom!"
     end
@@ -160,31 +158,31 @@ class TestHandler < Test::Unit::TestCase
     end
   end
 
-  should "recognize regular expressions" do
+  test "recognize regular expressions" do
     handler = Jabbot::Handler.new /(?:what|where) is (.*)/i
-    message = message "dude", "Where is this shit?"
+    message = mock_message "dude", "Where is this shit?"
     assert handler.recognize?(message)
 
-    message = message "dude", "How is this shit?"
+    message = mock_message "dude", "How is this shit?"
     assert !handler.recognize?(message)
   end
 
-  should "recognize regular expressions from specific users" do
+  test "recognize regular expressions from specific users" do
     handler = Jabbot::Handler.new /(?:what|where) is (.*)/i, :from => "cjno"
-    message = message "dude", "Where is this shit?"
+    message = mock_message "dude", "Where is this shit?"
     assert !handler.recognize?(message)
 
-    message = message "cjno", "Where is this shit?"
+    message = mock_message "cjno", "Where is this shit?"
     assert handler.recognize?(message)
   end
 
-  should "provide parameters as arrays when matching regular expressions" do
+  test "provide parameters as arrays when matching regular expressions" do
     handler = Jabbot::Handler.new(/time ([^\s]*) ([^\s]*)/) do |message, params|
       assert_equal "oslo", params[0]
       assert_equal "norway", params[1]
     end
 
-    message = message "cjno", "time oslo norway"
+    message = mock_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
     handler.dispatch(message)
   end