active_mocker 1.4.2 → 1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6369f2b909f9690d9294add97ecaeb74166e64d
-  data.tar.gz: 57d0325c6e6f3e63d09871b8faee78c5b6c0c007
+  metadata.gz: 4906c7473f9d0958f72a17b3ffea9fedd8675e40
+  data.tar.gz: 37a17866216a3179a00c00698dd40a439162ce03
 SHA512:
-  metadata.gz: fdd6ab3f988e0e279c5badebe532bc097ba0416d8d8876f427b0252318b755ef064a3ad047288e903d74c1f902e666d17fb47af4c12612110c0f3758bd8afe18
-  data.tar.gz: 230af5efe3fe3c0c7de30156009135aec0d93fd3f0f8c1ae83dab5e4a5e154978bcd83bb9d636747671537b0118f01cb6fb853f43803fdfec6451f17f2195431
+  metadata.gz: 0b16c13ff134b3bd3c4c78629a69ef70ffdf58fcfd253a16207ef742ff22fc344361e4189a6dfc74ec6dca7dbf9136f38c22bd394d0dddbb3da121ab05328fb6
+  data.tar.gz: 8fe0cbcfc25c4540fd1476ab4644d0caeead8222ba6f4bdb86787161935a0c0b8a0e7d3c7b7730cf6fdfd4fe472ec24dde8f605d2c476008f9155e8369065742

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+## 1.5 - 2014-07-07
+
+### Added
+- Modules that are included/extended in ActiveRecord Models are now available. This may cause failing tests, requiring the modules will fix the issues. 
+- Scoped methods from association will be available if the associated mock is loaded.
+- rspec_helper.rb
+  - Using `tag active_mocker:true` will stub ActiveRecord Model constants for Mock constants. To use with `before(:all)` wrap Constant in `#mock_class('ClassName')`. Using all AR Model names will allow a spec file to run as a full Rails test and as a unit test. 
+  - Tag will also clear all mocks after(:all)
+  
+### Deprecated
+- mock_class_method and mock_instance_method are deprecated and will be removed in 2.0. Rspec 3 mocks has a better implantation of this feature.
+
+### Removed
+- Nothing.
+
+### Fixed
+- `has_many#create_assocation` will now correctly add it self to the parent record.

data/README.md

@@ -1,6 +1,9 @@
 # ActiveMocker
+[![Gem Version](https://badge.fury.io/rb/active_mocker.svg)](http://badge.fury.io/rb/active_mocker)
 [![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)
+[![Dependency Status](https://gemnasium.com/zeisler/active_mocker.svg)](https://gemnasium.com/zeisler/active_mocker)
+[![Gitter chat](https://badges.gitter.im/zeisler/active_mocker.png)](https://gitter.im/zeisler/active_mocker)
 
 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.
 
@@ -11,9 +14,11 @@ Example from a real app
 
 
 ------------------------------------------
-
+* [Contact](#contact)
 * [Installation](#installation)
 * [Setup](#setup)
+  * [Configuration](#overwrite_defaults_configuration)
+  * [Generate](#generate_mocks)
 * [Dependencies](#dependencies)
 * [Usage](#usage)
 * [Mocking Methods](#mocking-methods)
@@ -26,6 +31,12 @@ Example from a real app
 
 ------------------------------------------
 
+## Contact
+
+Ask a question in the [chat room](https://gitter.im/zeisler/active_mocker).
+
+------------------------
+
 
 ## Installation
 
@@ -48,34 +59,20 @@ Or install it yourself as:
 
 ## Setup
 
-### Configure the Mock Generator
-  config/initializers/active_mocker.rb
+### Overwrite defaults configuration
 
     ActiveMocker::Generate.configure do |config|
-      # Required Options
       config.schema_file = File.join(Rails.root, 'db/schema.rb')
       config.model_dir   = File.join(Rails.root, 'app/models')
       config.mock_dir    = File.join(Rails.root, 'spec/mocks')
-      # Logging
       config.logger      = Rails.logger
     end
 
-### Create a Rake Task to Auto Regenerate Mocks
+### Generate 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.
+Running this rake task builds/rebuilds the mocks. It will be ran automatically after every schema modification. 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
-
-    task rebuild_mocks: :environment do
-      puts 'rebuilding mocks'
-      ActiveMocker.create_mocks
-    end
-
-    ['db:schema:load', 'db:migrate', 'db:reset'].each do |task|
-      Rake::Task[task].enhance do
-        Rake::Task['rebuild_mocks'].invoke
-      end
-    end
+    rake active_mocker::build
 
 ## Usage
 
@@ -158,7 +155,8 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
      PersonMock.bar('baz')
         => RuntimeError: ::bar is not Implemented for Class: PersonMock
 
-     PersonMock.mock_class_method(:bar) do  |name, type=nil|
+     # Rspec 3 Mocks
+     allow(PersonMock).to receive(:bar) do  |name, type=nil|
         "Now implemented with #{name} and #{type}"
      end
      
@@ -168,14 +166,11 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
       PersonMock.new.bar('foo', 'type')
         => "Now implemented with foo and type"
 
-      PersonMock.mock_instance_method(:bar) do
+      # Rspec 3 Mocks
+      allow_any_instance(PersonMock).to receive(: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
 (Requires a regeneration of the mocks files.)
@@ -215,13 +210,22 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
 
      #person_spec.rb
 
-    person_mock.mock_instance_method(:bar) do  |name, type=nil|
+    # Rspec 3 Mocks
+    allow(person_mock).to receive(:bar) do  |name, type=nil|
       "Now implemented with #{name} and #{type}"
     end
       => NoMethodError: undefined method `bar' for class `PersonMock'
 
 ### Managing Mocks
 
+Rspec Tag - active_mocker:true
+
+    describe 'Example', active_mocker:true do
+    
+    end
+    
+  Assigning this tag will stub any ActiveRecord model Constants for Mock classes in any `it's` or `before(:each)`. To stub any Constants in `before(:all)`, `after(:all)` use `mock_class('ClassName')`. 
+
 Deletes All Records and Clears Mocked Methods
     
     PersonMock.clear_mock     
@@ -243,8 +247,10 @@ Map The Mock Class to it's Model
 
 	ActiveMocker::LoadedMocks.class_name_to_mock
 		=> { 'Person' => PersonMock } 
+		
+
 
-### Constants are Available -  (Modules and classes are excluded.)     
+### Constants and included and extended Modules are Available.
 
 	#app/models/person.rb
 
@@ -338,9 +344,9 @@ Map The Mock Class to it's Model
 
 ### 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.
-* Whatever associations are setup in one mock object will not effect any other objects.
+* Whatever associations are setup in one mock object will not reflected in any other objects.
 * Validation are not present in mocks.
+* Sql queries, joins, etc will never be supported.
 
 ## Inspiration
 Thanks to Jeff Olfert for being my original inspiration for this project.

data/lib/active_mocker.rb

@@ -1,6 +1,8 @@
 require "active_mocker/version"
-$:.unshift File.expand_path('../../', __FILE__)
 
+require 'active_mocker/railtie' if defined?(Rails)
+require 'ruby-progressbar'
+require 'forwardable'
 require 'active_mocker/public_methods'
 require 'active_mocker/config'
 require 'active_mocker/generate'

data/lib/active_mocker/active_record.rb

@@ -3,16 +3,14 @@ require 'active_mocker/active_record/scope'
 require 'active_mocker/active_record/relationships'
 require 'active_mocker/active_record/unknown_class_method'
 require 'active_mocker/active_record/unknown_module'
-require 'active_mocker/active_record/const_missing'
 
 module ActiveMocker
   module ActiveRecord
-    class Base
+    class Base #< ::ActiveRecord::Base
       extend Scope
       extend Relationships
       extend UnknownClassMethod
-      extend UnknownModule
-      extend ConstMissing
+      # extend UnknownModule
 
       def self.table_name=(table_name)
         @table_name = table_name
@@ -32,8 +30,32 @@ module ActiveMocker
         @primary_key
       end
 
+      class ConstMissing
+
+        def self.const_missing(name)
+          self.const_set name, Class.new(ConstMissing)
+        end
+
+      end
+
       def self.const_missing(name)
-        # Logger_.debug "ActiveMocker :: Can't can't find Constant #{name} from class #{}."
+        Object.const_set name, Class.new(ConstMissing)
+      end
+
+      def self.include(name)
+        _included << name
+      end
+
+      def self._included
+        @included ||= []
+      end
+
+      def self.extend(name)
+        _extended << name
+      end
+
+      def self._extended
+        @extended ||= []
       end
     end
   end

data/lib/active_mocker/active_record/scope.rb

@@ -1,11 +1,11 @@
 module Scope
 
   def scope(method_name, proc)
-    singleton_class.class_eval do
-      params = ActiveMocker::Reparameterize.call(proc.parameters)
-      block = eval("lambda { |#{params}| }")
-      define_method(method_name, block)
-    end
+    get_named_scopes[method_name] = proc
+  end
+
+  def get_named_scopes
+    @scope_methods ||= {}
   end
 
 end

data/lib/active_mocker/active_record/unknown_module.rb

@@ -3,20 +3,20 @@ module ActiveMocker
   module UnknownModule
 
     def include(_module)
-      try_and_log('include', _module)
+      try_and_log('include', _module, caller)
     end
 
     def extend(_module)
-      try_and_log('extend', _module)
+      try_and_log('extend', _module, caller)
     end
 
     private
 
-    def try_and_log(type, name)
+    def try_and_log(type, name, _caller)
       begin
         super _module
       rescue => e
-        Logger.debug "ActiveMocker :: Debug :: Can't #{type} module #{name} from class #{self.name}.\n\t\t\t\t\t\t\t\t#{caller}\n"
+        Logger.debug "ActiveMocker :: Debug :: Can't #{type} module #{name} from class #{self.name}.\n\t\t\t\t\t\t\t\t#{_caller}\n"
         Logger.debug "\t\t\t\t\t\t\t\t#{e}"
       end
     end

data/lib/active_mocker/generate.rb

@@ -1,3 +1,5 @@
+require 'ruby-progressbar'
+require 'forwardable'
 module ActiveMocker
 class Generate
   extend Config
@@ -14,7 +16,10 @@ class Generate
                  :mock_dir,
                  :logger
 
-  def initialize
+  attr_reader :silence
+
+  def initialize(silence: false)
+    @silence = silence
     create_template
   end
 
@@ -32,30 +37,46 @@ class Generate
   end
 
   def generate_model_schema
-    ActiveMocker::ModelSchema::Generate.new(schema_file: schema_file, models_dir: model_dir, logger: logger).run
+    ActiveMocker::ModelSchema::Generate.new(schema_file: schema_file, models_dir: model_dir, logger: logger, progress: progress).run
+  end
+
+  def model_count
+    ActiveMocker::ModelSchema::Generate.new(schema_file: schema_file, models_dir: model_dir, logger: logger).models.count
+  end
+
+  def progress
+    return @progress if !@progress.nil? || silence == true
+    progress_options = {:title => "Generating Mocks",
+                        :total => model_count * 2,
+                        format: '%t |%b>>%i| %p%%'}
+    @progress = ProgressBar.create(progress_options)
+  end
+
+  def increment_progress
+    progress.increment unless silence
   end
 
   def create_template
     mocks_created = 0
-    models = generate_model_schema
-    models.each do |model|
-      # begin
-        klass_str = ''
-        klass_str = model.render(File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read, mock_append_name)
+    generate_model_schema.each do |model|
+      begin
+
+      klass_str = model.render(File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read, mock_append_name)
       FileUtils::mkdir_p mock_dir unless File.directory? mock_dir
       File.open(File.join(mock_dir,"#{model.table_name.singularize}_mock.rb"), 'w').write(klass_str)
       logger.info "saving mock #{model.class_name} to #{mock_dir}"
 
-      # rescue Exception => exception
-      #   logger.debug $!.backtrace
-      #   logger.debug exception
-      #   logger.info "failed to load #{model} model"
-      #   next
-      # end
+      rescue Exception => exception
+        logger.debug $!.backtrace
+        logger.debug exception
+        logger.info "failed to load #{model} model"
+        next
+      end
       mocks_created += 1
-
+      increment_progress
     end
-    logger.info "Generated #{mocks_created} of #{models.count} mocks"
+    progress.finish unless silence
+    logger.info "Generated #{mocks_created} of #{model_count} mocks"
   end
 
   def mock_append_name

data/lib/active_mocker/loaded_mocks.rb

@@ -1,75 +1,81 @@
 module ActiveMocker
 
   class LoadedMocks
-    def self.add(mocks_to_add)
-      mocks.merge!({mocks_to_add.name => mocks_to_add})
-    end
+    
+    class << self
 
-    def self.add_subclass(subclass)
-      subclasses.merge!({subclass.mocked_class => subclass})
-    end
+      def add(mocks_to_add)
+        mocks.merge!({mocks_to_add.name => mocks_to_add})
+      end
 
-    def self.subclasses
-      @subclasses ||= {}
-    end
+      def add_subclass(subclass)
+        subclasses.merge!({subclass.mocked_class => subclass})
+      end
 
-    def self.clear_subclasses
-      @subclasses = nil
-    end
+      def subclasses
+        @subclasses ||= {}
+      end
 
-    def self.mocks
-      @mocks ||= {}
-    end
+      def clear_subclasses
+        subclasses.clear
+      end
 
-    def self.find(klass)
-      class_name_to_mock[klass]
-    end
+      def mocks
+        @mocks ||= {}
+      end
 
-    def self.all
-      mocks
-    end
+      def find(klass)
+        class_name_to_mock[klass]
+      end
 
-    def self.clear_all
-      action = -> (mocks){ mocks.each { |n, m| m.clear_mock } }
-      action.call(mocks)
-      action.call(subclasses)
-      clear_subclasses
-    end
+      def all
+        mocks
+      end
 
-    def self.delete_all
-      action = -> (mocks) { mocks.each { |n, m| m.delete_all } }
-      action.call(mocks)
-      action.call(subclasses)
-    end
+      def clear_all
+        all_mocks.each { |m| m.clear_mock }
+        clear_subclasses
+      end
 
-    def self.reload_all
-      action = -> (mocks) { mocks.each { |n, m| m.send(:reload) } }
-      action.call(mocks)
-      action.call(subclasses)
-    end
+      def delete_all
+        all_mocks.each { |m| m.delete_all }
+      end
 
-    def self.undefine_all
-      action = -> (mocks) { mocks.each do |n, m|
-        Object.send(:remove_const, n) if Object.const_defined?(n)
-      end }
-      action.call(mocks)
-      action.call(subclasses)
-    end
+      def reload_all
+        all_mocks.each { |m| m.send(:reload) }
+      end
 
-    def self.class_name_to_mock
-      hash = {}
-      mocks.each do |mock_name, mock_constant|
-        hash[mock_constant.mocked_class] = mock_constant
+      def undefine_all
+        all_mocks_as_str.each do |n|
+          Object.send(:remove_const, n) if Object.const_defined?(n)
+        end
       end
-      hash.merge(subclasses)
-    end
 
-    private
+      def all_mocks_as_str
+        mocks.keys + subclasses.keys
+      end
 
-    def self.internal_clear
-      clear_subclasses
-      @mocks = nil
+      def class_name_to_mock
+        hash = mocks.values.each_with_object({}) do |mock_constant, hash|
+          hash[mock_constant.mocked_class] = mock_constant
+        end
+        hash.merge(subclasses)
+      end
+
+      private
+
+      def internal_clear
+        clear_subclasses
+        mocks.clear
+      end
+
+
+      def all_mocks
+        mocks.values + subclasses.values
+      end
+      
     end
+   
   end
 
 end