active_mocker 1.2.4 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e684a654d8e47814ac2209637285a842b5245e
-  data.tar.gz: 6e07c88e5de98f426e121e96fece67cf98236369
+  metadata.gz: 469e40ce463c581d08ddf136c0a2e91082680baf
+  data.tar.gz: 347c0a56642bddfe071b63022705ada95e85baf9
 SHA512:
-  metadata.gz: 86f0bb7c31b2f3e82da0983f4334f336b11f71ebef6f5f7e64d43ae4b291489949579dcfccc9896b76b159842c451a68e7693c95ca68b5b4ff000df92aec25ba
-  data.tar.gz: e1aadb3d62c9ad798aab36fef644a4181139c10e58acda01a7693627831a6541d76c4d33c1677d0a9a0670a7359e1fe7e530ab9ecb2b3eff56b3c580a7e1e536
+  metadata.gz: e8c4e249f4eb55352ce3f3815a3f0daef791109970bdbf6e3fd89f035afe95967a583d4133c7b70fe20b98bac0aadca964f5bc512b99aa932ff335dc1ebfc90c
+  data.tar.gz: c672f2b89c749780ac4797357d2fd15e01a0d816fcd36f41c9246f3bf5c4b76be3cc721ab024c7f5dca81d89ab1fca15d2736b301c8beb65b6208875d7f491e8

data/README.md

@@ -1,7 +1,7 @@
 # ActiveMocker
 [![Build Status](https://travis-ci.org/zeisler/active_mocker.png?branch=master)](https://travis-ci.org/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 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.
+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.
 
 Example from a real app
 
@@ -166,27 +166,28 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
 ### ActiveRecord supported methods
 **class methods**
   
-* new
-  * create
+  * new
+  * create/create!
   * column_names
   * find
-  * find_by
-  * find_by!
+  * find_by/find_by!
   * find_or_create_by
   * find_or_initialize_by
-  * where - (only supports hash input)
+  * where(conditions_hash)
   * delete_all/destroy_all
+  * delete_all(conditions_hash)
+  * destroy(id)/delete(id)
   * all
   * count
   * first/last
+  
 
 **instance methods**
   
-* attributes
+  * attributes
   * update
-  * save
-  * write_attribute - (private, can be used within an included module)
-  * read_attribute  - (private)
+  * save/save!
+  * write_attribute/read_attribute - (private, can be used within an included module)
 
 **has_many associations**
   
@@ -210,7 +211,6 @@ Here is an example of a rake task to regenerate mocks after every schema modifia
 
 * 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

data/active_mocker.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Dustin Zeisler"]
   spec.email         = ["dustin@zive.me"]
   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.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 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.}
   spec.homepage      = "https://github.com/zeisler/active_mocker"
   spec.license       = "MIT"
 

data/lib/active_hash/ar_api.rb

@@ -1,12 +1,12 @@
-require_relative 'update'
-require_relative 'find_by'
 require_relative 'init'
+require_relative '../active_mocker/collection/queries'
+require_relative '../active_mocker/collection/base'
+require_relative '../active_mocker/collection/relation'
 module ActiveMocker
   module ActiveHash
 
     module ARApi
 
-      include ::ActiveHash::ARApi::Update
       include ::ActiveHash::ARApi::Init
 
       def delete
@@ -16,12 +16,27 @@ module ActiveMocker
         records.delete_at(index)
       end
 
+      def update(options={})
+        options.each do |method, value|
+          send("#{method}=", value)
+        end
+
+      end
+
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       module ClassMethods
-        include ::ActiveHash::ARApi::FindBy
+        include ActiveMocker::Collection::Queries
+
+        def create(attributes = {}, &block)
+          record = new(attributes)
+          record = new(attributes, &block) if block_given?
+          record.save
+          mark_dirty
+          record
+        end
 
         def find_or_create_by(attributes)
           find_by(attributes) || create(attributes)
@@ -35,6 +50,10 @@ module ActiveMocker
           find(id).delete
         end
 
+        def to_a
+          @records
+        end
+
         alias_method :destroy, :delete
 
         def delete_all(options=nil)

data/lib/active_hash/init.rb

@@ -6,8 +6,9 @@ module ActiveHash
 
       attr_reader :associations, :types
 
-      def initialize(attributes = {})
+      def initialize(attributes = {}, &block)
         @types = {}
+        yield self if block_given?
         attributes.each do |key, value|
           begin
             send "#{key}=", value
@@ -17,6 +18,9 @@ module ActiveHash
         end
 
       end
+
+
+
     end
   end
 

data/lib/active_mocker.rb

@@ -16,7 +16,6 @@ require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/schema_reader'
 require 'active_mocker/active_record/schema'
-require 'active_mocker/collection_association'
 require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/reparameterize'

data/lib/active_mocker/collection/association.rb

@@ -0,0 +1,12 @@
+module ActiveMocker
+
+module Collection
+
+  class Association < Base
+
+    include Queries
+
+  end
+
+end
+end

data/lib/active_mocker/collection/base.rb

@@ -0,0 +1,65 @@
+module ActiveMocker
+
+  module Collection
+
+
+    class Base
+
+      include Enumerable
+
+      def initialize(collection=[])
+        @collection = [*collection]
+      end
+
+      def <<(*records)
+        collection.concat(records.flatten)
+      end
+
+      delegate :take, :push, :clear, :first, :last, :concat, :replace, :distinct, :uniq, :count, :size, :length, :empty?, :any?, :include?, :delete, to: :collection
+      alias distinct uniq
+
+      # def delete(obj)
+      #   collection.delete(obj)
+      # end
+
+      def order(key)
+        self.class.new(collection.sort_by{ |item| item.send(key) })
+      end
+
+      def reverse_order
+        self.class.new(collection.reverse)
+      end
+
+      def select(&block)
+        self.class.new(collection.select(&block))
+      end
+
+      def each(&block)
+        self.class.new(collection.each do |item|
+          block.call(item)
+        end)
+      end
+
+      def to_a
+        @collection
+      end
+
+      def ==(val)
+        return false if val.nil?
+        collection.hash == val.hash
+      end
+
+      private
+
+      def collection
+        @collection
+      end
+
+    end
+
+  end
+
+
+
+
+end

data/lib/active_mocker/collection/queries.rb

@@ -0,0 +1,105 @@
+module ActiveMocker
+
+  class RecordNotFound < Exception
+
+  end
+module Collection
+
+
+
+  module Queries
+
+    def delete_all
+      all.map(&:delete)
+    end
+
+    def destroy_all
+      delete_all
+    end
+
+    def all(options={})
+      if options.has_key?(:conditions)
+        where(options[:conditions])
+      else
+        Relation.new( to_a || [] )
+      end
+    end
+
+    class WhereNotChain
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def not(options={})
+        @collection.reject do |record|
+          options.all? { |col, match| record.send(col) == match }
+        end
+      end
+
+    end
+
+    def where(options=nil)
+      return WhereNotChain.new(all) if options.nil?
+      all.select do |record|
+        options.all? { |col, match| record.send(col) == match }
+      end
+    end
+
+    def find(ids)
+      ids_array = [*ids]
+      results = ids_array.map do |id|
+        where(id: id).first
+      end
+      return Relation.new(results) if ids.class == Array
+      return results.first
+    end
+
+    def update_all(options)
+      all.each{ |i| i.update(options)}
+    end
+
+    def find_by(options = {})
+      send(:where, options).first
+    end
+
+    def find_by!(options={})
+      result = find_by(options)
+      raise RecordNotFound if result.blank?
+      result
+    end
+
+    def limit(num)
+      Relation.new(all.take(num))
+    end
+
+    def sum(key)
+      values = values_by_key(key)
+      values.inject { |sum, n| sum + n }
+    end
+
+    def average(key)
+      values = values_by_key(key)
+      total = values.inject { |sum, n| sum + n }
+      BigDecimal.new(total) / BigDecimal.new(values.count)
+    end
+
+    def minimum(key)
+      values_by_key(key).min_by{|i| i }
+    end
+
+    def maximum(key)
+      values_by_key(key).max_by { |i| i }
+    end
+
+    private
+
+    def values_by_key(key)
+      all.map { |obj| obj.send(key) }
+    end
+
+  end
+
+end
+end
+

data/lib/active_mocker/collection/relation.rb

@@ -0,0 +1,11 @@
+module ActiveMocker
+
+module Collection
+
+  class Relation < Base
+    include Queries
+
+  end
+
+end
+end

data/lib/active_mocker/mock_instance_methods.rb

@@ -33,7 +33,9 @@ module MockInstanceMethods
   end
 
   def ==(obj)
-    hash == obj.attributes.hash
+    return false if obj.nil?
+    return hash == obj.attributes.hash if obj.respond_to?(:attributes)
+    hash == obj.hash if obj.respond_to?(:hash)
   end
 
   private

data/lib/active_mocker/mock_requires.rb

@@ -1,4 +1,6 @@
-require 'active_mocker/collection_association'
+require 'active_mocker/collection/queries'
+require 'active_mocker/collection/base'
+require 'active_mocker/collection/association'
 require 'active_mocker/mock_class_methods'
 require 'active_mocker/mock_instance_methods'
 require 'active_hash'

data/lib/active_mocker/mock_template.erb

@@ -6,10 +6,10 @@ class <%= class_name %> < ::ActiveHash::Base
   include ActiveMocker::MockInstanceMethods
   extend  ActiveMocker::MockClassMethods
 
-  def initialize(attributes = {})
+  def initialize(attributes={}, &block)
     @attributes = HashWithIndifferentAccess.new(<%= default_attributes %>)
     @associations = HashWithIndifferentAccess.new(<%= associations %>)
-    super(attributes)
+    super(attributes, &block)
   end
 
 
@@ -18,7 +18,7 @@ class <%= class_name %> < ::ActiveHash::Base
   end
 
   def self.attribute_names
-    @attribute_names = <%= attribute_names.map{|a| a.to_sym} %>
+    @attribute_names = <%= attribute_names %>
   end
 
   ##################################
@@ -26,7 +26,7 @@ class <%= class_name %> < ::ActiveHash::Base
   ##################################
 <% attributes.each do |meth| %>
   def <%= meth.name %>
-  @attributes['<%= meth.name %>']
+    @attributes['<%= meth.name %>']
   end
 
   def <%= meth.name %>=(val)
@@ -52,11 +52,11 @@ class <%= class_name %> < ::ActiveHash::Base
 <% end -%>
 <% collection_associations.each do |meth| %>
   def <%= meth %>
-    associations['<%= meth %>'] ||= ActiveMocker::CollectionAssociation.new
+    associations['<%= meth %>'] ||= ActiveMocker::Collection::Association.new
   end
 
   def <%= meth %>=(val)
-    associations['<%= meth %>'] = ActiveMocker::CollectionAssociation.new(val)
+    associations['<%= meth %>'] = ActiveMocker::Collection::Association.new(val)
   end
 <% end -%>
 

data/lib/active_mocker/version.rb

@@ -1,3 +1,3 @@
 module ActiveMocker
-  VERSION = "1.2.4"
+  VERSION = "1.3"
 end

data/sample_app_rails_4/config/application.rb

@@ -5,7 +5,7 @@
     # require "rails/test_unit/railtie"
 
     # Assets should be precompiled for production (so we don't need the gems loaded then)
-    Bundler.require(*Rails.groups(assets: %w(development test)))
+    # Bundler.require(*Rails.groups(assets: %w(development test)))
 
     module SampleApp
       class Application < Rails::Application

data/sample_app_rails_4/db/schema.rb

@@ -16,6 +16,7 @@ ActiveRecord::Schema.define(version: 20130315230445) do
   create_table "microposts", force: true do |t|
     t.string   "content"
     t.integer  "user_id"
+    t.integer  "up_votes"
     t.datetime "created_at"
     t.datetime "updated_at"
   end