rspec-rails 1.3.2 → 6.1.2

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

@@ -0,0 +1,172 @@
+module RSpec
+  module Rails
+    # @api public
+    # Container class for system tests
+    module SystemExampleGroup
+      extend ActiveSupport::Concern
+      include RSpec::Rails::RailsExampleGroup
+      include RSpec::Rails::Matchers::RedirectTo
+      include RSpec::Rails::Matchers::RenderTemplate
+      include ActionDispatch::Integration::Runner
+      include ActionDispatch::Assertions
+      include ActionController::TemplateAssertions
+
+      # Special characters to translate into underscores for #method_name
+      CHARS_TO_TRANSLATE = ['/', '.', ':', ',', "'", '"', " "].freeze
+
+      # @private
+      module BlowAwayTeardownHooks
+        # @private
+        def before_teardown
+        end
+
+        # @private
+        def after_teardown
+        end
+      end
+
+      # for the SystemTesting Screenshot situation
+      def passed?
+        return false if RSpec.current_example.exception
+        return true unless defined?(::RSpec::Expectations::FailureAggregator)
+
+        failure_notifier = ::RSpec::Support.failure_notifier
+        return true unless failure_notifier.is_a?(::RSpec::Expectations::FailureAggregator)
+
+        failure_notifier.failures.empty? && failure_notifier.other_errors.empty?
+      end
+
+      # @private
+      def method_name
+        @method_name ||= [
+          self.class.name.underscore,
+          RSpec.current_example.description.underscore
+        ].join("_").tr(CHARS_TO_TRANSLATE.join, "_").byteslice(0...200).scrub("") + "_#{rand(1000)}"
+      end
+
+      if ::Rails::VERSION::STRING.to_f >= 7.1
+        # @private
+        # Allows failure screenshot to work whilst not exposing metadata
+        class SuppressRailsScreenshotMetadata
+          def initialize
+            @example_data = {}
+          end
+
+          def [](key)
+            if @example_data.key?(key)
+              @example_data[key]
+            else
+              raise_wrong_scope_error
+            end
+          end
+
+          def []=(key, value)
+            if key == :failure_screenshot_path
+              @example_data[key] = value
+            else
+              raise_wrong_scope_error
+            end
+          end
+
+          def method_missing(_name, *_args, &_block)
+            raise_wrong_scope_error
+          end
+
+          private
+
+          def raise_wrong_scope_error
+            raise RSpec::Core::ExampleGroup::WrongScopeError,
+                  "`metadata` is not available from within an example " \
+                  "(e.g. an `it` block) or from constructs that run in the " \
+                  "scope of an example (e.g. `before`, `let`, etc). It is " \
+                  "only available on an example group (e.g. a `describe` or "\
+                  "`context` block)"
+          end
+        end
+
+        # @private
+        def metadata
+          @metadata ||= SuppressRailsScreenshotMetadata.new
+        end
+      end
+
+      # Delegates to `Rails.application`.
+      def app
+        ::Rails.application
+      end
+
+      included do |other|
+        ActiveSupport.on_load(:action_dispatch_system_test_case) do
+          ActionDispatch::SystemTesting::Server.silence_puma = true
+        end
+
+        require 'action_dispatch/system_test_case'
+
+        begin
+          require 'capybara'
+        rescue LoadError => e
+          abort """
+            LoadError: #{e.message}
+            System test integration has a hard
+            dependency on a webserver and `capybara`, please add capybara to
+            your Gemfile and configure a webserver (e.g. `Capybara.server =
+            :puma`) before attempting to use system specs.
+          """.gsub(/\s+/, ' ').strip
+        end
+
+        original_before_teardown =
+          ::ActionDispatch::SystemTesting::TestHelpers::SetupAndTeardown.instance_method(:before_teardown)
+
+        original_after_teardown =
+          ::ActionDispatch::SystemTesting::TestHelpers::SetupAndTeardown.instance_method(:after_teardown)
+
+        other.include ::ActionDispatch::SystemTesting::TestHelpers::SetupAndTeardown
+        other.include ::ActionDispatch::SystemTesting::TestHelpers::ScreenshotHelper
+        other.include BlowAwayTeardownHooks
+
+        attr_reader :driver
+
+        if ActionDispatch::SystemTesting::Server.respond_to?(:silence_puma=)
+          ActionDispatch::SystemTesting::Server.silence_puma = true
+        end
+
+        def initialize(*args, &blk)
+          super(*args, &blk)
+          @driver = nil
+
+          self.class.before do
+            # A user may have already set the driver, so only default if driver
+            # is not set
+            driven_by(:selenium) unless @driver
+          end
+        end
+
+        def driven_by(driver, **driver_options, &blk)
+          @driver = ::ActionDispatch::SystemTestCase.driven_by(driver, **driver_options, &blk).tap(&:use)
+        end
+
+        before do
+          @routes = ::Rails.application.routes
+        end
+
+        after do
+          orig_stdout = $stdout
+          $stdout = StringIO.new
+          begin
+            original_before_teardown.bind(self).call
+          ensure
+            myio = $stdout
+            myio.rewind
+            RSpec.current_example.metadata[:extra_failure_lines] = myio.readlines
+            $stdout = orig_stdout
+          end
+        end
+
+        around do |example|
+          example.run
+          original_after_teardown.bind(self).call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+require 'rspec/rails/view_assigns'
+require 'rspec/rails/view_spec_methods'
+require 'rspec/rails/view_path_builder'
+
+module RSpec
+  module Rails
+    # @api public
+    # Container class for view spec functionality.
+    module ViewExampleGroup
+      extend ActiveSupport::Concern
+      include RSpec::Rails::RailsExampleGroup
+      include ActionView::TestCase::Behavior
+      include RSpec::Rails::ViewAssigns
+      include RSpec::Rails::Matchers::RenderTemplate
+
+      # @private
+      module StubResolverCache
+        def self.resolver_for(hash)
+          @resolvers ||= {}
+          @resolvers[hash] ||= ActionView::FixtureResolver.new(hash)
+        end
+      end
+
+      # @private
+      module ClassMethods
+        def _default_helper
+          base = metadata[:description].split('/')[0..-2].join('/')
+          (base.camelize + 'Helper').constantize unless base.to_s.empty?
+        rescue NameError
+          nil
+        end
+
+        def _default_helpers
+          helpers = [_default_helper].compact
+          helpers << ApplicationHelper if Object.const_defined?('ApplicationHelper')
+          helpers
+        end
+      end
+
+      # DSL exposed to view specs.
+      module ExampleMethods
+        extend ActiveSupport::Concern
+
+        included do
+          include ::Rails.application.routes.url_helpers
+          include ::Rails.application.routes.mounted_helpers
+        end
+
+        # @overload render
+        # @overload render({partial: path_to_file})
+        # @overload render({partial: path_to_file}, {... locals ...})
+        # @overload render({partial: path_to_file}, {... locals ...}) do ... end
+        #
+        # Delegates to ActionView::Base#render, so see documentation on that
+        # for more info.
+        #
+        # The only addition is that you can call render with no arguments, and
+        # RSpec will pass the top level description to render:
+        #
+        #     describe "widgets/new.html.erb" do
+        #       it "shows all the widgets" do
+        #         render # => view.render(file: "widgets/new.html.erb")
+        #         # ...
+        #       end
+        #     end
+        def render(options = {}, local_assigns = {}, &block)
+          options = _default_render_options if Hash === options && options.empty?
+          options = options.merge(_default_render_options) if Hash === options && options.keys == [:locals]
+          super(options, local_assigns, &block)
+        end
+
+        # The instance of `ActionView::Base` that is used to render the template.
+        # Use this to stub methods _before_ calling `render`.
+        #
+        #     describe "widgets/new.html.erb" do
+        #       it "shows all the widgets" do
+        #         view.stub(:foo) { "foo" }
+        #         render
+        #         # ...
+        #       end
+        #     end
+        def view
+          _view
+        end
+
+        # Simulates the presence of a template on the file system by adding a
+        # Rails' FixtureResolver to the front of the view_paths list. Designed to
+        # help isolate view examples from partials rendered by the view template
+        # that is the subject of the example.
+        #
+        #     stub_template("widgets/_widget.html.erb" => "This content.")
+        def stub_template(hash)
+          controller.prepend_view_path(StubResolverCache.resolver_for(hash))
+        end
+
+        # Provides access to the params hash that will be available within the
+        # view.
+        #
+        #     params[:foo] = 'bar'
+        def params
+          controller.params
+        end
+
+        # @deprecated Use `view` instead.
+        def template
+          RSpec.deprecate("template", replacement: "view")
+          view
+        end
+
+        # @deprecated Use `rendered` instead.
+        def response
+          # `assert_template` expects `response` to implement a #body method
+          # like an `ActionDispatch::Response` does to force the view to
+          # render. For backwards compatibility, we use #response as an alias
+          # for #rendered, but it needs to implement #body to avoid
+          # `assert_template` raising a `NoMethodError`.
+          unless rendered.respond_to?(:body)
+            def rendered.body
+              self
+            end
+          end
+
+          rendered
+        end
+
+      private
+
+        def _default_render_options
+          formats = if ActionView::Template::Types.respond_to?(:symbols)
+                      ActionView::Template::Types.symbols
+                    else
+                      [:html, :text, :js, :css, :xml, :json].map(&:to_s)
+                    end.map { |x| Regexp.escape(x) }.join("|")
+
+          handlers = ActionView::Template::Handlers.extensions.map { |x| Regexp.escape(x) }.join("|")
+          locales = "[a-z]{2}(?:-[A-Z]{2})?"
+          variants = "[^.]*"
+          path_regex = %r{
+          \A
+          (?<template>.*?)
+          (?:\.(?<locale>#{locales}))??
+            (?:\.(?<format>#{formats}))??
+            (?:\+(?<variant>#{variants}))??
+            (?:\.(?<handler>#{handlers}))?
+            \z
+          }x
+
+          # This regex should always find a match.
+          # Worst case, everything will be nil, and :template will just be
+          # the original string.
+          match = path_regex.match(_default_file_to_render)
+
+          render_options = { template: match[:template] }
+          render_options[:handlers] = [match[:handler].to_sym] if match[:handler]
+          render_options[:formats] = [match[:format].to_sym] if match[:format]
+          render_options[:locales] = [match[:locale].to_sym] if match[:locale]
+          render_options[:variants] = [match[:variant].to_sym] if match[:variant]
+
+          render_options
+        end
+
+        def _path_parts
+          _default_file_to_render.split("/")
+        end
+
+        def _controller_path
+          _path_parts[0..-2].join("/")
+        end
+
+        def _inferred_action
+          _path_parts.last.split(".").first
+        end
+
+        def _include_controller_helpers
+          helpers = controller._helpers
+          view.singleton_class.class_exec do
+            include helpers unless included_modules.include?(helpers)
+          end
+        end
+      end
+
+      included do
+        include ExampleMethods
+
+        helper(*_default_helpers)
+
+        before do
+          _include_controller_helpers
+          view.lookup_context.prefixes << _controller_path
+
+          controller.controller_path = _controller_path
+
+          path_params_to_merge = {}
+          path_params_to_merge[:controller] = _controller_path
+          path_params_to_merge[:action] = _inferred_action unless _inferred_action =~ /^_/
+
+          path_params = controller.request.path_parameters
+
+          controller.request.path_parameters = path_params.reverse_merge(path_params_to_merge)
+          controller.request.path = ViewPathBuilder.new(::Rails.application.routes).path_for(controller.request.path_parameters)
+          ViewSpecMethods.add_to(::ActionView::TestCase::TestController)
+        end
+
+        after do
+          ViewSpecMethods.remove_from(::ActionView::TestCase::TestController)
+        end
+
+        let(:_default_file_to_render) do |example|
+          example.example_group.top_level_description
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/example.rb

@@ -0,0 +1,13 @@
+require 'rspec/rails/example/rails_example_group'
+require 'rspec/rails/example/controller_example_group'
+require 'rspec/rails/example/request_example_group'
+require 'rspec/rails/example/helper_example_group'
+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'
+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

@@ -0,0 +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.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

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

data/lib/rspec/rails/feature_check.rb

@@ -0,0 +1,51 @@
+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)
+      end
+
+      def has_action_mailer_parameterized?
+        has_action_mailer? && defined?(::ActionMailer::Parameterized::DeliveryJob)
+      end
+
+      def has_action_mailer_unified_delivery?
+        has_action_mailer? && defined?(::ActionMailer::MailDeliveryJob)
+      end
+
+      def has_action_mailer_legacy_delivery_job?
+        defined?(ActionMailer::DeliveryJob)
+      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,18 @@
+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
+        if defined?(ActiveStorage::FixtureSet)
+          ActiveStorage::FixtureSet.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,45 @@
+module RSpec
+  module Rails
+    # @private
+    module FixtureFileUploadSupport
+      delegate :fixture_file_upload, to: :rails_fixture_file_wrapper
+
+    private
+
+      # In Rails 7.0 fixture file path needs to be relative to `file_fixture_path` instead, this change
+      # was brought in with a deprecation warning on 6.1. In Rails 7.0 expect to rework this to remove
+      # the old accessor.
+      def rails_fixture_file_wrapper
+        RailsFixtureFileWrapper.file_fixture_path = nil
+        resolved_fixture_path =
+          if respond_to?(:file_fixture_path) && !file_fixture_path.nil?
+            file_fixture_path.to_s
+          elsif respond_to?(:fixture_paths)
+            (RSpec.configuration.fixture_paths&.first || '').to_s
+          else
+            (RSpec.configuration.fixture_path || '').to_s
+          end
+        RailsFixtureFileWrapper.file_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)
+        include ActiveSupport::Testing::FileFixtures
+
+        class << self
+          if ::Rails::VERSION::STRING < "7.1.0"
+            attr_accessor :fixture_path
+          else
+            attr_accessor :fixture_paths
+          end
+
+          # Get instance of wrapper
+          def instance
+            @instance ||= new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails/fixture_support.rb

@@ -0,0 +1,89 @@
+module RSpec
+  module Rails
+    # @private
+    module FixtureSupport
+      if defined?(ActiveRecord::TestFixtures)
+        extend ActiveSupport::Concern
+        include RSpec::Rails::SetupAndTeardownAdapter
+        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.
+        def run_in_transaction?
+          current_example_name = (RSpec.current_example && RSpec.current_example.metadata[:description])
+          use_transactional_tests && !self.class.uses_transaction?(current_example_name)
+        end
+
+        included do
+          if RSpec.configuration.use_active_record?
+            include Fixtures
+
+            # TestFixtures#fixture_path is deprecated and will be removed in Rails 7.2
+            if respond_to?(:fixture_paths=)
+              self.fixture_paths = RSpec.configuration.fixture_paths
+            else
+              self.fixture_path = RSpec.configuration.fixture_path
+            end
+
+            self.use_transactional_tests = RSpec.configuration.use_transactional_fixtures
+            self.use_instantiated_fixtures = RSpec.configuration.use_instantiated_fixtures
+
+            fixtures RSpec.configuration.global_fixtures if RSpec.configuration.global_fixtures
+          end
+        end
+
+        module Fixtures
+          extend ActiveSupport::Concern
+
+          # rubocop:disable Metrics/BlockLength
+          class_methods do
+            if ::Rails.version.to_f >= 7.1
+              def fixtures(*args)
+                super.tap do
+                  fixture_sets.each_pair do |method_name, fixture_name|
+                    proxy_method_warning_if_called_in_before_context_scope(method_name, fixture_name)
+                  end
+                end
+              end
+
+              def proxy_method_warning_if_called_in_before_context_scope(method_name, fixture_name)
+                define_method(method_name) do |*args, **kwargs, &blk|
+                  if RSpec.current_scope == :before_context_hook
+                    RSpec.warn_with("Calling fixture method in before :context ")
+                  else
+                    access_fixture(fixture_name, *args, **kwargs, &blk)
+                  end
+                end
+              end
+            else
+              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 RSpec.current_scope == :before_context_hook
+                    RSpec.warn_with("Calling fixture method in before :context ")
+                  else
+                    orig_implementation.bind(self).call(*args, &blk)
+                  end
+                end
+              end
+            end
+          end
+          # rubocop:enable Metrics/BlockLength
+        end
+      end
+    end
+  end
+end