lita 1.1.2 → 2.0.0

data/spec/lita/config_spec.rb

@@ -16,8 +16,24 @@ describe Lita::Config do
 
   describe ".default_config" do
     it "has predefined values for certain keys" do
-      expect(described_class.default_config.robot.name).to eq("Lita")
-      expect(described_class.default_config.robot.adapter).to eq(:shell)
+      default_config = described_class.default_config
+      expect(default_config.robot.name).to eq("Lita")
+      expect(default_config.robot.adapter).to eq(:shell)
+    end
+
+    it "loads configuration from registered handlers" do
+      handler = Class.new(Lita::Handler) do
+        def self.default_config(handler_config)
+          handler_config.bar = :baz
+        end
+
+        def self.name
+          "Lita::Handlers::Foo"
+        end
+      end
+      allow(Lita).to receive(:handlers).and_return([handler])
+      default_config = described_class.default_config
+      expect(default_config.handlers.foo.bar).to eq(:baz)
     end
   end
 

data/spec/lita/handler_spec.rb

@@ -1,40 +1,33 @@
 require "spec_helper"
 
 describe Lita::Handler do
-  let(:robot) do
-    robot = double("Robot")
-    allow(robot).to receive(:name).and_return("Lita")
-    robot
-  end
+  let(:robot) { double("Lita::Robot", name: "Lita") }
+  let(:user) { double("Lita::User") }
 
   let(:message) do
-    message = double("Message")
-    allow(message).to receive(:scan).and_return(matches)
-    allow(message).to receive(:command?).and_return(false)
-    allow(message).to receive(:source).and_return(source)
-    allow(message).to receive(:user).and_return(user)
+    message = double("Lita::Message", user: user, command?: false)
+    allow(message).to receive(:match)
     message
   end
 
-  let(:matches) { double("MatchData") }
-
-  let(:source) { double("Source") }
-
-  let(:user) { double("User") }
-
   let(:handler_class) do
     Class.new(described_class) do
-      route(/\w{3}/, to: :foo)
-      route(/\w{4}/, to: :blah, command: true)
-      route(/secret/, to: :secret, restrict_to: :admins)
+      route(/\w{3}/, :foo)
+      route(/\w{4}/, :blah, command: true)
+      route(/secret/, :secret, restrict_to: :admins)
+
+      http.get "web", :web
+
+      def foo(response)
+      end
 
-      def foo(matches)
+      def blah(response)
       end
 
-      def blah(matches)
+      def secret(response)
       end
 
-      def secret(matches)
+      def web(request, response)
       end
 
       def self.name
@@ -43,7 +36,7 @@ describe Lita::Handler do
     end
   end
 
-  subject { described_class.new(robot, message) }
+  subject { described_class.new(robot) }
 
   describe ".dispatch" do
     it "routes a matching message to the supplied method" do
@@ -94,38 +87,42 @@ describe Lita::Handler do
     end
   end
 
-  describe "#args" do
-    it "delegates to Message" do
-      expect(message).to receive(:args)
-      subject.args
+  describe ".namespace" do
+    it "provides a snake cased namespace for the handler" do
+      handler_class = Class.new(described_class) do
+        def self.name
+          "Lita::Handlers::FooBarBaz"
+        end
+      end
+      expect(handler_class.namespace).to eq("foo_bar_baz")
     end
-  end
 
-  describe "#command?" do
-    it "delegates to Message" do
-      expect(message).to receive(:command?)
-      subject.command?
+    it "raises an exception if the handler doesn't define self.name" do
+      handler_class = Class.new(described_class)
+      expect { handler_class.namespace }.to raise_error
     end
   end
 
-  describe "#message_body" do
-    it "delegates to Message" do
-      expect(message).to receive(:body)
-      subject.message_body
+  describe "#http" do
+    it "returns a Faraday connection" do
+      expect(subject.http).to be_a(Faraday::Connection)
     end
-  end
 
-  describe "#reply" do
-    it "calls Robot#send_message with the messages to send" do
-      expect(robot).to receive(:send_messages).with(source, "foo", "bar")
-      subject.reply("foo", "bar")
+    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
-  end
 
-  describe "#scan" do
-    it "delegates to Message" do
-      expect(message).to receive(:scan)
-      subject.scan
+    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
 end

data/spec/lita/handlers/authorization_spec.rb

@@ -1,8 +1,7 @@
 require "spec_helper"
 
-describe Lita::Handlers::Authorization, lita: true do
+describe Lita::Handlers::Authorization, lita_handler: true do
   before do
-    allow(robot).to receive(:send_messages)
     allow(Lita::Authorization).to receive(:user_is_admin?).with(
       user
     ).and_return(true)
@@ -10,39 +9,33 @@ describe Lita::Handlers::Authorization, lita: true do
 
   let(:target_user) { double("Lita::User", id: "1", name: "Carl") }
 
-  it { routes("#{robot.name}: auth add foo bar").to(:add) }
-  it { routes("#{robot.name}: auth add foo@bar.com baz").to(:add) }
-  it { routes("#{robot.name}: auth remove foo bar").to(:remove) }
-  it { routes("#{robot.name}: auth remove foo@bar.com baz").to(:remove) }
-
-  describe ".help" do
-    it "returns a hash of command help" do
-      expect(described_class.help).to be_a(Hash)
-    end
-  end
+  it { routes_command("auth add foo bar").to(:add) }
+  it { routes_command("auth add foo@bar.com baz").to(:add) }
+  it { routes_command("auth remove foo bar").to(:remove) }
+  it { routes_command("auth remove foo@bar.com baz").to(:remove) }
 
   describe "#add" do
     it "replies with the proper format if the require commands are missing" do
-      expect_reply(/^Format:/)
-      send_test_message("#{robot.name}: auth add foo")
+      send_command("auth add foo")
+      expect(replies.last).to match(/^Format:/)
     end
 
     it "replies with a warning if target user is not known" do
-      expect_reply(/No user was found/)
-      send_test_message("#{robot.name}: auth add foo bar")
+      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)
-      expect_reply("#{target_user.name} was added to bar.")
-      send_test_message("#{robot.name}: auth add foo bar")
+      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_test_message("#{robot.name}: auth add foo bar")
-      expect_reply("#{target_user.name} was already in bar.")
-      send_test_message("#{robot.name}: auth add foo bar")
+      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 requesting user is not an admin" do
@@ -50,34 +43,34 @@ describe Lita::Handlers::Authorization, lita: true do
       allow(Lita::Authorization).to receive(:user_is_admin?).with(
         user
       ).and_return(false)
-      expect_reply(/Only administrators can add/)
-      send_test_message("#{robot.name}: auth add foo bar")
+      send_command("auth add foo bar")
+      expect(replies.last).to match(/Only administrators can add/)
     end
   end
 
   describe "#remove" do
     before do
       allow(Lita::User).to receive(:find_by_id).and_return(target_user)
-      send_test_message("#{robot.name}: auth add foo bar")
+      send_command("auth add foo bar")
     end
 
     it "replies with success if a valid user and group were supplied" do
-      expect_reply("#{target_user.name} was removed from bar.")
-      send_test_message("#{robot.name}: auth remove foo bar")
+      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_test_message("#{robot.name}: auth remove foo bar")
-      expect_reply("#{target_user.name} was not in bar.")
-      send_test_message("#{robot.name}: auth remove foo bar")
+      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 requesting user is not an admin" do
       allow(Lita::Authorization).to receive(:user_is_admin?).with(
         user
       ).and_return(false)
-      expect_reply(/Only administrators can remove/)
-      send_test_message("#{robot.name}: auth remove foo bar")
+      send_command("auth remove foo bar")
+      expect(replies.last).to match(/Only administrators can remove/)
     end
   end
 end

data/spec/lita/handlers/help_spec.rb

@@ -1,19 +1,21 @@
 require "spec_helper"
 
-describe Lita::Handlers::Help, lita: true do
-  it { routes("#{robot.name}: help").to(:help) }
-  it { routes("#{robot.name}: help foo").to(:help) }
+describe Lita::Handlers::Help, lita_handler: true do
+  it { routes_command("help").to(:help) }
+  it { routes_command("help foo").to(:help) }
 
   describe "#help" do
     it "sends help information for all commands" do
-      expect_reply(/help - Lists.+help COMMAND - Lists/m)
-      send_test_message("#{robot.name}: help")
+      send_command("help")
+      expect(replies.last).to match(
+        /#{robot.mention_name}: help.+#{robot.mention_name}: help COMMAND/m
+      )
     end
 
     it "sends help information for commands starting with COMMAND" do
-      expect_reply(/help COMMAND - Lists/)
-      expect_no_reply(/help - Lists/)
-      send_test_message("#{robot.name}: help help command")
+      send_command("help help COMMAND")
+      expect(replies.last).to match(/help COMMAND - Lists/)
+      expect(replies.last).not_to match(/help - Lists/)
     end
   end
 end

data/spec/lita/handlers/web_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Lita::Handlers::Web, lita_handler: true do
+  it { routes_http(:get, "/lita/info").to(:info) }
+  it { doesnt_route_http(:post, "/lita/info").to(:info) }
+
+  let(:request) { double("Rack::Request") }
+  let(:response) { Rack::Response.new }
+
+  describe "#info" do
+    it "returns JSON with info about the running robot" do
+      subject.info(request, response)
+      expect(response.headers["Content-Type"]).to eq("application/json")
+      expect(response.body.join).to include(
+        %{"lita_version":"#{Lita::VERSION}"}
+      )
+    end
+  end
+end

data/spec/lita/logger_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Lita::Logger do
+  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
+    stderr = StringIO.new
+    stub_const("STDERR", stderr)
+    logger = described_class.get_logger(:debug)
+    logger.fatal "foo"
+    expect(stderr.string).to match(%r{^\[.+\] FATAL: foo$})
+  end
+end

data/spec/lita/message_spec.rb

@@ -11,10 +11,6 @@ describe Lita::Message do
     expect(subject.body).to eq("Hello")
   end
 
-  it "aliases #body with #message" do
-    expect(subject.message).to eq("Hello")
-  end
-
   it "has a source" do
     expect(subject.source).to eq("Carl")
   end
@@ -48,15 +44,17 @@ describe Lita::Message do
       expect(subject).to be_a_command
     end
 
-    it "is false when the message is not addressed to the Robot" do
-      expect(subject).not_to be_a_command
+    it "is true when the Robot's name is capitalized differently" do
+      subject = described_class.new(
+        robot,
+        "#{robot.mention_name.upcase}: hello",
+        "Carl"
+      )
+      expect(subject).to be_a_command
     end
-  end
 
-  describe "#scan" do
-    it "delegates to #body" do
-      expect(subject.body).to receive(:scan)
-      subject.scan
+    it "is false when the message is not addressed to the Robot" do
+      expect(subject).not_to be_a_command
     end
   end
 
@@ -66,4 +64,11 @@ describe Lita::Message do
       subject.user
     end
   end
+
+  describe "#reply" do
+    it "sends strings back to the source through the robot" do
+      expect(robot).to receive(:send_messages).with("Carl", "foo", "bar")
+      subject.reply("foo", "bar")
+    end
+  end
 end

data/spec/lita/robot_spec.rb

@@ -10,8 +10,8 @@ describe Lita::Robot do
   end
 
   describe "#receive" do
-    let(:handler1) { double("Handler 1") }
-    let(:handler2) { double("Handler 2") }
+    let(:handler1) { double("Handler 1").as_null_object }
+    let(:handler2) { double("Handler 2").as_null_object }
 
     it "dispatches messages to every registered handler" do
       allow(Lita).to receive(:handlers).and_return([handler1, handler2])
@@ -22,11 +22,34 @@ describe Lita::Robot do
   end
 
   describe "#run" do
+    let(:thread) { double("Thread", :abort_on_exception= => true, join: nil) }
+
+    before do
+      allow_any_instance_of(Lita::Adapters::Shell).to receive(:run)
+      allow_any_instance_of(Thin::Server).to receive(:start)
+
+      allow(Thread).to receive(:new) do |&block|
+        block.call
+        thread
+      end
+    end
+
     it "starts the adapter" do
       expect_any_instance_of(Lita::Adapters::Shell).to receive(:run)
       subject.run
     end
 
+    it "starts the web server" do
+      expect_any_instance_of(Thin::Server).to receive(:start)
+      subject.run
+    end
+
+    it "doesn't silence thin if config.http.debug is true" do
+      Lita.config.http.debug = true
+      expect_any_instance_of(Thin::Server).not_to receive(:silent=)
+      subject.run
+    end
+
     it "rescues interrupts and calls #shut_down" do
       allow_any_instance_of(
         Lita::Adapters::Shell

data/spec/lita/rspec_spec.rb

@@ -1,15 +1,24 @@
 require "spec_helper"
 
 handler_class = Class.new(Lita::Handler) do
-  route(/\w{3}/, to: :foo)
-  route(/\w{4}/, to: :blah, command: true)
+  route(/^\w{3}$/, :foo)
+  route(/^\w{4}$/, :blah, command: true)
+  route("restricted", :restricted, restrict_to: :some_group)
 
-  def foo(matches)
-    reply "baz"
+  http.get "web", :web
+
+  def foo(response)
+    response.reply "baz"
+  end
+
+  def blah(response)
+    response.reply "bongo", "wongo"
+  end
+
+  def restricted(response)
   end
 
-  def blah(matches)
-    reply "bongo", "wongo"
+  def web(request, response)
   end
 
   def self.name
@@ -17,33 +26,36 @@ handler_class = Class.new(Lita::Handler) do
   end
 end
 
-describe handler_class, lita: true do
+describe handler_class, lita_handler: true do
   it { routes("foo").to(:foo) }
-  it { routes("#{robot.name}: blah").to(:blah) }
+  it { routes_command("blah").to(:blah) }
   it { doesnt_route("blah").to(:blah) }
   it { does_not_route("blah").to(:blah) }
+  it { doesnt_route_command("yo").to(:foo) }
+  it { does_not_route_command("yo").to(:foo) }
+  it { routes("restricted").to(:restricted) }
+  it { routes_http(:get, "web").to(:web) }
+  it { doesnt_route_http(:post, "web").to(:web) }
 
   describe "#foo" do
     it "replies with baz" do
-      expect_reply("baz")
-      send_test_message("foo")
-    end
-
-    it "doesn't reply with blam" do
-      expect_no_reply("blam")
-      send_test_message("foo")
+      send_message("foo")
+      expect(replies).to eq(["baz"])
     end
   end
 
   describe "#blah" do
     it "replies with bongo and wongo" do
-      expect_replies("bongo", "wongo")
-      send_test_message("#{robot.name}: blah")
+      send_command("blah")
+      expect(replies).to eq(["bongo", "wongo"])
     end
+  end
 
-    it "doesn't reply with foo and bar" do
-      expect_no_replies("foo", "bar")
-      send_test_message("#{robot.name}: blah")
+  it "allows the sending user to be specified" do
+    another_user = Lita::User.create(2, name: "Another User")
+    expect(robot).to receive(:receive) do |message|
+      expect(message.source.user).to eq(another_user)
     end
+    send_message("foo", as: another_user)
   end
 end