rspec-rails 2.14.2 → 4.1.2

data/lib/generators/rspec/view/templates/view_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe "<%= file_path %>/<%= @action %>" do
+RSpec.describe "<%= file_path %>/<%= @action %>", <%= type_metatag(:view) %> do
   pending "add some examples to (or delete) #{__FILE__}"
 end

data/lib/generators/rspec/view/view_generator.rb

@@ -2,10 +2,11 @@ require 'generators/rspec'
 
 module Rspec
   module Generators
+    # @private
     class ViewGenerator < Base
-      argument :actions, :type => :array, :default => [], :banner => "action action"
+      argument :actions, type: :array, default: [], banner: "action action"
 
-      class_option :template_engine, :desc => "Template engine to generate view files"
+      class_option :template_engine, desc: "Template engine to generate view files"
 
       def create_view_specs
         empty_directory File.join("spec", "views", file_path)

data/lib/generators/rspec.rb

@@ -1,30 +1,38 @@
 require 'rails/generators/named_base'
+require 'rspec/rails/feature_check'
 
+# @private
+# Weirdly named generators namespace (should be `RSpec`) for compatability with
+# rails loading.
 module Rspec
+  # @private
   module Generators
+    # @private
     class Base < ::Rails::Generators::NamedBase
-      def self.source_root
-        @_rspec_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'rspec', generator_name, 'templates'))
-      end
+      include RSpec::Rails::FeatureCheck
 
-      if ::Rails::VERSION::STRING < '3.1'
-        def module_namespacing
-          yield if block_given?
+      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
     end
   end
 end
 
+# @private
 module Rails
   module Generators
+    # @private
     class GeneratedAttribute
       def input_type
         @input_type ||= if type == :text
-          "textarea"
-        else
-          "input"
-        end
+                          "textarea"
+                        else
+                          "input"
+                        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

@@ -1,27 +1,36 @@
 require 'delegate'
 require 'active_support'
 require 'active_support/concern'
+require 'active_support/core_ext/string'
 
 module RSpec
   module Rails
-    if ::Rails::VERSION::STRING >= '4.1.0'
+    # @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'
-      require 'minitest/assertions'
-      Assertions = Minitest::Assertions
     else
-      begin
-        require 'test/unit/assertions'
-      rescue LoadError
-        # work around for Rubinius not having a std std-lib
-        require 'rubysl-test-unit' if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-        require 'test/unit/assertions'
-      end
-      Assertions = Test::Unit::Assertions
+      require 'minitest'
     end
+    require 'minitest/assertions'
+    # Constant aliased to either Minitest or TestUnit, depending on what is
+    # loaded.
+    Assertions = Minitest::Assertions
 
-    # @api private
+    # @private
     class AssertionDelegator < Module
-      # @api private
       def initialize(*assertion_modules)
         assertion_class = Class.new(SimpleDelegator) do
           include ::RSpec::Rails::Assertions
@@ -30,12 +39,10 @@ module RSpec
         end
 
         super() do
-          # @api private
           define_method :build_assertion_instance do
             assertion_class.new(self)
           end
 
-          # @api private
           def assertion_instance
             @assertion_instance ||= build_assertion_instance
           end
@@ -43,11 +50,10 @@ module RSpec
           assertion_modules.each do |mod|
             mod.public_instance_methods.each do |method|
               next if method == :method_missing || method == "method_missing"
-              class_eval <<-EOM, __FILE__, __LINE__ + 1
-                def #{method}(*args, &block)
-                  assertion_instance.send(:#{method}, *args, &block)
-                end
-              EOM
+
+              define_method(method.to_sym) do |*args, &block|
+                assertion_instance.send(method.to_sym, *args, &block)
+              end
             end
           end
         end
@@ -56,7 +62,7 @@ module RSpec
 
     # Adapts example groups for `Minitest::Test::LifecycleHooks`
     #
-    # @api private
+    # @private
     module MinitestLifecycleAdapter
       extend ActiveSupport::Concern
 
@@ -84,29 +90,22 @@ module RSpec
       end
     end
 
-    # @api private
+    # @private
     module MinitestCounters
-      # @api private
+      attr_writer :assertions
       def assertions
         @assertions ||= 0
       end
-
-      # @api private
-      def assertions=(assertions)
-        @assertions = assertions
-      end
     end
 
-    # @api private
+    # @private
     module SetupAndTeardownAdapter
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # @api private
-        #
         # Wraps `setup` calls from within Rails' testing framework in `before`
         # hooks.
-        def setup(*methods)
+        def setup(*methods, &block)
           methods.each do |method|
             if method.to_s =~ /^setup_(with_controller|fixtures|controller_request_and_response)$/
               prepend_before { __send__ method }
@@ -114,18 +113,24 @@ module RSpec
               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)
+        def teardown(*methods, &block)
           methods.each { |method| after { __send__ method } }
+          after(&block) if block
         end
       end
 
-      # @api private
+      def initialize(*args)
+        super
+        @example = nil
+      end
+
       def method_name
         @example
       end
@@ -135,36 +140,33 @@ module RSpec
     module MinitestAssertionAdapter
       extend ActiveSupport::Concern
 
+      # @private
       module ClassMethods
-        # @api private
-        #
         # 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{|m| m.to_s =~ /^(assert|flunk|refute)/} +
-            [:build_message]
+          ::RSpec::Rails::Assertions
+            .public_instance_methods
+            .select do |m|
+              m.to_s =~ /^(assert|flunk|refute)/
+            end
         end
 
-        # @api private
         def define_assertion_delegators
           assertion_method_names.each do |m|
-            class_eval <<-CODE, __FILE__, __LINE__ + 1
-              def #{m}(*args, &block)
-                assertion_delegator.send :#{m}, *args, &block
-              end
-            CODE
+            define_method(m.to_sym) do |*args, &block|
+              assertion_delegator.send(m.to_sym, *args, &block)
+            end
           end
         end
       end
 
-      # @api private
       class AssertionDelegator
         include ::RSpec::Rails::Assertions
         include ::RSpec::Rails::MinitestCounters
       end
 
-      # @api private
       def assertion_delegator
         @assertion_delegator ||= AssertionDelegator.new
       end
@@ -177,7 +179,7 @@ module RSpec
     # Backwards compatibility. It's unlikely that anyone is using this
     # constant, but we had forgotten to mark it as `@private` earlier
     #
-    # @api private
+    # @private
     TestUnitAssertionAdapter = MinitestAssertionAdapter
   end
 end

data/lib/rspec/rails/configuration.rb

@@ -0,0 +1,194 @@
+# 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],
+      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
+      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
+      config.add_setting :fixture_path
+      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
+
+      if ::Rails::VERSION::STRING > '5'
+        config.add_setting :file_fixture_path, default: 'spec/fixtures/files'
+        config.include RSpec::Rails::FileFixtureSupport
+      end
+
+      # 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
+      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