lita 3.3.1 → 4.0.0.rc1

data/spec/lita/handler/chat_router_spec.rb

@@ -0,0 +1,192 @@
+require "spec_helper"
+
+handler = Class.new do
+  extend Lita::Handler::ChatRouter
+
+  def self.name
+    "Test"
+  end
+
+  route(/message/, :message)
+  route(/command/, :command, command: true)
+  route(/admin/, :admin, restrict_to: :admins)
+  route(/error/, :error)
+  route(/validate route hook/, :validate_route_hook, code_word: true)
+  route(/trigger route hook/, :trigger_route_hook, custom_data: "trigger route hook")
+
+  def message(response)
+    response.reply("message")
+  end
+
+  def command(response)
+    response.reply("command")
+  end
+
+  def admin(response)
+    response.reply("admin")
+  end
+
+  def error(_response)
+    raise
+  end
+
+  def validate_route_hook(response)
+    response.reply("validate route hook")
+  end
+
+  def trigger_route_hook(response)
+    response.reply(response.extensions[:custom_data])
+  end
+
+  route(/block/) do |response|
+    response.reply("block")
+  end
+end
+
+describe handler, lita_handler: true do
+  describe ".dispatch" do
+    it "routes a matching message to the supplied method" do
+      send_message("message")
+      expect(replies.last).to eq("message")
+    end
+
+    it "routes a matching message even if addressed to the robot" do
+      send_command("message")
+      expect(replies.last).to eq("message")
+    end
+
+    it "routes a command message to the supplied method" do
+      send_command("command")
+      expect(replies.last).to eq("command")
+    end
+
+    it "requires command routes to be addressed to the robot" do
+      send_message("command")
+      expect(replies).to be_empty
+    end
+
+    it "doesn't route messages that don't match anything" do
+      send_message("nothing")
+      expect(replies).to be_empty
+    end
+
+    it "dispatches to restricted routes if the user is in the auth group" do
+      allow(robot.auth).to receive(:user_is_admin?).with(user).and_return(true)
+      send_message("admin")
+      expect(replies.last).to eq("admin")
+    end
+
+    it "doesn't route unauthorized users' messages to restricted routes" do
+      send_message("admin")
+      expect(replies).to be_empty
+    end
+
+    it "ignores messages from itself" do
+      allow(user).to receive(:name).and_return(robot.name)
+      send_message("message")
+      expect(replies).to be_empty
+    end
+
+    it "allows route callbacks to be provided as blocks" do
+      send_message("block")
+      expect(replies.last).to eq("block")
+    end
+
+    it "logs exceptions without crashing" do
+      test_mode = Lita.test_mode?
+
+      begin
+        Lita.test_mode = false
+        expect(Lita.logger).to receive(:error).with(/Test crashed/)
+        send_message("error")
+      ensure
+        Lita.test_mode = test_mode
+      end
+    end
+
+    it "raises exceptions in test mode" do
+      expect { send_message("error") }.to raise_error(RuntimeError)
+    end
+
+    context "with a custom validate_route hook" do
+      let(:hook) do
+        proc do |payload|
+          if payload[:route].extensions[:code_word]
+            payload[:message].body.include?("code word")
+          else
+            true
+          end
+        end
+      end
+
+      before { registry.register_hook(:validate_route, hook) }
+
+      it "matches if the hook returns true" do
+        send_message("validate route hook - code word")
+        expect(replies.last).to eq("validate route hook")
+      end
+
+      it "does not match if the hook returns false" do
+        send_message("validate route hook")
+        expect(replies).to be_empty
+      end
+    end
+
+    context "with a custom trigger_route hook" do
+      let(:hook) do
+        proc do |payload|
+          payload[:response].extensions[:custom_data] = payload[:route].extensions[:custom_data]
+        end
+      end
+
+      before { registry.register_hook(:trigger_route, hook) }
+
+      it "adds data to the response's extensions" do
+        send_message("trigger route hook")
+        expect(replies.last).to eq("trigger route hook")
+      end
+    end
+  end
+end
+
+handler = Class.new do
+  extend Lita::Handler::ChatRouter
+  extend Lita::Handler::EventRouter
+
+  def self.name
+    "Test"
+  end
+
+  route(/one/) { |response| response.reply "got one" }
+  route(/two/) { |response| response.reply "got two" }
+
+  on :unhandled_message do |payload|
+    message = payload[:message]
+    robot.send_message(message.source, message.body)
+  end
+end
+
+describe handler, lita_handler: true do
+  it "triggers the unhandled message event if no route matches" do
+    send_message("this won't match any routes")
+    expect(replies.last).to eq("this won't match any routes")
+  end
+
+  it "doesn't stop checking routes when the first one matches" do
+    send_message("one two")
+    expect(replies.last).to eq("got two")
+  end
+
+  context "with another handler registered" do
+    before do
+      registry.register_handler(:test_2)  do
+        route(/three/)  { |response| response.reply "got three" }
+      end
+    end
+
+    it "doesn't stop dispatching to handlers when there is a matching route in one" do
+      send_message("two three")
+      expect(replies.last).to eq("got three")
+    end
+  end
+end

data/spec/lita/handler/common_spec.rb

@@ -0,0 +1,272 @@
+require "spec_helper"
+
+describe Lita::Handler::Common, lita: true do
+  let(:robot) { Lita::Robot.new(registry) }
+
+  let(:handler) do
+    Class.new do
+      include Lita::Handler::Common
+
+      namespace "foo"
+    end
+  end
+
+  subject { handler.new(robot) }
+
+  describe ".config" do
+    it "sets configuration attributes" do
+      handler.config :foo
+
+      config = handler.configuration.finalize
+
+      expect(config.foo).to be_nil
+      config.foo = :bar
+      expect(config.foo).to eq(:bar)
+    end
+  end
+
+  describe ".configuration" do
+    it "returns a Configuration object" do
+      expect(handler.configuration).to be_a(Lita::Configuration)
+    end
+
+    it "is memoized" do
+      expect(handler.configuration).to equal(handler.configuration)
+    end
+  end
+
+  describe ".namespace" do
+    it "returns a snake cased namesapce for the handler based on class name" do
+      handler = Class.new do
+        include Lita::Handler::Common
+
+        def self.name
+          "Lita::Handlers::FooBarBaz"
+        end
+      end
+
+      expect(handler.namespace).to eq("foo_bar_baz")
+    end
+
+    it "allows the namespace to be set with a simple string" do
+      handler = Class.new do
+        include Lita::Handler::Common
+
+        namespace "common"
+      end
+
+      expect(handler.namespace).to eq("common")
+    end
+
+    it "allows the namespace to be set with the full path to an object as a string" do
+      handler = Class.new do
+        include Lita::Handler::Common
+
+        namespace "Lita::Handler::Common"
+      end
+
+      expect(handler.namespace).to eq("common")
+    end
+
+    it "allows the namespace to be set with an object" do
+      handler = Class.new do
+        include Lita::Handler::Common
+
+        namespace Lita::Handler::Common
+      end
+
+      expect(handler.namespace).to eq("common")
+    end
+
+    it "raises an exception if the handler doesn't have a name to derive the namespace from" do
+      handler = Class.new { include Lita::Handler::Common }
+      expect { handler.namespace }.to raise_error
+    end
+  end
+
+  describe "#config" do
+    before { registry.register_handler(handler) }
+
+    context "with old-style config" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo_bar_baz"
+
+          def self.default_config(config)
+            config.style = :old
+          end
+        end
+      end
+
+      it "returns the handler's config settings" do
+        expect(subject.config.style).to eq(:old)
+      end
+    end
+
+    context "with new-style config" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo_bar_baz"
+
+          config :style, default: :new
+        end
+      end
+
+      it "returns the handler's config settings" do
+        expect(subject.config.style).to eq(:new)
+      end
+    end
+
+    context "with both types of configuration" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo_bar_baz"
+
+          config :style, default: :new
+
+          def self.default_config(config)
+            config.style = :old
+          end
+        end
+      end
+
+      it "gives precedence to the new style" do
+        expect(subject.config.style).to eq(:new)
+      end
+    end
+
+    context "with no configuration" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo_bar_baz"
+        end
+      end
+
+      it "uses an old-style config object" do
+        subject.config.style = :old
+        expect(subject.config.style).to eq(:old)
+      end
+    end
+  end
+
+  describe "#http" do
+    it "returns a Faraday connection" do
+      expect(subject.http).to be_a(Faraday::Connection)
+    end
+
+    it "sets a default user agent" do
+      expect(subject.http.headers["User-Agent"]).to eq("Lita v#{Lita::VERSION}")
+    end
+
+    it "merges in user-supplied options" do
+      connection = subject.http(headers: {
+        "User-Agent" => "Foo", "X-Bar" => "Baz"
+      })
+      expect(connection.headers["User-Agent"]).to eq("Foo")
+      expect(connection.headers["X-Bar"]).to eq("Baz")
+    end
+
+    it "passes blocks on to Faraday" do
+      connection = subject.http { |builder| builder.response :logger }
+      expect(connection.builder.handlers).to include(Faraday::Response::Logger)
+    end
+  end
+
+  describe "#log" do
+    it "returns the Lita logger" do
+      expect(subject.log).to eq(Lita.logger)
+    end
+  end
+
+  describe "timer methods" do
+    let(:queue) { Queue.new }
+
+    subject { handler.new(robot) }
+
+    before { allow_any_instance_of(Lita::Timer).to receive(:sleep) }
+
+    describe "#after" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo"
+
+          def after_test(queue)
+            after(2) { queue.push("Waited 2 seconds!") }
+          end
+        end
+      end
+
+      it "triggers the block after the given number of seconds" do
+        subject.after_test(queue)
+        expect(queue.pop).to eq("Waited 2 seconds!")
+        expect { queue.pop(true) }.to raise_error(ThreadError)
+      end
+    end
+
+    describe "#every" do
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo"
+
+          def every_test(queue)
+            array = [1, 2, 3]
+
+            every(2) do |timer|
+              value = array.shift
+
+              if value
+                queue.push(value)
+              else
+                timer.stop
+              end
+            end
+          end
+        end
+      end
+
+      it "triggers the block until the timer is stopped" do
+        subject.every_test(queue)
+        expect(queue.pop).to eq(1)
+        expect(queue.pop).to eq(2)
+        expect(queue.pop).to eq(3)
+        expect { queue.pop(true) }.to raise_error(ThreadError)
+      end
+    end
+
+    context "with an infinite timer" do
+      let(:response) { instance_double("Lita::Response") }
+
+      let(:handler) do
+        Class.new do
+          include Lita::Handler::Common
+
+          namespace "foo"
+
+          def infinite_every_test(response)
+            thread = every(5) { "Looping forever!" }
+            response.reply("Replying after timer!")
+            thread
+          end
+        end
+      end
+
+      it "doesn't block the handler's thread" do
+        expect(response).to receive(:reply)
+        thread = subject.infinite_every_test(response)
+        thread.kill
+      end
+    end
+  end
+end