rspec-rails 2.14.2 → 4.1.2

data/lib/rspec/rails/example.rb

@@ -6,37 +6,8 @@ require 'rspec/rails/example/view_example_group'
 require 'rspec/rails/example/mailer_example_group'
 require 'rspec/rails/example/routing_example_group'
 require 'rspec/rails/example/model_example_group'
+require 'rspec/rails/example/job_example_group'
 require 'rspec/rails/example/feature_example_group'
-
-RSpec::configure do |c|
-  def c.escaped_path(*parts)
-    Regexp.compile(parts.join('[\\\/]') + '[\\\/]')
-  end
-
-  c.include RSpec::Rails::ControllerExampleGroup, :type => :controller, :example_group => {
-    :file_path => c.escaped_path(%w[spec controllers])
-  }
-  c.include RSpec::Rails::HelperExampleGroup, :type => :helper, :example_group => {
-    :file_path => c.escaped_path(%w[spec helpers])
-  }
-  if defined?(RSpec::Rails::MailerExampleGroup)
-    c.include RSpec::Rails::MailerExampleGroup, :type => :mailer, :example_group => {
-      :file_path => c.escaped_path(%w[spec mailers])
-    }
-  end
-  c.include RSpec::Rails::ModelExampleGroup, :type => :model, :example_group => {
-    :file_path => c.escaped_path(%w[spec models])
-  }
-  c.include RSpec::Rails::RequestExampleGroup, :type => :request, :example_group => {
-    :file_path => c.escaped_path(%w[spec (requests|integration|api)])
-  }
-  c.include RSpec::Rails::RoutingExampleGroup, :type => :routing, :example_group => {
-    :file_path => c.escaped_path(%w[spec routing])
-  }
-  c.include RSpec::Rails::ViewExampleGroup, :type => :view, :example_group => {
-    :file_path => c.escaped_path(%w[spec views])
-  }
-  c.include RSpec::Rails::FeatureExampleGroup, :type => :feature, :example_group => {
-    :file_path => c.escaped_path(%w[spec features])
-  }
-end
+require 'rspec/rails/example/system_example_group'
+require 'rspec/rails/example/channel_example_group'
+require 'rspec/rails/example/mailbox_example_group'

data/lib/rspec/rails/extensions/active_record/proxy.rb

@@ -1,17 +1,11 @@
 RSpec.configure do |rspec|
   # Delay this in order to give users a chance to configure `expect_with`...
   rspec.before(:suite) do
-    if defined?(RSpec::Matchers) && RSpec::Matchers.configuration.syntax.include?(:should) && defined?(ActiveRecord::Associations)
-      # In Rails 3.0, it was AssociationProxy.
-      # In 3.1+, it's CollectionProxy.
-      const_name = [:CollectionProxy, :AssociationProxy].find do |const|
-        ActiveRecord::Associations.const_defined?(const)
-      end
-
-      proxy_class = ActiveRecord::Associations.const_get(const_name)
-
-      RSpec::Matchers.configuration.add_should_and_should_not_to proxy_class
+    if defined?(RSpec::Matchers) &&
+        RSpec::Matchers.configuration.respond_to?(:syntax) && # RSpec 4 dropped support for monkey-patching `should` syntax
+        RSpec::Matchers.configuration.syntax.include?(:should) &&
+        defined?(ActiveRecord::Associations)
+      RSpec::Matchers.configuration.add_should_and_should_not_to ActiveRecord::Associations::CollectionProxy
     end
   end
 end
-

data/lib/rspec/rails/extensions.rb

@@ -1,2 +1 @@
-require 'rspec/rails/extensions/active_record/base'
 require 'rspec/rails/extensions/active_record/proxy'

data/lib/rspec/rails/feature_check.rb

@@ -0,0 +1,47 @@
+module RSpec
+  module Rails
+    # @private
+    module FeatureCheck
+      module_function
+      def has_active_job?
+        defined?(::ActiveJob)
+      end
+
+      def has_active_record?
+        defined?(::ActiveRecord)
+      end
+
+      def has_active_record_migration?
+        has_active_record? && defined?(::ActiveRecord::Migration)
+      end
+
+      def has_action_mailer?
+        defined?(::ActionMailer)
+      end
+
+      def has_action_mailer_preview?
+        has_action_mailer? && defined?(::ActionMailer::Preview)
+      end
+
+      def has_action_cable_testing?
+        defined?(::ActionCable) && ActionCable::VERSION::MAJOR >= 6
+      end
+
+      def has_action_mailer_parameterized?
+        has_action_mailer? && defined?(::ActionMailer::Parameterized)
+      end
+
+      def has_action_mailer_unified_delivery?
+        has_action_mailer? && defined?(::ActionMailer::MailDeliveryJob)
+      end
+
+      def has_action_mailbox?
+        defined?(::ActionMailbox)
+      end
+
+      def type_metatag(type)
+        "type: :#{type}"
+      end
+    end
+  end
+end

data/lib/rspec/rails/file_fixture_support.rb

@@ -0,0 +1,17 @@
+if ::Rails::VERSION::STRING > '5'
+  require 'active_support/testing/file_fixtures'
+
+  module RSpec
+    module Rails
+      # @private
+      module FileFixtureSupport
+        extend ActiveSupport::Concern
+        include ActiveSupport::Testing::FileFixtures
+
+        included do
+          self.file_fixture_path = RSpec.configuration.file_fixture_path
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/fixture_file_upload_support.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Rails
+    # @private
+    module FixtureFileUploadSupport
+      delegate :fixture_file_upload, to: :rails_fixture_file_wrapper
+
+    private
+
+      def rails_fixture_file_wrapper
+        RailsFixtureFileWrapper.fixture_path = nil
+        resolved_fixture_path =
+          if respond_to?(:fixture_path) && !fixture_path.nil?
+            fixture_path.to_s
+          else
+            (RSpec.configuration.fixture_path || '').to_s
+          end
+        RailsFixtureFileWrapper.fixture_path = File.join(resolved_fixture_path, '') unless resolved_fixture_path.strip.empty?
+        RailsFixtureFileWrapper.instance
+      end
+
+      class RailsFixtureFileWrapper
+        include ActionDispatch::TestProcess if defined?(ActionDispatch::TestProcess)
+
+        class << self
+          attr_accessor :fixture_path
+
+          # Get instance of wrapper
+          def instance
+            @instance ||= new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/fixture_support.rb

@@ -1,38 +1,69 @@
 module RSpec
   module Rails
-    if defined?(ActiveRecord::TestFixtures)
-      module FixtureSupport
+    # @private
+    module FixtureSupport
+      if defined?(ActiveRecord::TestFixtures)
         extend ActiveSupport::Concern
         include RSpec::Rails::SetupAndTeardownAdapter
-        include RSpec::Rails::MinitestLifecycleAdapter if ::ActiveRecord::VERSION::STRING > '4'
+        include RSpec::Rails::MinitestLifecycleAdapter
         include RSpec::Rails::MinitestAssertionAdapter
         include ActiveRecord::TestFixtures
 
+        # @private prevent ActiveSupport::TestFixtures to start a DB transaction.
+        # Monkey patched to avoid collisions with 'let(:name)' in Rails 6.1 and after
+        # and let(:method_name) before Rails 6.1.
+        if ::Rails::VERSION::STRING > '5'
+          def run_in_transaction?
+            use_transactional_tests && !self.class.uses_transaction?(self)
+          end
+        else
+          def run_in_transaction?
+            use_transactional_fixtures && !self.class.uses_transaction?(self)
+          end
+        end
+
         included do
-          # TODO (DC 2011-06-25) this is necessary because fixture_file_upload
-          # accesses fixture_path directly on ActiveSupport::TestCase. This is
-          # fixed in rails by https://github.com/rails/rails/pull/1861, which
-          # should be part of the 3.1 release, at which point we can include
-          # these lines for rails < 3.1.
-          ActiveSupport::TestCase.class_eval do
-            include ActiveRecord::TestFixtures
+          if RSpec.configuration.use_active_record?
+            include Fixtures
+
             self.fixture_path = RSpec.configuration.fixture_path
-          end
-          # /TODO
+            if ::Rails::VERSION::STRING > '5'
+              self.use_transactional_tests = RSpec.configuration.use_transactional_fixtures
+            else
+              self.use_transactional_fixtures = RSpec.configuration.use_transactional_fixtures
+            end
+            self.use_instantiated_fixtures = RSpec.configuration.use_instantiated_fixtures
 
-          self.fixture_path = RSpec.configuration.fixture_path
-          self.use_transactional_fixtures = RSpec.configuration.use_transactional_fixtures
-          self.use_instantiated_fixtures  = RSpec.configuration.use_instantiated_fixtures
-          fixtures RSpec.configuration.global_fixtures if RSpec.configuration.global_fixtures
+            fixtures RSpec.configuration.global_fixtures if RSpec.configuration.global_fixtures
+          end
         end
-      end
 
-      RSpec.configure do |c|
-        c.include RSpec::Rails::FixtureSupport
-        c.add_setting :use_transactional_fixtures, :alias_with => :use_transactional_examples
-        c.add_setting :use_instantiated_fixtures
-        c.add_setting :global_fixtures
-        c.add_setting :fixture_path
+        module Fixtures
+          extend ActiveSupport::Concern
+
+          class_methods do
+            def fixtures(*args)
+              orig_methods = private_instance_methods
+              super.tap do
+                new_methods = private_instance_methods - orig_methods
+                new_methods.each do |method_name|
+                  proxy_method_warning_if_called_in_before_context_scope(method_name)
+                end
+              end
+            end
+
+            def proxy_method_warning_if_called_in_before_context_scope(method_name)
+              orig_implementation = instance_method(method_name)
+              define_method(method_name) do |*args, &blk|
+                if inspect.include?("before(:context)")
+                  RSpec.warn_with("Calling fixture method in before :context ")
+                else
+                  orig_implementation.bind(self).call(*args, &blk)
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/rspec/rails/matchers/action_cable/have_broadcasted_to.rb

@@ -0,0 +1,170 @@
+module RSpec
+  module Rails
+    module Matchers
+      module ActionCable
+        # rubocop: disable Metrics/ClassLength
+        # @private
+        class HaveBroadcastedTo < RSpec::Matchers::BuiltIn::BaseMatcher
+          def initialize(target, channel:)
+            @target = target
+            @channel = channel
+            @block = proc { }
+            @data = nil
+            set_expected_number(:exactly, 1)
+          end
+
+          def with(data = nil, &block)
+            @data = data
+            @data = @data.with_indifferent_access if @data.is_a?(Hash)
+            @block = block if block
+            self
+          end
+
+          def exactly(count)
+            set_expected_number(:exactly, count)
+            self
+          end
+
+          def at_least(count)
+            set_expected_number(:at_least, count)
+            self
+          end
+
+          def at_most(count)
+            set_expected_number(:at_most, count)
+            self
+          end
+
+          def times
+            self
+          end
+
+          def once
+            exactly(:once)
+          end
+
+          def twice
+            exactly(:twice)
+          end
+
+          def thrice
+            exactly(:thrice)
+          end
+
+          def failure_message
+            "expected to broadcast #{base_message}".tap do |msg|
+              if @unmatching_msgs.any?
+                msg << "\nBroadcasted messages to #{stream}:"
+                @unmatching_msgs.each do |data|
+                  msg << "\n   #{data}"
+                end
+              end
+            end
+          end
+
+          def failure_message_when_negated
+            "expected not to broadcast #{base_message}"
+          end
+
+          def message_expectation_modifier
+            case @expectation_type
+            when :exactly then "exactly"
+            when :at_most then "at most"
+            when :at_least then "at least"
+            end
+          end
+
+          def supports_block_expectations?
+            true
+          end
+
+          def matches?(proc)
+            raise ArgumentError, "have_broadcasted_to and broadcast_to only support block expectations" unless Proc === proc
+
+            original_sent_messages_count = pubsub_adapter.broadcasts(stream).size
+            proc.call
+            in_block_messages = pubsub_adapter.broadcasts(stream).drop(original_sent_messages_count)
+
+            check(in_block_messages)
+          end
+
+          def from_channel(channel)
+            @channel = channel
+            self
+          end
+
+        private
+
+          def stream
+            @stream ||= if @target.is_a?(String)
+                          @target
+                        else
+                          check_channel_presence
+                          @channel.broadcasting_for(@target)
+                        end
+          end
+
+          def check(messages)
+            @matching_msgs, @unmatching_msgs = messages.partition do |msg|
+              decoded = ActiveSupport::JSON.decode(msg)
+              decoded = decoded.with_indifferent_access if decoded.is_a?(Hash)
+
+              if @data.nil? || @data === decoded
+                @block.call(decoded)
+                true
+              else
+                false
+              end
+            end
+
+            @matching_msgs_count = @matching_msgs.size
+
+            case @expectation_type
+            when :exactly then @expected_number == @matching_msgs_count
+            when :at_most then @expected_number >= @matching_msgs_count
+            when :at_least then @expected_number <= @matching_msgs_count
+            end
+          end
+
+          def set_expected_number(relativity, count)
+            @expectation_type = relativity
+            @expected_number =
+              case count
+              when :once then 1
+              when :twice then 2
+              when :thrice then 3
+              else Integer(count)
+              end
+          end
+
+          def base_message
+            "#{message_expectation_modifier} #{@expected_number} messages to #{stream}".tap do |msg|
+              msg << " with #{data_description(@data)}" unless @data.nil?
+              msg << ", but broadcast #{@matching_msgs_count}"
+            end
+          end
+
+          def data_description(data)
+            if data.is_a?(RSpec::Matchers::Composable)
+              data.description
+            else
+              data
+            end
+          end
+
+          def pubsub_adapter
+            ::ActionCable.server.pubsub
+          end
+
+          def check_channel_presence
+            return if @channel.present? && @channel.respond_to?(:channel_name)
+
+            error_msg = "Broadcasting channel can't be infered. Please, specify it with `from_channel`"
+            raise ArgumentError, error_msg
+          end
+        end
+        # rubocop: enable Metrics/ClassLength
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/action_cable/have_streams.rb

@@ -0,0 +1,58 @@
+module RSpec
+  module Rails
+    module Matchers
+      module ActionCable
+        # @api private
+        # Provides the implementation for `have_stream`, `have_stream_for`, and `have_stream_from`.
+        # Not intended to be instantiated directly.
+        class HaveStream < RSpec::Matchers::BuiltIn::BaseMatcher
+          # @api private
+          # @return [String]
+          def failure_message
+            "expected to have #{base_message}"
+          end
+
+          # @api private
+          # @return [String]
+          def failure_message_when_negated
+            "expected not to have #{base_message}"
+          end
+
+          # @api private
+          # @return [Boolean]
+          def matches?(subscription)
+            raise(ArgumentError, "have_streams is used for negated expectations only") if no_expected?
+
+            match(subscription)
+          end
+
+          # @api private
+          # @return [Boolean]
+          def does_not_match?(subscription)
+            !match(subscription)
+          end
+
+        private
+
+          def match(subscription)
+            case subscription
+            when ::ActionCable::Channel::Base
+              @actual = subscription.streams
+              no_expected? ? actual.any? : actual.any? { |i| expected === i }
+            else
+              raise ArgumentError, "have_stream, have_stream_from and have_stream_from support expectations on subscription only"
+            end
+          end
+
+          def base_message
+            no_expected? ? "any stream started" : "stream #{expected_formatted} started, but have #{actual_formatted}"
+          end
+
+          def no_expected?
+            !defined?(@expected)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/action_cable.rb

@@ -0,0 +1,65 @@
+require "rspec/rails/matchers/action_cable/have_broadcasted_to"
+
+module RSpec
+  module Rails
+    module Matchers
+      # Namespace for various implementations of ActionCable features
+      #
+      # @api private
+      module ActionCable
+      end
+
+      # @api public
+      # Passes if a message has been sent to a stream/object inside a block.
+      # May chain `at_least`, `at_most` or `exactly` to specify a number of times.
+      # To specify channel from which message has been broadcasted to object use `from_channel`.
+      #
+      #
+      # @example
+      #     expect {
+      #       ActionCable.server.broadcast "messages", text: 'Hi!'
+      #     }.to have_broadcasted_to("messages")
+      #
+      #     expect {
+      #       SomeChannel.broadcast_to(user)
+      #     }.to have_broadcasted_to(user).from_channel(SomeChannel)
+      #
+      #     # Using alias
+      #     expect {
+      #       ActionCable.server.broadcast "messages", text: 'Hi!'
+      #     }.to broadcast_to("messages")
+      #
+      #     expect {
+      #       ActionCable.server.broadcast "messages", text: 'Hi!'
+      #       ActionCable.server.broadcast "all", text: 'Hi!'
+      #     }.to have_broadcasted_to("messages").exactly(:once)
+      #
+      #     expect {
+      #       3.times { ActionCable.server.broadcast "messages", text: 'Hi!' }
+      #     }.to have_broadcasted_to("messages").at_least(2).times
+      #
+      #     expect {
+      #       ActionCable.server.broadcast "messages", text: 'Hi!'
+      #     }.to have_broadcasted_to("messages").at_most(:twice)
+      #
+      #     expect {
+      #       ActionCable.server.broadcast "messages", text: 'Hi!'
+      #     }.to have_broadcasted_to("messages").with(text: 'Hi!')
+      def have_broadcasted_to(target = nil)
+        check_action_cable_adapter
+
+        ActionCable::HaveBroadcastedTo.new(target, channel: described_class)
+      end
+      alias_method :broadcast_to, :have_broadcasted_to
+
+    private
+
+      # @private
+      def check_action_cable_adapter
+        return if ::ActionCable::SubscriptionAdapter::Test === ::ActionCable.server.pubsub
+
+        raise StandardError, "To use ActionCable matchers set `adapter: test` in your cable.yml"
+      end
+    end
+  end
+end

data/lib/rspec/rails/matchers/action_mailbox.rb

@@ -0,0 +1,64 @@
+module RSpec
+  module Rails
+    module Matchers
+      # Namespace for various implementations of ActionMailbox features
+      #
+      # @api private
+      module ActionMailbox
+        # @private
+        class Base < RSpec::Rails::Matchers::BaseMatcher
+          private
+
+          def create_inbound_email(message)
+            RSpec::Rails::MailboxExampleGroup.create_inbound_email(message)
+          end
+        end
+
+        # @private
+        class ReceiveInboundEmail < Base
+          def initialize(message)
+            super()
+
+            @inbound_email = create_inbound_email(message)
+          end
+
+          def matches?(mailbox)
+            @mailbox  = mailbox
+            @receiver = ApplicationMailbox.router.send(:match_to_mailbox, inbound_email)
+
+            @receiver == @mailbox
+          end
+
+          def failure_message
+            "expected #{describe_inbound_email} to route to #{mailbox}".tap do |msg|
+              if receiver
+                msg << ", but routed to #{receiver} instead"
+              end
+            end
+          end
+
+          def failure_message_when_negated
+            "expected #{describe_inbound_email} not to route to #{mailbox}"
+          end
+
+        private
+
+          attr_reader :inbound_email, :mailbox, :receiver
+
+          def describe_inbound_email
+            "mail to #{inbound_email.mail.to.to_sentence}"
+          end
+        end
+      end
+
+      # @api public
+      # Passes if the given inbound email would be routed to the subject inbox.
+      #
+      # @param message [Hash, Mail::Message] a mail message or hash of
+      #   attributes used to build one
+      def receive_inbound_email(message)
+        ActionMailbox::ReceiveInboundEmail.new(message)
+      end
+    end
+  end
+end