rspec-rails-mocha 0.2.2 → 0.3.0

data/lib/rspec-rails-mocha.rb

@@ -1,7 +1,7 @@
-require 'spec'
+require 'rspec/core'
 require 'rspec/rails/mocha'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.mock_with :mocha
-  config.include Spec::Rails::Mocha
+  config.include RSpec::Rails::Mocha
 end

data/lib/rspec/rails/mocha.rb

@@ -1,139 +1,207 @@
-# copied from rspec-rails v1.3 and tweaked to work as expected with Mocha
-# TODO: update to reflect the API of rspec-rails 2.0
-module Spec
+require 'active_model'
+
+module RSpec
   module Rails
-    unless defined?(IllegalDataAccessException)
-      class IllegalDataAccessException < StandardError; end
-    end
-    
     module Mocha
-      # 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 = stub("#{model_class.name}_#{id}", options_and_stubs)
-        m.instance_eval <<-CODE
-          def as_new_record
-            self.stubs(:id).returns(nil)
-            self.stubs(:to_param).returns(nil)
-            self.stubs(:new_record?).returns(true)
-            self
-          end
-          def is_a?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def kind_of?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def instance_of?(other)
-            other == #{model_class}
-          end
-          def class
-            #{model_class}
-          end
-        CODE
-        yield m if block_given?
-        m
+      module ActiveModelInstanceMethods
+        def as_new_record
+          self.stubs(:persisted?) { false }
+          self.stubs(:id) { nil }
+          self
+        end
+
+        def persisted?
+          true
+        end
+
+        def respond_to?(message, include_private=false)
+          message.to_s =~ /_before_type_cast$/ ? false : super
+        end
       end
-      
-      module ModelStubber
-        def connection
-          raise IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+
+      module ActiveRecordInstanceMethods
+        def destroy
+          self.stubs(:persisted?) { false }
+          self.stubs(:id) { nil }
         end
+
         def new_record?
-          id.nil?
+          !persisted?
+        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.
+      #
+      # NOTE that only ActiveModel's 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
+            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 = stubs.reverse_merge(:id => next_id)
+        stubs = stubs.reverse_merge(:persisted? => !!stubs[:id])
+        stubs = stubs.reverse_merge(:destroyed? => false)
+        stubs = stubs.reverse_merge(:marked_for_destruction? => false)
+        stubs = stubs.reverse_merge(:errors => stub("errors", :count => 0, :[] => [], :empty? => true))
+
+        stub("#{model_class.name}_#{stubs[:id]}", stubs).tap do |m|
+          m.extend ActiveModelInstanceMethods
+          model_class.__send__ :include, ActiveModel::Conversion
+          model_class.__send__ :include, ActiveModel::Validations
+          if defined?(ActiveRecord)
+            m.extend ActiveRecordInstanceMethods
+            [:save, :update_attributes].each do |key|
+              if stubs[key] == false
+                m.errors.stubs(:empty?) { false }
+              end
+            end
+          end
+          m.instance_eval(<<-CODE, __FILE__, __LINE__)
+            def is_a?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def kind_of?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def instance_of?(other)
+              other == #{model_class}
+            end
+            def respond_to?(method_name, include_private=false)
+              #{model_class}.respond_to?(:column_names) && #{model_class}.column_names.include?(method_name.to_s) || super
+            end
+            def class
+              #{model_class}
+            end
+            def to_s
+              "#{model_class.name}_#{to_param}"
+            end
+
+            def to_key
+              [id]
+            end
+          CODE
+          yield m if block_given?
         end
+      end
+
+      module ActiveModelStubExtensions
         def as_new_record
-          self.id = nil
+          self.stubs(:persisted?)  { false }
+          self.stubs(:id)          { nil }
           self
         end
       end
 
+      module ActiveRecordStubExtensions
+        def as_new_record
+          self.__send__("#{self.class.primary_key}=", nil)
+          super
+        end
+
+        def new_record?
+          !persisted?
+        end
+
+        def connection
+          raise RSpec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+        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.
+      # 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 +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
+      # <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 new_record? will return true, but using +as_new_record+ makes the
+      # 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.
       #
-      # == 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, :to_param => 37)
       #   stub_model(Person) do |person|
       #     person.first_name = "David"
       #   end
       def stub_model(model_class, stubs={})
-        stubs = {:id => next_id}.merge(stubs)
-        model_class.new.tap do |model|
-          model.id = stubs.delete(:id)
-          model.extend ModelStubber
+        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 = stubs.reverse_merge(primary_key => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[primary_key])
+          else
+            stubs = stubs.reverse_merge(:id => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[:id])
+          end
           stubs.each do |k,v|
-            if model.has_attribute?(k)
-              model[k] = stubs.delete(k)
-            end
+            m.__send__("#{k}=", stubs.delete(k)) if m.respond_to?("#{k}=")
           end
-          model.stubs(stubs)
-          yield model if block_given?
+          m.stubs(stubs)
+          yield m if block_given?
         end
       end
-      
-      # DEPRECATED - use object.stubs(:method => value, :method2 => value)
-      #
-      # 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:
-        Kernel.warn <<-WARNING
-DEPRECATION NOTICE: add_stubs is deprecated and will be removed
-from a future version of rspec-rails. Use this instead:
-  
-  object.stubs(:method => value, :method2 => value)
-  
-WARNING
-        object.stubs(stubs)
-      end
 
-      private
+    private
 
-        @@model_id = 1000
-
-        def next_id
-          @@model_id += 1
-        end
+      @@model_id = 1000
 
+      def next_id
+        @@model_id += 1
+      end
     end
   end
 end

data/spec/mocha_spec.rb

@@ -1,8 +1,25 @@
-require 'spec/autorun'
+require 'rspec'
 require 'rspec-rails-mocha'
-require 'active_support/core_ext'
 
-class Person
+# Simple stub for ActiveRecord::Base
+module ActiveRecord
+  class Base
+    extend ActiveModel::Naming
+    class << self
+      def primary_key; "id"; end
+    end
+  end
+end
+
+module RSpec::Rails
+  # usually defined in "rspec/rails/mocks"
+  class IllegalDataAccessException < StandardError; end
+end
+
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/object'
+
+class Person < ActiveRecord::Base
   attr_accessor :id, :name
   
   def has_attribute?(attr)
@@ -42,6 +59,13 @@ describe "rspec-rails Mocha plugin" do
       person.id.should == 66
     end
     
+    it "should use given ID in to_key" do
+      personA = create(Person, :id => 66)
+      personA.to_key.should == [66]
+      personB = create(Person)
+      personB.to_key.first.should >= 1000
+    end
+    
     it "should mock a record with properties" do
       hacker = create(Hacker, :name => "Mislav", :skillz => 1337)
       hacker.name.should == "Mislav"
@@ -66,6 +90,8 @@ describe "rspec-rails Mocha plugin" do
     
     it "should have no errors" do
       create(Person).errors.count.should == 0
+      create(Person).errors.empty?.should be_true
+      create(Person).errors[:name].should == []
     end
   end
   
@@ -79,8 +105,8 @@ describe "rspec-rails Mocha plugin" do
     it "can't connect" do
       lambda {
         create(Person).connection
-      }.should raise_error(Spec::Rails::IllegalDataAccessException)
+      }.should raise_error(RSpec::Rails::IllegalDataAccessException)
     end
   end
   
-end
+end

metadata

@@ -5,17 +5,18 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
+- Paul Rosania
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-20 00:00:00 +01:00
+date: 2011-02-13 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +43,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 15
         segments: 
-        - 1
-        - 3
         - 2
-        version: 1.3.2
+        - 0
+        - 0
+        version: 2.0.0
   type: :runtime
   version_requirements: *id002
 description: Ports functionality of mock_model and stub_model from rspec-rails using Mocha.