lita 3.3.1 → 4.0.0.rc1

data/spec/lita/handlers/authorization_spec.rb

@@ -2,19 +2,17 @@ require "spec_helper"
 
 describe Lita::Handlers::Authorization, lita_handler: true do
   before do
-    allow(Lita::Authorization).to receive(:user_is_admin?).with(
-      user
-    ).and_return(true)
+    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 { 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) }
-  it { routes_command("auth list").to(:list) }
-  it { routes_command("auth list foo").to(:list) }
+  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
@@ -77,8 +75,8 @@ describe Lita::Handlers::Authorization, lita_handler: true do
 
       before do
         groups.each do |group|
-          Lita::Authorization.add_user_to_group(user, user1, group)
-          Lita::Authorization.add_user_to_group(user, user2, group)
+          subject.robot.auth.add_user_to_group(user, user1, group)
+          subject.robot.auth.add_user_to_group(user, user2, group)
         end
       end
 

data/spec/lita/handlers/deprecation_check_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Lita::Handlers::DeprecationCheck, lita_handler: true do
+  it { is_expected.to route_event(:loaded).to(:check_handlers_for_default_config) }
+
+  describe "#check_handlers_for_default_config" do
+    before do
+      registry.register_handler(:foo) do
+        def self.default_config(old_config)
+          old_config.bar = :baz
+        end
+      end
+    end
+
+    it "logs a warning for handlers using the default_config method" do
+      expect(Lita.logger).to receive(:warn).with(/found defined in the foo handler/)
+
+      robot.trigger(:loaded, {})
+    end
+  end
+end

data/spec/lita/handlers/help_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
 describe Lita::Handlers::Help, lita_handler: true do
-  it { routes_command("help").to(:help) }
-  it { routes_command("help foo").to(:help) }
+  it { is_expected.to route_command("help").to(:help) }
+  it { is_expected.to route_command("help foo").to(:help) }
 
   describe "#help" do
     let(:secret_handler_class) do
@@ -12,6 +12,7 @@ describe Lita::Handlers::Help, lita_handler: true do
         })
       end
     end
+
     it "sends help information for all commands" do
       send_command("help")
       expect(replies.last).to match(
@@ -25,13 +26,34 @@ describe Lita::Handlers::Help, lita_handler: true do
       expect(replies.last).not_to match(/help - Lists/)
     end
 
-    it "doesn't show help for commands the user doesn't have access to" do
-      allow(Lita).to receive(:handlers).and_return([
-        described_class,
-        secret_handler_class
-      ])
-      send_command("help")
-      expect(replies.last).not_to include("secret")
+    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
+
+      before { registry.register_handler(secret_handler_class) }
+
+      it "doesn't show help for commands the user doesn't have access to" do
+        send_command("help")
+        expect(replies.last).not_to include("secret")
+      end
+
+      it "shows help for restricted routes if the user has access" do
+        send_command("help", as: authorized_user)
+        expect(replies.last).to include("secret")
+      end
     end
   end
 end

data/spec/lita/handlers/info_spec.rb

@@ -1,8 +1,8 @@
 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) }
+  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 }

data/spec/lita/handlers/room_spec.rb

@@ -1,8 +1,10 @@
+require "spec_helper"
+
 describe Lita::Handlers::Room, lita_handler: true do
-  it { routes_command("join #lita.io").to(:join) }
-  it { routes_command("part #lita.io").to(:part) }
+  it { is_expected.to route_command("join #lita.io").to(:join) }
+  it { is_expected.to route_command("part #lita.io").to(:part) }
 
-  before { allow(Lita::Authorization).to receive(:user_is_admin?).with(user).and_return(true) }
+  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

data/spec/lita/robot_spec.rb

@@ -1,13 +1,9 @@
 require "spec_helper"
 
-describe Lita::Robot do
-  it "logs and quits if the specified adapter can't be found" do
-    adapter_registry = double("adapter_registry")
-    allow(Lita).to receive(:adapters).and_return(adapter_registry)
-    allow(adapter_registry).to receive(:[]).and_return(nil)
-    expect(Lita.logger).to receive(:fatal).with(/Unknown adapter/)
-    expect { subject }.to raise_error(SystemExit)
-  end
+describe Lita::Robot, lita: true do
+  subject { described_class.new(registry) }
+
+  before { registry.register_adapter(:shell, Lita::Adapters::Shell) }
 
   it "triggers a loaded event after initialization" do
     expect_any_instance_of(described_class).to receive(:trigger).with(:loaded)
@@ -15,11 +11,12 @@ describe Lita::Robot do
   end
 
   context "with registered handlers" do
-    let(:handler1) { class_double("Lita::Handler", http_routes: [], trigger: nil) }
-    let(:handler2) { class_double("Lita::Handler", http_routes: [], trigger: nil) }
+    let(:handler1) { Class.new(Lita::Handler) { namespace :test } }
+    let(:handler2) { Class.new(Lita::Handler) { namespace :test } }
 
     before do
-      allow(Lita).to receive(:handlers).and_return([handler1, handler2])
+      registry.register_handler(handler1)
+      registry.register_handler(handler2)
     end
 
     describe "#receive" do
@@ -70,6 +67,26 @@ describe Lita::Robot do
       expect_any_instance_of(Lita::Adapters::Shell).to receive(:shut_down)
       subject.run
     end
+
+    it "logs and quits if the specified adapter can't be found" do
+      registry.config.robot.adapter = :does_not_exist
+      expect(Lita.logger).to receive(:fatal).with(/Unknown adapter/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
+
+    it "logs and aborts if the web server's port is in use" do
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener).and_raise(Errno::EADDRINUSE)
+
+      expect(Lita.logger).to receive(:fatal).with(/web server/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
+
+    it "logs and aborts if the web server's port is privileged" do
+      allow_any_instance_of(Puma::Server).to receive(:add_tcp_listener).and_raise(Errno::EACCES)
+
+      expect(Lita.logger).to receive(:fatal).with(/web server/)
+      expect { subject.run }.to raise_error(SystemExit)
+    end
   end
 
   describe "#join" do
@@ -151,6 +168,8 @@ describe Lita::Robot do
   end
 
   describe "#shut_down" do
+    before { allow_any_instance_of(Lita::Adapters::Shell).to receive(:puts) }
+
     it "gracefully stops the adapter" do
       expect_any_instance_of(Lita::Adapters::Shell).to receive(:shut_down)
       subject.shut_down

data/spec/lita/rspec_spec.rb

@@ -1,20 +1,21 @@
 require "spec_helper"
 
 handler_class = Class.new(Lita::Handler) do
-  route(/^\w{3}$/, :foo)
-  route(/^\w{4}$/, :blah, command: true)
+  route(/^message$/, :message)
+  route(/^command$/, :command, command: true)
   route("restricted", :restricted, restrict_to: :some_group)
+  route("admins only", :admins_only, restrict_to: :admins)
 
   http.get "web", :web
 
   on :connected, :greet
 
-  def foo(response)
-    response.reply "baz"
+  def message(response)
+    response.reply(response.user.name)
   end
 
-  def blah(response)
-    response.reply "bongo", "wongo"
+  def command(response)
+    response.reply("a", "command")
   end
 
   def restricted(_response)
@@ -32,38 +33,77 @@ handler_class = Class.new(Lita::Handler) do
 end
 
 describe handler_class, lita_handler: true do
-  it { routes("foo").to(:foo) }
-  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) }
-  it { routes_event(:connected).to(:greet) }
-  it { doesnt_route_event(:connected).to(:web) }
-  it { does_not_route_event(:connected).to(:web) }
-
-  describe "#foo" do
-    it "replies with baz" do
-      send_message("foo")
-      expect(replies).to eq(["baz"])
+  describe "routing messages" do
+    it { is_expected.to route("message") }
+    it { is_expected.to route("message").to(:message) }
+    it { is_expected.not_to route("message").to(:not_a_message) }
+  end
+
+  describe "routing commands" do
+    it { is_expected.to route_command("command") }
+    it { is_expected.not_to route("command") }
+    it { is_expected.not_to route_command("not a command") }
+    it { is_expected.to route_command("command").to(:command) }
+    it { is_expected.not_to route_command("command").to(:not_a_command) }
+  end
+
+  describe "routing to restricted routes" do
+    it { is_expected.not_to route("restricted") }
+    it { is_expected.to route("restricted").with_authorization_for(:some_group) }
+    it { is_expected.not_to route("restricted").with_authorization_for(:wrong_group) }
+    it { is_expected.to route("admins only").with_authorization_for(:admins) }
+    it { is_expected.to route("restricted").with_authorization_for(:some_group).to(:restricted) }
+    it { is_expected.not_to route("restricted").with_authorization_for(:some_group).to(:nothing) }
+  end
+
+  describe "routing HTTP routes" do
+    it { is_expected.to route_http(:get, "web") }
+    it { is_expected.to route_http(:get, "web").to(:web) }
+    it { is_expected.not_to route_http(:get, "web").to(:message) }
+    it { is_expected.not_to route_http(:post, "web") }
+  end
+
+  describe "routing events" do
+    it { is_expected.to route_event(:connected) }
+    it { is_expected.to route_event(:connected).to(:greet) }
+    it { is_expected.not_to route_event(:not_an_event) }
+    it { is_expected.not_to route_event(:connected).to(:message) }
+  end
+
+  describe "deprecated routing syntax" do
+    before { allow(STDERR).to receive(:puts) }
+
+    it { routes("message").to(:message) }
+    it { routes_command("command").to(:command) }
+    it { doesnt_route("command").to(:command) }
+    it { does_not_route("command").to(:command) }
+    it { doesnt_route_command("not a command").to(:message) }
+    it { does_not_route_command("not a command").to(:message) }
+    it { routes("restricted").to(:restricted) }
+    it { routes_http(:get, "web").to(:web) }
+    it { doesnt_route_http(:post, "web").to(:web) }
+    it { routes_event(:connected).to(:greet) }
+    it { doesnt_route_event(:connected).to(:web) }
+    it { does_not_route_event(:connected).to(:web) }
+  end
+
+  describe "#message" do
+    it "replies with a string" do
+      send_message("message")
+      expect(replies).to eq(["Test User"])
     end
   end
 
-  describe "#blah" do
-    it "replies with bongo and wongo" do
-      send_command("blah")
-      expect(replies).to eq(%w(bongo wongo))
+  describe "#command" do
+    it "replies with two strings" do
+      send_command("command")
+      expect(replies).to eq(%w(a command))
     end
   end
 
   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)
+    send_message("message", as: another_user)
+    expect(replies.last).to eq("Another User")
   end
 end

data/spec/lita/user_spec.rb

@@ -6,13 +6,13 @@ describe Lita::User, lita: true do
       user = described_class.create(1, name: "Carl")
       expect(user.id).to eq("1")
       expect(user.name).to eq("Carl")
-      persisted_user = described_class.find(1)
+      persisted_user = described_class.find_by_id(1)
       expect(user).to eq(persisted_user)
     end
 
     it "returns existing users" do
       described_class.create(1, name: "Carl")
-      user = described_class.find(1)
+      user = described_class.find_by_id(1)
       expect(user.id).to eq("1")
       expect(user.name).to eq("Carl")
     end

data/spec/lita_spec.rb

@@ -4,7 +4,6 @@ describe Lita do
   before { described_class.register_adapter(:shell, Lita::Adapters::Shell) }
 
   it "memoizes a Config" do
-    expect(described_class.config).to be_a(Lita::Config)
     expect(described_class.config).to eql(described_class.config)
   end
 
@@ -60,10 +59,57 @@ describe Lita do
   end
 
   describe ".redis" do
+    let(:redis_namespace) { instance_double("Redis") }
+
+    before do
+      if described_class.instance_variable_defined?(:@redis)
+        described_class.remove_instance_variable(:@redis)
+      end
+
+      allow(redis_namespace).to receive(:ping).and_return("PONG")
+      allow(Redis::Namespace).to receive(:new).and_return(redis_namespace)
+    end
+
     it "memoizes a Redis::Namespace" do
-      expect(described_class.redis).to respond_to(:namespace)
+      expect(described_class.redis).to equal(redis_namespace)
       expect(described_class.redis).to eql(described_class.redis)
     end
+
+    it "logs a fatal warning and raises an exception if it can't connection to Redis" do
+      allow(redis_namespace).to receive(:ping).and_raise(Redis::CannotConnectError)
+
+      expect(Lita.logger).to receive(:fatal)
+      expect { Lita.redis }.to raise_error(SystemExit)
+    end
+  end
+
+  describe ".register_adapter" do
+    let(:robot) { instance_double("Lita::Robot") }
+
+    it "builds an adapter out of a provided block" do
+      described_class.register_adapter(:foo) {}
+      expect(Lita.logger).to receive(:warn).with(/not implemented/)
+      Lita.adapters[:foo].new(robot).run
+    end
+
+    it "raises if a non-class object is passed as the adapter" do
+      expect do
+        described_class.register_adapter(:foo, :bar)
+      end.to raise_error(ArgumentError, /requires a class/)
+    end
+  end
+
+  describe ".register_handler" do
+    it "builds a handler out of a provided block" do
+      described_class.register_handler(:foo) {}
+      expect(described_class.handlers.to_a.last.namespace).to eq("foo")
+    end
+
+    it "raises if a non-class object is the only argument" do
+      expect do
+        described_class.register_handler(:foo)
+      end.to raise_error(ArgumentError, /requires a class/)
+    end
   end
 
   describe ".reset" do
@@ -74,13 +120,13 @@ describe Lita do
     end
 
     it "clears adapters" do
-      described_class.register_adapter(:foo, double)
+      described_class.register_adapter(:foo, Class.new)
       described_class.reset
       expect(described_class.adapters).to be_empty
     end
 
     it "clears handlers" do
-      described_class.register_handler(double)
+      described_class.register_handler(Class.new)
       described_class.reset
       expect(described_class.handlers).to be_empty
     end
@@ -94,11 +140,17 @@ describe Lita do
 
   describe ".run" do
     let(:hook) { double("Hook") }
+    let(:validator) { instance_double("Lita::ConfigurationValidator", call: nil) }
 
     before do
       allow_any_instance_of(Lita::Robot).to receive(:run)
+      allow(Lita::ConfigurationValidator).to receive(:new).with(described_class).and_return(
+        validator
+       )
     end
 
+    after { described_class.reset }
+
     it "runs a new Robot" do
       expect_any_instance_of(Lita::Robot).to receive(:run)
       described_class.run
@@ -109,5 +161,11 @@ describe Lita do
       expect(hook).to receive(:call).with(config_path: "path/to/config")
       described_class.run("path/to/config")
     end
+
+    it "raises if the configuration is not valid" do
+      allow(validator).to receive(:call).and_raise(Lita::ValidationError)
+
+      expect { described_class.run }.to raise_error(Lita::ValidationError)
+    end
   end
 end