rita 0.1.0 → 5.0.0.alpha.1

data/spec/lita/handler/chat_router_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+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 "triggers a :route_authorization_failed event when a user is not authorized" do
+      allow(robot).to receive(:trigger)
+      expect(robot).to receive(:trigger).with(:route_authorization_failed, anything)
+      send_message("admin")
+    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(robot.logger).to receive(:error).with(/Test crashed/)
+        send_message("error")
+      ensure
+        Lita.test_mode = test_mode
+      end
+    end
+
+    it "triggers a message_dispatched event" do
+      expect(robot).to receive(:trigger).with(:message_received, anything)
+      expect(robot).to receive(:trigger).with(:message_dispatched, anything)
+      send_message("message")
+    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
+
+    context "with a custom post_route hook" do
+      let(:hook) do
+        proc do |payload|
+          Lita.logger.info(
+            "#{payload[:response].message.body} triggered /#{payload[:route].pattern.source}/"
+          )
+        end
+      end
+
+      before { registry.register_hook(:post_route, hook) }
+
+      it "executes after the message has been routed" do
+        expect(Lita.logger).to receive(:info).with("message triggered /message/")
+
+        send_message("message")
+      end
+    end
+  end
+end
+
+handler = Class.new do
+  extend Lita::Handler::ChatRouter
+  extend Lita::Handler::EventRouter
+
+  def self.name
+    "Test"
+  end
+
+  route(/boom/) { |_response| 2 + nil }
+
+  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
+
+  context "when the handler raises an exception" do
+    it "calls the error handler with the exception as argument" do
+      expect(registry.config.robot.error_handler).to receive(:call) do |error, *_args|
+        expect(error).to be_an_instance_of(TypeError)
+      end
+
+      expect { send_message("boom!") }.to raise_error(TypeError)
+    end
+  end
+end

data/spec/lita/handler/common_spec.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+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_builder.build
+
+      expect(config.foo).to be_nil
+      config.foo = :bar
+      expect(config.foo).to eq(:bar)
+    end
+  end
+
+  describe ".configuration_builder" do
+    it "returns a ConfigurationBuilder object" do
+      expect(handler.configuration_builder).to be_a(Lita::ConfigurationBuilder)
+    end
+
+    it "is memoized" do
+      expect(handler.configuration_builder).to equal(handler.configuration_builder)
+    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(RuntimeError, /must set a namespace/)
+    end
+  end
+
+  describe "#config" do
+    before { registry.register_handler(handler) }
+
+    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
+
+  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 robot's logger" do
+      expect(subject.log).to eq(robot.logger)
+    end
+  end
+
+  describe "#render_template" do
+    context "with the template root set" do
+      before do
+        handler.template_root(File.expand_path(File.join("..", "..", "..", "templates"), __FILE__))
+      end
+
+      it "renders the given template to a string" do
+        expect(subject.render_template("basic")).to eq("Template rendered from a file!")
+      end
+
+      it "interpolates variables into the rendered template" do
+        result = subject.render_template("interpolated", first: "Carl", last: "Pug")
+
+        expect(result).to eq("I love Carl Pug!")
+      end
+
+      it "renders adapter-specific templates if available" do
+        robot.config.robot.adapter = :irc
+        expect(subject.render_template("basic")).to eq("IRC template rendered from a file!")
+      end
+    end
+
+    it "raises an exception if the template root hasn't been set" do
+      expect { subject.render_template("basic") }.to raise_error(Lita::MissingTemplateRootError)
+    end
+  end
+
+  describe "#render_template_with_helpers" do
+    before do
+      handler.template_root(File.expand_path(File.join("..", "..", "..", "templates"), __FILE__))
+    end
+
+    it "extends custom helpers into the template evaluation context" do
+      helpers = Module.new do
+        def reverse_name(first, last)
+          "#{last}, #{first}"
+        end
+      end
+
+      result = subject.render_template_with_helpers(
+        "helpers",
+        [helpers],
+        first: "Carl",
+        last: "Pug",
+      )
+
+      expect(result).to eq("Pug, Carl")
+    end
+  end
+
+  describe "#store" do
+    it "shares data between instances" do
+      subject.store[:foo] = :bar
+
+      second_instance = handler.new(robot)
+
+      expect(second_instance.store[:foo]).to eq(:bar)
+    end
+  end
+
+  describe "timer methods" do
+    let(:queue) { Queue.new }
+
+    subject { handler.new(robot) }
+
+    before do
+      # Don't wait for sleeps while testing.
+      allow_any_instance_of(Lita::Timer).to receive(:sleep)
+
+      # Since we're not using the `:lita_handler` RSpec metadata in this test, we need to do this
+      # manually or we will reach an `exit(false)` when `robot.run_concurrently` delegates to the
+      # adapter and there isn't one!
+      registry.register_adapter(:test, Lita::Adapters::Test)
+      registry.config.robot.adapter = :test
+      registry.config.adapters.test.blocking = false
+    end
+
+    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

data/spec/lita/handler/event_router_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handler::EventRouter, lita: true do
+  let(:robot) { Lita::Robot.new(registry) }
+
+  subject do
+    Class.new do
+      extend Lita::Handler::EventRouter
+
+      def self.name
+        "Test"
+      end
+
+      on :connected, :greet
+
+      def greet(payload)
+        robot.send_message("Hi, #{payload[:name]}! Lita has started!")
+      end
+
+      on :block_test do |payload|
+        robot.send_message("#{payload[:data]} received via block!")
+      end
+
+      on :callable_test, lambda { |payload|
+        robot.send_message("#{payload[:data]} received via callable!")
+      }
+
+      on(:multiple_callbacks) { robot.send_message("first callback") }
+      on(:multiple_callbacks) { robot.send_message("second callback") }
+
+      on(:multiple_errors) do
+        robot.send_message("first error")
+        raise ArgumentError, "first"
+      end
+
+      on(:multiple_errors) do
+        robot.send_message("second error")
+        raise ArgumentError, "second"
+      end
+    end
+  end
+
+  describe ".trigger" do
+    it "invokes methods registered with .on and passes an arbitrary payload" do
+      expect(robot).to receive(:send_message).with(
+        "Hi, Carl! Lita has started!"
+      )
+      subject.trigger(robot, :connected, name: "Carl")
+    end
+
+    it "calls blocks that were passed to .on" do
+      expect(robot).to receive(:send_message).with("Data received via block!")
+      subject.trigger(robot, :block_test, data: "Data")
+    end
+
+    it "calls arbitrary callables that were passed to .on" do
+      expect(robot).to receive(:send_message).with("Data received via callable!")
+      subject.trigger(robot, :callable_test, data: "Data")
+    end
+
+    it "doesn't stop triggering callbacks after the first is triggered" do
+      allow(robot).to receive(:send_message)
+
+      expect(robot).to receive(:send_message).with("second callback")
+
+      subject.trigger(robot, :multiple_callbacks)
+    end
+
+    it "normalizes the event name" do
+      expect(robot).to receive(:send_message).twice
+      subject.trigger(robot, "connected")
+      subject.trigger(robot, " ConNected  ")
+    end
+
+    context "not in test mode" do
+      before { stub_const("STDERR", StringIO.new) }
+
+      around do |example|
+        test_mode = Lita.test_mode?
+        Lita.test_mode = false
+        begin
+          example.run
+        ensure
+          Lita.test_mode = test_mode
+        end
+      end
+
+      it "doesn't stop triggering callbacks after an exception is raised" do
+        expect(robot).to receive(:send_message).with("first error").once
+        expect(robot).to receive(:send_message).with("second error").once
+        subject.trigger(robot, :multiple_errors)
+      end
+
+      it "reports callback exceptions to the error handler" do
+        allow(robot).to receive(:send_message)
+        expect(registry.config.robot.error_handler).to receive(:call).twice
+        subject.trigger(robot, :multiple_errors)
+      end
+    end
+
+    context "in test mode" do
+      around do |example|
+        test_mode = Lita.test_mode?
+        Lita.test_mode = true
+        begin
+          example.run
+        ensure
+          Lita.test_mode = test_mode
+        end
+      end
+
+      it "re-raises callback exceptions immediately" do
+        allow(robot).to receive(:send_message)
+        expect(registry.config.robot.error_handler).to receive(:call).once
+        expect { subject.trigger(robot, :multiple_errors) }.to raise_error(ArgumentError, "first")
+      end
+    end
+  end
+end