active_mocker 1.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 439e04b0f76f49bdf4e00ec5e2b89e7e4956b355
-  data.tar.gz: fbac11173deec5cc2bd514e60d8969b4bed1def6
+  metadata.gz: 7f014b144505ba0f608261c141298febf45e73a8
+  data.tar.gz: 68c6f7bb51432d351aa977856121b2d78d893f66
 SHA512:
-  metadata.gz: fda21c454f146b0f71ab12534c6e9b002a9ade2f55a94580ed1bc2aef1939906450d37e93895a7642d75337049e39961599caf30b664fcbf0d5c215b69011593
-  data.tar.gz: e383efe824051292bd4215db6c824d59b8186c0b4e4605f751e434c54d1e942e0afa82aa3b95bc5e564008d7650acd80d4ac69a1d9389762f75c7b1fad931b93
+  metadata.gz: e0f87e4cf4ea8d106193343d7c7b93444bcf369966d1c0934616c5761235eab288a9421acc0314e7210ae16401f813a51c0999fd28cd8ee09a1853d8b645c091
+  data.tar.gz: 87b90a2801324d5f16bb9adc915c415a67c5ccc832d70970e77781b10c4fc5eab642ed3ff511c60db7d5976628c3b6d554b1d9577e370ab6657da75e9d7e9f1e

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 sample_app_rails_4/log/*
+log/test.log

data/README.md

@@ -1,11 +1,12 @@
 # ActiveMocker
 [![Build Status](https://travis-ci.org/zeisler/active_mocker.png?branch=master)](https://travis-ci.org/zeisler/active_mocker)
 
-Create static mocks from active record models without loading rails or running a database.
+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 definded 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.
 
 Example from a real app
-Finished in 0.54599 seconds
-190 examples, 0 failures
+
+		Finished in 0.54599 seconds
+		190 examples, 0 failures
 
 ## Installation
 
@@ -21,11 +22,37 @@ Or install it yourself as:
 
     $ gem install active_mocker
 
-## Usage
 
-Needs updating, for now see the rails sample application
+### Setup
+  config/initializers/active_mocker.rb
+
+    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
+
+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
+
+    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
+
+## Usage
 
-    #db/schema.rb
+ db/schema.rb
 
     ActiveRecord::Schema.define(version: 20140327205359) do
 
@@ -52,22 +79,11 @@ Needs updating, for now see the rails sample application
       end
 
     end
+    
 
-    require 'active_mocker'
-
-    ActiveMocker.configure do |config|
-      # Required Options
-      config.schema_file = "#{APP_ROOT}/db/schema.rb"
-      config.model_dir   = "#{APP_ROOT}/app/models"
-      # Additional Options
-      config.schema_attributes   = true  #default
-      config.model_attributes    = true  #default
-      # Logging
-      config.log_level = Logger::WARN       #default
-    end
+ spec/models/person_spec.rb
 
-    ActiveMocker.mock('Person')
-        => PersonMock
+    load 'spec/mocks/person_mock.rb'
 
     PersonMock.column_names
         => ["id", "account_id", "first_name", "last_name", "address", "city"]
@@ -80,7 +96,7 @@ Needs updating, for now see the rails sample application
 
 ### When schema.rb changes, the mock fails
 
-     #db/schema.rb
+ db/schema.rb
 
      ActiveRecord::Schema.define(version: 20140327205359) do
 
@@ -116,7 +132,7 @@ Needs updating, for now see the rails sample application
 
 ### When the model changes, the mock fails
 
-    #app/models/person.rb
+ app/models/person.rb
 
     class Person < ActiveRecord::Base
       belongs_to :account
@@ -169,13 +185,33 @@ Needs updating, for now see the rails sample application
 * attributes
   * update
   * save
-  * write_attribute - (private)
+  * write_attribute - (private, can be used within an included module)
   * read_attribute  - (private)
 
+**has_many associations**
+  
+  * empty?
+  * length/size/count
+  * uniq
+  * replace
+  * first/last
+  * concat
+  * include
+  * push
+  * clear
+  * take
+
+  **Schema/Migration Option Support**
+ 
+ * All schema types are supported and on initalization coerced by Virtus. If coercsion fails the passed value will be retained.
+ * Default value 
+
 ### Known Limitations
 
-* **::mock** model names and table names must follow the default ActiveRecord naming pattern.
-* Included/extended module methods will not be included on the mock.
+* 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. 
+* Deleting one record at a time is not support, this is a limitation of ActiveHash.
+* Queries will not call other mocks classes, for example when using `where` all attributes must reside inside of each record.
 
 ## Inspiration
 Thanks to Jeff Olfert for being my original inspiration for this project.

data/Rakefile

@@ -16,5 +16,5 @@ task :specs do
     end
   end
   raise "Tests Failed" unless system 'rspec'
-  raise "Tests Failed" unless system 'rspec sample_app_rails_4/spec'
+  raise "Tests Failed" unless system 'cd sample_app_rails_4 && rspec'
 end

data/active_mocker.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = ActiveMocker::VERSION
   spec.authors       = ["Dustin Zeisler"]
   spec.email         = ["dustin@zive.me"]
-  spec.summary       = %q{Create static mocks from active record models without loading rails or running a database.}
-  spec.description   = %q{Create static mocks from active record models without loading rails or running a database. The Mock's methods have the same arguments as the AR model and if they change you get a error in your test.}
+  spec.summary       = %q{Creates mocks from Active Record models. Allows your test suite to run very fast by not loading Rails or hooking to a database.}
+  spec.description   = %q{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 definded 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.}
   spec.homepage      = "https://github.com/zeisler/active_mocker"
   spec.license       = "MIT"
 
@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.0.0'
 
-  spec.add_runtime_dependency "activerecord", "~>4.1"
   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"

data/lib/active_hash/init.rb

@@ -1,37 +1,28 @@
 require 'active_support/core_ext/hash/indifferent_access'
 module ActiveHash
-
   module ARApi
 
     module Init
 
-      attr_reader :associations
+      attr_reader :associations, :types
 
       def initialize(attributes = {})
-        filter_associations(HashWithIndifferentAccess.new(attributes))
-        @attributes.dup.merge(@associations.dup).each do |key, value|
-          send "#{key}=", value #maybe could just check if responds_to method? How AR works?
+        @types = {}
+        attributes.each do |key, value|
+          begin
+            send "#{key}=", value
+          rescue NoMethodError
+            raise ActiveMocker::RejectedParams, "{:#{key}=>#{value.inspect}} for #{self.class.name}"
+          end
         end
-      end
-
-      private
-
-      def filter_associations(attributes)
-        permitted_params = [*self.class.send(:attribute_names), *self.class.send(:association_names)]
-        rejected_params = attributes.reject{ |p| permitted_params.include? p.to_sym}
-        raise "Rejected params: #{rejected_params} for #{self.class.name}" if !rejected_params.empty?
-        @attributes = attributes.select do |k, v|
-          self.class.send(:attribute_names).include? k.to_sym
-        end
-        @attributes = self.class.send(:attribute_template).merge(@attributes)
-        @associations = attributes.select do |k, v|
-          self.class.send(:association_names).include? k.to_sym
-        end
-        @associations = self.class.send(:association_template).merge(associations)
 
       end
-
     end
   end
 
+end
+
+module ActiveMocker
+  class RejectedParams < Exception
+  end
 end

data/lib/active_mocker.rb

@@ -21,3 +21,4 @@ require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/reparameterize'
 require 'active_hash/ar_api'
+require 'virtus'

data/lib/active_mocker/active_record/unknown_class_method.rb

@@ -3,7 +3,7 @@ module ActiveMocker
   module UnknownClassMethod
 
     def method_missing(meth, *args)
-      Logger_.debug "ActiveMocker :: #{meth} called from class #{self.name} is unknown and will not be available in mock."
+      Logger.debug "ActiveMocker :: #{meth} called from class #{self.name} is unknown and will not be available in mock."
     end
 
   end

data/lib/active_mocker/active_record/unknown_module.rb

@@ -6,8 +6,8 @@ module ActiveMocker
       begin
         super _module
       rescue => e
-        Logger_.debug e
-        Logger_.debug "ActiveMocker :: Can't include module #{_module} from class #{self.name}.\n #{caller}"
+        Logger.debug e
+        Logger.debug "ActiveMocker :: Can't include module #{_module} from class #{self.name}.\n #{caller}"
 
       end
     end
@@ -16,7 +16,7 @@ module ActiveMocker
       begin
         super _module
       rescue
-        Logger_.debug "ActiveMocker :: Can't extend module #{_module} from class #{self.name}..\n #{caller}"
+        Logger.debug "ActiveMocker :: Can't extend module #{_module} from class #{self.name}..\n #{caller}"
       end
     end
 

data/lib/active_mocker/collection_association.rb

@@ -4,39 +4,38 @@ module ActiveMocker
 
     include Enumerable
 
-    attr_accessor :collection
-
     def initialize(collection=[])
-      @collection = *collection ||=[]
-    end
-
-    def each(&block)
-      collection.each do |item|
-        block.call(item)
-      end
-    end
-
-    def last
-      collection.last
+      @association = [*collection]
     end
 
     def <<(*records)
-      collection.concat(records.flatten)
+      association.concat(records.flatten)
     end
 
+    delegate :any?, :empty?, :length, :size, :count, :uniq, :replace, :first, :last, :concat, :include?, :push, :clear, :take, to: :association
+    alias distinct uniq
+
     def sum(attribute=nil)
-      values = collection.map{ |obj| obj.send(attribute) }
-      values.inject{ |sum, n| sum + n }
+      values = association.map { |obj| obj.send(attribute) }
+      values.inject { |sum, n| sum + n }
     end
 
     def ==(other_ary)
-      collection == other_ary
+      association == other_ary
+    end
+
+    def each(&block)
+      association.each do |item|
+        block.call(item)
+      end
     end
 
-    def method_missing(meth, *args, &block)
-      collection.send(meth, *args, &block)
+    def to_a
+      @association
     end
 
+    private
+    attr_accessor :association
+
   end
 end
-

data/lib/active_mocker/config.rb

@@ -11,7 +11,9 @@ module ActiveMocker
                   :model_file_reader,
                   :clear_cache,
                   :migration_dir,
-                  :mock_dir
+                  :mock_dir,
+                  :logger,
+                  :log_level
 
     def config
       @@first_load ||= reload_default
@@ -20,7 +22,6 @@ module ActiveMocker
     end
 
     def reload_default
-      @log_level           = Logger::WARN
       @schema_file         = nil
       @model_dir           = nil
       @schema_attributes   = true
@@ -30,6 +31,7 @@ module ActiveMocker
       @model_file_reader   = nil
       @migration_dir       = nil
       @mock_dir            = nil
+      @logger              = ::Logger.new(STDOUT)
     end
 
     def check_required_settings
@@ -38,8 +40,9 @@ module ActiveMocker
       raise 'mock_dir must be specified'    if mock_dir.nil?
     end
 
-    def log_level=(level)
-      Logger_.level = level
+    def logger=(logger)
+      @logger = logger
+      Logger.set(logger)
     end
 
   end

data/lib/active_mocker/field.rb

@@ -2,12 +2,13 @@ module ActiveMocker
 
   class Field
 
-    attr_reader :name, :type, :options
+    attr_accessor :name, :type, :options
 
     def initialize(name, type, options)
       @name    = name
       @type    = type
-      @options = options
+      @options = {}
+      options.each{|hash| @options[hash.keys.first] = hash.values.first}
       create_option_methods
     end
 
@@ -18,8 +19,7 @@ module ActiveMocker
     alias_method :to_hash, :to_h
 
     def create_option_methods
-      options.each do |opt|
-        key, value = opt.first
+      options.each do |key, value|
         self.instance_variable_set("@#{key}", value)
         self.class.send(:attr_accessor, key)
       end

data/lib/active_mocker/generate.rb

@@ -11,7 +11,8 @@ class Generate
                  :schema_file,
                  :model_file_reader,
                  :schema_file_reader,
-                 :mock_dir
+                 :mock_dir,
+                 :logger
 
   def initialize
     create_template
@@ -22,10 +23,10 @@ class Generate
   end
 
   def self.mock(model_name, force_reload: false)
-    load_mock(model_name, force_reload: force_reload)
+    load_mock(model_name)
   end
 
-  def self.load_mock(model_name, force_reload: false)
+  def self.load_mock(model_name)
     load File.join(mock_dir, "#{model_name.tableize.singularize}_mock.rb")
     "#{model_name}Mock".constantize
   end
@@ -53,50 +54,102 @@ class Generate
   end
 
   def create_template
+    mocks_created = 0
     tables.each do |table|
       begin
       mock_template = MockTemplate.new
       # Schema Attributes
       mock_template.class_name      = mock_class_name(table.name)
       mock_template.attribute_names = table.column_names
-      mock_template.attributes      = table.column_names
+      mock_template.attributes      = field_type_to_class(table.fields)
+      mock_template.default_attributes =default_attr_values(table.fields)
 
       # Model associations
       mock_template.single_associations     = model_definition(table.name).single_relationships
       mock_template.collection_associations = model_definition(table.name).collections
       mock_template.association_names       = [*model_definition(table.name).single_relationships, *model_definition(table.name).collections]
+      mock_template.associations            = associations(mock_template.association_names)
 
       # Model Methods
-      mock_template.instance_methods      = instance_methods(table.name).methods
+      mock_template.instance_methods       = instance_methods(table.name).methods
       mock_template.model_instance_methods = instance_methods(table.name).model_instance_methods
-      mock_template.class_methods         = class_methods(table.name).methods
+      mock_template.class_methods          = class_methods(table.name).methods
       mock_template.model_class_methods    = class_methods(table.name).model_class_methods
 
       klass_str = mock_template.render( File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read)
       FileUtils::mkdir_p mock_dir unless File.directory? mock_dir
       File.open(File.join(mock_dir,"#{table.name.singularize}_mock.rb"), 'w').write(klass_str)
-      rescue
-        Logger_.debug "failed to load #{table_to_model_file(table.name)} model"
+      logger.info "saving mock #{table_to_model_file(table.name)} to #{mock_dir}"
+
+      rescue Exception => exception
+        logger.debug $!.backtrace
+        logger.debug exception
+        logger.info "failed to load #{table_to_model_file(table.name)} model"
         next
       end
+      mocks_created += 1
+
+    end
+    logger.info "Generated #{mocks_created} of #{tables.count} mocks"
+  end
+
+  def field_type_to_class(fields)
+    fields.map do |field|
+      field.type = case field.type
+         when :integer then
+           Fixnum
+         when :float then
+           Float
+         when :decimal then
+           BigDecimal
+         when :timestamp, :time then
+           Time
+         when :datetime then
+           DateTime
+         when :date then
+           Date
+         when :text, :string, :binary then
+           String
+         when :boolean then
+           ::Virtus::Attribute::Boolean
+       end
+      field
     end
 
   end
 
-
-
-
   def mock_class_name(table_name)
     "#{table_to_class_name(table_name)}Mock"
   end
 
+  def associations(names)
+    hash = {}
+    names.each do |name|
+      hash[name] = nil
+    end
+    hash
+  end
+
+  def default_attr_values(fields)
+    attributes = {}
+    fields.each do |f|
+      if f.options[:default].nil?
+        attributes[f.name] = nil
+      else
+        value = f.default.class == String ? f.default : f.default
+        attributes[f.name] = value
+      end
+    end
+    attributes
+  end
+
   def instance_methods(table_name)
     model_instance_methods = []
     instance_methods = Methods.new
     instance_methods.methods = model_definition(table_name).instance_methods_with_arguments.map do |method|
-      m = method.keys.first
+      m = method.keys.first.to_s
       if m == :attributes
-        Logger_.warn "ActiveMocker Depends on the #attributes method. It will not be redefined for the model."
+        logger.warn "ActiveMocker Depends on the #attributes method. It will not be redefined for the model."
         next
       end
       params      = Reparameterize.call(method.values.first)
@@ -110,7 +163,8 @@ class Generate
       model_instance_methods << m
       instance_method
     end
-    instance_methods.model_instance_methods = model_instance_methods
+    instance_methods.model_instance_methods = {}
+    model_instance_methods.each{|meth| instance_methods.model_instance_methods[meth] = :not_implemented }
     instance_methods
   end
 
@@ -118,7 +172,7 @@ class Generate
     model_class_methods = []
     class_methods = Methods.new
     class_methods.methods = model_definition(table_name).class_methods_with_arguments.map do |method|
-      m = method.keys.first
+      m = method.keys.first.to_s
       params      = Reparameterize.call(method.values.first)
       params_pass = Reparameterize.call(method.values.first, true)
 
@@ -129,7 +183,8 @@ class Generate
       model_class_methods << m
       class_method
     end
-    class_methods.model_class_methods = model_class_methods
+    class_methods.model_class_methods = {}
+    model_class_methods.each { |meth| class_methods.model_class_methods[meth] = :not_implemented }
     class_methods
   end
 
@@ -152,10 +207,12 @@ class Generate
                   :instance_methods,
                   :class_methods,
                   :model_instance_methods,
-                  :model_class_methods
+                  :model_class_methods,
+                  :default_attributes,
+                  :associations
 
     def render(template)
-      ERB.new(template,nil,true).result(binding)
+      ERB.new(template, nil, '-').result(binding)
     end
   end