rspec-activemodel-mocks 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a5cc1ea66ca12596ba1723b13be6ada5fbcc6bc
+  data.tar.gz: 9bad54a7e796d1465ecf0922b6d11d32e74c0b80
+SHA512:
+  metadata.gz: 17a71ff3a6b9b8ce1ef5878966b11ad2cf549499cb09aeb02d1ae3eea0800fc4ba5de63365298d0406e7c86a273d78f52cabb53de84ad72f70ebcc09dd3de5f1
+  data.tar.gz: 94d431c9b32d5fea92dfdb428d3156dfc526a8e22ca6d489c0225a3f3fb7224c25fa9c93d1fc51838fc2c6f195e0154ba1d93b5d5177ba48873b19937fab4015

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--exclude features
+--markup markdown
+--template-path yard/template/

data/License.txt

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2012 David Chelimsky, Andy Lindeman
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# RSpec::ActiveModel::Mocks [![Build Status](https://secure.travis-ci.org/rspec/rspec-activemodel-mocks.png?branch=master)](http://travis-ci.org/rspec/rspec-activemodel-mocks)
+
+RSpec::ActiveModel::Mocks provides tools for testing `ActiveModel` classes.
+
+    mock_model(Person, name: "Fred")
+
+## Install
+
+Add this line to your application's gemfile:
+
+    gem 'rspec-activemodel-mocks'
+
+And then execute:
+
+    $ bundle
+
+If you are using [rspec-rails](https://github.com/rspec/rspec-rails) and have
+followed the installation instructions there, you're all set to use `stub_model`
+and `mock_model`.
+
+To use `stub_model` and `mock_model` without rspec-rails, require the
+following file:
+
+    require 'rspec/active_model/mocks'
+
+## Usage
+
+### Mock
+
+Creates a test double representing `string_or_model_class` with common
+ActiveModel methods stubbed out. Additional methods may be easily stubbed
+(via `add_stubs`) if `stubs` is passed. This is most useful for impersonating
+models that don't exist yet.
+
+ActiveModel methods, plus `new_record?`, are stubbed out implicitly.
+`new_record?` returns the inverse of `persisted?`, and is present only for
+compatibility with extension frameworks that have yet to update themselves to
+the ActiveModel API (which declares `persisted?`, not `new_record?`).
+
+`string_or_model_class` can be any of:
+
+  * A String representing a Class that does not exist
+  * A String representing a Class that extends `ActiveModel::Naming`
+  * A Class that extends `ActiveModel::Naming`
+
+### Stub
+
+Creates an instance of `Model` with `to_param` stubbed using a generated value
+that is unique to each object. If `Model` is an `ActiveRecord` model, it is
+prohibited from accessing the database.
+
+For each key in `stubs`, if the model has a matching attribute (determined by
+`respond_to?`) it is 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.
+
+`persisted?` is overridden to return the result of `!id.nil?` This means that
+by default `persisted?` will return true. 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 `persisted?` will return false, 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.
+
+    stub_model(Person)
+    stub_model(Person).as_new_record
+    stub_model(Person, :to_param => 37)
+    stub_model(Person) {|person| person.first_name = "David"}

data/features/mocks/mock_model.feature

@@ -0,0 +1,147 @@
+Feature: mock_model
+
+  The `mock_model` method generates a test double that acts like an instance of
+  `ActiveModel`. This is different from the `stub_model` method which generates
+  an instance of a real model class.
+
+  The benefit of `mock_model` over `stub_model` is that it is a true double, so
+  the examples are not dependent on the behavior (or mis-behavior), or even the
+  existence of any other code. If you're working on a controller spec and you
+  need a model that doesn't exist, you can pass `mock_model` a string and the
+  generated object will act as though its an instance of the class named by
+  that string.
+   
+  Scenario: passing a string that represents a non-existent constant
+    Given a file named "spec/models/car_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "mock_model('Car') with no Car constant in existence" do
+        it "generates a constant" do
+          expect(Object.const_defined?(:Car)).to be_falsey
+          mock_model("Car")
+          expect(Object.const_defined?(:Car)).to be_truthy
+        end
+
+        describe "generates an object that ..." do
+          it "returns the correct name" do
+            car = mock_model("Car")
+            expect(car.class.name).to eq("Car")
+          end
+
+          it "says it is a Car" do
+            car = mock_model("Car")
+            expect(car).to be_a(Car)
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/car_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a string that represents an existing constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        it "uses the existing constant" do
+          widget = mock_model("Widget")
+          expect(widget).to be_a(Widget)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing a class that does not extend ActiveModel::Naming
+    Given a file named "spec/models/string_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe String do
+        it "raises" do
+          expect { mock_model(String) }.to raise_exception
+        end
+      end
+      """
+    When I run `rspec spec/models/string_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe Widget do
+        let(:widget) { mock_model(Widget) }
+
+        it "is valid by default" do
+          expect(widget).to be_valid
+        end
+
+        it "is not a new record by default" do
+          expect(widget).not_to be_new_record
+        end
+
+        it "can be converted to a new record" do
+          expect(widget.as_new_record).to be_new_record
+        end
+
+        it "sets :id to nil upon destroy" do
+          widget.destroy
+          expect(widget.id).to be_nil
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: passing an Active Record constant with method stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "mock_model(Widget) with stubs" do
+        let(:widget) do
+          mock_model Widget, :foo => "bar",
+                             :save => true,
+                             :update_attributes => false
+        end
+
+        it "supports stubs for methods that don't exist in ActiveModel or ActiveRecord" do
+          expect(widget.foo).to eq("bar")
+        end
+
+        it "supports stubs for methods that do exist" do
+          expect(widget.save).to eq(true)
+          expect(widget.update_attributes).to be_falsey
+        end
+
+        describe "#errors" do
+          context "with update_attributes => false" do
+            it "is not empty" do
+              expect(widget.errors).not_to be_empty
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+
+  Scenario: mock_model outside rails
+    Given a file named "mock_model_outside_rails_spec.rb" with:
+      """ruby
+      require 'rspec/active_model/mocks'
+
+      describe "Foo" do
+        it "is mockable" do
+          foo = mock_model("Foo")
+          expect(foo.id).to eq(1001)
+          expect(foo.to_param).to eq("1001")
+        end
+      end
+      """
+    When I run `rspec mock_model_outside_rails_spec.rb`
+    Then the examples should all pass

data/features/mocks/stub_model.feature

@@ -0,0 +1,58 @@
+Feature: stub_model
+  
+  The stub_model method generates an instance of a Active Model model.
+  
+  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.
+   
+  Scenario: passing an Active Record constant with a hash of stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "stub_model(Widget) with a hash of stubs" do
+        let(:widget) do
+          stub_model Widget, :id => 5, :random_attribute => true
+        end
+        
+        it "stubs :id" do
+          expect(widget.id).to eql(5)
+        end
+        
+        it "stubs :random_attribute" do
+          expect(widget.random_attribute).to be_truthy
+        end
+        
+        it "returns false for new_record? if :id is set" do
+          expect(widget).not_to be_new_record
+        end
+        
+        it "can be converted to a new record" do
+          widget.as_new_record
+          expect(widget).to be_new_record
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass
+    
+  Scenario: passing an Active Record constant with a block of stubs
+    Given a file named "spec/models/widget_spec.rb" with:
+      """ruby
+      require "spec_helper"
+
+      describe "stub_model(Widget) with a block of stubs" do
+        let(:widget) do
+          stub_model Widget do |widget|
+            widget.id = 5
+          end
+        end
+        
+        it "stubs :id" do
+          expect(widget.id).to eql(5)
+        end
+      end
+      """
+    When I run `rspec spec/models/widget_spec.rb`
+    Then the examples should all pass

data/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,4 @@
+Then /^the example(s)? should( all)? pass$/ do |_, _|
+  step %q{the output should contain "0 failures"}
+  step %q{the exit status should be 0}
+end

data/features/step_definitions/model_steps.rb

@@ -0,0 +1,3 @@
+Given /a (\w+) model/ do |model_class_name|
+  puts eval(model_class_name)
+end

data/features/support/env.rb

@@ -0,0 +1,53 @@
+require 'aruba/cucumber'
+
+module ArubaExt
+  def run(cmd)
+    super(cmd =~ /^rspec/ ? "bin/#{cmd}" : cmd)
+  end
+end
+
+World(ArubaExt)
+
+Before do
+  @aruba_timeout_seconds = 30
+end
+
+unless File.directory?('./tmp/sample')
+  system "rake generate:sample"
+end
+
+def aruba_path(file_or_dir)
+  File.expand_path("../../../#{file_or_dir.sub('sample','aruba')}", __FILE__)
+end
+
+def sample_path(file_or_dir)
+  File.expand_path("../../../#{file_or_dir}", __FILE__)
+end
+
+def write_symlink(file_or_dir)
+  source = sample_path(file_or_dir)
+  target = aruba_path(file_or_dir)
+  system "ln -s #{source} #{target}"
+end
+
+def copy(file_or_dir)
+  source = sample_path(file_or_dir)
+  target = aruba_path(file_or_dir)
+  system "cp -r #{source} #{target}"
+end
+
+Before do
+  steps %Q{
+    Given a directory named "spec"
+  }
+
+  Dir['tmp/sample/*'].each do |file_or_dir|
+    if !(file_or_dir =~ /spec$/)
+      write_symlink(file_or_dir)
+    end
+  end
+
+  ["spec/spec_helper.rb"].each do |file_or_dir|
+    write_symlink("tmp/sample/#{file_or_dir}")
+  end
+end

data/features/support/rubinius.rb

@@ -0,0 +1,6 @@
+# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
+ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
+
+Around "@unsupported-on-rbx" do |scenario, block|
+  block.call unless defined?(Rubinius)
+end

data/lib/rspec/active_model/mocks/mocks.rb

@@ -0,0 +1,271 @@
+require 'active_support'
+require 'active_support/core_ext/object/to_param'
+require 'active_model'
+
+module RSpec::ActiveModel::Mocks
+  class IllegalDataAccessException < StandardError; end
+  module Mocks
+
+    module ActiveModelInstanceMethods
+      # Stubs `persisted?` to return false and `id` to return nil
+      # @return self
+      def as_new_record
+        RSpec::Mocks.allow_message(self, :persisted?).and_return(false)
+        RSpec::Mocks.allow_message(self, :id).and_return(nil)
+        self
+      end
+
+      # Returns true by default. Override with a stub.
+      def persisted?
+        true
+      end
+
+      # Returns false for names matching <tt>/_before_type_cast$/</tt>,
+      # otherwise delegates to super.
+      def respond_to?(message, include_private=false)
+        message.to_s =~ /_before_type_cast$/ ? false : super
+      end
+    end
+
+    # Starting with Rails 4.1, ActiveRecord associations are inversible
+    # by default. This class represents an association from the mocked
+    # model's perspective.
+    #
+    # @private
+    class Association
+      attr_accessor :target, :inversed
+
+      def initialize(association_name)
+        @association_name = association_name
+      end
+    end
+
+    module ActiveRecordInstanceMethods
+      # Stubs `persisted?` to return `false` and `id` to return `nil`.
+      def destroy
+        RSpec::Mocks.allow_message(self, :persisted?).and_return(false)
+        RSpec::Mocks.allow_message(self, :id).and_return(nil)
+      end
+
+      # Transforms the key to a method and calls it.
+      def [](key)
+        send(key)
+      end
+
+      # Returns the opposite of `persisted?`
+      def new_record?
+        !persisted?
+      end
+
+      # Returns an object representing an association from the mocked
+      # model's perspective. For use by Rails internally only.
+      def association(association_name)
+        @associations ||= Hash.new { |h, k| h[k] = Association.new(k) }
+        @associations[association_name]
+      end
+    end
+
+    # Creates a test double representing `string_or_model_class` with common
+    # ActiveModel methods stubbed out. Additional methods may be easily
+    # stubbed (via add_stubs) if `stubs` is passed. This is most useful for
+    # impersonating models that don't exist yet.
+    #
+    # ActiveModel methods, plus <tt>new_record?</tt>, are
+    # stubbed out implicitly.  <tt>new_record?</tt> returns the inverse of
+    # <tt>persisted?</tt>, and is present only for compatibility with
+    # extension frameworks that have yet to update themselves to the
+    # ActiveModel API (which declares <tt>persisted?</tt>, not
+    # <tt>new_record?</tt>).
+    #
+    # `string_or_model_class` can be any of:
+    #
+    #   * A String representing a Class that does not exist
+    #   * A String representing a Class that extends ActiveModel::Naming
+    #   * A Class that extends ActiveModel::Naming
+    def mock_model(string_or_model_class, stubs = {})
+      if String === string_or_model_class
+        if Object.const_defined?(string_or_model_class)
+          model_class = Object.const_get(string_or_model_class)
+        else
+          model_class = Object.const_set(string_or_model_class, Class.new do
+            extend ::ActiveModel::Naming
+            def self.primary_key; :id; end
+          end)
+        end
+      else
+        model_class = string_or_model_class
+      end
+
+      unless model_class.kind_of? ::ActiveModel::Naming
+        raise ArgumentError.new <<-EOM
+The mock_model method can only accept as its first argument:
+* A String representing a Class that does not exist
+* A String representing a Class that extends ActiveModel::Naming
+* A Class that extends ActiveModel::Naming
+
+It received #{model_class.inspect}
+EOM
+      end
+
+      stubs = {:id => next_id}.merge(stubs)
+      stubs = {:persisted? => !!stubs[:id],
+               :destroyed? => false,
+               :marked_for_destruction? => false,
+               :valid? => true,
+               :blank? => false}.merge(stubs)
+
+      double("#{model_class.name}_#{stubs[:id]}", stubs).tap do |m|
+        msingleton = class << m; self; end
+        msingleton.class_eval do
+          include ActiveModelInstanceMethods
+          include ActiveRecordInstanceMethods if defined?(ActiveRecord)
+          include ActiveModel::Conversion
+          include ActiveModel::Validations
+        end
+        if defined?(ActiveRecord)
+          [:save, :update_attributes, :update].each do |key|
+            if stubs[key] == false
+              RSpec::Mocks.allow_message(m.errors, :empty?).and_return(false)
+            end
+          end
+        end
+
+        msingleton.__send__(:define_method, :is_a?) do |other|
+          model_class.ancestors.include?(other)
+        end unless stubs.has_key?(:is_a?)
+
+        msingleton.__send__(:define_method, :kind_of?) do |other|
+          model_class.ancestors.include?(other)
+        end unless stubs.has_key?(:kind_of?)
+
+        msingleton.__send__(:define_method, :instance_of?) do |other|
+          other == model_class
+        end unless stubs.has_key?(:instance_of?)
+
+        msingleton.__send__(:define_method, :__model_class_has_column?) do |method_name|
+          model_class.respond_to?(:column_names) && model_class.column_names.include?(method_name.to_s)
+        end
+
+        msingleton.__send__(:define_method, :has_attribute?) do |attr_name|
+          __model_class_has_column?(attr_name)
+        end unless stubs.has_key?(:has_attribute?)
+
+        msingleton.__send__(:define_method, :respond_to?) do |method_name, *args|
+        include_private = args.first || false
+          __model_class_has_column?(method_name) ? true : super(method_name, include_private)
+        end unless stubs.has_key?(:respond_to?)
+
+        msingleton.__send__(:define_method, :method_missing) do |m, *a, &b|
+          respond_to?(m) ? null_object? ? self : nil : super(m, *a, &b)
+        end
+
+        msingleton.__send__(:define_method, :class) do
+          model_class
+        end unless stubs.has_key?(:class)
+
+        mock_param = to_param
+        msingleton.__send__(:define_method, :to_s) do
+          "#{model_class.name}_#{mock_param}"
+        end unless stubs.has_key?(:to_s)
+        yield m if block_given?
+      end
+    end
+
+    module ActiveModelStubExtensions
+      # Stubs `persisted` to return false and `id` to return nil
+      def as_new_record
+        RSpec::Mocks.allow_message(self, :persisted?).and_return(false)
+        RSpec::Mocks.allow_message(self, :id).and_return(nil)
+        self
+      end
+
+      # Returns `true` by default. Override with a stub.
+      def persisted?
+        true
+      end
+    end
+
+    module ActiveRecordStubExtensions
+      # Stubs `id` (or other primary key method) to return nil
+      def as_new_record
+        self.__send__("#{self.class.primary_key}=", nil)
+        super
+      end
+
+      # Returns the opposite of `persisted?`.
+      def new_record?
+        !persisted?
+      end
+
+      # Raises an IllegalDataAccessException (stubbed models are not allowed to access the database)
+      # @raises IllegalDataAccessException
+      def connection
+        raise RSpec::ActiveModel::Mocks::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+      end
+    end
+
+    # Creates an instance of `Model` with `to_param` stubbed using a
+    # generated value that is unique to each object. If `Model` is an
+    # `ActiveRecord` model, it is prohibited from accessing the database.
+    #
+    # For each key in `stubs`, if the model has a matching attribute
+    # (determined by `respond_to?`) it is 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>persisted?</tt> is overridden to return the result of !id.nil?
+    # This means that by default persisted? will return true. 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 persisted? will return false, 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.
+    #
+    # @example
+    #
+    #     stub_model(Person)
+    #     stub_model(Person).as_new_record
+    #     stub_model(Person, :to_param => 37)
+    #     stub_model(Person) {|person| person.first_name = "David"}
+    def stub_model(model_class, stubs={})
+      model_class.new.tap do |m|
+        m.extend ActiveModelStubExtensions
+        if defined?(ActiveRecord) && model_class < ActiveRecord::Base
+          m.extend ActiveRecordStubExtensions
+          primary_key = model_class.primary_key.to_sym
+          stubs = {primary_key => next_id}.merge(stubs)
+          stubs = {:persisted? => !!stubs[primary_key]}.merge(stubs)
+        else
+          stubs = {:id => next_id}.merge(stubs)
+          stubs = {:persisted? => !!stubs[:id]}.merge(stubs)
+        end
+        stubs = {:blank? => false}.merge(stubs)
+
+        stubs.each do |message, return_value|
+          if m.respond_to?("#{message}=")
+            m.__send__("#{message}=", return_value)
+          else
+            RSpec::Mocks.allow_message(m, message).and_return(return_value)
+          end
+        end
+
+        yield m if block_given?
+      end
+    end
+
+  private
+
+    @@model_id = 1000
+
+    def next_id
+      @@model_id += 1
+    end
+
+  end
+end
+
+RSpec.configuration.include RSpec::ActiveModel::Mocks::Mocks

data/lib/rspec/active_model/mocks/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module ActiveModel
+    module Mocks
+      module Version
+        STRING = '1.0.0.beta1'
+      end
+    end
+  end
+end

data/lib/rspec/active_model/mocks.rb

@@ -0,0 +1,8 @@
+require 'rspec/core'
+
+RSpec::configure do |c|
+  c.backtrace_exclusion_patterns << /lib\/rspec\/active_model\/mocks/
+end
+
+require 'rspec/active_model/mocks/version'
+require 'rspec/active_model/mocks/mocks'

data/lib/rspec-activemodel-mocks.rb

@@ -0,0 +1 @@
+require 'rspec/active_model/mocks'