lita 2.7.2 → 3.0.0

data/spec/lita/adapters/shell_spec.rb

@@ -1,6 +1,6 @@
 describe Lita::Adapters::Shell do
   let(:robot) do
-    double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: "/")
+    instance_double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: "/")
   end
 
   subject { described_class.new(robot) }
@@ -37,12 +37,12 @@ describe Lita::Adapters::Shell do
       expect(subject).to receive(:puts) do |messages|
         expect(messages.first).to include("bar")
       end
-      subject.send_messages(double("target"), "bar")
+      subject.send_messages(instance_double("Lita::Source"), "bar")
     end
 
     it "doesn't output empty messages" do
       expect(subject).to receive(:puts).with([])
-      subject.send_messages(double("target"), "")
+      subject.send_messages(instance_double("Lita::Source"), "")
     end
   end
 

data/spec/lita/authorization_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
 describe Lita::Authorization, lita: true do
-  let(:requesting_user) { double("Lita::User", id: "1") }
-  let(:user) { double("Lita::User", id: "2") }
+  let(:requesting_user) { instance_double("Lita::User", id: "1") }
+  let(:user) { instance_double("Lita::User", id: "2") }
 
   before do
     Lita.config.robot.admins = ["1"]
@@ -11,7 +11,7 @@ describe Lita::Authorization, lita: true do
   describe ".add_user_to_group" do
     it "adds users to an auth group" do
       described_class.add_user_to_group(requesting_user, user, "employees")
-      expect(described_class.user_in_group?(user, "employees")).to be_true
+      expect(described_class.user_in_group?(user, "employees")).to be true
     end
 
     it "can only be called by admins" do
@@ -22,12 +22,12 @@ describe Lita::Authorization, lita: true do
         "employees"
       )
       expect(result).to eq(:unauthorized)
-      expect(described_class.user_in_group?(user, "employees")).to be_false
+      expect(described_class.user_in_group?(user, "employees")).to be false
     end
 
     it "normalizes the group name" do
       described_class.add_user_to_group(requesting_user, user, "eMPLoYeeS")
-      expect(described_class.user_in_group?(user, "  EmplOyEEs  ")).to be_true
+      expect(described_class.user_in_group?(user, "  EmplOyEEs  ")).to be true
     end
   end
 
@@ -35,7 +35,7 @@ describe Lita::Authorization, lita: true do
     it "removes users from an auth group" do
       described_class.add_user_to_group(requesting_user, user, "employees")
       described_class.remove_user_from_group(requesting_user, user, "employees")
-      expect(described_class.user_in_group?(user, "employees")).to be_false
+      expect(described_class.user_in_group?(user, "employees")).to be false
     end
 
     it "can only be called by admins" do
@@ -47,19 +47,19 @@ describe Lita::Authorization, lita: true do
         "employees"
       )
       expect(result).to eq(:unauthorized)
-      expect(described_class.user_in_group?(user, "employees")).to be_true
+      expect(described_class.user_in_group?(user, "employees")).to be true
     end
 
     it "normalizes the group name" do
       described_class.add_user_to_group(requesting_user, user, "eMPLoYeeS")
       described_class.remove_user_from_group(requesting_user, user, "EmployeeS")
-      expect(described_class.user_in_group?(user, "  EmplOyEEs  ")).to be_false
+      expect(described_class.user_in_group?(user, "  EmplOyEEs  ")).to be false
     end
   end
 
   describe ".user_in_group?" do
     it "returns false if the user is in the group" do
-      expect(described_class.user_in_group?(user, "employees")).to be_false
+      expect(described_class.user_in_group?(user, "employees")).to be false
     end
 
     it "delegates to .user_is_admin? if the group is admins" do
@@ -70,12 +70,12 @@ describe Lita::Authorization, lita: true do
 
   describe ".user_is_admin?" do
     it "returns true if the user's ID is in the config" do
-      expect(described_class.user_is_admin?(requesting_user)).to be_true
+      expect(described_class.user_is_admin?(requesting_user)).to be true
     end
 
     it "returns false if the user's ID is not in the config" do
       Lita.config.robot.admins = nil
-      expect(described_class.user_is_admin?(user)).to be_false
+      expect(described_class.user_is_admin?(user)).to be false
     end
   end
 

data/spec/lita/config_spec.rb

@@ -48,6 +48,7 @@ describe Lita::Config do
     end
 
     it "doesn't attempt to load lita_config.rb if it doesn't exist" do
+      allow(File).to receive(:exist?).and_return(false)
       expect(described_class).not_to receive(:load)
       described_class.load_user_config
     end
@@ -59,4 +60,11 @@ describe Lita::Config do
       expect { described_class.load_user_config }.to raise_error(SystemExit)
     end
   end
+
+  describe "#finalize" do
+    it "freezes the configuration" do
+      subject.finalize
+      expect { subject.robot = "Assignment is impossible!" }.to raise_error(RuntimeError, /frozen/)
+    end
+  end
 end

data/spec/lita/daemon_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Lita::Daemon do
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:log_file) { StringIO.new }
+
+  before do
+    allow(Process).to receive(:daemon)
+    allow(Process).to receive(:kill)
+    allow(File).to receive(:new).and_return("log")
+    allow(File).to receive(:open)
+    allow(File).to receive(:read)
+    allow_any_instance_of(described_class).to receive(:stdout).and_return(stdout)
+    allow_any_instance_of(described_class).to receive(:stderr).and_return(stderr)
+  end
+
+  subject { described_class.new("/tmp/lita_pid", "/tmp/lita_log", false) }
+
+  describe "#daemonize" do
+    it "daemonizes the running process" do
+      expect(Process).to receive(:daemon).with(true)
+      subject.daemonize
+    end
+
+    context "when the user has not requested that existing processes should be killed" do
+      it "aborts if a Lita process is already running" do
+        allow(File).to receive(:exists?).and_return(true)
+        expect(subject).to receive(:abort)
+        subject.daemonize
+      end
+    end
+
+    context "when the user has requested that existing process be killed" do
+      subject { described_class.new("/tmp/lita_pid", "/tmp/lita_log", true) }
+
+      it "kills existing processes" do
+        allow(File).to receive(:exists?).and_return(true)
+        expect(Process).to receive(:kill)
+        subject.daemonize
+      end
+
+      it "aborts if it can't kill an existing process" do
+        allow(File).to receive(:exists?).and_return(true)
+        allow(Process).to receive(:kill).and_raise(Errno::ESRCH)
+        expect(subject).to receive(:abort)
+        subject.daemonize
+      end
+    end
+
+    it "redirects stdout to the log file" do
+      allow(File).to receive(:new).with("/tmp/lita_log", "a").and_return(log_file)
+      subject.daemonize
+      stdout.write "foo"
+      expect(log_file.string).to eq("foo")
+    end
+
+    it "redirects stderr to the log file" do
+      allow(File).to receive(:new).with("/tmp/lita_log", "a").and_return(log_file)
+      subject.daemonize
+      stderr.write "bar"
+      expect(log_file.string).to eq("bar")
+    end
+  end
+end

data/spec/lita/handler_spec.rb

@@ -1,15 +1,17 @@
 require "spec_helper"
 
 describe Lita::Handler, lita: true do
-  let(:robot) { double("Lita::Robot", name: "Lita") }
-  let(:user) { double("Lita::User", name: "Test User") }
+  let(:robot) { instance_double("Lita::Robot", name: "Lita") }
+  let(:user) { instance_double("Lita::User", name: "Test User") }
 
   let(:message) do
-    message = double("Lita::Message", user: user, command?: false)
+    message = instance_double("Lita::Message", user: user, command?: false)
     allow(message).to receive(:match)
     message
   end
 
+  let(:queue) { Queue.new }
+
   let(:handler_class) do
     Class.new(described_class) do
       route(/\w{3}/, :foo)
@@ -17,8 +19,6 @@ describe Lita::Handler, lita: true do
       route(/secret/, :secret, restrict_to: :admins)
       route(/danger/, :danger)
 
-      http.get "web", :web
-
       on :connected, :greet
       on :some_hook, :test_payload
 
@@ -31,9 +31,6 @@ describe Lita::Handler, lita: true do
       def secret(response)
       end
 
-      def web(request, response)
-      end
-
       def danger(response)
         raise "The developer of this handler's got a bug in their code!"
       end
@@ -42,6 +39,24 @@ describe Lita::Handler, lita: true do
         robot.send_message("Hi, #{payload[:name]}! Lita has started!")
       end
 
+      def after_test(response, queue)
+        after(2) { |timer| queue.push("Waited 2 seconds!") }
+      end
+
+      def every_test(response, queue)
+        array = [1, 2, 3]
+
+        every(2) do |timer|
+          value = array.shift
+
+          if value
+            queue.push(value)
+          else
+            timer.stop
+          end
+        end
+      end
+
       def self.name
         "Lita::Handlers::Test"
       end
@@ -109,9 +124,7 @@ describe Lita::Handler, lita: true do
     it "logs exceptions but doesn't crash the bot" do
       allow(message).to receive(:body).and_return("#{robot.name}: danger")
       allow(handler_class).to receive(:rspec_loaded?).and_return(false)
-      expect(Lita.logger).to receive(:error).with(
-        %r{Lita::Handlers::Test crashed}
-      )
+      expect(Lita.logger).to receive(:error).with(/Lita::Handlers::Test crashed/)
       expect { handler_class.dispatch(robot, message) }.not_to raise_error
     end
 
@@ -174,4 +187,30 @@ describe Lita::Handler, lita: true do
       expect(connection.builder.handlers).to include(Faraday::Response::Logger)
     end
   end
+
+  describe "timer methods" do
+    let(:response) { instance_double("Lita::Response") }
+
+    subject { handler_class.new(robot) }
+
+    before { allow_any_instance_of(Lita::Timer).to receive(:sleep) }
+
+    describe "#after" do
+      it "triggers the block after the given number of seconds" do
+        subject.after_test(response, queue)
+        expect(queue.pop).to eq("Waited 2 seconds!")
+        expect { queue.pop(true) }.to raise_error(ThreadError)
+      end
+    end
+
+    describe "#every" do
+      it "triggers the block until the timer is stopped" do
+        subject.every_test(response, 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
+  end
 end

data/spec/lita/handlers/authorization_spec.rb

@@ -7,7 +7,7 @@ describe Lita::Handlers::Authorization, lita_handler: true do
     ).and_return(true)
   end
 
-  let(:target_user) { double("Lita::User", id: "1", name: "Carl") }
+  let(:target_user) { instance_double("Lita::User", id: "1", name: "Carl") }
 
   it { routes_command("auth add foo bar").to(:add) }
   it { routes_command("auth add foo@bar.com baz").to(:add) }

data/spec/lita/handlers/info_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Lita::Handlers::Info, lita_handler: true do
+  it { routes_command("info").to(:chat) }
+  it { routes_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.last).to include(Lita::VERSION)
+    end
+
+    it "responds with a link to the website" do
+      send_command("info")
+      expect(replies.last).to include("lita.io")
+    end
+  end
+
+  describe "#web" do
+    it "returns JSON with info about the running robot" do
+      subject.web(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/handlers/room_spec.rb

@@ -0,0 +1,20 @@
+describe Lita::Handlers::Room, lita_handler: true do
+  it { routes_command("join #lita.io").to(:join) }
+  it { routes_command("part #lita.io").to(:part) }
+
+  before { allow(Lita::Authorization).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/logger_spec.rb

@@ -21,6 +21,6 @@ describe Lita::Logger do
     stub_const("STDERR", stderr)
     logger = described_class.get_logger(:debug)
     logger.fatal "foo"
-    expect(stderr.string).to match(%r{^\[.+\] FATAL: foo$})
+    expect(stderr.string).to match(/^\[.+\] FATAL: foo$/)
   end
 end

data/spec/lita/message_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Lita::Message do
   let(:robot) do
-    double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: ".")
+    instance_double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: ".")
   end
 
   subject do
@@ -20,12 +20,12 @@ describe Lita::Message do
   describe "#args" do
     it "returns an array of the 2nd through nth word in the message" do
       subject = described_class.new(robot, "args foo bar", "Carl")
-      expect(subject.args).to eq(["foo", "bar"])
+      expect(subject.args).to eq(%w(foo bar))
     end
 
     it "escapes messages that have mismatched quotes" do
       subject = described_class.new(robot, "args it's working", "Carl")
-      expect(subject.args).to eq(["it's", "working"])
+      expect(subject.args).to eq(%w(it's working))
     end
   end
 
@@ -92,7 +92,7 @@ describe Lita::Message do
       )
       expect(robot).to receive(:send_messages) do |source, *strings|
         expect(source).to be_a_private_message
-        expect(strings).to eq(["foo", "bar"])
+        expect(strings).to eq(%w(foo bar))
       end
       subject.reply_privately("foo", "bar")
     end

data/spec/lita/rack_app_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe Lita::RackApp do
+  let(:handler_class) do
+    Class.new(Lita::Handler) do
+      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
+
+      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 self.name
+        "Lita::Handlers::Test"
+      end
+    end
+  end
+
+  let(:robot) { instance_double("Lita::Robot") }
+
+  before { allow(Lita).to receive(:handlers).and_return([handler_class]) }
+
+  subject { described_class.new(robot) }
+
+  it "responds to requests for simple paths" do
+    env = Rack::MockRequest.env_for("/web")
+    status, _headers, body_proxy = subject.call(env)
+    expect(status).to eq(200)
+    expect(body_proxy.body.first).to eq("it worked")
+  end
+
+  it "responds to requests with variable paths" do
+    env = Rack::MockRequest.env_for("/path/with/some_id", method: "POST")
+    status, _headers, body_proxy = subject.call(env)
+    expect(status).to eq(200)
+    expect(body_proxy.body.first).to eq("id is some_id")
+  end
+
+  it "responds to requests with globs in their paths" do
+    env = Rack::MockRequest.env_for("/heres/a/giant/glob/in/a/path")
+    status, _headers, body_proxy = subject.call(env)
+    expect(status).to eq(200)
+    expect(body_proxy.body.first).to eq("a/giant")
+  end
+
+  it "responds to requests with variable path constraints" do
+    env = Rack::MockRequest.env_for("/123/otherwise/identical/path")
+    status, _headers, body_proxy = subject.call(env)
+    expect(status).to eq(200)
+    expect(body_proxy.body.first).to eq("constraint")
+
+    env = Rack::MockRequest.env_for("/an/otherwise/identical/path")
+    status, _headers, body_proxy = subject.call(env)
+    expect(status).to eq(200)
+    expect(body_proxy.body.first).to eq("no constraint")
+  end
+
+  it "responds to HEAD requests for GET routes" do
+    env = Rack::MockRequest.env_for("/web", method: "HEAD")
+    status, _headers, body = subject.call(env)
+    expect(status).to eq(204)
+    expect(body).to be_empty
+  end
+
+  it "doesn't respond to HEAD requests for non-GET routes" do
+    env = Rack::MockRequest.env_for("/path/with/some_id", method: "HEAD")
+    status, _headers, _body = subject.call(env)
+    expect(status).to eq(405)
+  end
+end