dchelimsky-rspec-rails 1.1.6

data/lib/spec/rails/mocks.rb

@@ -0,0 +1,132 @@
+module Spec
+  module Rails
+
+    class IllegalDataAccessException < StandardError; end
+
+    module Mocks
+      
+      # Creates a mock object instance for a +model_class+ with common
+      # methods stubbed out. Additional methods may be easily stubbed (via
+      # add_stubs) if +stubs+ is passed.
+      def mock_model(model_class, options_and_stubs = {})
+        id = options_and_stubs[:id] || next_id
+        options_and_stubs = options_and_stubs.reverse_merge({
+          :id => id,
+          :to_param => id.to_s,
+          :new_record? => false,
+          :errors => stub("errors", :count => 0)
+        })
+        m = mock("#{model_class.name}_#{id}", options_and_stubs)
+        m.send(:__mock_proxy).instance_eval <<-CODE
+          def @target.as_new_record
+            self.stub!(:id).and_return nil
+            self.stub!(:to_param).and_return nil
+            self.stub!(:new_record?).and_return true
+            self
+          end
+          def @target.is_a?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.kind_of?(other)
+            #{model_class}.ancestors.include?(other)
+          end
+          def @target.instance_of?(other)
+            other == #{model_class}
+          end
+          def @target.class
+            #{model_class}
+          end
+        CODE
+        yield m if block_given?
+        m
+      end
+      
+      module ModelStubber
+        def connection
+          raise Spec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+        end
+        def new_record?
+          id.nil?
+        end
+        def as_new_record
+          self.id = nil
+          self
+        end
+      end
+
+      # :call-seq:
+      #   stub_model(Model)
+      #   stub_model(Model).as_new_record
+      #   stub_model(Model, hash_of_stubs)
+      #   stub_model(Model, instance_variable_name, hash_of_stubs)
+      #
+      # Creates an instance of +Model+ that is prohibited from accessing the
+      # database*. For each key in +hash_of_stubs+, if the model has a
+      # matching attribute (determined by asking it) are simply assigned the
+      # submitted values. If the model does not have a matching attribute, the
+      # key/value pair is assigned as a stub return value using RSpec's
+      # mocking/stubbing framework.
+      #
+      # <tt>new_record?</tt> is overridden to return the result of id.nil?
+      # This means that by default new_record? will return false. If  you want
+      # the object to behave as a new record, sending it +as_new_record+ will
+      # set the id to nil. You can also explicitly set :id => nil, in which
+      # case new_record? will return true, but using +as_new_record+ makes the
+      # example a bit more descriptive.
+      #
+      # While you can use stub_model in any example (model, view, controller,
+      # helper), it is especially useful in view examples, which are
+      # inherently more state-based than interaction-based.
+      #
+      # == Database Independence
+      #
+      # +stub_model+ does not make your examples entirely
+      # database-independent. It does not stop the model class itself from
+      # loading up its columns from the database. It just prevents data access
+      # from the object itself. To completely decouple from the database, take
+      # a look at libraries like unit_record or NullDB.
+      #
+      # == Examples
+      #
+      #   stub_model(Person)
+      #   stub_model(Person).as_new_record
+      #   stub_model(Person, :id => 37)
+      #   stub_model(Person) do |person|
+      #     person.first_name = "David"
+      #   end
+      def stub_model(model_class, stubs={})
+        stubs = {:id => next_id}.merge(stubs)
+        returning model_class.new do |model|
+          model.id = stubs.delete(:id)
+          model.extend ModelStubber
+          stubs.each do |k,v|
+            if model.has_attribute?(k)
+              model[k] = stubs.delete(k)
+            end
+          end
+          add_stubs(model, stubs)
+          yield model if block_given?
+        end
+      end
+      
+      #--
+      # TODO - Shouldn't this just be an extension of stub! ??
+      # - object.stub!(:method => return_value, :method2 => return_value2, :etc => etc)
+      #++
+      # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
+      # with that name will be created). +stubs+ is a Hash of +method=>value+
+      def add_stubs(object, stubs = {}) #:nodoc:
+        m = [String, Symbol].index(object.class) ? mock(object.to_s) : object
+        stubs.each {|k,v| m.stub!(k).and_return(v)}
+        m
+      end
+
+      private
+        @@model_id = 1000
+        def next_id
+          @@model_id += 1
+        end
+
+    end
+  end
+end

data/lib/spec/rails/story_adapter.rb

@@ -0,0 +1,79 @@
+# WARNING - THIS IS PURELY EXPERIMENTAL AT THIS POINT
+# Courtesy of Brian Takita and Yurii Rashkovskii
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec lib])
+if defined?(ActiveRecord::Base)
+  require 'test_help' 
+else
+  require 'action_controller/test_process'
+  require 'action_controller/integration'
+end
+require 'test/unit/testresult'
+require 'spec'
+require 'spec/rails'
+
+Test::Unit.run = true
+
+ActionController::Integration::Session.send(:include, Spec::Matchers)
+ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)
+
+class RailsStory < ActionController::IntegrationTest
+  if defined?(ActiveRecord::Base)
+    self.use_transactional_fixtures = true
+  else
+    def self.fixture_table_names; []; end # Workaround for projects that don't use ActiveRecord
+  end
+
+  def initialize #:nodoc:
+    # TODO - eliminate this hack, which is here to stop
+    # Rails Stories from dumping the example summary.
+    Spec::Runner::Options.class_eval do
+      def examples_should_be_run?
+        false
+      end
+    end
+    @_result = Test::Unit::TestResult.new
+  end
+end
+
+class ActiveRecordSafetyListener
+  include Singleton
+  def scenario_started(*args)
+    if defined?(ActiveRecord::Base)
+      if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
+        ActiveRecord::Base.connection.increment_open_transactions
+      else
+        ActiveRecord::Base.send :increment_open_transactions
+      end
+    end
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+
+  def scenario_succeeded(*args)
+    if defined?(ActiveRecord::Base)
+      ActiveRecord::Base.connection.rollback_db_transaction
+      if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
+        ActiveRecord::Base.connection.decrement_open_transactions
+      else
+        ActiveRecord::Base.send :decrement_open_transactions
+      end
+    end
+  end
+  alias :scenario_pending :scenario_succeeded
+  alias :scenario_failed :scenario_succeeded
+end
+
+class Spec::Story::Runner::ScenarioRunner
+  def initialize
+    @listeners = [ActiveRecordSafetyListener.instance]
+  end
+end
+
+class Spec::Story::GivenScenario
+  def perform(instance, name = nil)
+    scenario = Spec::Story::Runner::StoryRunner.scenario_from_current_story @name
+    runner = Spec::Story::Runner::ScenarioRunner.new
+    runner.instance_variable_set(:@listeners,[])
+    runner.run(scenario, instance)
+  end
+end

data/lib/spec/rails/version.rb

@@ -0,0 +1,15 @@
+module Spec
+  module Rails
+    module VERSION #:nodoc:
+      unless defined? MAJOR
+        MAJOR  = 1
+        MINOR  = 1
+        TINY   = 6
+
+        STRING = [MAJOR, MINOR, TINY].join('.')
+
+        SUMMARY = "rspec-rails #{STRING}"
+      end
+    end
+  end
+end

data/lib/spec/rails.rb

@@ -0,0 +1,15 @@
+silence_warnings { RAILS_ENV = "test" }
+
+require_dependency 'application'
+require 'action_controller/test_process'
+require 'action_controller/integration'
+require 'active_record/fixtures' if defined?(ActiveRecord::Base)
+require 'test/unit'
+
+require 'spec'
+
+require 'spec/rails/matchers'
+require 'spec/rails/mocks'
+require 'spec/rails/example'
+require 'spec/rails/extensions'
+require 'spec/rails/interop/testcase'

data/spec/rails/autotest/mappings_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.join(File.dirname(__FILE__), *%w[.. .. .. lib autotest rails_rspec])
+require File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec spec autotest autotest_matchers])
+
+describe Autotest::RailsRspec, "file mapping" do
+  before(:each) do
+    @autotest = Autotest::RailsRspec.new
+    @autotest.hook :initialize
+  end
+  
+  it "should map model example to model" do
+    @autotest.should map_specs(['spec/models/thing_spec.rb']).
+                            to('app/models/thing.rb')
+  end
+  
+  it "should map controller example to controller" do
+    @autotest.should map_specs(['spec/controllers/things_controller_spec.rb']).
+                            to('app/controllers/things_controller.rb')
+  end
+  
+  it "should map view.rhtml" do
+    @autotest.should map_specs(['spec/views/things/index.rhtml_spec.rb']).
+                            to('app/views/things/index.rhtml')
+  end
+  
+  it "should map view.rhtml with underscores in example filename" do
+    @autotest.should map_specs(['spec/views/things/index_rhtml_spec.rb']).
+                            to('app/views/things/index.rhtml')
+  end
+  
+  it "should map view.html.erb" do
+    @autotest.should map_specs(['spec/views/things/index.html.erb_spec.rb']).
+                            to('app/views/things/index.html.erb')
+  end
+  
+end

data/spec/rails/example/assigns_hash_proxy_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AssignsHashProxy" do
+  def orig_assigns
+    @object.assigns
+  end
+  
+  before(:each) do
+    @object = Class.new do
+      attr_accessor :assigns
+    end.new
+    @object.assigns = Hash.new
+    @proxy = Spec::Rails::Example::AssignsHashProxy.new self do
+      @object
+    end
+  end
+  
+  it "should set ivars on object using string" do
+    @proxy['foo'] = 'bar'
+    @object.instance_eval{@foo}.should == 'bar'
+  end
+  
+  it "should set ivars on object using symbol" do
+    @proxy[:foo] = 'bar'
+    @object.instance_eval{@foo}.should == 'bar'
+  end
+  
+  it "should access object's assigns with a string" do
+    @object.assigns['foo'] = 'bar'
+    @proxy[:foo].should == 'bar'
+  end
+  
+  it "should access object's assigns with a symbol" do
+    @object.assigns['foo'] = 'bar'
+    @proxy[:foo].should == 'bar'
+  end
+
+  it "iterates through each element like a Hash" do
+    values = {
+      'foo' => 1,
+      'bar' => 2,
+      'baz' => 3
+    }
+    @proxy['foo'] = values['foo']
+    @proxy['bar'] = values['bar']
+    @proxy['baz'] = values['baz']
+  
+    @proxy.each do |key, value|
+      key.should == key
+      value.should == values[key]
+    end
+  end
+  
+  it "deletes the element of passed in key" do
+    @object.assigns['foo'] = 'bar'
+    @proxy.delete('foo').should == 'bar'
+    @proxy['foo'].should be_nil
+  end
+  
+  it "detects the presence of a key" do
+    @object.assigns['foo'] = 'bar'
+    @proxy.has_key?('foo').should == true
+    @proxy.has_key?('bar').should == false
+  end
+  
+  it "should expose values set in example" do
+    @proxy[:foo] = 'bar'
+    @proxy[:foo].should == 'bar'
+  end
+end

data/spec/rails/example/configuration_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe Configuration, :shared => true do
+      before(:each) { @config = Configuration.new }
+    end
+
+    describe Configuration, "#use_transactional_fixtures" do
+      it_should_behave_like "Spec::Example::Configuration"
+
+      it "should return Test::Unit::TestCase.use_transactional_fixtures" do
+        @config.use_transactional_fixtures.should == Test::Unit::TestCase.use_transactional_fixtures
+      end
+
+      it "should set Test::Unit::TestCase.use_transactional_fixtures to false" do
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.should_receive(:use_transactional_fixtures=).with(false)
+        end
+        @config.use_transactional_fixtures = false
+      end
+
+      it "should set Test::Unit::TestCase.use_transactional_fixtures to true" do
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.should_receive(:use_transactional_fixtures=).with(true)
+        end
+        @config.use_transactional_fixtures = true
+      end
+    end
+
+    describe Configuration, "#use_instantiated_fixtures" do
+      it_should_behave_like "Spec::Example::Configuration"
+
+      it "should return Test::Unit::TestCase.use_transactional_fixtures" do
+        @config.use_instantiated_fixtures.should == Test::Unit::TestCase.use_instantiated_fixtures
+      end
+
+      it "should set Test::Unit::TestCase.use_instantiated_fixtures to false" do
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.should_receive(:use_instantiated_fixtures=).with(false)
+        end
+        @config.use_instantiated_fixtures = false
+      end
+
+      it "should set Test::Unit::TestCase.use_instantiated_fixtures to true" do
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.should_receive(:use_instantiated_fixtures=).with(true)
+        end
+        @config.use_instantiated_fixtures = true
+      end
+    end
+
+    describe Configuration, "#fixture_path" do
+      it_should_behave_like "Spec::Example::Configuration"
+
+      it "should default to RAILS_ROOT + '/spec/fixtures'" do
+        @config.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
+        end
+      end
+
+      it "should set fixture_path" do
+        @config.fixture_path = "/new/path"
+        @config.fixture_path.should == "/new/path"
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.fixture_path.should == "/new/path"
+        end
+      end
+    end
+
+    describe Configuration, "#global_fixtures" do
+      it_should_behave_like "Spec::Example::Configuration"
+
+      it "should set fixtures on TestCase" do
+        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
+          example_group.should_receive(:fixtures).with(:blah)
+        end
+        @config.global_fixtures = [:blah]
+      end
+    end
+  end
+end

data/spec/rails/example/controller_isolation_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'controller_spec_controller'
+
+describe "a controller spec running in isolation mode", :type => :controller do
+  controller_name :controller_spec
+
+  it "should not care if the template doesn't exist" do
+    get 'some_action'
+    response.should be_success
+    response.should render_template("template/that/does/not/actually/exist")
+  end
+
+  it "should not care if the template has errors" do
+    get 'action_with_errors_in_template'
+    response.should be_success
+    response.should render_template("action_with_errors_in_template")
+  end
+end
+
+describe "a controller spec running in integration mode", :type => :controller do
+  controller_name :controller_spec
+  integrate_views
+  
+  before(:each) do
+    controller.class.send(:define_method, :rescue_action) { |e| raise e }
+  end
+
+  it "should render a template" do
+    get 'action_with_template'
+    response.should be_success
+    response.should have_tag('div', 'This is action_with_template.rhtml')
+  end
+
+  it "should choke if the template doesn't exist" do
+    error = defined?(ActionController::MissingTemplate) ? ActionController::MissingTemplate : ActionView::MissingTemplate    
+    lambda { get 'some_action' }.should raise_error(error)
+    response.should_not be_success
+  end
+
+  it "should choke if the template has errors" do
+    lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
+    response.should_not be_success
+  end
+  
+  describe "nested" do
+    it "should render a template" do
+      get 'action_with_template'
+      response.should be_success
+      response.should have_tag('div', 'This is action_with_template.rhtml')
+    end
+    
+    describe "with integrate_views turned off" do
+      integrate_views false
+      
+      it "should not care if the template doesn't exist" do
+        get 'some_action'
+        response.should be_success
+        response.should render_template("template/that/does/not/actually/exist")
+      end
+    end
+  end
+end