lita 3.3.1 → 4.0.0.rc1

data/lib/lita/rspec/matchers/chat_route_matcher.rb

@@ -0,0 +1,48 @@
+module Lita
+  module RSpec
+    module Matchers
+      # RSpec matchers for chat routes.
+      # @since 4.0.0
+      module ChatRouteMatcher
+        extend ::RSpec::Matchers::DSL
+
+        matcher :route do |message_body|
+          match do
+            message = Message.new(robot, message_body, source)
+
+            if defined?(@group) and @group.to_s.downcase == "admins"
+              robot.config.robot.admins = Array(robot.config.robot.admins) + [source.user.id]
+            elsif defined?(@group)
+              robot.auth.add_user_to_group!(source.user, @group)
+            end
+
+            matching_routes = described_class.routes.select do |route|
+              RouteValidator.new(described_class, route, message, robot).call
+            end
+
+            if defined?(@method_name)
+              matching_routes.any? { |route| route.callback.method_name == @method_name }
+            else
+              !matching_routes.empty?
+            end
+          end
+
+          chain :with_authorization_for do |group|
+            @group = group
+          end
+
+          chain :to do |method_name|
+            @method_name = method_name
+          end
+        end
+
+        # Sets an expectation that the provided message routes to a command.
+        # @param message_body [String] The body of the message.
+        # @return [void]
+        def route_command(message_body)
+          route("#{robot.mention_name} #{message_body}")
+        end
+      end
+    end
+  end
+end

data/lib/lita/rspec/matchers/deprecated.rb

@@ -0,0 +1,36 @@
+module Lita
+  module RSpec
+    module Matchers
+      # Lita 3 versions of the routing  matchers.
+      # @deprecated Will be removed in Lita 5.0. Use the +is_expected+ forms instead.
+      class Deprecated
+        # @param context [RSpec::ExampleGroup] The example group where the matcher was called.
+        # @param new_method_name [String, Symbol] The method that should be used instead.
+        # @param positive [Boolean] Whether or not a positive expectation is being made.
+        def initialize(context, new_method_name, positive, *args)
+          @context = context
+          @new_method_name = new_method_name
+          @expectation_method_name = positive ? :to : :not_to
+          @args = args
+
+          @context.instance_exec do
+            allow_any_instance_of(Authorization).to receive(:user_in_group?).and_return(true)
+          end
+        end
+
+        # Sets an expectation that the previously supplied message will route to the provided
+        # method.
+        # @param method_name [String, Symbol] The name of the method that should be routed to.
+        def to(method_name)
+          emn = @expectation_method_name
+          matcher = @context.public_send(@new_method_name, *@args)
+          matcher.to(method_name)
+
+          @context.instance_exec do
+            is_expected.public_send(emn, matcher)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lita/rspec/matchers/event_route_matcher.rb

@@ -0,0 +1,27 @@
+module Lita
+  module RSpec
+    module Matchers
+      # RSpec matchers for event routes.
+      # @since 4.0.0
+      module EventRouteMatcher
+        extend ::RSpec::Matchers::DSL
+
+        matcher :route_event do |event_name|
+          match do
+            callbacks = described_class.event_subscriptions_for(event_name)
+
+            if defined?(@method_name)
+              callbacks.any? { |callback| callback.method_name.equal?(@method_name) }
+            else
+              !callbacks.empty?
+            end
+          end
+
+          chain :to do |method_name|
+            @method_name = method_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lita/rspec/matchers/http_route_matcher.rb

@@ -2,70 +2,28 @@ module Lita
   module RSpec
     # A namespace to hold all of Lita's RSpec matchers.
     module Matchers
-      # Used to complete an HTTP routing test chain.
-      class HTTPRouteMatcher
-        attr_accessor :context, :http_method, :expectation, :path
-        attr_reader :expected_route
-
-        def initialize(context, http_method, path, expectation: true)
-          self.context = context
-          self.http_method = http_method
-          self.path = path
-          self.expectation = expectation
-          set_description
-        end
-
-        # Sets an expectation that an HTTP route will or will not be triggered,
-        #   then makes an HTTP request against the app with the HTTP request
-        #   method and path originally provided.
-        # @param route [Symbol] The name of the method that should or should not
-        #   be triggered.
-        # @return [void]
-        def to(route)
-          self.expected_route = route
-
-          e = expectation
-          m = http_method.upcase
-          p = path
-          i = i18n_key
-
-          context.instance_eval do
-            called = false
-            allow(subject).to receive(route) { called = true }
-            env = Rack::MockRequest.env_for(p, method: m)
-            robot.app.call(env)
-            expect(called).to be(e), I18n.t(i, method: m, path: p, route: route)
-          end
-        end
-
-        private
-
-        def description_prefix
-          if expectation
-            "routes"
-          else
-            "doesn't route"
+      # RSpec matchers for HTTP routes.
+      # @since 4.0.0
+      module HTTPRouteMatcher
+        extend ::RSpec::Matchers::DSL
+
+        matcher :route_http do |http_method, path|
+          match do
+            env = Rack::MockRequest.env_for(path, method: http_method)
+
+            matching_routes = robot.app.recognize(env)
+
+            if defined?(@method_name)
+              matching_routes.include?(@method_name)
+            else
+              !matching_routes.empty?
+            end
           end
-        end
 
-        def expected_route=(route)
-          @expected_route = route
-          set_description
-        end
-
-        def i18n_key
-          if expectation
-            "lita.rspec.http_route_failure"
-          else
-            "lita.rspec.negative_http_route_failure"
+          chain :to do |method_name|
+            @method_name = method_name
           end
         end
-
-        def set_description
-          description = "#{description_prefix} #{http_method.upcase} #{path}"
-          description << " to :#{expected_route}" if expected_route
-          ::RSpec.current_example.metadata[:description] = description
-        end
       end
     end
   end

data/lib/lita/user.rb

@@ -23,12 +23,6 @@ module Lita
         user
       end
 
-      # @deprecated Use {.create} instead.
-      def find(id, metadata = {})
-        Lita.logger.warn I18n.t("lita.user.find_deprecated")
-        create(id, metadata)
-      end
-
       # Finds a user by ID.
       # @param id [Integer, String] The user's unique ID.
       # @return [Lita::User, nil] The user or +nil+ if no such user is known.

data/lib/lita/util.rb

@@ -1,9 +1,6 @@
 module Lita
   # Handy utilities used by other Lita classes.
   module Util
-    # A regular expression for acronyms.
-    ACRONYM_REGEX = /(?=a)b/
-
     class << self
       # Returns a hash with any symbol keys converted to strings.
       # @param hash [Hash] The hash to convert.
@@ -14,16 +11,12 @@ module Lita
         result
       end
 
-      # Transforms a camel-cased string into a snaked-cased string. Taken from
-      # +ActiveSupport.+
+      # Transforms a camel-cased string into a snaked-cased string. Taken from +ActiveSupport.+
       # @param camel_cased_word [String] The word to transform.
       # @return [String] The transformed word.
       def underscore(camel_cased_word)
         word = camel_cased_word.to_s.dup
         word.gsub!("::", "/")
-        word.gsub!(/(?:([A-Za-z\d])|^)(#{ACRONYM_REGEX})(?=\b|[^a-z])/) do
-          "#{Regexp.last_match[1]}#{Regexp.last_match[1] && "_"}#{Regexp.last_match[2].downcase}"
-        end
         word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
         word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
         word.tr!("-", "_")

data/lib/lita/version.rb

@@ -1,4 +1,4 @@
 module Lita
   # The current version of Lita.
-  VERSION = "3.3.1"
+  VERSION = "4.0.0.rc1"
 end

data/lita.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "thor", ">= 0.18.1"
 
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rspec", ">= 3.0.0"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "coveralls"

data/spec/lita/adapter_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-describe Lita::Adapter do
-  let(:robot) { instance_double("Lita::Robot") }
+describe Lita::Adapter, lita: true do
+  let(:robot) { Lita::Robot.new(registry) }
 
   let(:required_methods) { [:join, :part, :run, :send_messages, :set_topic, :shut_down] }
 
@@ -33,13 +33,31 @@ describe Lita::Adapter do
       expect(Lita.logger).to receive(:fatal).with(/foo, bar, baz, blah, bleh/)
       expect { subject }.to raise_error(SystemExit)
     end
+
+    it "logs a deprecation warning when the adapter is initialized" do
+      expect(Lita.logger).to receive(:warn).with(/Use Lita::Adapter\.config instead/)
+
+      expect { adapter_class.new(robot) }.to raise_error(SystemExit)
+    end
   end
 
-  describe ".namespace" do
-    it "raises an exception if self.name is not implemented" do
-      expect do
-        Class.new(Lita::Adapter).namespace
-      end.to raise_error(RuntimeError)
+  describe "#config" do
+    let(:adapter) do
+      Class.new(described_class) do
+        namespace "test"
+
+        config :foo, default: :bar
+      end
+    end
+
+    let(:robot) { Lita::Robot.new(registry) }
+
+    before { registry.register_adapter(:test, adapter) }
+
+    subject { adapter.new(robot) }
+
+    it "provides access to the adapter's configuration object" do
+      expect(subject.config.foo).to eq(:bar)
     end
   end
 

data/spec/lita/adapters/shell_spec.rb

@@ -1,12 +1,21 @@
-describe Lita::Adapters::Shell do
+require "spec_helper"
+
+describe Lita::Adapters::Shell, lita: true do
   let(:robot) do
-    instance_double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: "/")
+    instance_double(
+      "Lita::Robot",
+      name: "Lita",
+      mention_name: "LitaBot",
+      alias: "/",
+      config: registry.config
+    )
   end
 
   subject { described_class.new(robot) }
 
   describe "#run" do
     before do
+      registry.register_adapter(:shell, described_class)
       allow(subject).to receive(:puts)
       allow(Readline).to receive(:readline).and_return("foo", "exit")
       allow(robot).to receive(:trigger)
@@ -19,8 +28,8 @@ describe Lita::Adapters::Shell do
       subject.run
     end
 
-    it "marks messages as commands if config.adapter.private_chat is true" do
-      Lita.config.adapter.private_chat = true
+    it "marks messages as commands if config.adapters.shell.private_chat is true" do
+      registry.config.adapters.shell.private_chat = true
       expect_any_instance_of(Lita::Message).to receive(:command!)
       subject.run
     end
@@ -29,6 +38,17 @@ describe Lita::Adapters::Shell do
       expect(robot).to receive(:trigger).with(:connected)
       subject.run
     end
+
+    it "exits cleanly when EOF is received" do
+      allow(Readline).to receive(:readline).and_return(nil)
+      subject.run
+    end
+
+    it "removes empty input from readline history" do
+      allow(Readline).to receive(:readline).and_return("", "exit")
+      expect(Readline::HISTORY).to receive(:pop)
+      subject.run
+    end
   end
 
   describe "#send_message" do

data/spec/lita/authorization_spec.rb

@@ -4,112 +4,131 @@ describe Lita::Authorization, lita: true do
   let(:requesting_user) { instance_double("Lita::User", id: "1") }
   let(:user) { instance_double("Lita::User", id: "2") }
 
+  subject { described_class.new(registry.config) }
+
   before do
-    Lita.config.robot.admins = ["1"]
+    registry.config.robot.admins = ["1"]
   end
 
-  describe ".add_user_to_group" do
+  describe "deprecated class methods" do
+    {
+      add_user_to_group: 3,
+      remove_user_from_group: 3,
+      user_in_group?: 2,
+      user_is_admin?: 1,
+      groups: 0,
+      groups_with_users: 0
+    }.each do |deprecated_method, arity|
+      it "logs a warning and calls the instance method version of .#{deprecated_method}" do
+        expect(Lita.logger).to receive(:warn).with(
+          /Lita::Authorization\.#{Regexp.escape(deprecated_method)} will be removed in Lita 5\.0/
+        )
+        expect_any_instance_of(described_class).to receive(deprecated_method)
+        described_class.public_send(deprecated_method, *arity.times.map { Object.new })
+      end
+    end
+  end
+
+  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
+      subject.add_user_to_group(requesting_user, user, "employees")
+      expect(subject.user_in_group?(user, "employees")).to be true
     end
 
     it "can only be called by admins" do
-      Lita.config.robot.admins = nil
-      result = described_class.add_user_to_group(
+      registry.config.robot.admins = nil
+      result = subject.add_user_to_group(
         requesting_user,
         user,
         "employees"
       )
       expect(result).to eq(:unauthorized)
-      expect(described_class.user_in_group?(user, "employees")).to be false
+      expect(subject.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
+      subject.add_user_to_group(requesting_user, user, "eMPLoYeeS")
+      expect(subject.user_in_group?(user, "  EmplOyEEs  ")).to be true
     end
   end
 
-  describe ".remove_user_from_group" do
+  describe "#remove_user_from_group" 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
+      subject.add_user_to_group(requesting_user, user, "employees")
+      subject.remove_user_from_group(requesting_user, user, "employees")
+      expect(subject.user_in_group?(user, "employees")).to be false
     end
 
     it "can only be called by admins" do
-      described_class.add_user_to_group(requesting_user, user, "employees")
-      Lita.config.robot.admins = nil
-      result = described_class.remove_user_from_group(
+      subject.add_user_to_group(requesting_user, user, "employees")
+      registry.config.robot.admins = nil
+      result = subject.remove_user_from_group(
         requesting_user,
         user,
         "employees"
       )
       expect(result).to eq(:unauthorized)
-      expect(described_class.user_in_group?(user, "employees")).to be true
+      expect(subject.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
+      subject.add_user_to_group(requesting_user, user, "eMPLoYeeS")
+      subject.remove_user_from_group(requesting_user, user, "EmployeeS")
+      expect(subject.user_in_group?(user, "  EmplOyEEs  ")).to be false
     end
   end
 
-  describe ".user_in_group?" do
+  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(subject.user_in_group?(user, "employees")).to be false
     end
 
     it "delegates to .user_is_admin? if the group is admins" do
-      expect(described_class).to receive(:user_is_admin?)
-      described_class.user_in_group?(user, "admins")
+      expect(subject).to receive(:user_is_admin?)
+      subject.user_in_group?(user, "admins")
     end
   end
 
-  describe ".user_is_admin?" 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(subject.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
+      registry.config.robot.admins = nil
+      expect(subject.user_is_admin?(user)).to be false
     end
   end
 
-  describe ".groups" do
+  describe "#groups" do
     before do
       %i(foo bar baz).each do |group|
-        described_class.add_user_to_group(requesting_user, user, group)
+        subject.add_user_to_group(requesting_user, user, group)
       end
     end
 
     it "returns a list of all authorization groups" do
-      expect(described_class.groups).to match_array(%i(foo bar baz))
+      expect(subject.groups).to match_array(%i(foo bar baz))
     end
   end
 
-  describe ".groups_with_users" do
+  describe "#groups_with_users" do
     before do
       %i(foo bar baz).each do |group|
-        described_class.add_user_to_group(requesting_user, user, group)
-        described_class.add_user_to_group(
+        subject.add_user_to_group(requesting_user, user, group)
+        subject.add_user_to_group(
           requesting_user,
           requesting_user,
           group
         )
       end
-      allow(Lita::User).to receive(:find_by_id).with("1").and_return(
-        requesting_user
-      )
+      allow(Lita::User).to receive(:find_by_id).with("1").and_return(requesting_user)
       allow(Lita::User).to receive(:find_by_id).with("2").and_return(user)
     end
 
     it "returns a hash of all authorization groups and their members" do
       groups = %i(foo bar baz)
-      groups_with_users = described_class.groups_with_users
+      groups_with_users = subject.groups_with_users
       expect(groups_with_users.keys).to match_array(groups)
       groups.each do |group|
         expect(groups_with_users[group]).to match_array([user, requesting_user])