rspec-rails 1.3.2 → 7.0.2

data/lib/generators/rspec.rb

@@ -0,0 +1,56 @@
+require 'rails/generators/named_base'
+require 'rspec/core'
+require 'rspec/rails/feature_check'
+
+# @private
+# Weirdly named generators namespace (should be `RSpec`) for compatibility with
+# rails loading.
+module Rspec
+  # @private
+  module Generators
+    # @private
+    class Base < ::Rails::Generators::NamedBase
+      include RSpec::Rails::FeatureCheck
+
+      def self.source_root(path = nil)
+        if path
+          @_rspec_source_root = path
+        else
+          @_rspec_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'rspec', generator_name, 'templates'))
+        end
+      end
+
+      # @private
+      # Load configuration from RSpec to ensure `--default-path` is set
+      def self.configuration
+        @configuration ||=
+          begin
+            configuration = RSpec.configuration
+            options = RSpec::Core::ConfigurationOptions.new({})
+            options.configure(configuration)
+            configuration
+          end
+      end
+
+      def target_path(*paths)
+        File.join(self.class.configuration.default_path, *paths)
+      end
+    end
+  end
+end
+
+# @private
+module Rails
+  module Generators
+    # @private
+    class GeneratedAttribute
+      def input_type
+        @input_type ||= if type == :text
+                          "textarea"
+                        else
+                          "input"
+                        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/active_record.rb

@@ -0,0 +1,25 @@
+module RSpec
+  module Rails
+    # Fake class to document RSpec ActiveRecord configuration options. In practice,
+    # these are dynamically added to the normal RSpec configuration object.
+    class ActiveRecordConfiguration
+      # @private
+      def self.initialize_activerecord_configuration(config)
+        config.before :suite do
+          # This allows dynamic columns etc to be used on ActiveRecord models when creating instance_doubles
+          if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && defined?(::RSpec::Mocks) && (::RSpec::Mocks.respond_to?(:configuration))
+            ::RSpec::Mocks.configuration.when_declaring_verifying_double do |possible_model|
+              target = possible_model.target
+
+              if Class === target && ActiveRecord::Base > target && !target.abstract_class?
+                target.define_attribute_methods
+              end
+            end
+          end
+        end
+      end
+
+      initialize_activerecord_configuration RSpec.configuration
+    end
+  end
+end

data/lib/rspec/rails/adapters.rb

@@ -0,0 +1,196 @@
+require 'delegate'
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/string'
+
+module RSpec
+  module Rails
+    # @private
+    def self.disable_testunit_autorun
+      # `Test::Unit::AutoRunner.need_auto_run=` was introduced to the test-unit
+      # gem in version 2.4.9. Previous to this version `Test::Unit.run=` was
+      # used. The implementation of test-unit included with Ruby has neither
+      # method.
+      if defined?(Test::Unit::AutoRunner.need_auto_run = ())
+        Test::Unit::AutoRunner.need_auto_run = false
+      elsif defined?(Test::Unit.run = ())
+        Test::Unit.run = false
+      end
+    end
+    private_class_method :disable_testunit_autorun
+
+    if defined?(Kernel.gem)
+      gem 'minitest'
+    else
+      require 'minitest'
+    end
+    require 'minitest/assertions'
+    # Constant aliased to either Minitest or TestUnit, depending on what is
+    # loaded.
+    Assertions = Minitest::Assertions
+
+    # @private
+    class AssertionDelegator < Module
+      def initialize(*assertion_modules)
+        assertion_class = Class.new(SimpleDelegator) do
+          include ::RSpec::Rails::Assertions
+          include ::RSpec::Rails::MinitestCounters
+          assertion_modules.each { |mod| include mod }
+        end
+
+        super() do
+          define_method :build_assertion_instance do
+            assertion_class.new(self)
+          end
+
+          def assertion_instance
+            @assertion_instance ||= build_assertion_instance
+          end
+
+          assertion_modules.each do |mod|
+            mod.public_instance_methods.each do |method|
+              next if method == :method_missing || method == "method_missing"
+
+              define_method(method.to_sym) do |*args, &block|
+                assertion_instance.send(method.to_sym, *args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Adapts example groups for `Minitest::Test::LifecycleHooks`
+    #
+    # @private
+    module MinitestLifecycleAdapter
+      extend ActiveSupport::Concern
+
+      included do |group|
+        group.before { after_setup }
+        group.after  { before_teardown }
+
+        group.around do |example|
+          before_setup
+          example.run
+          after_teardown
+        end
+      end
+
+      def before_setup
+      end
+
+      def after_setup
+      end
+
+      def before_teardown
+      end
+
+      def after_teardown
+      end
+    end
+
+    # @private
+    module MinitestCounters
+      attr_writer :assertions
+      def assertions
+        @assertions ||= 0
+      end
+    end
+
+    # @private
+    module SetupAndTeardownAdapter
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Wraps `setup` calls from within Rails' testing framework in `before`
+        # hooks.
+        def setup(*methods, &block)
+          methods.each do |method|
+            if method.to_s =~ /^setup_(with_controller|fixtures|controller_request_and_response)$/
+              prepend_before { __send__ method }
+            else
+              before         { __send__ method }
+            end
+          end
+          before(&block) if block
+        end
+
+        # @api private
+        #
+        # Wraps `teardown` calls from within Rails' testing framework in
+        # `after` hooks.
+        def teardown(*methods, &block)
+          methods.each { |method| after { __send__ method } }
+          after(&block) if block
+        end
+      end
+
+      def initialize(*args)
+        super
+        @example = nil
+      end
+
+      def method_name
+        @example
+      end
+    end
+
+    # @private
+    module MinitestAssertionAdapter
+      extend ActiveSupport::Concern
+
+      # @private
+      module ClassMethods
+        # Returns the names of assertion methods that we want to expose to
+        # examples without exposing non-assertion methods in Test::Unit or
+        # Minitest.
+        def assertion_method_names
+          ::RSpec::Rails::Assertions
+            .public_instance_methods
+            .select do |m|
+              m.to_s =~ /^(assert|flunk|refute)/
+            end
+        end
+
+        def define_assertion_delegators
+          assertion_method_names.each do |m|
+            define_method(m.to_sym) do |*args, &block|
+              assertion_delegator.send(m.to_sym, *args, &block)
+            end
+          end
+        end
+      end
+
+      class AssertionDelegator
+        include ::RSpec::Rails::Assertions
+        include ::RSpec::Rails::MinitestCounters
+      end
+
+      def assertion_delegator
+        @assertion_delegator ||= AssertionDelegator.new
+      end
+
+      included do
+        define_assertion_delegators
+      end
+    end
+
+    # Backwards compatibility. It's unlikely that anyone is using this
+    # constant, but we had forgotten to mark it as `@private` earlier
+    #
+    # @private
+    TestUnitAssertionAdapter = MinitestAssertionAdapter
+
+    # @private
+    module TaggedLoggingAdapter
+      private
+      # Vendored from activesupport/lib/active_support/testing/tagged_logging.rb
+      # This implements the tagged_logger method where it is expected, but
+      # doesn't call `name` or set it up like Rails does.
+      def tagged_logger
+        @tagged_logger ||= (defined?(Rails.logger) && Rails.logger)
+      end
+    end
+  end
+end

data/lib/rspec/rails/configuration.rb

@@ -0,0 +1,222 @@
+# rubocop: disable Metrics/ModuleLength
+module RSpec
+  module Rails
+    # Fake class to document RSpec Rails configuration options. In practice,
+    # these are dynamically added to the normal RSpec configuration object.
+    class Configuration
+      # @!method infer_spec_type_from_file_location!
+      # Automatically tag specs in conventional directories with matching `type`
+      # metadata so that they have relevant helpers available to them. See
+      # `RSpec::Rails::DIRECTORY_MAPPINGS` for details on which metadata is
+      # applied to each directory.
+
+      # @!method render_views=(val)
+      #
+      # When set to `true`, controller specs will render the relevant view as
+      # well. Defaults to `false`.
+
+      # @!method render_views(val)
+      # Enables view rendering for controllers specs.
+
+      # @!method render_views?
+      # Reader for currently value of `render_views` setting.
+    end
+
+    # Mappings used by `infer_spec_type_from_file_location!`.
+    #
+    # @api private
+    DIRECTORY_MAPPINGS = {
+      channel: %w[spec channels],
+      controller: %w[spec controllers],
+      generator: %w[spec generator],
+      helper: %w[spec helpers],
+      job: %w[spec jobs],
+      mailer: %w[spec mailers],
+      model: %w[spec models],
+      request: %w[spec (requests|integration|api)],
+      routing: %w[spec routing],
+      view: %w[spec views],
+      feature: %w[spec features],
+      system: %w[spec system],
+      mailbox: %w[spec mailboxes]
+    }
+
+    # Sets up the different example group modules for the different spec types
+    #
+    # @api private
+    def self.add_test_type_configurations(config)
+      config.include RSpec::Rails::ControllerExampleGroup, type: :controller
+      config.include RSpec::Rails::HelperExampleGroup,     type: :helper
+      config.include RSpec::Rails::ModelExampleGroup,      type: :model
+      config.include RSpec::Rails::RequestExampleGroup,    type: :request
+      config.include RSpec::Rails::RoutingExampleGroup,    type: :routing
+      config.include RSpec::Rails::ViewExampleGroup,       type: :view
+      config.include RSpec::Rails::FeatureExampleGroup,    type: :feature
+      config.include RSpec::Rails::Matchers
+      config.include RSpec::Rails::SystemExampleGroup, type: :system
+    end
+
+    # @private
+    def self.initialize_configuration(config) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
+      config.backtrace_exclusion_patterns << /vendor\//
+      config.backtrace_exclusion_patterns << %r{lib/rspec/rails}
+
+      # controller settings
+      config.add_setting :infer_base_class_for_anonymous_controllers, default: true
+
+      # fixture support
+      config.add_setting :use_active_record, default: true
+      config.add_setting :use_transactional_fixtures, alias_with: :use_transactional_examples
+      config.add_setting :use_instantiated_fixtures
+      config.add_setting :global_fixtures
+
+      if ::Rails::VERSION::STRING < "7.1.0"
+        config.add_setting :fixture_path
+      else
+        config.add_setting :fixture_paths
+      end
+
+      config.include RSpec::Rails::FixtureSupport, :use_fixtures
+
+      # We'll need to create a deprecated module in order to properly report to
+      # gems / projects which are relying on this being loaded globally.
+      #
+      # See rspec/rspec-rails#1355 for history
+      #
+      # @deprecated Include `RSpec::Rails::RailsExampleGroup` or
+      #   `RSpec::Rails::FixtureSupport` directly instead
+      config.include RSpec::Rails::FixtureSupport
+
+      config.add_setting :file_fixture_path, default: 'spec/fixtures/files'
+      config.include RSpec::Rails::FileFixtureSupport
+
+      # Add support for fixture_path on fixture_file_upload
+      config.include RSpec::Rails::FixtureFileUploadSupport
+
+      # This allows us to expose `render_views` as a config option even though it
+      # breaks the convention of other options by using `render_views` as a
+      # command (i.e. `render_views = true`), where it would normally be used
+      # as a getter. This makes it easier for rspec-rails users because we use
+      # `render_views` directly in example groups, so this aligns the two APIs,
+      # but requires this workaround:
+      config.add_setting :rendering_views, default: false
+
+      config.instance_exec do
+        def render_views=(val)
+          self.rendering_views = val
+        end
+
+        def render_views
+          self.rendering_views = true
+        end
+
+        def render_views?
+          rendering_views?
+        end
+
+        undef :rendering_views? if respond_to?(:rendering_views?)
+        def rendering_views?
+          !!rendering_views
+        end
+
+        # Define boolean predicates rather than relying on rspec-core due
+        # to the bug fix in rspec/rspec-core#2736, note some of these
+        # predicates are a bit nonsensical, but they exist for backwards
+        # compatibility, we can tidy these up in `rspec-rails` 5.
+        undef :fixture_path? if respond_to?(:fixture_path?)
+        def fixture_path?
+          !!fixture_path
+        end
+
+        undef :global_fixtures? if respond_to?(:global_fixtures?)
+        def global_fixtures?
+          !!global_fixtures
+        end
+
+        undef :infer_base_class_for_anonymous_controllers? if respond_to?(:infer_base_class_for_anonymous_controllers?)
+        def infer_base_class_for_anonymous_controllers?
+          !!infer_base_class_for_anonymous_controllers
+        end
+
+        undef :use_instantiated_fixtures? if respond_to?(:use_instantiated_fixtures?)
+        def use_instantiated_fixtures?
+          !!use_instantiated_fixtures
+        end
+
+        undef :use_transactional_fixtures? if respond_to?(:use_transactional_fixtures?)
+        def use_transactional_fixtures?
+          !!use_transactional_fixtures
+        end
+
+        def infer_spec_type_from_file_location!
+          DIRECTORY_MAPPINGS.each do |type, dir_parts|
+            escaped_path = Regexp.compile(dir_parts.join('[\\\/]') + '[\\\/]')
+            define_derived_metadata(file_path: escaped_path) do |metadata|
+              metadata[:type] ||= type
+            end
+          end
+        end
+
+        # Adds exclusion filters for gems included with Rails
+        def filter_rails_from_backtrace!
+          filter_gems_from_backtrace "actionmailer", "actionpack", "actionview"
+          filter_gems_from_backtrace "activemodel", "activerecord",
+                                     "activesupport", "activejob"
+        end
+
+        # @deprecated TestFixtures#fixture_path is deprecated and will be removed in Rails 7.2
+        if ::Rails::VERSION::STRING >= "7.1.0"
+          def fixture_path
+            RSpec.deprecate(
+              "config.fixture_path",
+              replacement: "config.fixture_paths",
+              message: "Rails 7.1 has deprecated the singular fixture_path in favour of an array." \
+              "You should migrate to plural:"
+            )
+            fixture_paths&.first
+          end
+
+          def fixture_path=(path)
+            RSpec.deprecate(
+              "config.fixture_path = #{path.inspect}",
+              replacement: "config.fixture_paths = [#{path.inspect}]",
+              message: "Rails 7.1 has deprecated the singular fixture_path in favour of an array." \
+              "You should migrate to plural:"
+            )
+            self.fixture_paths = Array(path)
+          end
+        end
+      end
+
+      add_test_type_configurations(config)
+
+      if defined?(::Rails::Controller::Testing)
+        [:controller, :view, :request].each do |type|
+          config.include ::Rails::Controller::Testing::TestProcess, type: type
+          config.include ::Rails::Controller::Testing::TemplateAssertions, type: type
+          config.include ::Rails::Controller::Testing::Integration, type: type
+        end
+      end
+
+      if RSpec::Rails::FeatureCheck.has_action_mailer?
+        config.include RSpec::Rails::MailerExampleGroup, type: :mailer
+        config.after { ActionMailer::Base.deliveries.clear }
+      end
+
+      if RSpec::Rails::FeatureCheck.has_active_job?
+        config.include RSpec::Rails::JobExampleGroup, type: :job
+      end
+
+      if RSpec::Rails::FeatureCheck.has_action_cable_testing?
+        config.include RSpec::Rails::ChannelExampleGroup, type: :channel
+      end
+
+      if RSpec::Rails::FeatureCheck.has_action_mailbox?
+        config.include RSpec::Rails::MailboxExampleGroup, type: :mailbox
+      end
+    end
+
+    initialize_configuration RSpec.configuration
+  end
+end
+# rubocop: enable Metrics/ModuleLength

data/lib/rspec/rails/example/channel_example_group.rb

@@ -0,0 +1,93 @@
+require "rspec/rails/matchers/action_cable/have_streams"
+
+module RSpec
+  module Rails
+    # @api public
+    # Container module for channel spec functionality. It is only available if
+    # ActionCable has been loaded before it.
+    module ChannelExampleGroup
+      # @private
+      module ClassMethods
+        # These blank modules are only necessary for YARD processing. It doesn't
+        # handle the conditional check below very well and reports undocumented objects.
+      end
+    end
+  end
+end
+
+if RSpec::Rails::FeatureCheck.has_action_cable_testing?
+  module RSpec
+    module Rails
+      # @api public
+      # Container module for channel spec functionality.
+      module ChannelExampleGroup
+        extend ActiveSupport::Concern
+        include RSpec::Rails::RailsExampleGroup
+        include ActionCable::Connection::TestCase::Behavior
+        include ActionCable::Channel::TestCase::Behavior
+
+        # Class-level DSL for channel specs.
+        module ClassMethods
+          # @private
+          def channel_class
+            (_channel_class || described_class).tap do |klass|
+              next if klass <= ::ActionCable::Channel::Base
+
+              raise "Described class is not a channel class.\n" \
+                    "Specify the channel class in the `describe` statement " \
+                    "or set it manually using `tests MyChannelClass`"
+            end
+          end
+
+          # @private
+          def connection_class
+            (_connection_class || described_class).tap do |klass|
+              next if klass <= ::ActionCable::Connection::Base
+
+              raise "Described class is not a connection class.\n" \
+                    "Specify the connection class in the `describe` statement " \
+                    "or set it manually using `tests MyConnectionClass`"
+            end
+          end
+        end
+
+        # Checks that the connection attempt has been rejected.
+        #
+        # @example
+        #     expect { connect }.to have_rejected_connection
+        def have_rejected_connection
+          raise_error(::ActionCable::Connection::Authorization::UnauthorizedError)
+        end
+
+        # Checks that the subscription is subscribed to at least one stream.
+        #
+        # @example
+        #     expect(subscription).to have_streams
+        def have_streams
+          check_subscribed!
+
+          RSpec::Rails::Matchers::ActionCable::HaveStream.new
+        end
+
+        # Checks that the channel has been subscribed to the given stream
+        #
+        # @example
+        #     expect(subscription).to have_stream_from("chat_1")
+        def have_stream_from(stream)
+          check_subscribed!
+
+          RSpec::Rails::Matchers::ActionCable::HaveStream.new(stream)
+        end
+
+        # Checks that the channel has been subscribed to a stream for the given model
+        #
+        # @example
+        #     expect(subscription).to have_stream_for(user)
+        def have_stream_for(object)
+          check_subscribed!
+          RSpec::Rails::Matchers::ActionCable::HaveStream.new(broadcasting_for(object))
+        end
+      end
+    end
+  end
+end