rspec-rails 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/rails/configuration_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe "configuration" do
-  before do
-    @orig_render_views = RSpec.configuration.render_views?
-  end
-
-  after do
-    RSpec.configuration.render_views = @orig_render_views
-  end
-
-  describe "#render_views?" do
-    it "is false by default" do
-      expect(RSpec.configuration.render_views?).to be_falsey
-    end
-  end
-
-  describe "#render_views" do
-    it "sets render_views? to return true" do
-      RSpec.configuration.render_views = false
-      RSpec.configuration.render_views
-
-      expect(RSpec.configuration.render_views?).to be_truthy
-    end
-  end
-end

data/spec/rspec/rails/deprecations_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe "rspec-rails-2 deprecations" do
-  context "controller specs" do
-    describe "::integrate_views" do
-      let(:group) do
-        RSpec::Core::ExampleGroup.describe do
-          include RSpec::Rails::ControllerExampleGroup
-        end
-      end
-
-      it "is deprecated" do
-        expect(RSpec).to receive(:deprecate)
-        group.integrate_views
-      end
-    end
-  end
-end

data/spec/rspec/rails/example/controller_example_group_spec.rb

@@ -1,159 +0,0 @@
-require "spec_helper"
-
-class ::ApplicationController
-  def self.abstract?; false; end
-end
-
-module RSpec::Rails
-  describe ControllerExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/controllers/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\controllers\\') }
-
-    let(:group) do
-      RSpec::Core::ExampleGroup.describe do
-        include ControllerExampleGroup
-      end
-    end
-
-    it "includes routing matchers" do
-      expect(group.included_modules).to include(RSpec::Rails::Matchers::RoutingMatchers)
-    end
-
-    it "adds :type => :controller to the metadata" do
-      expect(group.metadata[:type]).to eq(:controller)
-    end
-
-    context "with implicit subject" do
-      it "uses the controller as the subject" do
-        controller = double('controller')
-        example = group.new
-        allow(example).to receive_messages(:controller => controller)
-        expect(example.subject).to eq(controller)
-      end
-    end
-
-    context "with explicit subject" do
-      it "uses the specified subject instead of the controller" do
-        group.subject { 'explicit' }
-        example = group.new
-        expect(example.subject).to eq('explicit')
-      end
-    end
-
-    describe "#controller" do
-      before do
-        group.class_eval do
-          controller(Class.new) { }
-        end
-      end
-
-      it "delegates named route helpers to the underlying controller" do
-        controller = double('controller')
-        allow(controller).to receive(:foos_url).and_return('http://test.host/foos')
-
-        example = group.new
-        allow(example).to receive_messages(:controller => controller)
-
-        # As in the routing example spec, this is pretty invasive, but not sure
-        # how to do it any other way as the correct operation relies on before
-        # hooks
-        routes = ActionDispatch::Routing::RouteSet.new
-        routes.draw { resources :foos }
-        example.instance_variable_set(:@orig_routes, routes)
-
-        expect(example.foos_url).to eq('http://test.host/foos')
-      end
-    end
-
-    describe "#bypass_rescue" do
-      it "overrides the rescue_with_handler method on the controller to raise submitted error" do
-        example = group.new
-        example.instance_variable_set("@controller", Class.new { def rescue_with_handler(e); end }.new)
-        example.bypass_rescue
-        expect do
-          example.controller.rescue_with_handler(RuntimeError.new("foo"))
-        end.to raise_error("foo")
-      end
-    end
-
-    describe "with inferred anonymous controller" do
-      before do
-        allow(group).to receive(:controller_class).and_return(Class.new)
-      end
-
-      it "defaults to inferring anonymous controller class" do
-        expect(RSpec.configuration.infer_base_class_for_anonymous_controllers).to be_truthy
-      end
-
-      context "when infer_base_class_for_anonymous_controllers is true" do
-        before do
-          allow(RSpec.configuration).to receive(:infer_base_class_for_anonymous_controllers?).and_return(true)
-        end
-
-        it "infers the anonymous controller class" do
-          group.controller { }
-
-          controller_class = group.metadata[:example_group][:described_class]
-          expect(controller_class.superclass).to eq(group.controller_class)
-        end
-
-        it "infers the anonymous controller class when no ApplicationController is present" do
-          hide_const '::ApplicationController'
-          group.controller { }
-
-          controller_class = group.metadata[:example_group][:described_class]
-          expect(controller_class.superclass).to eq(group.controller_class)
-        end
-      end
-
-      context "when infer_base_class_for_anonymous_controllers is false" do
-        before do
-          allow(RSpec.configuration).to receive(:infer_base_class_for_anonymous_controllers?).and_return(false)
-        end
-
-        it "sets the anonymous controller class to ApplicationController" do
-          group.controller { }
-
-          controller_class = group.metadata[:example_group][:described_class]
-          expect(controller_class.superclass).to eq(ApplicationController)
-        end
-
-        it "sets the anonymous controller class to ActiveController::Base when no ApplicationController is present" do
-          hide_const '::ApplicationController'
-          group.controller { }
-
-          controller_class = group.metadata[:example_group][:described_class]
-          expect(controller_class.superclass).to eq(ActionController::Base)
-        end
-      end
-    end
-
-    describe "controller name" do
-      let(:controller_class) { group.metadata[:example_group][:described_class] }
-
-      it "sets the name as AnonymousController if it's anonymous" do
-        group.controller { }
-        expect(controller_class.name).to eq "AnonymousController"
-      end
-
-      it "sets the name according to defined controller if it is not anonymous" do
-        stub_const "FoosController", Class.new(::ApplicationController)
-        group.controller(FoosController) { }
-        expect(controller_class.name).to eq "FoosController"
-      end
-
-      it "sets name as AnonymousController if defined as ApplicationController" do
-        group.controller(ApplicationController) { }
-        expect(controller_class.name).to eq "AnonymousController"
-      end
-
-      it "sets name as AnonymousController the controller is abstract" do
-        abstract_controller = Class.new(::ApplicationController)
-        def abstract_controller.abstract?; true; end
-
-        group.controller(abstract_controller) { }
-        expect(controller_class.name).to eq "AnonymousController"
-      end
-    end
-  end
-end

data/spec/rspec/rails/example/feature_example_group_spec.rb

@@ -1,56 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe FeatureExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/features/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\features\\') }
-
-    it "adds :type => :feature to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include FeatureExampleGroup
-      end
-
-      expect(group.metadata[:type]).to eq(:feature)
-    end
-
-    it "includes Rails route helpers" do
-      Rails.application.routes.draw do
-        get "/foo", :as => :foo, :to => "foo#bar"
-      end
-
-      group = RSpec::Core::ExampleGroup.describe do
-        include FeatureExampleGroup
-      end
-
-      expect(group.new.foo_path).to eq("/foo")
-      expect(group.new.foo_url).to eq("http://www.example.com/foo")
-    end
-
-    describe "#visit" do
-      it "raises an error informing about missing Capybara" do
-        group = RSpec::Core::ExampleGroup.describe do
-          include FeatureExampleGroup
-        end
-
-        expect {
-          group.new.visit('/foobar')
-        }.to raise_error(/Capybara not loaded/)
-      end
-
-      it "is resistant to load order errors" do
-        capybara = Module.new do
-          def visit(url)
-            "success: #{url}"
-          end
-        end
-
-        group = RSpec::Core::ExampleGroup.describe do
-          include capybara
-          include FeatureExampleGroup
-        end
-
-        expect(group.new.visit("/foo")).to eq("success: /foo")
-      end
-    end
-  end
-end

data/spec/rspec/rails/example/helper_example_group_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe HelperExampleGroup do
-    module ::FoosHelper; end
-    subject { HelperExampleGroup }
-
-    it { is_expected.to be_included_in_files_in('./spec/helpers/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\helpers\\') }
-
-    it "provides a controller_path based on the helper module's name" do
-      example = double
-      example.stub_chain(:example_group, :described_class) { FoosHelper }
-
-      helper_spec = Object.new.extend HelperExampleGroup
-      expect(helper_spec.__send__(:_controller_path, example)).to eq("foos")
-    end
-
-    it "adds :type => :helper to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include HelperExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:helper)
-    end
-
-    describe "#helper" do
-      it "returns the instance of AV::Base provided by AV::TC::Behavior" do
-        helper_spec = Object.new.extend HelperExampleGroup
-        expect(helper_spec).to receive(:view_assigns)
-        av_tc_b_view = double('_view')
-        expect(av_tc_b_view).to receive(:assign)
-        allow(helper_spec).to receive(:_view) { av_tc_b_view }
-        expect(helper_spec.helper).to eq(av_tc_b_view)
-      end
-
-      before do
-        Object.const_set(:ApplicationHelper, Module.new)
-      end
-
-      after do
-        Object.__send__(:remove_const, :ApplicationHelper)
-      end
-
-      it "includes ApplicationHelper" do
-        group = RSpec::Core::ExampleGroup.describe do
-          include HelperExampleGroup
-          def _view
-            ActionView::Base.new
-          end
-        end
-        expect(group.new.helper).to be_kind_of(ApplicationHelper)
-      end
-    end
-  end
-
-  describe HelperExampleGroup::ClassMethods do
-    describe "determine_default_helper_class" do
-      it "returns the helper module passed to describe" do
-        helper_spec = Object.new.extend HelperExampleGroup::ClassMethods
-        allow(helper_spec).to receive(:described_class) { FoosHelper }
-        expect(helper_spec.determine_default_helper_class("ignore this")).
-          to eq(FoosHelper)
-      end
-    end
-  end
-end

data/spec/rspec/rails/example/mailer_example_group_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe MailerExampleGroup do
-    module ::Rails; end
-    before do
-      Rails.stub_chain(:application, :routes, :url_helpers).and_return(Rails)
-      Rails.stub_chain(:configuration, :action_mailer, :default_url_options).and_return({})
-    end
-
-    it { is_expected.to be_included_in_files_in('./spec/mailers/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\mailers\\') }
-
-    it "adds :type => :mailer to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include MailerExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:mailer)
-    end
-  end
-end

data/spec/rspec/rails/example/model_example_group_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe ModelExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/models/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\models\\') }
-
-    it "adds :type => :model to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include ModelExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:model)
-    end
-  end
-end

data/spec/rspec/rails/example/request_example_group_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe RequestExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/requests/') }
-    it { is_expected.to be_included_in_files_in('./spec/integration/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\requests\\') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\integration\\') }
-
-    it "adds :type => :request to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include RequestExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:request)
-    end
-  end
-end

data/spec/rspec/rails/example/routing_example_group_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe RoutingExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/routing/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\routing\\') }
-
-    it "adds :type => :routing to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include RoutingExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:routing)
-    end
-
-    describe "named routes" do
-      it "delegates them to the route_set" do
-        group = RSpec::Core::ExampleGroup.describe do
-          include RoutingExampleGroup
-        end
-
-        example = group.new
-
-        # Yes, this is quite invasive
-        url_helpers = double('url_helpers', :foo_path => "foo")
-        routes = double('routes', :url_helpers => url_helpers)
-        allow(example).to receive_messages(:routes => routes)
-
-        expect(example.foo_path).to eq("foo")
-      end
-    end
-  end
-end

data/spec/rspec/rails/example/view_example_group_spec.rb

@@ -1,235 +0,0 @@
-require "spec_helper"
-
-module RSpec::Rails
-  describe ViewExampleGroup do
-    it { is_expected.to be_included_in_files_in('./spec/views/') }
-    it { is_expected.to be_included_in_files_in('.\\spec\\views\\') }
-
-    it "adds :type => :view to the metadata" do
-      group = RSpec::Core::ExampleGroup.describe do
-        include ViewExampleGroup
-      end
-      expect(group.metadata[:type]).to eq(:view)
-    end
-
-    describe 'automatic inclusion of helpers' do
-      module ::ThingsHelper; end
-      module ::Namespaced; module ThingsHelper; end; end
-
-      it 'includes the helper with the same name' do
-        group = RSpec::Core::ExampleGroup.describe 'things/show.html.erb'
-        expect(group).to receive(:helper).with(ThingsHelper)
-        group.class_eval do
-          include ViewExampleGroup
-        end
-      end
-
-      it 'includes the namespaced helper with the same name' do
-        group = RSpec::Core::ExampleGroup.describe 'namespaced/things/show.html.erb'
-        expect(group).to receive(:helper).with(Namespaced::ThingsHelper)
-        group.class_eval do
-          include ViewExampleGroup
-        end
-      end
-
-      it 'operates normally when no helper with the same name exists' do
-        raise 'unexpected constant found' if Object.const_defined?('ClocksHelper')
-        expect {
-          RSpec::Core::ExampleGroup.describe 'clocks/show.html.erb' do
-            include ViewExampleGroup
-          end
-        }.not_to raise_error
-      end
-
-      context 'application helper exists' do
-        before do
-          if !Object.const_defined? 'ApplicationHelper'
-            module ::ApplicationHelper; end
-            @application_helper_defined = true
-          end
-        end
-
-        after do
-          if @application_helper_defined
-            Object.__send__ :remove_const, 'ApplicationHelper'
-          end
-        end
-
-        it 'includes the application helper' do
-          group = RSpec::Core::Example.describe 'bars/new.html.erb'
-          expect(group).to receive(:helper).with(ApplicationHelper)
-          group.class_eval do
-            include ViewExampleGroup
-          end
-        end
-      end
-
-      context 'no application helper exists' do
-        before do
-          if Object.const_defined? 'ApplicationHelper'
-            @application_helper = ApplicationHelper
-            Object.__send__ :remove_const, 'ApplicationHelper'
-          end
-        end
-
-        after do
-          if @application_helper
-            ApplicationHelper = @application_helper
-          end
-        end
-
-        it 'operates normally' do
-          expect {
-            RSpec::Core::ExampleGroup.describe 'foos/edit.html.erb' do
-              include ViewExampleGroup
-            end
-          }.not_to raise_error
-        end
-      end
-    end
-
-    describe "#render" do
-      let(:view_spec) do
-        Class.new do
-          module Local
-            def received
-              @received ||= []
-            end
-            def render(options={}, local_assigns={}, &block)
-              received << [options, local_assigns, block]
-            end
-            def _assigns
-              {}
-            end
-          end
-          include Local
-          include ViewExampleGroup::ExampleMethods
-        end.new
-      end
-
-      context "given no input" do
-        it "sends render(:template => (described file)) to the view" do
-          allow(view_spec).to receive(:_default_file_to_render) { "widgets/new" }
-          view_spec.render
-          expect(view_spec.received.first).to eq([{:template => "widgets/new"},{}, nil])
-        end
-
-        it "converts the filename components into render options" do
-          allow(view_spec).to receive(:_default_file_to_render) { "widgets/new.en.html.erb" }
-          view_spec.render
-
-          if ::Rails::VERSION::STRING >= '3.2'
-            expect(view_spec.received.first).to eq([{:template => "widgets/new", :locales=>['en'], :formats=>['html'], :handlers=>['erb']}, {}, nil])
-          else
-            expect(view_spec.received.first).to eq([{:template => "widgets/new.en.html.erb"}, {}, nil])
-          end
-        end
-      end
-
-      context "given a string" do
-        it "sends string as the first arg to render" do
-          view_spec.render('arbitrary/path')
-          expect(view_spec.received.first).to eq(["arbitrary/path", {}, nil])
-        end
-      end
-
-      context "given a hash" do
-        it "sends the hash as the first arg to render" do
-          view_spec.render(:foo => 'bar')
-          expect(view_spec.received.first).to eq([{:foo => "bar"}, {}, nil])
-        end
-      end
-    end
-
-    describe '#params' do
-      let(:view_spec) do
-        Class.new do
-          include ViewExampleGroup::ExampleMethods
-          def controller
-            @controller ||= Object.new
-          end
-        end.new
-      end
-
-      it 'delegates to the controller' do
-        expect(view_spec.controller).to receive(:params).and_return({})
-        view_spec.params[:foo] = 1
-      end
-    end
-
-    describe "#_controller_path" do
-      let(:view_spec) do
-        Class.new do
-          include ViewExampleGroup::ExampleMethods
-        end.new
-      end
-      context "with a common _default_file_to_render" do
-        it "it returns the directory" do
-          allow(view_spec).to receive(:_default_file_to_render).
-            and_return("things/new.html.erb")
-          expect(view_spec.__send__(:_controller_path)).
-            to eq("things")
-        end
-      end
-
-      context "with a nested _default_file_to_render" do
-        it "it returns the directory path" do
-          allow(view_spec).to receive(:_default_file_to_render).
-            and_return("admin/things/new.html.erb")
-          expect(view_spec.__send__(:_controller_path)).
-            to eq("admin/things")
-        end
-      end
-    end
-
-    describe "#view" do
-      let(:view_spec) do
-        Class.new do
-          include ViewExampleGroup::ExampleMethods
-        end.new
-      end
-
-      it "delegates to _view" do
-        view = double("view")
-        allow(view_spec).to receive(:_view) { view }
-        expect(view_spec.view).to eq(view)
-      end
-
-      it 'is accessible to hooks' do
-        with_isolated_config do
-          run_count = 0
-          RSpec.configuration.before(:each, :type => :view) do
-            allow(view).to receive(:a_stubbed_helper) { :value }
-            run_count += 1
-          end
-          group = RSpec::Core::ExampleGroup.describe 'a view', :type => :view do
-            specify { true }
-          end
-          group.run NullObject.new
-          expect(run_count).to eq 1
-        end
-      end
-    end
-
-    describe "#template" do
-      let(:view_spec) do
-        Class.new do
-          include ViewExampleGroup::ExampleMethods
-          def _view; end
-        end.new
-      end
-
-      before { allow(RSpec).to receive(:deprecate) }
-
-      it "is deprecated" do
-        expect(RSpec).to receive(:deprecate)
-        view_spec.template
-      end
-
-      it "delegates to #view" do
-        expect(view_spec).to receive(:view)
-        view_spec.template
-      end
-    end
-  end
-end