rspec-rails-mocha 0.2.2

data/README.markdown

@@ -0,0 +1,22 @@
+rspec-rails Mocha extension
+===========================
+
+Functionality of `mock_model` and `stub_model` from rspec-rails for those using Mocha.
+
+Installation:
+
+    # Gemfile
+    group :test do
+      gem 'rspec-rails-mocha'
+    end
+
+Usage:
+
+    describe "Mocha plugin" do
+      it "#mock_model should use given ID" do
+        person = mock_model(Person, :id => 66)
+        
+        person.should_not be_new_record
+        person.id.should == 66
+      end
+    end

data/Rakefile

@@ -0,0 +1,5 @@
+task :default => :spec
+
+task :spec do
+  exec 'bundle exec ruby -Ilib spec/mocha_spec.rb --color'
+end

data/lib/rspec-rails-mocha.rb

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

data/lib/rspec/rails/mocha.rb

@@ -0,0 +1,139 @@
+# 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
+  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
+      end
+      
+      module ModelStubber
+        def connection
+          raise 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)
+        model_class.new.tap 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
+          model.stubs(stubs)
+          yield model 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
+
+        @@model_id = 1000
+
+        def next_id
+          @@model_id += 1
+        end
+
+    end
+  end
+end

data/spec/mocha_spec.rb

@@ -0,0 +1,86 @@
+require 'spec/autorun'
+require 'rspec-rails-mocha'
+require 'active_support/core_ext'
+
+class Person
+  attr_accessor :id, :name
+  
+  def has_attribute?(attr)
+    respond_to?(attr)
+  end
+  
+  def []=(attr, value)
+    self.send("#{attr}=", value)
+  end
+end
+
+class Hacker < Person
+end
+
+describe "rspec-rails Mocha plugin" do
+  
+  share_examples_for "model" do
+    it "should be of correct class" do
+      model = create(Hacker)
+      
+      model.is_a?(Person).should be_true
+      model.kind_of?(Person).should be_true
+      model.instance_of?(Person).should be_false
+      model.instance_of?(Hacker).should be_true
+      model.class.should == Hacker
+    end
+    
+    it "should auto-generate IDs" do
+      personA = create(Person)
+      personB = create(Person)
+      personA.id.should >= 1000
+      personB.id.should > personA.id
+    end
+    
+    it "should use given ID" do
+      person = create(Person, :id => 66)
+      person.id.should == 66
+    end
+    
+    it "should mock a record with properties" do
+      hacker = create(Hacker, :name => "Mislav", :skillz => 1337)
+      hacker.name.should == "Mislav"
+      hacker.skillz.should == 1337
+    end
+    
+    it "should not be new record" do
+      create(Person).should_not be_new_record
+    end
+    
+    it "should be new record when explicitly stated" do
+      create(Person).as_new_record.should be_new_record
+    end
+  end
+  
+  describe "#mock_model" do
+    it_should_behave_like "model"
+    
+    def create(*args)
+      mock_model(*args)
+    end
+    
+    it "should have no errors" do
+      create(Person).errors.count.should == 0
+    end
+  end
+  
+  describe "#stub_model" do
+    it_should_behave_like "model"
+    
+    def create(*args)
+      stub_model(*args)
+    end
+    
+    it "can't connect" do
+      lambda {
+        create(Person).connection
+      }.should raise_error(Spec::Rails::IllegalDataAccessException)
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: rspec-rails-mocha
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-20 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 3
+        - 2
+        version: 1.3.2
+  type: :runtime
+  version_requirements: *id002
+description: Ports functionality of mock_model and stub_model from rspec-rails using Mocha.
+email: mislav.marohnic@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/rspec/rails/mocha.rb
+- lib/rspec-rails-mocha.rb
+- spec/mocha_spec.rb
+- README.markdown
+has_rdoc: false
+homepage: http://github.com/mislav/rspec-rails-mocha
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: mock_model and stub_model with Mocha
+test_files: []
+