active_mocker 1.3.2 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21a518671785c535883e4fa2f3fe1aeb95538c07
-  data.tar.gz: b3fef1e6496ce8e5fcbe686d8c75441481a378ea
+  metadata.gz: 6dee4f02b727c2c89ef5d4c74de74b6fa308b1cf
+  data.tar.gz: 4943e1fc8b417dfd2afbd4239a2d50bed8cca98f
 SHA512:
-  metadata.gz: e4d11855ab91ea06085f8eb42b4af4ff9d1926b1ca1e732846200cc610ba9dd6bab82fcf1939cedd9b268e00e1737363a881b6d1a12c8570f2d3bfa7132713c4
-  data.tar.gz: 23e84bfeaaaf244364ab54e1219a2c2d5483e847739a7a613a9c233004ff259532ab8240f2cccc65e1551a3c4ff509bed18c08e566ea17590bbab1a7edacf0e4
+  metadata.gz: 8a844dd82570b6c67170723113f883c0270c273bf89467b349c99141fe28b00be4bbf8093228b4dbd72f10534e400a0960bef18430a0158dfeb3e6cc8bbc9b52
+  data.tar.gz: 44e29ca9c8da2cb8db4901bd92993ca1ab0ecd45196a29d1e79cfec05688e3c99595601cb5b41a4abab9dfa91d08d5cff0af8141710d120e604111fb486d051a

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - "2.0.0"
   - "2.1.0"
   - "2.1.1"
+  - "2.1.2"

data/README.md

@@ -1,13 +1,32 @@
 # ActiveMocker
 [![Build Status](https://travis-ci.org/zeisler/active_mocker.png?branch=master)](https://travis-ci.org/zeisler/active_mocker)
+[![Code Climate](https://codeclimate.com/github/zeisler/active_mocker.png)](https://codeclimate.com/github/zeisler/active_mocker)
 
-Creates mocks from Active Record models. Allows your test suite to run very fast by not loading Rails or hooking to a database. It parse the schema definition and the defined methods on a model then saves a ruby file that can be included with a test. Mocks are regenerated when the schema is modified so your mocks will not go stale. This prevents the case where your units tests pass but production code is failing.
+ActiveMocker creates mocks classes from ActiveRecord models. Allowing your test suite to run very fast by not loading Rails or hooking to a database. It parses the schema definition and the defined methods on a model then saves a ruby file that can be included within a test. Mocks are regenerated when the schema is modified so your mocks will not go stale. This prevents the case where your units tests pass but production code is failing.
 
 Example from a real app
 
 		Finished in 0.54599 seconds
 		190 examples, 0 failures
 
+
+------------------------------------------
+
+* [Installation](#installation)
+* [Setup](#setup)
+* [Dependencies](#dependencies)
+* [Usage](#usage)
+* [Mocking Methods](#mocking-methods)
+* [Managing Mocks](#managing-mocks)
+* [ActiveRecord supported methods](#activerecord-supported-methods)
+* [Known Limitations](#known-limitations)
+* [Inspiration](#inspiration)
+* [Contributing](#contributing)
+
+
+------------------------------------------
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -22,8 +41,14 @@ Or install it yourself as:
 
     $ gem install active_mocker
 
+## Dependencies
+* Tested with Rails 4.1 may work with older versions but not supported.
+* Requires Ruby MRI =< 2.1.
 
-### Setup
+
+## Setup
+
+### Configure the Mock Generator
   config/initializers/active_mocker.rb
 
     ActiveMocker::Generate.configure do |config|
@@ -35,6 +60,8 @@ Or install it yourself as:
       config.logger      = Rails.logger
     end
 
+### Create a Rake Task to Auto Regenerate Mocks
+
 Here is an example of a rake task to regenerate mocks after every schema modifiation. If the model changes this rake task needs to be called manually. You could add a file watcher for when your models change and have it run the rake task.
 
   lib/tasks/active_mocker.rake
@@ -52,7 +79,7 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
 
 ## Usage
 
- db/schema.rb
+    #db/schema.rb
 
     ActiveRecord::Schema.define(version: 20140327205359) do
 
@@ -65,6 +92,7 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
       end
 
     end
+--------------
 
     #app/models/person.rb
 
@@ -79,24 +107,29 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
       end
 
     end
-    
+ 
+-----------------   
 
- spec/models/person_spec.rb
+    #person_spec.rb
 
-    load 'spec/mocks/person_mock.rb'
+    require 'spec/mocks/person_mock.rb'
+    require 'spec/mocks/account_mock.rb'
 
     PersonMock.column_names
         => ["id", "account_id", "first_name", "last_name", "address", "city"]
 
-    person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler", account: ActiveMocker.mock('Account').new)
-        => "#<PersonMock id: nil, account_id: nil, first_name: \"Dustin\", last_name: \"Zeisler\", address: nil, city: nil>"
+    person_mock = PersonMock.new( first_name:  "Dustin", 
+    							  last_name:   "Zeisler", 
+    							  account:      AccountMock.new )
+        => "#<PersonMock id: nil, account_id: nil, first_name: "Dustin", last_name: "Zeisler, address: nil, city: nil>"
 
      person_mock.first_name
         => "Dustin"
 
 ### When schema.rb changes, the mock fails
-
- db/schema.rb
+(Requires a regeneration of the mocks files.)
+ 
+	#db/schema.rb
 
      ActiveRecord::Schema.define(version: 20140327205359) do
 
@@ -110,29 +143,44 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
 
      end
 
+--------------
+
+    #person_spec.rb
+
      PersonMock.new(first_name: "Dustin", last_name: "Zeisler")
              =>#<RuntimeError Rejected params: {"first_name"=>"Dustin", "last_name"=>"Zeisler"} for PersonMock>
 
+## Mocking Methods
+
 
-### Mocking instance and class methods
+### Class Methods
 
-     person_mock.bar('baz')
+     PersonMock.bar('baz')
         => RuntimeError: ::bar is not Implemented for Class: PersonMock
 
-     person_mock.mock_instance_method(:bar) do  |name, type=nil|
+     PersonMock.mock_class_method(:bar) do  |name, type=nil|
         "Now implemented with #{name} and #{type}"
      end
+     
 
-     person_mock.new.bar('foo', 'type')
+### Instance Methods
+
+      PersonMock.new.bar('foo', 'type')
         => "Now implemented with foo and type"
 
-     person_mock.mock_class_method(:bar) do
-       "Now implemented"
+      PersonMock.mock_instance_method(:bar) do
+         "Now implemented"
+      end
+
+	# override mock on an individual instance
+	PersonMock.new.mock_instance_method(:bar) do
+        "Now implemented!!!!"
      end
 
-### When the model changes, the mock fails
+#### When the model changes, the mock fails
+(Requires a regeneration of the mocks files.)
 
- app/models/person.rb
+    #app/models/person.rb
 
     class Person < ActiveRecord::Base
       belongs_to :account
@@ -142,12 +190,17 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
       end
 
     end
+   
+--------------
+
+    #person_spec.rb
 
     person_mock.new.bar('foo', 'type')
       => ArgumentError: wrong number of arguments (2 for 1)
 
+----------------
 
-    app/models/person.rb
+    #app/models/person.rb
 
     class Person < ActiveRecord::Base
       belongs_to :account
@@ -157,12 +210,62 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
       end
 
     end
+    
+--------------
+
+     #person_spec.rb
 
     person_mock.mock_instance_method(:bar) do  |name, type=nil|
       "Now implemented with #{name} and #{type}"
     end
       => NoMethodError: undefined method `bar' for class `PersonMock'
 
+### Managing Mocks
+
+Deletes All Records and Clears Mocked Methods
+    
+    PersonMock.clear_mock     
+    
+Clears all Loaded Mocks - (Use in after(:all) to keep state from leaking to other tests.)
+    
+    ActiveMocker::LoadedMocks.clear_all
+
+Deletes All Records for Loaded Mocks - (Useful in after(:each) to clean up state between examples)
+    
+    ActiveMocker::LoadedMocks.delete_all
+    
+List All Loaded Mocks
+    
+    ActiveMocker::LoadedMocks.all
+    		=> { 'PersonMock' => PersonMock } 
+
+Map The Mock Class to it's Model
+
+	ActiveMocker::LoadedMocks.class_name_to_mock
+		=> { 'Person' => PersonMock } 
+
+### Constants are Available -  (Modules and classes are excluded.)     
+
+	#app/models/person.rb
+
+	class User < ActiveRecord::Base
+	   CONSTANT_VALUE = 13
+	end
+
+-----------------------
+
+	#user_spec.rb
+
+	require 'spec/mocks/user_mock.rb'
+
+	UserMock::CONSTANT_VALUE
+		=> 13
+
+### Mocked Class
+	
+	UserMock.mocked_class
+		=> 'User'
+
 ### ActiveRecord supported methods
 **class methods**
 
@@ -190,9 +293,15 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
   * attributes
   * update
   * save/save!
-  * write_attribute/read_attribute - (private, can be used within an included module)
+  * write_attribute/read_attribute - (protected, can be used within modules)
   * delete
 
+**has_one/belongs_to**
+
+  * build_< association >
+  * create_< association >
+  * create_< association >!
+
 **has_many associations/Collections**
 
   * empty?
@@ -219,22 +328,25 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
   * order(:field_name)
   * reverse_order
   * limit
+  * < association >.create
+  * < association >.build
 
 ### Schema/Migration Option Support
-* All schema types are supported and on initalization coerced by Virtus. If coercsion fails the passed value will be retained.
+* All schema types are supported and coerced by [Virtus](https://github.com/solnic/virtus). If coercion fails the passed value will be retained.
 * Default value
+* Scale and Precision not supported.
 
 ### Known Limitations
 * Model names and table names must follow the default ActiveRecord naming pattern.
-* Included/extended module methods will not be included on the mock. I suggest you keep domain logic out of the model and only add database queries. Domain logic can be put into modules and then included into the mock during test setup. 
-* Queries will not call other mocks classes, for example when using `where` all attributes must reside inside of each record.
-* Creation of association like `User.create_friend` or `User.build_friend` are not supported. If you need this functionality use rspec's stub any instance.
+* Included/extended module methods will not be included on the mock. I suggest you keep domain logic out of the model and only add database queries. Domain logic can be put into modules and then included into the mock during test setup.
+* Whatever associations are setup in one mock object will not effect any other objects.
 * Validation are not present in mocks.
 
 ## Inspiration
 Thanks to Jeff Olfert for being my original inspiration for this project.
 
 ## Contributing
+Your contribution are welcome!
 
 1. Fork it ( http://github.com/zeisler/active_mocker/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/Rakefile

@@ -15,6 +15,12 @@ task :specs do
       end
     end
   end
-  raise "Tests Failed" unless system 'rspec'
-  raise "Tests Failed" unless system 'cd sample_app_rails_4 && rspec'
+  raise "Tests Failed" unless system "rspec --seed #{random_seed}"
+  raise "Tests Failed" unless system "cd sample_app_rails_4 && rspec --seed #{random_seed}"
+end
+
+def random_seed
+  seed = rand(99999)
+  puts "Seed: #{seed}"
+  seed
 end

data/active_mocker.gemspec

@@ -21,16 +21,16 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.0.0'
 
   spec.add_runtime_dependency "activesupport", "~>4.1"
-  spec.add_runtime_dependency "active_hash", "~>1.3"
   spec.add_runtime_dependency "virtus", '~> 1.0'
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", "~>10.1"
-  spec.add_development_dependency "rspec", "~>2.14"
+  spec.add_development_dependency "rspec", "2.14.1"
   spec.add_development_dependency "sqlite3", "~>1.3"
   spec.add_development_dependency "rails", "~>4.1"
-  spec.add_development_dependency "rspec-rails", "~>2"
+  spec.add_development_dependency "rspec-rails", "2.14.1"
   spec.add_development_dependency "fuubar", "~>1.3"
+  spec.add_development_dependency "rspec-given", "~>3.5"
 
   if ENV['DEBUG'] == '1'
     spec.add_development_dependency "debase", "~>0.0"

data/lib/active_mock/association.rb

@@ -0,0 +1,7 @@
+module ActiveMock
+  class Association < Collection
+
+    include Queries
+
+  end
+end

data/lib/active_mock/base.rb

@@ -0,0 +1,250 @@
+module ActiveMock
+
+class RecordNotFound < StandardError
+end
+
+class ReservedFieldError < StandardError
+end
+
+class IdError < StandardError
+end
+
+class FileTypeMismatchError < StandardError
+end
+
+class RejectedParams < Exception
+end
+
+class Base
+
+  include DoNothingActiveRecordMethods
+  extend  ActiveMock::Queries
+  extend  ActiveMock::Creators
+
+  def self.inherited(subclass)
+    return ActiveMocker::LoadedMocks.add(subclass) if subclass.superclass == Base
+    ActiveMocker::LoadedMocks.add_subclass(subclass)
+  end
+
+  class << self
+
+    def records
+      @records ||= Records.new
+    end
+
+    private :records
+
+    delegate :count, :insert, :exists?, :to_a, :to => :records
+    delegate :first, :last, :to => :all
+
+    def delete(id)
+      find(id).delete
+    end
+
+    alias_method :destroy, :delete
+
+    def delete_all(options=nil)
+      return records.reset_all_records if options.nil?
+      where(options).map { |r| r.delete }.count
+    end
+
+    alias_method :destroy_all, :delete_all
+
+    def build_type(type)
+      Virtus::Attribute.build(type)
+    end
+
+    def classes(klass)
+      ActiveMocker::LoadedMocks.find(klass)
+    end
+
+    private :classes
+
+    public
+
+    def clear_mock
+      @model_class_methods, @model_instance_methods = nil, nil
+      delete_all
+    end
+
+  end
+
+  def classes(klass)
+    self.class.send(:classes, klass)
+  end
+
+  private :classes
+
+  attr_reader :associations, :types, :attributes
+
+  def initialize(attributes = {}, &block)
+    setup_instance_variables
+    set_properties_block(attributes, &block)
+  end
+
+  def setup_instance_variables
+    {:@model_instance_methods => :model_instance_methods,
+     :@model_class_methods    => :model_class_methods,
+     :@associations           => :associations,
+     :@attributes             => :attributes,
+     :@types                  => :types}.each do |var, value|
+      instance_variable_set(var, self.class.send(value).dup)
+    end
+  end
+
+  private :setup_instance_variables
+
+  def set_properties_block(attributes = {}, &block)
+    yield self if block_given?
+    set_properties(attributes)
+  end
+  private :set_properties_block
+
+  def update(attributes={})
+    set_properties(attributes)
+  end
+
+  def set_properties(attributes={})
+    attributes.each do |key, value|
+      begin
+        send "#{key}=", value
+      rescue NoMethodError
+        raise ActiveMock::RejectedParams, "{:#{key}=>#{value.inspect}} for #{self.class.name}"
+      end
+    end
+  end
+
+  private :set_properties
+
+  def save(*args)
+    unless self.class.exists?(self)
+      self.class.send(:insert, self)
+    end
+    true
+  end
+
+  alias save! save
+
+  def records
+    self.class.send(:records)
+  end
+
+  private :records
+
+  def delete
+    records.delete(self)
+  end
+
+  delegate :[], :[]=, to: :attributes
+
+  def new_record?
+    !records.new_record?(self)
+  end
+
+  def persisted?
+    records.persisted?(id)
+  end
+
+  def to_hash
+    attributes
+  end
+
+  def inspect
+    ObjectInspect.new(self.class.name, attributes)
+  end
+
+  def hash
+    attributes.hash
+  end
+
+  def ==(obj)
+    return false if obj.nil?
+    return hash == obj.attributes.hash if obj.respond_to?(:attributes)
+    hash == obj.hash if obj.respond_to?(:hash)
+  end
+
+  module PropertiesGetterAndSetter
+
+    def read_attribute(attr)
+      @attributes[attr]
+    end
+
+    def write_attribute(attr, value)
+      @attributes[attr] = types[attr].coerce(value)
+    end
+
+    def read_association(attr)
+      @associations[attr]
+    end
+
+    def write_association(attr, value)
+      @associations[attr] = value
+    end
+
+    protected :read_attribute, :write_attribute, :read_association, :write_association
+
+  end
+
+  include PropertiesGetterAndSetter
+
+  module MockAbilities
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def mock_instance_method(method, &block)
+        model_instance_methods[method.to_s] = block
+      end
+
+      def mock_class_method(method, &block)
+        model_class_methods[method.to_s] = block
+      end
+
+      def model_class_methods
+        @model_class_methods ||= HashWithIndifferentAccess.new
+      end
+
+      def model_instance_methods
+        @model_instance_methods ||= HashWithIndifferentAccess.new
+      end
+
+      private :model_class_methods, :model_instance_methods
+
+
+      def is_implemented(val, method)
+        raise "#{method} is not Implemented for Class: #{name}" if val == :not_implemented
+      end
+
+    end
+
+    def mock_instance_method(method, &block)
+      @model_instance_methods[method.to_s] = block
+    end
+
+    def model_instance_methods
+      class_level_mocks = self.class.send(:model_instance_methods)
+      merged_mocks      = class_level_mocks.merge(@model_instance_methods)
+      return class_level_mocks if all_not_implemented?(merged_mocks) && !all_not_implemented?(class_level_mocks)
+      merged_mocks
+    end
+
+    def all_not_implemented?(hash)
+      hash.select { |k, v| v == :not_implemented }.count == hash.count
+    end
+    
+    private :all_not_implemented?
+
+    def model_class_methods
+      self.class.send(:model_class_methods).merge(@model_class_methods)
+    end
+
+    private :model_class_methods, :model_instance_methods
+
+  end
+
+  include MockAbilities
+
+end
+end