rita 0.1.0 → 5.0.0.alpha.1

data/spec/lita/handler/http_router_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+handler = Class.new do
+  extend Lita::Handler::HTTPRouter
+
+  namespace "test"
+
+  http.get "web", :web
+  http.post "path/with/:id", :variable
+  http.link "foo", :foo
+  http.get "heres/*a/glob/in/a/path", :glob
+  http.get ":var/otherwise/identical/path", :constraint, var: /\d+/
+  http.get ":var/otherwise/identical/path", :no_constraint
+  http.get("block") { |_request, response| response.write("block") }
+  http.get "middleware", :middleware
+  http.get "boom", :boom
+
+  def web(_request, response)
+    response.write("it worked")
+  end
+
+  def variable(request, response)
+    id = request.env["router.params"][:id]
+    response.write("id is #{id}")
+  end
+
+  def glob(request, response)
+    segments = request.env["router.params"][:a]
+    response.write(segments.join("/"))
+  end
+
+  def constraint(_request, response)
+    response.write("constraint")
+  end
+
+  def no_constraint(_request, response)
+    response.write("no constraint")
+  end
+
+  def middleware(request, response)
+    response["Custom-Header"] = request.env["header_value"] if request.env["use_header"]
+    response.write("middleware worked") if request.env["custom_rack_middleware_working"]
+  end
+
+  def boom(_request, _response)
+    # rubocop:disable Style/StringConcatenation
+    1 + "2"
+    # rubocop:enable Style/StringConcatenation
+  end
+end
+
+describe handler, lita_handler: true do
+  it "responds to requests for simple paths" do
+    response = http.get("/web")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("it worked")
+  end
+
+  it "responds to requests with variable paths" do
+    response = http.post("/path/with/some_id")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("id is some_id")
+  end
+
+  it "responds to requests with globs in their paths" do
+    response = http.get("heres/a/giant/glob/in/a/path")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("a/giant")
+  end
+
+  it "responds to requests with variable path constraints" do
+    response = http.get("/123/otherwise/identical/path")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("constraint")
+
+    response = http.get("/an/otherwise/identical/path")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("no constraint")
+  end
+
+  it "responds to HEAD requests for GET routes" do
+    response = http.head("/web")
+    expect(response.status).to eq(204)
+    expect(response.body).to be_empty
+  end
+
+  it "allows route callbacks to be provided as blocks" do
+    response = http.get("/block")
+    expect(response.status).to eq(200)
+    expect(response.body).to eq("block")
+  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 { http.get("/boom") }.to raise_error(TypeError, "String can't be coerced into Integer")
+    end
+  end
+end
+
+describe handler, lita_handler: true do
+  let(:middleware) do
+    Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["custom_rack_middleware_working"] = true
+        @app.call(env)
+      end
+    end
+  end
+
+  prepend_before { registry.config.http.middleware.push(middleware) }
+
+  it "uses any custom middlewares registered" do
+    response = http.get("/middleware")
+    expect(response.body).to eq("middleware worked")
+  end
+end
+
+describe handler, lita_handler: true do
+  let(:middleware) do
+    Class.new do
+      # rubocop:disable Style/OptionalBooleanParameter
+      def initialize(app, use_header = false, &block)
+        @app = app
+        @use_header = use_header
+        @block = block
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      def call(env)
+        env["use_header"] = @use_header
+        env["header_value"] = @block.call
+        @app.call(env)
+      end
+    end
+  end
+
+  prepend_before do
+    registry.config.http.middleware.use(middleware, true) { "header value" }
+  end
+
+  it "uses any custom middlewares registered" do
+    response = http.get("/middleware")
+    expect(response["Custom-Header"]).to eq("header value")
+  end
+end

data/spec/lita/handler_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handler, lita_handler: true do
+  before { registry.handlers.delete(described_class) }
+
+  prepend_before(after_config: true) do
+    registry.register_handler(:foo) do
+      config :foo_response, required: true, type: String
+
+      after_config do |config|
+        route(/foo/) do |response|
+          response.reply(config.foo_response)
+        end
+      end
+    end
+  end
+
+  it "includes chat routes" do
+    registry.register_handler(:foo) do
+      route(/foo/) do |response|
+        response.reply("bar")
+      end
+    end
+
+    send_message("foo")
+
+    expect(replies.last).to include("bar")
+  end
+
+  it "includes HTTP routes" do
+    registry.register_handler(:foo) do
+      http.get "foo" do |_request, response|
+        response.write("bar")
+      end
+    end
+
+    http_client = Faraday::Connection.new { |c| c.adapter(:rack, Lita::RackApp.new(robot)) }
+    response = http_client.get("/foo")
+
+    expect(response.body).to eq("bar")
+  end
+
+  it "includes event routes" do
+    registry.register_handler(:foo) do
+      on(:some_event) { robot.send_message("payload received") }
+    end
+
+    expect(robot).to receive(:send_message).with("payload received")
+
+    robot.trigger(:some_event)
+  end
+
+  it "runs the after_config block configuration is finalized", after_config: true do
+    registry.config.handlers.foo.foo_response = "baz"
+
+    send_message("foo")
+
+    expect(replies.last).to include("baz")
+  end
+end

data/spec/lita/handlers/authorization_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handlers::Authorization, lita_handler: true do
+  before do
+    allow(robot.auth).to receive(:user_is_admin?).with(user).and_return(true)
+  end
+
+  let(:target_user) { instance_double("Lita::User", id: "1", name: "Carl") }
+
+  it { is_expected.to route_command("auth add foo bar").to(:add) }
+  it { is_expected.to route_command("auth add foo@bar.com baz").to(:add) }
+  it { is_expected.to route_command("auth remove foo bar").to(:remove) }
+  it { is_expected.to route_command("auth remove foo@bar.com baz").to(:remove) }
+  it { is_expected.to route_command("auth list").to(:list) }
+  it { is_expected.to route_command("auth list foo").to(:list) }
+
+  describe "#add" do
+    it "replies with the proper format if the require commands are missing" do
+      send_command("auth add foo")
+      expect(replies.last).to match(/^Format:/)
+    end
+
+    it "replies with a warning if target user is not known" do
+      send_command("auth add foo bar")
+      expect(replies.last).to match(/No user was found/)
+    end
+
+    it "replies with success if a valid user and group were supplied" do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+      expect(replies.last).to eq("#{target_user.name} was added to bar.")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+      send_command("auth add foo bar")
+      expect(replies.last).to eq("#{target_user.name} was already in bar.")
+    end
+
+    it 'replies with a warning if the group was "admins"' do
+      send_command("auth add foo admins")
+      expect(replies.last).to match(/Administrators can only be managed/)
+    end
+  end
+
+  describe "#remove" do
+    before do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+    end
+
+    it "replies with success if a valid user and group were supplied" do
+      send_command("auth remove foo bar")
+      expect(replies.last).to eq("#{target_user.name} was removed from bar.")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      send_command("auth remove foo bar")
+      send_command("auth remove foo bar")
+      expect(replies.last).to eq("#{target_user.name} was not in bar.")
+    end
+
+    it 'replies with a warning if the group was "admins"' do
+      send_command("auth add foo admins")
+      expect(replies.last).to match(/Administrators can only be managed/)
+    end
+  end
+
+  describe "#list" do
+    context "when there are populated groups" do
+      let(:groups) { %i[foo bar] }
+      let(:user_1) { Lita::User.create(3, name: "Bongo") }
+      let(:user_2) { Lita::User.create(4, name: "Carl") }
+
+      before do
+        groups.each do |group|
+          subject.robot.auth.add_user_to_group(user, user_1, group)
+          subject.robot.auth.add_user_to_group(user, user_2, group)
+        end
+      end
+
+      it "lists all authorization groups and their members" do
+        send_command("auth list")
+        groups.each do |group|
+          expect(replies.last).to include(
+            "#{group}: #{user_1.name}, #{user_2.name}"
+          )
+        end
+      end
+
+      it "lists only the requested group" do
+        send_command("auth list foo")
+        expect(replies.last).to include("foo")
+        expect(replies.last).not_to include("bar")
+      end
+    end
+
+    it "replies that there are no groups" do
+      send_command("auth list")
+      expect(replies.last).to include("no authorization groups yet")
+    end
+
+    it "replies that the specified group doesn't exist" do
+      send_command("auth list nothing")
+      expect(replies.last).to include("no authorization group named nothing")
+    end
+  end
+end

data/spec/lita/handlers/help_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handlers::Help, lita_handler: true do
+  it { is_expected.to route_command("help").to(:help) }
+  it { is_expected.to route_command("help foo").to(:help) }
+
+  describe "#help" do
+    let(:dummy_handler_class) do
+      Class.new(Lita::Handler) do
+        def self.name
+          "Dummy"
+        end
+
+        route(/secret/, :secret, restrict_to: :the_nobodies, help: {
+          "secret" => "This help message should be accompanied by a caveat"
+        })
+
+        def secret(_response); end
+      end
+    end
+
+    let(:dummy_handler_class_2) do
+      Class.new(Lita::Handler) do
+        def self.name
+          "Dummy2"
+        end
+
+        namespace "Dummy"
+
+        route(/foo/, :foo, help: { "foo" => "foo" })
+
+        def foo(_response); end
+      end
+    end
+
+    let(:another_handler) do
+      Class.new(Lita::Handler) do
+        def self.name
+          "Another"
+        end
+
+        route(/bar dummy/, :bar, help: { "bar dummy" => "bar" })
+        route(/baz/, :baz, help: { "baz" => "baz dummy" })
+
+        def bar(_response); end
+
+        def baz(_response); end
+      end
+    end
+
+    before do
+      registry.register_handler(dummy_handler_class)
+      registry.register_handler(dummy_handler_class_2)
+      registry.register_handler(another_handler)
+      registry.config.robot.alias = "!"
+    end
+
+    it "lists all installed handlers in alphabetical order with duplicates removed" do
+      send_command("help")
+      expect(replies.last).to match(
+        /^Send the message "!help QUERY".+installed:\n\nanother\ndummy\nhelp$/
+      )
+    end
+
+    it "sends help information for all commands under a given handler" do
+      send_command("help another")
+      expect(replies.last).to match(/bar.+baz/m)
+    end
+
+    it "sends help information for all commands matching a given substring" do
+      send_command("help foo")
+      expect(replies.last).to match(/foo/)
+    end
+
+    it("sends help information for all relevant commands "\
+      "when the given substring matches a handler + individual help messages") do
+      send_command("help dummy")
+      expect(replies.last).to match(/secret.+foo.+bar.+baz/m)
+    end
+
+    it "uses the mention name when no alias is defined" do
+      allow(robot.config.robot).to receive(:alias).and_return(nil)
+      send_command("help help")
+      expect(replies.last).to match(/#{robot.mention_name}: help/)
+    end
+
+    it "responds with an error if the given substring has no matches" do
+      send_command("help asdf")
+      expect(replies.last).to eq("No matching handlers, message patterns, or descriptions found.")
+    end
+
+    it "doesn't crash if a handler doesn't have routes" do
+      event_handler = Class.new do
+        extend Lita::Handler::EventRouter
+      end
+
+      registry.register_handler(event_handler)
+
+      expect { send_command("help") }.not_to raise_error
+    end
+
+    describe "restricted routes" do
+      let(:authorized_user) do
+        user = Lita::User.create(2, name: "Authorized User")
+        Lita::Authorization.new(robot).add_user_to_group!(user, :the_nobodies)
+        user
+      end
+
+      it "shows the unauthorized message for commands the user doesn't have access to" do
+        send_command("help secret")
+        expect(replies.last).to include("secret")
+        expect(replies.last).to include("Unauthorized")
+      end
+
+      it "omits the unauthorized message if the user has access" do
+        send_command("help secret", as: authorized_user)
+        expect(replies.last).to include("secret")
+        expect(replies.last).not_to include("Unauthorized")
+      end
+    end
+  end
+end

data/spec/lita/handlers/info_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handlers::Info, lita_handler: true do
+  it { is_expected.to route_command("info").to(:chat) }
+  it { is_expected.to route_http(:get, "/lita/info").to(:web) }
+
+  let(:request) { double("Rack::Request") }
+  let(:response) { Rack::Response.new }
+
+  describe "#chat" do
+    it "responds with the current version of Lita" do
+      send_command("info")
+      expect(replies.first).to include(Lita::VERSION)
+    end
+
+    it "responds with a link to the website" do
+      send_command("info")
+      expect(replies.first).to include("lita.io")
+    end
+
+    it "responds with the Redis version and memory usage" do
+      send_command("info")
+      expect(replies.last).to match(/Redis [\d.]+ - Memory used: [\d.]+[BKMG]/)
+    end
+  end
+
+  describe "#web" do
+    let(:json) { JSON.parse(response.body.join) }
+
+    it "returns JSON" do
+      subject.web(request, response)
+      expect(response.headers["Content-Type"]).to eq("application/json")
+    end
+
+    it "includes the current version of Lita" do
+      subject.web(request, response)
+      expect(json).to include("lita_version" => Lita::VERSION)
+    end
+
+    it "includes the adapter being used" do
+      subject.web(request, response)
+      expect(json).to include("adapter" => registry.config.robot.adapter.to_s)
+    end
+
+    it "includes the robot's name" do
+      subject.web(request, response)
+      expect(json).to include("robot_name" => robot.name)
+    end
+
+    it "includes the robot's mention name" do
+      subject.web(request, response)
+      expect(json).to include("robot_mention_name" => robot.mention_name)
+    end
+
+    it "includes the Redis version" do
+      subject.web(request, response)
+      expect(json).to have_key("redis_version")
+    end
+
+    it "includes the Redis memory usage" do
+      subject.web(request, response)
+      expect(json).to have_key("redis_memory_usage")
+    end
+  end
+end

data/spec/lita/handlers/room_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handlers::Room, lita_handler: true do
+  it { is_expected.to route_command("join #lita.io").to(:join) }
+  it { is_expected.to route_command("part #lita.io").to(:part) }
+
+  before { allow(robot.auth).to receive(:user_is_admin?).with(user).and_return(true) }
+
+  describe "#join" do
+    it "calls Robot#join with the provided ID" do
+      expect(robot).to receive(:join).with("#lita.io")
+      send_command("join #lita.io")
+    end
+  end
+
+  describe "#part" do
+    it "calls Robot#part with the provided ID" do
+      expect(robot).to receive(:part).with("#lita.io")
+      send_command("part #lita.io")
+    end
+  end
+end

data/spec/lita/handlers/users_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Handlers::Users, lita_handler: true do
+  it { is_expected.to route_command("users find carl").to(:find) }
+
+  describe "#find" do
+    it "finds users by ID" do
+      send_command("users find 1")
+
+      expect(replies.first).to eq("Test User (ID: 1, Mention name: Test User)")
+    end
+
+    it "finds users by name" do
+      send_command("users find 'Test User'")
+
+      expect(replies.first).to eq("Test User (ID: 1, Mention name: Test User)")
+    end
+
+    it "finds users by mention name" do
+      Lita::User.create(2, name: "Mr. Pug", mention_name: "carl")
+
+      send_command("users find carl")
+
+      expect(replies.first).to eq("Mr. Pug (ID: 2, Mention name: carl)")
+    end
+
+    it "replies with a message when no matches are found" do
+      send_command("users find nobody")
+
+      expect(replies.first).to eq("No matching users found.")
+    end
+  end
+end

data/spec/lita/logger_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Logger do
+  let(:io) { StringIO.new }
+
+  it "uses a custom log level" do
+    logger = described_class.get_logger(:debug)
+    expect(logger.level).to eq(Logger::DEBUG)
+  end
+
+  it "uses the info level if the config is nil" do
+    logger = described_class.get_logger(nil)
+    expect(logger.level).to eq(Logger::INFO)
+  end
+
+  it "uses the info level if the config level is invalid" do
+    logger = described_class.get_logger(:foo)
+    expect(logger.level).to eq(Logger::INFO)
+  end
+
+  it "logs messages with a custom format" do
+    logger = described_class.get_logger(:debug, io: io)
+    logger.fatal "foo"
+    expect(io.string).to match(/^\[.+\] FATAL: foo$/)
+  end
+end