active_mocker 1.8.4 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae228af179be61ae85b6dcacebff1adbad0c2de3
-  data.tar.gz: d4b1cc0d7d6209bbe2ca6210534e54348746d7ef
+  metadata.gz: fb2357b680e38a103a603361d01ca9ed9a67f62f
+  data.tar.gz: 0f82aa8aa703d9919650d19d5ff02eac1f4ad6ae
 SHA512:
-  metadata.gz: b68c2749a6ec8ef1c1617345bca88413cc22ca5f2ff4b7feadd9120d38a2dea9839fc6fc1352b336d966d93119b67b3e330d1b7d2f5dc1092bd16cf5f5e26628
-  data.tar.gz: 01f7f45c33a3ec713045d38114653bf5a345b27836ff9ed3ced1a222528e3d50e0cbaf5289ea426097eda7209bee880d11db22c34bc87d164f7cc45b6d57335e
+  metadata.gz: ed04ff66eb99a25b4930262cdda6e124b26df1db6e2177e8f80ea20ef55d81ef8233dbdfda54b5c99dc9edb8454a8f5210ea57fe33cc5a4c76c2cc5b66604cd5
+  data.tar.gz: 5417b116dc8afda6894b717e90c2fbfc212a44291aa92a2c717a39887e86e3842301ccd1c813290b9f536851064e4fe0fe4301abc286b451697a2b45ff22986c

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 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`.
+- `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
+- `log/active_mocker.log` is replaced env `ERROR_VERBOSITY=[0,1,2] rake active_mocker:build` or in Ruby `ActiveMocker::Config.error_verbosity=`
+- Removing undocumented feature of treating children of mocks differently. Remove the ability to sub class a mock and have it for use in that context when creating/finding association.
+
+### Depracating
+- `mock_class` for rspec_helper, use `instead active_mocker.mocks.find('ClassName')`. Will be removed in v2.1
+
 ## 1.8.4 - 2015-10-06
 ### Fix
 - Calling scoped method that has not been stubbed raises incorrect error. https://github.com/zeisler/active_mocker/issues/22

data/README.md

@@ -4,8 +4,10 @@
 [![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)
+[![Gittip](http://img.shields.io/gittip/zeisler.svg)](https://www.gittip.com/zeisler/)
 
-ActiveMocker creates mocks classes from ActiveRecord models. Allowing your test suite to run very fast by not loading Rails or a database. It parses the schema.rb and the defined methods on a model then generates a ruby file that can be included within a test. The mock file can be run by themselves and come with a partial implementation of ActiveRecord. Attributes and associations can be used just the same as in ActiveRecord. Methods will have the correct arguments but raise an NotImplementedError when called. Mocks are regenerated when the schema is modified so your mocks will not go stale; preventing the case where your units tests pass but production code fails.
+## Description
+ActiveMocker creates mock classes from ActiveRecord models, allowing your test suite to run at breakneck speed. This can be done by not loading Rails or hitting a database. The models are read dynamically and statically so that ActiveMocker can generate a Ruby file to require within a test. The mock file can be run by itself and comes with a partial implementation of ActiveRecord. Attributes and associations can be used the same as in ActiveRecord. Methods have the same argument signature but raise a NotImplementedError when called, allowing you to stub it with a mocking framework, like RSpec. Mocks are regenerated when the schema is modified so your mocks won't go stale, preventing the case where your units tests pass but production code fails.
 
 Examples from a real apps
 
@@ -254,7 +256,7 @@ end
  ```     
 ### Constants and Modules
 
-* Any locally defined modules will not be included or extended.
+* Any locally defined modules will not be included or extended. It can be disabled by `ActiveMocker::Config.disable_modules_and_constants = true`
 
 ---------------
 ```ruby

data/lib/active_mocker.rb

@@ -1,32 +1,16 @@
 require 'active_mocker/version'
-
-require 'logger'
 require 'active_mocker/railtie' if defined?(Rails)
 require 'ruby-progressbar'
 require 'forwardable'
 require 'active_support/all'
-require 'singleton'
-require 'parser/current'
-require 'unparser'
-require 'virtus'
-require 'attr_permit'
-require 'active_mocker/version'
-require 'active_mocker/ruby_parse'
 require 'active_mocker/public_methods'
 require 'active_mocker/config'
-require 'active_mocker/generate'
-require 'active_mocker/logger'
-require 'active_mocker/active_record/table'
-require 'active_mocker/active_record/field'
-require 'active_mocker/file_reader'
-require 'active_mocker/reparameterize'
-require 'active_mocker/active_record'
-require 'active_mocker/model_reader'
-require 'active_mocker/schema_reader'
-require 'active_mocker/active_record/schema'
-require 'active_mocker/active_record'
-require 'active_mocker/model_reader'
-require 'active_mocker/reparameterize'
-require 'active_mocker/db_to_ruby_type'
-require 'active_mocker/model_schema'
-require 'active_mocker/model_schema/assemble'
+require "reverse_parameters"
+require "active_record_schema_scrapper"
+require "dissociated_introspection"
+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/generate"

data/lib/active_mocker/config.rb

@@ -3,73 +3,53 @@ module ActiveMocker
   class Config
     class << self
 
-      attr_accessor :schema_file,
-                    :model_dir,
+      attr_accessor :model_dir,
                     :mock_dir,
-                    :model_base_classes,
-                    :file_reader,
-                    :build_in_progress,
-                    :log_location,
-                    :clear_log_on_build,
-                    :generate_for_mock
+                    :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
 
       def model_base_classes=(val)
         @model_base_classes = val
       end
 
-      def set
+      def set(&block)
         load_defaults
         yield self
       end
 
       def load_defaults
-        @schema_file        = nil unless @schema_file
-        @model_dir          = nil unless @model_dir
-        @mock_dir           = nil unless @mock_dir
-        @model_base_classes = %w[ ActiveRecord::Base ] unless @model_base_classes
-        @file_reader        = FileReader     unless @file_reader
-        @log_location       = 'log/active_mocker.log' unless @log_location
-        @clear_log_on_build = true
-        @generate_for_mock  = ENV['MODEL']
+        @error_verbosity               = 1
+        @progress_bar                  = true
+        @disable_modules_and_constants = false
+        @model_dir                     = nil unless @model_dir
+        @mock_dir                      = nil unless @mock_dir
         rails_defaults if Object.const_defined?('Rails')
       end
 
-      def logger
-        default_logger
-      end
-
       def reset_all
-        [ :@schema_file,
-          :@model_dir,
-          :@mock_dir,
-          :@model_base_classes,
-          :@file_reader,
-          :@logger,
-          :@schema_file,
-          :@model_dir,
-          :@mock_dir].each{|ivar| instance_variable_set(ivar, nil)}
-      end
-
-      def default_logger
-        FileUtils.mkdir_p(File.dirname(@log_location)) unless File.directory?(File.dirname(@log_location))
-        ::Logger.new(@log_location)
+        [:model_dir,
+         :mock_dir,
+         :log_location,
+         :single_model_path,
+         :progress_bar,
+         :error_verbosity
+        ].each { |ivar| instance_variable_set("@#{ivar}", nil) }
       end
 
       def rails_defaults
-        @schema_file = File.join(Rails.root, 'db/schema.rb') unless @schema_file
-        @model_dir   = File.join(Rails.root, 'app/models')   unless @model_dir
-        @mock_dir    = File.join(Rails.root, 'spec/mocks')   unless @mock_dir
+        @model_dir = File.join(Rails.root, 'app/models') unless @model_dir
+        @mock_dir  = File.join(Rails.root, 'spec/mocks') unless @mock_dir
       end
 
-      def clear_log
-        if @clear_log_on_build && File.exist?(@log_location)
-          FileUtils.rm(@log_location)
-        end
+      def progress_class
+        @progress_bar ? Progress : NullProgress
       end
-
     end
-
   end
-
 end
-

data/lib/active_mocker/generate.rb

@@ -1,134 +1,139 @@
-require 'ruby-progressbar'
-require 'forwardable'
 module ActiveMocker
-class Generate
-  extend Forwardable
-
-  attr_reader :silence
-
-  def initialize(silence: false)
-    @silence = silence
-    Config.clear_log
-    Config.build_in_progress = true
-    create_template
-    Config.build_in_progress = false
-  end
-
-  private
-
-  def generate_model_schema
-    ActiveMocker::ModelSchema::Assemble.new(progress: progress).run
-  end
+  class Generate
+
+    def initialize
+      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 = []
+    end
 
-  def model_count
-    @model_count ||= ActiveMocker::ModelSchema::Assemble.new.models.count
-  end
+    # @returns 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)
+        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?
+          rescue => e
+            rescue_clean_up(e, file_out, model_name)
+          end
+        end
+        progress.increment
+      end
+      display_errors
+      failure_count_message
+      self
+    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
+    private
 
-  def increment_progress
-    progress.increment unless silence
-  end
+    attr_reader :success_count, :errors
 
-  attr_accessor :mocks_created, :not_valid_models
-  def create_template
-    @mocks_created    = 0
-    @not_valid_models = 0
-    clean_up
-    generate_model_schema.each do |model|
-      next unless generate_and_rescue(model)
+    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
     end
-    exit_message
-  end
 
-  def generate_and_rescue(model)
-    begin
-      raise_if_is_exception!(model)
-      generate_mock(model)
-      increase_mocks_created
-    rescue Exception => exception
-      log_failed_mock(exception, model)
-      false
+    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))
+      end
     end
-  end
 
-  def increase_mocks_created
-    @mocks_created += 1
-    increment_progress
-  end
-
-  def raise_if_is_exception!(model)
-    raise model if model.class.ancestors.include?(Exception)
-  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 exit_message
-    progress.finish unless silence
-    Config.logger.info "Generated #{mocks_created} of #{model_count} mocks."
-    failed_mocks = (model_count - not_valid_models) - mocks_created
-    if failed_mocks > 0
-      puts "#{failed_mocks} mock(s) out of #{model_count} failed. See `log/active_mocker.log` for more info."
+    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
-  end
 
-  def generate_mock(model)
-    klass_str = generate_mock_string(model)
-    save_mock_file(klass_str, model)
-    log_save(model)
-  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 log_failed_mock(exception, model)
-    Config.logger.debug $!.backtrace
-    Config.logger.debug exception
-    Config.logger.info "Failed to load #{model.class_name} model."
-  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
+    end
 
-  def log_save(model)
-    Config.logger.info "saving mock #{model.class_name} to #{Config.mock_dir}"
-  end
+    def model_name(file)
+      File.basename(file, '.rb').camelize
+    end
 
-  def save_mock_file(klass_str, model)
-    File.open(File.join(Config.mock_dir, "#{model.class_name.underscore}_mock.rb"), 'w') do |f|
-      f.write(klass_str)
+    def model_names
+      @model_names ||= models_paths.map { |p| model_name(p) }
     end
-  end
 
-  def generate_mock_string(model)
-    model.render(File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read, mock_append_name)
-  end
+    def progress
+      @progress
+    end
 
-  def clean_up
-    delete_mocks if delete_mocks?
-    create_mock_dir
-  end
+    def progress_init
+      @progress = config.progress_class.new(models_paths.count)
+    end
 
-  def delete_mocks
-    FileUtils.rm Dir.glob(File.join(mock_dir, "*_#{mock_append_name.underscore}.rb")) 
-  end
+    def models_paths
+      @models_paths ||= Dir.glob(config.single_model_path || File.join(config.model_dir, "*.rb"))
+    end
 
-  def mock_dir
-    raise 'ActiveMocker::Config.mock_dir is set to nil!' if Config.mock_dir.nil? || Config.mock_dir.empty?
-    File.expand_path(Config.mock_dir)
-  end
+    def config
+      ActiveMocker::Config
+    end
 
-  def delete_mocks?
-    !Config.generate_for_mock && Dir.exists?(mock_dir)
-  end
+    def create_mock_dir
+      FileUtils::mkdir_p(config.mock_dir) unless Dir.exists?(config.mock_dir)
+    end
 
-  def create_mock_dir
-    FileUtils::mkdir_p(mock_dir) unless Dir.exists?(mock_dir)
-  end
+    def mock_append_name
+      'Mock'
+    end
 
-  def mock_append_name
-    'Mock'
+    def enabled_partials
+      if config.disable_modules_and_constants
+        MockCreator.enabled_partials_default - [*:modules_constants]
+      else
+        MockCreator.enabled_partials_default
+      end
+    end
   end
-
-end
-end
-
-
+end

data/lib/active_mocker/loaded_mocks.rb

@@ -1,91 +1,102 @@
 module ActiveMocker
-
   class LoadedMocks
-    
     class << self
 
-      # Input ActiveRecord Model as String returns ActiveMock equivalent class.
-      #   +find('User')+ => UserMock
-      def find(klass)
-        class_name_to_mock[klass]
-      end
+      extend Forwardable
+      def_delegators :mocks, :find, :delete_all
 
-      # Returns Hash key being a string of the active_record class name
-      # and the value being the mocked class.
-      #   ActiveMocker::LoadedMocks.all
-      #      => {'PersonMock' => PersonMock}
-      def all
-        mocks
+      # Returns an Enumerable of all currently loaded mocks.
+      #
+      #   ActiveMocker::LoadedMocks.mocks
+      #       => <Collection @hash: {'Person' => PersonMock}>
+      # @return ActiveMocker::LoadedMocks::Collection
+      def mocks
+        Collection.new(mocks_store.values.each_with_object({}) do |mock_constant, hash|
+                         hash[mock_constant.send(:mocked_class)] = mock_constant
+                       end)
       end
 
-      # Calls clear_all for all mocks, which deletes all saved records and removes mock_class/instance_method.
-      #   It will also clear any sub classed mocks from the list
-      #   Method will be deprecated in v2 because mocking is deprecated
-      def clear_all
-        all_mocks.each { |m| m.clear_mock }
-        clear_subclasses
-      end
+      # @deprecated Use {#mocks} instead of this method.
+      alias_method :class_name_to_mock, :mocks
 
-      # Calls delete_all for all mocks, which deletes all saved records.
-      #
-      def delete_all
-        all_mocks.each { |m| m.delete_all }
-      end
+      # @deprecated Use {#mocks} instead of this method.
+      alias_method :all, :mocks
 
-      # Returns Hash +{"ActiveRecordModel" => MockVersion}+, key being a string of the active_record class name
-      # and the value being the mocked class. Any sub classed mocked will override the original mock until clear_all is called.
-      #
-      #   ActiveMocker::LoadedMocks.class_name_to_mock
-      #       => {'Person' => PersonMock}
-      def class_name_to_mock
-        mocks.values.each_with_object({}) do |mock_constant, hash|
-          hash[mock_constant.send(:mocked_class)] = mock_constant
-        end.merge(subclasses)
-      end
+      # @deprecated Use {#delete_all} instead of this method.
+      alias_method :clear_all, :delete_all
 
-      private
+      class Collection
 
-      def add(mocks_to_add)
-        mocks.merge!({mocks_to_add.name => mocks_to_add})
-      end
+        include Enumerable
 
-      def add_subclass(subclass)
-        subclasses.merge!({subclass.send(:mocked_class) => subclass})
-      end
+        # @option opts [Hash] hash
+        def initialize(hash={})
+          @hash = Hash[hash]
+        end
 
-      def mocks
-        @mocks ||= {}
-      end
+        extend Forwardable
+        def_delegators :hash, :[]=, :[], :each, :to_hash, :to_h
 
-      def undefine_all
-        all_mocks_as_str.each do |n|
-          Object.send(:remove_const, n) if Object.const_defined?(n)
+        # Calls {#delete_all} for all mocks globally, which removes all records that were saved or created.
+        # @return [NilClass]
+        def delete_all
+          mocks.each(&__method__)
         end
-      end
 
-      def all_mocks_as_str
-        mocks.keys + subclasses.keys
-      end
+        # @param [Array<Symbol, String, ActiveMocker::Mock>] args an array of ActiveRecord Model Names as Strings or Symbols
+        # or of mock object.
+        # @return [ActiveMocker::LoadedMocks::Collection] returns ActiveMock equivalent class.
+        def slice(*args)
+          self.class.new(select { |k, v| get_item(args, k, v) })
+        end
 
-      def subclasses
-        @subclasses ||= {}
-      end
+        # Input ActiveRecord Model Name as String or Symbol and it returns everything but that ActiveMock equivalent class.
+        #    except('User') => [AccountMock, OtherMock]
+        # @param [Array<Symbol, String, ActiveMocker::Mock>] args
+        # @return ActiveMocker::LoadedMocks::Collection
+        def except(*args)
+          self.class.new(reject { |k, v| get_item(args, k, v) })
+        end
+
+        # Input ActiveRecord Model Name as String or Symbol returns ActiveMock equivalent class.
+        #    find('User') => UserMock
+        # @param [Symbol, String, ActiveMocker::Mock] item
+        # @return ActiveMocker::Mock
+        def find(item)
+          slice(item).mocks.first
+        end
+
+        # @return [Array<ActiveMocker::Mock>]
+        def mocks
+          hash.values
+        end
+        alias_method :values, :mocks
+
+        private
+        attr_reader :hash
+
+        def get_item(args, k, v)
+          args.map do |e|
+            if [:to_str, :to_sym].any?{|i| e.respond_to? i}
+              e.to_s == k
+            else
+              e == v
+            end
+          end.any? { |a| a }
+        end
 
-      def clear_subclasses
-        subclasses.clear
       end
 
-      def internal_clear
-        clear_subclasses
-        mocks.clear
+      private
+
+      def mocks_store
+        @mocks ||= {}
       end
 
-      def all_mocks
-        mocks.values + subclasses.values
+      def add(mocks_to_add)
+        mocks_store.merge!({ mocks_to_add.name => mocks_to_add })
       end
-      
+
     end
-   
   end
-
 end