rspec-activemodel-mocks 1.0.0.beta1

data/spec/rspec/active_model/mocks/mock_model_spec.rb

@@ -0,0 +1,435 @@
+require 'spec_helper'
+
+describe "mock_model(RealModel)" do
+  context "given a String" do
+    context "that does not represent an existing constant" do
+      it "class says it's name" do
+        model = mock_model("Foo")
+        expect(model.class.name).to eq("Foo")
+      end
+    end
+
+    context "that represents an existing constant" do
+      context "that extends ActiveModel::Naming" do
+        it "treats the constant as the class" do
+          model = mock_model("MockableModel")
+          expect(model.class.name).to eq("MockableModel")
+        end
+      end
+
+      context "that does not extend ActiveModel::Naming" do
+        it "raises with a helpful message" do
+          expect do
+            mock_model("String")
+          end.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  context "given a class that does not extend ActiveModel::Naming" do
+    it "raises with a helpful message" do
+      expect do
+        mock_model(String)
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "with #id stubbed" do
+    before(:each) do
+      @model = mock_model(MockableModel, :id => 1)
+    end
+
+    it "is named using the stubbed id value" do
+      expect(@model.instance_variable_get(:@name)).to eq("MockableModel_1")
+    end
+  end
+
+  describe "destroy" do
+    it "sets persisted to false" do
+      model = mock_model(MockableModel)
+      model.destroy
+      expect(model).not_to be_persisted
+    end
+  end
+
+  describe "association" do
+    it "constructs a mock association object" do
+      model = mock_model(MockableModel)
+      expect(model.association(:association_name)).to be
+    end
+
+    it "returns a different association object for each association name" do
+      model = mock_model(MockableModel)
+      posts = model.association(:posts)
+      authors = model.association(:authors)
+
+      expect(posts).not_to equal(authors)
+    end
+
+    it "returns the same association model each time for the same association name" do
+      model = mock_model(MockableModel)
+      posts1 = model.association(:posts)
+      posts2 = model.association(:posts)
+
+      expect(posts1).to equal(posts2)
+    end
+  end
+
+  describe "errors" do
+    context "default" do
+      it "is empty" do
+        model = mock_model(MockableModel)
+        expect(model.errors).to be_empty
+      end
+    end
+
+    context "with :save => false" do
+      it "is not empty" do
+        model = mock_model(MockableModel, :save => false)
+        expect(model.errors).not_to be_empty
+      end
+    end
+
+    context "with :update_attributes => false" do
+      it "is not empty" do
+        model = mock_model(MockableModel, :save => false)
+        expect(model.errors).not_to be_empty
+      end
+    end
+  end
+
+  describe "with params" do
+    it "does not mutate its parameters" do
+      params = {:a => 'b'}
+      mock_model(MockableModel, params)
+      expect(params).to eq({:a => 'b'})
+    end
+  end
+
+  describe "as association" do
+    before(:each) do
+      @real = AssociatedModel.create!
+      @mock_model = mock_model(MockableModel)
+      @real.mockable_model = @mock_model
+    end
+
+    it "passes: associated_model == mock" do
+      expect(@mock_model).to eq(@real.mockable_model)
+    end
+
+    it "passes: mock == associated_model" do
+      expect(@real.mockable_model).to eq(@mock_model)
+    end
+  end
+
+  describe "as association that doesn't exist yet" do
+    before(:each) do
+      @real = AssociatedModel.create!
+      @mock_model = mock_model("Other")
+      @real.nonexistent_model = @mock_model
+    end
+
+    it "passes: associated_model == mock" do
+      expect(@mock_model).to eq(@real.nonexistent_model)
+    end
+
+    it "passes: mock == associated_model" do
+      expect(@real.nonexistent_model).to eq(@mock_model)
+    end
+  end
+
+  describe "#is_a?" do
+    before(:each) do
+      @model = mock_model(SubMockableModel)
+    end
+
+    it "says it is_a?(RealModel)" do
+      expect(@model.is_a?(SubMockableModel)).to be(true)
+    end
+
+    it "says it is_a?(OtherModel) if RealModel is an ancestors" do
+      expect(@model.is_a?(MockableModel)).to be(true)
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :is_a? => true).is_a?(:Foo)).to be_truthy
+    end
+  end
+
+  describe "#kind_of?" do
+    before(:each) do
+      @model = mock_model(SubMockableModel)
+    end
+
+    it "says it is kind_of? if RealModel is" do
+      expect(@model.kind_of?(SubMockableModel)).to be(true)
+    end
+
+    it "says it is kind_of? if RealModel's ancestor is" do
+      expect(@model.kind_of?(MockableModel)).to be(true)
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :kind_of? => true).kind_of?(:Foo)).to be_truthy
+    end
+  end
+
+  describe "#instance_of?" do
+    before(:each) do
+      @model = mock_model(SubMockableModel)
+    end
+
+    it "says it is instance_of? if RealModel is" do
+      expect(@model.instance_of?(SubMockableModel)).to be(true)
+    end
+
+    it "does not say it instance_of? if RealModel isn't, even if it's ancestor is" do
+      expect(@model.instance_of?(MockableModel)).to be(false)
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :instance_of? => true).instance_of?(:Foo)).to be_truthy
+    end
+  end
+
+  describe "#has_attribute?" do
+    context "with an ActiveRecord model" do
+      before(:each) do
+        MockableModel.stub(:column_names).and_return(["column_a", "column_b"])
+        @model = mock_model(MockableModel)
+      end
+
+      it "has a given attribute if the underlying model has column of the same name" do
+        expect(@model.has_attribute?("column_a")).to be_truthy
+        expect(@model.has_attribute?("column_b")).to be_truthy
+        expect(@model.has_attribute?("column_c")).to be_falsey
+      end
+
+      it "accepts symbols" do
+        expect(@model.has_attribute?(:column_a)).to be_truthy
+        expect(@model.has_attribute?(:column_b)).to be_truthy
+        expect(@model.has_attribute?(:column_c)).to be_falsey
+      end
+
+      it "allows has_attribute? to be explicitly stubbed" do
+        @model = mock_model(MockableModel, :has_attribute? => false)
+        expect(@model.has_attribute?(:column_a)).to be_falsey
+        expect(@model.has_attribute?(:column_b)).to be_falsey
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    context "with an ActiveRecord model" do
+      before(:each) do
+        allow(MockableModel).to receive(:column_names).and_return(["column_a", "column_b"])
+        @model = mock_model(MockableModel)
+      end
+
+      it "accepts two arguments" do
+        expect do
+          @model.respond_to?("title_before_type_cast", false)
+        end.to_not raise_exception
+      end
+
+      context "without as_null_object" do
+        it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
+          expect(@model.respond_to?("column_a")).to be(true)
+        end
+        it "stubs column accessor (with string)" do
+          @model.respond_to?("column_a")
+          expect(@model.column_a).to be_nil
+        end
+        it "stubs column accessor (with symbol)" do
+          @model.respond_to?(:column_a)
+          expect(@model.column_a).to be_nil
+        end
+        it "does not stub column accessor if already stubbed in declaration (with string)" do
+          model = mock_model(MockableModel, "column_a" => "a")
+          model.respond_to?("column_a")
+          expect(model.column_a).to eq("a")
+        end
+        it "does not stub column accessor if already stubbed in declaration (with symbol)" do
+          model = mock_model(MockableModel, :column_a => "a")
+          model.respond_to?("column_a")
+          expect(model.column_a).to eq("a")
+        end
+        it "does not stub column accessor if already stubbed after declaration (with string)" do
+          allow(@model).to receive(:column_a) { "a" }
+          @model.respond_to?("column_a")
+          expect(@model.column_a).to eq("a")
+        end
+        it "does not stub column accessor if already stubbed after declaration (with symbol)" do
+          allow(@model).to receive(:column_a) { "a" }
+          @model.respond_to?("column_a")
+          expect(@model.column_a).to eq("a")
+        end
+        it "says it will not respond_to?(key) if RealModel does not have the attribute 'key'" do
+          expect(@model.respond_to?("column_c")).to be(false)
+        end
+        it "says it will not respond_to?(xxx_before_type_cast)" do
+          expect(@model.respond_to?("title_before_type_cast")).to be(false)
+        end
+      end
+
+      context "with as_null_object" do
+        it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
+          expect(@model.as_null_object.respond_to?("column_a")).to be(true)
+        end
+        it "says it will respond_to?(key) even if RealModel does not have the attribute 'key'" do
+          expect(@model.as_null_object.respond_to?("column_c")).to be(true)
+        end
+        it "says it will not respond_to?(xxx_before_type_cast)" do
+          expect(@model.as_null_object.respond_to?("title_before_type_cast")).to be(false)
+        end
+        it "returns self for any unprepared message" do
+          @model.as_null_object.tap do |x|
+            expect(x.non_existant_message).to be(@model)
+          end
+        end
+      end
+    end
+
+    context "with a non-ActiveRecord model" do
+      it "responds as normal" do
+        model = NonActiveRecordModel.new
+        expect(model).to respond_to(:to_param)
+      end
+
+      context "with as_null_object" do
+        it "says it will not respond_to?(xxx_before_type_cast)" do
+          model = NonActiveRecordModel.new.as_null_object
+          expect(model.respond_to?("title_before_type_cast")).to be(false)
+        end
+      end
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :respond_to? => true).respond_to?(:foo)).to be_truthy
+    end
+  end
+
+  describe "#class" do
+    it "returns the mocked model" do
+      expect(mock_model(MockableModel).class).to eq(MockableModel)
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :class => String).class).to be(String)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns (model.name)_(model#to_param)" do
+      expect(mock_model(MockableModel).to_s).to eq("MockableModel_#{to_param}")
+    end
+
+    it "can be stubbed" do
+      expect(mock_model(MockableModel, :to_s => "this string").to_s).to eq("this string")
+    end
+  end
+
+  describe "#destroyed?" do
+    context "default" do
+      it "returns false" do
+        @model = mock_model(SubMockableModel)
+        expect(@model.destroyed?).to be(false)
+      end
+    end
+  end
+
+  describe "#marked_for_destruction?" do
+    context "default" do
+      it "returns false" do
+        @model = mock_model(SubMockableModel)
+        expect(@model.marked_for_destruction?).to be(false)
+      end
+    end
+  end
+
+  describe "#persisted?" do
+    context "with default identifier" do
+      it "returns true" do
+        expect(mock_model(MockableModel)).to be_persisted
+      end
+    end
+
+    context "with explicit identifier via :id" do
+      it "returns true" do
+        expect(mock_model(MockableModel, :id => 37)).to be_persisted
+      end
+    end
+
+    context "with id => nil" do
+      it "returns false" do
+        expect(mock_model(MockableModel, :id => nil)).not_to be_persisted
+      end
+    end
+  end
+
+  describe "#valid?" do
+    context "default" do
+      it "returns true" do
+        expect(mock_model(MockableModel)).to be_valid
+      end
+    end
+
+    context "stubbed with false" do
+      it "returns false" do
+        expect(mock_model(MockableModel, :valid? => false)).not_to be_valid
+      end
+    end
+  end
+
+  describe "#as_new_record" do
+    it "says it is a new record" do
+      m = mock_model(MockableModel)
+      expect(m.as_new_record).to be_new_record
+    end
+
+    it "says it is not persisted" do
+      m = mock_model(MockableModel)
+      expect(m.as_new_record).not_to be_persisted
+    end
+
+    it "has a nil id" do
+      expect(mock_model(MockableModel).as_new_record.id).to be(nil)
+    end
+
+    it "returns nil for #to_param" do
+      expect(mock_model(MockableModel).as_new_record.to_param).to be(nil)
+    end
+  end
+
+  describe "#blank?" do
+    it "is false" do
+      expect(mock_model(MockableModel)).not_to be_blank
+    end
+  end
+
+  describe "ActiveModel Lint tests" do
+    begin
+      require 'minitest/assertions'
+      include Minitest::Assertions
+      include MinitestAssertion
+    rescue LoadError
+      require 'test/unit/assertions'
+      include Test::Unit::Assertions
+    end
+
+    require 'active_model/lint'
+    include ActiveModel::Lint::Tests
+
+    # to_s is to support ruby-1.9
+    ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m|
+      example m.gsub('_',' ') do
+        send m
+      end
+    end
+
+    def model
+      mock_model(MockableModel, :id => nil)
+    end
+  end
+end

data/spec/rspec/active_model/mocks/stub_model_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe "stub_model" do
+
+  shared_examples_for "stub model" do
+    describe "with a block" do
+      it "yields the model" do
+        model = stub_model(model_class) do |block_arg|
+          @block_arg = block_arg
+        end
+        expect(model).to be(@block_arg)
+      end
+    end
+
+    describe "#persisted?" do
+      context "default" do
+        it "returns true" do
+          model = stub_model(model_class)
+          expect(model).to be_persisted
+        end
+      end
+
+      context "with as_new_record" do
+        it "returns false" do
+          model = stub_model(model_class).as_new_record
+          expect(model).not_to be_persisted
+        end
+      end
+    end
+
+    it "increments the value returned by to_param" do
+      first = stub_model(model_class)
+      second = stub_model(model_class)
+      expect(second.to_param.to_i).to eq(first.to_param.to_i + 1)
+    end
+
+    describe "#blank?" do
+      it "is false" do
+        expect(stub_model(model_class)).not_to be_blank
+      end
+    end
+  end
+
+  context "with ActiveModel (not ActiveRecord)" do
+    it_behaves_like "stub model" do
+      def model_class
+        NonActiveRecordModel
+      end
+    end
+  end
+
+  context "with an ActiveRecord model" do
+    let(:model_class) { MockableModel }
+
+    it_behaves_like "stub model"
+
+    describe "#new_record?" do
+      context "default" do
+        it "returns false" do
+          model = stub_model(model_class)
+          expect(model.new_record?).to be_falsey
+        end
+      end
+
+      context "with as_new_record" do
+        it "returns true" do
+          model = stub_model(model_class).as_new_record
+          expect(model.new_record?).to be_truthy
+        end
+      end
+    end
+
+    describe "defaults" do
+      it "has an id" do
+        expect(stub_model(MockableModel).id).to be > 0
+      end
+
+      it "says it is not a new record" do
+        expect(stub_model(MockableModel)).not_to be_new_record
+      end
+    end
+
+    describe "#as_new_record" do
+      it "has a nil id" do
+        expect(stub_model(MockableModel).as_new_record.id).to be(nil)
+      end
+    end
+
+    it "raises when hitting the db" do
+      expect do
+        stub_model(MockableModel).connection
+      end.to raise_error(RSpec::ActiveModel::Mocks::IllegalDataAccessException, /stubbed models are not allowed to access the database/)
+    end
+
+    it "increments the id" do
+      first = stub_model(model_class)
+      second = stub_model(model_class)
+      expect(second.id).to eq(first.id + 1)
+    end
+
+    it "accepts a stub id" do
+      expect(stub_model(MockableModel, :id => 37).id).to eq(37)
+    end
+
+    it "says it is a new record when id is set to nil" do
+      expect(stub_model(MockableModel, :id => nil)).to be_new_record
+    end
+
+    it "accepts a stub for save" do
+      expect(stub_model(MockableModel, :save => false).save).to be(false)
+    end
+
+    describe "alternate primary key" do
+      it "has the correct primary_key name" do
+        expect(stub_model(AlternatePrimaryKeyModel).class.primary_key.to_s).to eq('my_id')
+      end
+
+      it "has a primary_key" do
+        expect(stub_model(AlternatePrimaryKeyModel).my_id).to be > 0
+      end
+
+      it "says it is not a new record" do
+        stub_model(AlternatePrimaryKeyModel) do |m|
+          expect(m).not_to be_new_record
+        end
+      end
+
+      it "says it is a new record if primary_key is nil" do
+        expect(stub_model(AlternatePrimaryKeyModel, :my_id => nil)).to be_new_record
+      end
+
+      it "accepts a stub for the primary_key" do
+        expect(stub_model(AlternatePrimaryKeyModel, :my_id => 5).my_id).to eq(5)
+      end
+    end
+
+    describe "as association" do
+      before(:each) do
+        @real = AssociatedModel.create!
+        @stub_model = stub_model(MockableModel)
+        @real.mockable_model = @stub_model
+      end
+
+      it "passes associated_model == mock" do
+        expect(@stub_model).to eq(@real.mockable_model)
+      end
+
+      it "passes mock == associated_model" do
+        expect(@real.mockable_model).to eq(@stub_model)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rspec/active_model/mocks'
+require 'active_record'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+class RSpec::Core::ExampleGroup
+  def self.run_all(reporter=nil)
+    run(reporter || RSpec::Mocks::Mock.new('reporter').as_null_object)
+  end
+end
+
+RSpec.configure do |config|
+  real_world = nil
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.before(:each) do
+    real_world = RSpec.world
+    RSpec.instance_variable_set(:@world, RSpec::Core::World.new)
+  end
+  config.after(:each) do
+    RSpec.instance_variable_set(:@world, real_world)
+  end
+
+  config.order = :random
+end

data/spec/support/ar_classes.rb

@@ -0,0 +1,42 @@
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)
+
+module Connections
+  def self.extended(host)
+    host.connection.execute <<-eosql
+      CREATE TABLE #{host.table_name} (
+        #{host.primary_key} integer PRIMARY KEY AUTOINCREMENT,
+        associated_model_id integer,
+        mockable_model_id integer,
+        nonexistent_model_id integer
+      )
+    eosql
+  end
+end
+
+class NonActiveRecordModel
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+end
+
+class MockableModel < ActiveRecord::Base
+  extend Connections
+  has_one :associated_model
+end
+
+class SubMockableModel < MockableModel
+end
+
+class AssociatedModel < ActiveRecord::Base
+  extend Connections
+  belongs_to :mockable_model
+  belongs_to :nonexistent_model, :class_name => "Other"
+end
+
+class AlternatePrimaryKeyModel < ActiveRecord::Base
+  self.primary_key = :my_id
+  extend Connections
+  attr_accessor :my_id
+end

data/spec/support/helpers.rb

@@ -0,0 +1,34 @@
+module Helpers
+  def stub_metadata(additional_metadata)
+    stub_metadata = metadata_with(additional_metadata)
+    allow(RSpec::Core::ExampleGroup).to receive(:metadata) { stub_metadata }
+  end
+
+  def metadata_with(additional_metadata)
+    m = RSpec::Core::Metadata.new
+    m.process("example group")
+
+    group_metadata = additional_metadata.delete(:example_group)
+    if group_metadata
+      m[:example_group].merge!(group_metadata)
+    end
+    m.merge!(additional_metadata)
+    m
+  end
+
+  def with_isolated_config
+    original_config = RSpec.configuration
+    RSpec.configuration = RSpec::Core::Configuration.new
+    RSpec.configure do |c|
+      c.include RSpec::Rails::FixtureSupport
+      c.add_setting :use_transactional_fixtures, :alias_with => :use_transactional_examples
+      c.add_setting :use_instantiated_fixtures
+      c.add_setting :global_fixtures
+      c.add_setting :fixture_path
+    end
+    yield
+    RSpec.configuration = original_config
+  end
+
+  RSpec.configure {|c| c.include self}
+end

data/spec/support/matchers.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers::define :be_included_in_files_in do |path|
+  match do |mod|
+    stub_metadata(
+      :example_group => {:file_path => "#{path}whatever_spec.rb:15"}
+    )
+    group = RSpec::Core::ExampleGroup.describe
+    group.included_modules.include?(mod)
+  end
+end