active_mocker 2.0.0.beta1 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb2357b680e38a103a603361d01ca9ed9a67f62f
-  data.tar.gz: 0f82aa8aa703d9919650d19d5ff02eac1f4ad6ae
+  metadata.gz: 8936b1f4fe07483ea78ff2ec8268d9ffb583b6c7
+  data.tar.gz: 18b528c86620ba5988e94acb77a666e1cd4ad601
 SHA512:
-  metadata.gz: ed04ff66eb99a25b4930262cdda6e124b26df1db6e2177e8f80ea20ef55d81ef8233dbdfda54b5c99dc9edb8454a8f5210ea57fe33cc5a4c76c2cc5b66604cd5
-  data.tar.gz: 5417b116dc8afda6894b717e90c2fbfc212a44291aa92a2c717a39887e86e3842301ccd1c813290b9f536851064e4fe0fe4301abc286b451697a2b45ff22986c
+  metadata.gz: 494897b8098ec22bf7e35871b0b5dd993823203c66d2fa373d61025000010a47041c79e2240e03b939561c03f7c337bf3a8ae2577d52dba9640dc690523a1982
+  data.tar.gz: 9ea5b695ac94d7c02d5b791992c7ffaea6d0e8bbfd06f053d11befa2f8dc704d97e42e4d0220480a4e442a3dabc9d493d1861be0a021530e73100d1d2e1f3bb0

data/CHANGELOG.md

@@ -1,10 +1,27 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 2.0.0.pre1 - 2015-12-13
+### Enhancement
+- The mock append name is now changeable using `ActiveMocker::Config.mock_append_name=`. The default still being `Mock`.
+- `ActiveMocker::Mock::MockRelation(mock, collection)` to create separate independent mock collections.
+- Change `ActiveMocker::Mock::Base` to `ActiveMocker::Base`
+- Provide more control over error when running `rake active_mocker:build`, error_verbosity now has setting for 0 to 3.
+
+### Fix
+- Reduce restriction on Virtus gem to 1.0.any
+- When id is not a fixnum and make it match ActiveRecord behavior of calling `#to_i`.
+
+### Depracated
+- Moved `ActiveMocker::MockAbilities` into "active_mocker/deprecated_components/mock_abilities" if a project is still dependent on it this file it can be required and used at least until version 2.1. The alternative is to use `RSpec` verified doubles.
+- `#mock_class("Mock")` method has been moved to "active_mocker/deprecated_components/rspec_helper" if a project is still dependent on it this file it can be required and used at least until version 2.1. The alternative is to use the new api that is accessible by `#active_mocker`.
+
 ## 2.0.0.beta1 - 2015-12-01
 ### Enhancement
 - db/schema.rb is no longer required to generate mocks.
-- `ActiveMocker::Config.disable_modules_and_constants=` Non locally defineded Modules are included/extended by default as well as constant declaration. To Disable to feature set to `true`.
+- Much better support for Single Table Inheritance and gems that add functionality by being the parent class of model.
+- New DB types can be registered with this API. `ActiveRecordSchemaScrapper::Attribute.register_type(name: :array, klass: Array)`
+- `ActiveMocker::Config.disable_modules_and_constants=` Non locally defined Modules are included/extended by default as well as constant declaration. To Disable to feature set to `true`.
 - `MODEL=User rake active_mocker:build` no longer takes a model name to generate just that mock. It now takes a path to a model file. `MODEL=[path-to-model] rake active_mocker:build`
 
 ### Removed

data/README.md

@@ -106,13 +106,10 @@ end
 class Person < ActiveRecord::Base
   belongs_to :account
 
-  def bar(name, type=nil)
+  def self.bar(name, type=nil)
 	puts name
   end
 
-  def self.bar
-  end
-
 end
  ```
 ----------------- 
@@ -136,8 +133,8 @@ end
 ----------
 
 * Assigning the tag `active_mocker:true` will stub any ActiveRecord model Constants for Mock classes in an `it` or a `before/after(:each)`. This removes any need for dependency injection. Write tests and code like you would normally.
-* To stub any Constants in `before(:all)`, `after(:all)` use `mock_class('ClassName')`.
-* Mock state will be cleaned up for you in an `after(:all)`. To clean state your self use `ActiveMocker::LoadedMocks.delete_all`.
+* To stub any Constants in `before(:all)`, `after(:all)` use `active_mocker.find('ClassName')`.
+* Mock state will be cleaned up for you in an `after(:all)`. To clean state your self use `active_mocker.delete_all`.
 
 ---------
     
@@ -206,11 +203,6 @@ end
 
 Person.bar('foo', 'type')
 => "Now implemented with foo and type"
-
-# Rspec 3 mock class method
-allow_any_instance_of(Person).to receive(:bar) do
-  "Now implemented"
-end
 ```
 
 #### When the model changes, the mock fails
@@ -222,7 +214,7 @@ end
 class Person < ActiveRecord::Base
   belongs_to :account
 
-  def bar(name)
+  def self.bar(name)
     puts name
   end
 
@@ -231,7 +223,7 @@ end
 
 --------------
 ```ruby
-Person.new.bar('foo', 'type')
+Person.bar('foo', 'type')
   => ArgumentError: wrong number of arguments (2 for 1)
 ```
 ----------------
@@ -241,7 +233,7 @@ Person.new.bar('foo', 'type')
 class Person < ActiveRecord::Base
   belongs_to :account
 
-  def foo(name, type=nil)
+  def self.foo(name, type=nil)
     puts name
   end
 
@@ -249,10 +241,10 @@ end
  ```   
 --------------
 ```ruby
-allow(person).to receive(:bar) do |name, type=nil|
+allow(Person).to receive(:bar) do |name, type=nil|
   "Now implemented with #{name} and #{type}"
 end
-=> NoMethodError : undefined method `bar' for class ` PersonMock '
+=> RSpec::Mocks::MockExpectationError: PersonMock does not implement: bar
  ```     
 ### Constants and Modules
 
@@ -353,17 +345,18 @@ See [Documentation](http://rdoc.info/github/zeisler/active_mocker/master/ActiveM
   
 
 ### Schema/Migration Option Support
+* A db/schema.rb is not required.
 * 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 is supported.
 * Scale and Precision are not supported.
 
 ### Known Limitations
-* Model names and table names must follow the default ActiveRecord naming pattern.
+* Namespaced modules are not currently supported.
 * When an association is set in one object it may not always be reflective in other objects, especially when it is a non standard/custom association. See [test_rails_4_app/spec/active_record_compatible_api.rb](https://github.com/zeisler/active_mocker/blob/master/test_rails_4_app/spec/active_record_compatible_api.rb) for a complete list of supported associations. 
 * Validation/Callbacks are not supported.
 * Sql queries, joins, etc will never be supported.
 * A record that has been created and then is modified will persist changes without calling `#save`, beware of this difference.
-* This is not a full replacement for ActiveRecord. It has been simplified, having only the most essential parts, so that the is code easier to maintain. I have done my best to make it work correctly, but it is up to you to know how ActiveRecord works and know it's limitations. I aim to make the code easy to read so that it can be understood and modified by it's users.
+* This is not a full replacement for ActiveRecord. It's simplified, with only the most essential parts. There are many tests to verify that is works the same as ActiveRecord, but's yours responsibility to know how ActiveRecord works.
 
 ## Inspiration
 Thanks to Jeff Olfert for being my original inspiration for this project.

data/lib/active_mocker.rb

@@ -1,3 +1,5 @@
+require "rubygems"
+
 require 'active_mocker/version'
 require 'active_mocker/railtie' if defined?(Rails)
 require 'ruby-progressbar'
@@ -8,9 +10,12 @@ require 'active_mocker/config'
 require "reverse_parameters"
 require "active_record_schema_scrapper"
 require "dissociated_introspection"
+require "colorize"
 require "active_mocker/null_progress"
 require "active_mocker/progress"
 require "active_mocker/parent_class"
 require "active_mocker/template_creator"
 require "active_mocker/mock_creator"
+require "active_mocker/error_object"
+require "active_mocker/display_errors"
 require "active_mocker/generate"

data/lib/active_mocker/config.rb

@@ -1,5 +1,4 @@
 module ActiveMocker
-
   class Config
     class << self
 
@@ -8,17 +7,15 @@ module ActiveMocker
                     :single_model_path,
                     :progress_bar,
                     :error_verbosity,
-                    :disable_modules_and_constants
-      #TODO add disable include/extend of modules
-      #TODO disable scope methods
-      #disable instance methods, class methods
-      # can't disable attribute as of yet
+                    :disable_modules_and_constants,
+                    :mock_append_name
 
       def model_base_classes=(val)
         @model_base_classes = val
       end
 
-      def set(&block)
+      # @see ActiveMocker#configure
+      def set
         load_defaults
         yield self
       end
@@ -29,6 +26,7 @@ module ActiveMocker
         @disable_modules_and_constants = false
         @model_dir                     = nil unless @model_dir
         @mock_dir                      = nil unless @mock_dir
+        @mock_append_name              = "Mock"
         rails_defaults if Object.const_defined?('Rails')
       end
 
@@ -38,7 +36,8 @@ module ActiveMocker
          :log_location,
          :single_model_path,
          :progress_bar,
-         :error_verbosity
+         :error_verbosity,
+         :mock_append_name
         ].each { |ivar| instance_variable_set("@#{ivar}", nil) }
       end
 

data/lib/active_mocker/{mock → deprecated_components}/mock_abilities.rb

@@ -1,7 +1,6 @@
 module ActiveMocker
-  module Mock
+  # @deprecated to keep using until removal, require this file.
   module MockAbilities
-
     module InstanceAndClassMethods
 
       def mock_instance_method(method, exe_bind=false, &block)
@@ -15,6 +14,12 @@ module ActiveMocker
         mockable_class_methods.clear
       end
 
+      # @deprecated
+      def clear_mock
+        clear_mocked_methods
+        delete_all
+      end
+
       private
 
       def mockable_instance_methods
@@ -27,7 +32,7 @@ module ActiveMocker
       end
 
       def is_implemented(val, method, type, call_stack)
-        raise NotImplementedError, "#{type}#{method} for Class: #{class_name}. To continue stub the method.", call_stack  if val.nil?
+        raise NotImplementedError, "#{type}#{method} for Class: #{class_name}. To continue stub the method.", call_stack if val.nil?
       end
 
       def execute_block(method)
@@ -41,6 +46,12 @@ module ActiveMocker
       base.extend(ClassMethods)
     end
 
+    def self.prepended(base)
+      class << base
+        prepend(ClassMethods)
+      end
+    end
+
     module ClassMethods
 
       include InstanceAndClassMethods
@@ -87,12 +98,13 @@ module ActiveMocker
       attr_accessor :block, :arguments, :exe_bind
 
       def initialize(block, exe_bind)
-        @block     = block
-        @exe_bind  = exe_bind
+        @block    = block
+        @exe_bind = exe_bind
       end
-
     end
-
   end
+
+  class Base
+    prepend MockAbilities
   end
 end

data/lib/active_mocker/deprecated_components/rspec.rb

@@ -0,0 +1,12 @@
+require "active_mocker/rspec"
+
+module ActiveMocker
+  module Rspec
+    # @deprecated method, will be removed in version 2.1
+    # Use +active_mocker.mocks.find('ClassName')+ instead
+    # To keep using until removal, require this file.
+    def mock_class(*args)
+      active_mocker.mocks.find(*args)
+    end
+  end
+end

data/lib/active_mocker/display_errors.rb

@@ -0,0 +1,64 @@
+module ActiveMocker
+  class DisplayErrors
+    attr_reader :errors, :model_count
+    attr_accessor :success_count
+
+    def initialize(model_count)
+      @errors        = []
+      @success_count = 0
+      @model_count   = model_count
+    end
+
+    def add(errors)
+      @errors.concat([*errors])
+    end
+
+    def wrap_errors(errors, model_name, type: nil)
+      add errors.map { |e| ErrorObject.build_from(object: e, class_name: model_name, type: type ? type : e.try(:type)) }
+    end
+
+    def wrap_an_exception(e, model_name)
+      add ErrorObject.build_from(exception: e, class_name: model_name)
+    end
+
+    def uniq_errors
+      @uniq_errors ||= errors.flatten.compact.uniq.sort_by(&:class_name)
+    end
+
+    def display_errors
+      uniq_errors.each do |e|
+        if ActiveMocker::Config.error_verbosity == 3
+          STDERR.puts "#{e.class_name} has the following errors:"
+          STDERR.puts e.message.colorize(e.level_color)
+          STDERR.puts e.level
+          STDERR.puts e.original_error.message.colorize(e.level_color) if e.original_error?
+          STDERR.puts e.original_error.backtrace if e.original_error?
+          STDERR.puts e.original_error.class.name.colorize(e.level_color) if e.original_error?
+        elsif ActiveMocker::Config.error_verbosity == 2
+          STDERR.puts e.message.colorize(e.level_color)
+        end
+      end
+      if ActiveMocker::Config.error_verbosity > 0 && uniq_errors.count > 0
+        STDERR.puts "Error Summary"
+        error_summary
+      end
+      failure_count_message
+      if ActiveMocker::Config.error_verbosity > 0 && uniq_errors.count > 0
+        STDERR.puts "To see more/less detail set error_verbosity = 0, 1, 2, 3"
+      end
+    end
+
+    def error_summary
+      error_count = uniq_errors.count { |e| [:red].include?(e.level_color) }
+      warn        = uniq_errors.count { |e| [:yellow].include?(e.level_color) }
+      info        = uniq_errors.count { |e| [:default].include?(e.level_color) }
+      STDERR.puts "errors: #{error_count}, warn: #{warn}, info: #{info}"
+    end
+
+    def failure_count_message
+      if ActiveMocker::Config.error_verbosity > 0 && (success_count < model_count || uniq_errors.count > 0)
+        STDERR.puts "#{ model_count - success_count } mock(s) out of #{model_count} failed."
+      end
+    end
+  end
+end

data/lib/active_mocker/error_object.rb

@@ -0,0 +1,46 @@
+module ActiveMocker
+  class ErrorObject
+
+    attr_reader :message, :level, :original_error, :type, :class_name
+
+    def initialize(level: :warn, message:, class_name:, type:, original_error: nil)
+      @level          = level
+      @message        = message
+      @class_name     = class_name
+      @type           = type
+      @original_error = original_error
+    end
+
+    def self.build_from(object: nil, exception: nil, class_name: nil, type: nil)
+      if object
+        args              = [:message, :original_error, :level, :type, :class_name].each_with_object({}) do |meth, hash|
+          hash[meth] = object.public_send(meth) if object.respond_to? meth
+        end
+        args[:type]       = type unless type.nil?
+        args[:class_name] = class_name unless class_name.nil?
+        return self.new(args)
+      elsif exception && class_name
+        return self.new(message:        exception.message,
+                        class_name:     class_name,
+                        original_error: exception,
+                        type:           type ? type : :standard_error)
+      end
+      raise ArgumentError
+    end
+
+    def original_error?
+      original_error.present?
+    end
+
+    def level_color
+      case level
+        when :standard_error, :fatal, :error
+          :red
+        when :warn
+          :yellow
+        when :info
+          :default
+      end
+    end
+  end
+end

data/lib/active_mocker/generate.rb

@@ -5,95 +5,65 @@ module ActiveMocker
       raise ArgumentError, "mock_dir is missing a valued value!" if config.mock_dir.nil? || config.mock_dir.empty?
       create_mock_dir
       raise ArgumentError, "model_dir is missing a valued value!" if config.model_dir.nil? || config.model_dir.empty? || !Dir.exists?(config.model_dir)
-      @success_count = 0
-      @errors = []
+      @display_errors = DisplayErrors.new(models_paths.count)
     end
 
-    # @returns self
+    # @return self
     def call
       progress_init
       models_paths.each do |file|
-        model_name     = model_name(file)
-        model          = model_name.constantize
-        mock_file_name = "#{model_name.underscore}_#{mock_append_name.underscore}.rb"
-        mock_file_path = File.join(Config.mock_dir, mock_file_name)
-        schema_scrapper = schema_scrapper(model)
+        model_name      = model_name(file)
+        model           = get_model_const(model_name)
+        mock_file_name  = "#{model_name.underscore}_#{config.mock_append_name.underscore}.rb"
+        mock_file_path  = File.join(Config.mock_dir, mock_file_name)
+        schema_scrapper = ActiveRecordSchemaScrapper.new(model: model)
         File.open(mock_file_path, 'w') do |file_out|
           begin
-            r = create_mock(file, file_out, schema_scrapper)
-            collect_errors(mock_file_path, r, schema_scrapper)
-            @success_count += 1 if r.completed?
+            result = create_mock(file, file_out, schema_scrapper)
+            collect_errors(mock_file_path, result.errors, schema_scrapper, model_name)
+            display_errors.success_count += 1 if result.completed?
           rescue => e
             rescue_clean_up(e, file_out, model_name)
           end
         end
         progress.increment
       end
-      display_errors
-      failure_count_message
+      display_errors.display_errors
       self
     end
 
+    def get_model_const(model_name)
+      model_name.constantize
+    rescue => e
+      display_errors.wrap_an_exception(e, model_name)
+    end
+
     private
 
-    attr_reader :success_count, :errors
+    attr_reader :display_errors
 
     def create_mock(file, file_out, schema_scrapper)
       MockCreator.new(file:                 File.open(file),
                       file_out:             file_out,
                       schema_scrapper:      schema_scrapper,
                       klasses_to_be_mocked: model_names,
-                      enabled_partials:     enabled_partials).create
+                      enabled_partials:     enabled_partials,
+                      mock_append_name:     config.mock_append_name).create
     end
 
-    def collect_errors(mock_file_path, r, schema_scrapper)
-      unless r.errors.empty?
-        File.delete(mock_file_path)
-        errors.concat(r.errors)
-      end
-      unless schema_scrapper.associations.errors.empty?
-        errors.concat(schema_scrapper.associations.errors.uniq(&:message))
-      end
-      unless schema_scrapper.attributes.errors.empty?
-        errors.concat(schema_scrapper.attributes.errors.uniq(&:message))
+    def collect_errors(mock_file_path, create_mock_errors, schema_scrapper, model_name)
+      unless create_mock_errors.empty?
+        File.delete(mock_file_path) if File.exists?(mock_file_path)
+        display_errors.add(create_mock_errors)
       end
+      display_errors.wrap_errors(schema_scrapper.associations.errors, model_name, type: :associations)
+      display_errors.wrap_errors(schema_scrapper.attributes.errors, model_name, type: :attributes)
     end
 
     def rescue_clean_up(e, file_out, model_name)
-      file_out.close
-      File.delete(file_out.path)
-      e = OpenStruct.new(message: e.message, class_name: model_name, original_error: e) if e.class <= Exception
-      errors << e
-    end
-
-    def schema_scrapper(model)
-      # if model.respond_to?(:abstract_class?) && model.abstract_class?
-      #   null_collection = OpenStruct.new(to_a: [], errors: [])
-      #   OpenStruct.new(associations: null_collection, attributes: null_collection, abstract_class?: true)
-      # else
-        ActiveRecordSchemaScrapper.new(model: model)
-      # end
-    end
-
-    def display_errors
-      errors.flatten.each do |e|
-        if config.error_verbosity == 2
-          puts "#{e.class_name} has failed:"
-          puts e.message
-          puts e.original_error.message if e.respond_to? :original_error
-          puts e.original_error.backtrace if e.respond_to? :original_error
-          puts e.original_error.class.name if e.respond_to? :original_error
-        elsif config.error_verbosity == 1
-          puts e.message
-        end
-      end
-    end
-
-    def failure_count_message
-      if config.error_verbosity > 0 && success_count < models_paths.count
-        "#{ models_paths.count - success_count } mock(s) out of #{models_paths.count} failed."\
-        "To see more detail set error_verbosity = 2 or to mute this error set error_verbosity = 0."
-      end
+      file_out.close unless file_out.closed?
+      File.delete(file_out.path) if File.exists?(file_out.path)
+      display_errors.wrap_an_exception(e, model_name)
     end
 
     def model_name(file)
@@ -124,10 +94,6 @@ module ActiveMocker
       FileUtils::mkdir_p(config.mock_dir) unless Dir.exists?(config.mock_dir)
     end
 
-    def mock_append_name
-      'Mock'
-    end
-
     def enabled_partials
       if config.disable_modules_and_constants
         MockCreator.enabled_partials_default - [*:modules_constants]
@@ -136,4 +102,4 @@ module ActiveMocker
       end
     end
   end
-end
+end