active_mocker 1.5.2 → 1.6

data/lib/active_mocker/mock/collection.rb

@@ -16,7 +16,7 @@ module Mock
     end
 
     extend ::Forwardable
-    def_delegators :@collection, :take, :push, :clear, :first, :last, :concat, :replace, :distinct, :uniq, :count, :size, :length, :empty?, :any?, :include?, :delete
+    def_delegators :@collection, :take, :push, :clear, :first, :last, :concat, :replace, :distinct, :uniq, :count, :size, :length, :empty?, :any?, :many?, :include?, :delete
     alias distinct uniq
 
     def select(&block)
@@ -51,6 +51,11 @@ module Mock
       @collection == val
     end
 
+    # Returns true if relation is blank.
+    def blank?
+      to_a.blank?
+    end
+
     protected
 
     attr_accessor :collection

data/lib/active_mocker/mock/do_nothing_active_record_methods.rb

@@ -52,6 +52,10 @@ module DoNothingActiveRecordMethods
     false
   end
 
+  def reload
+    self
+  end
+
 end
 end
 end

data/lib/active_mocker/mock/exceptions.rb

@@ -12,7 +12,17 @@ module Mock
   class FileTypeMismatchError < StandardError
   end
 
-  class RejectedParams < Exception
+  # Raised when unknown attributes are supplied via mass assignment.
+  class UnknownAttributeError < NoMethodError
+
+    attr_reader :record, :attribute
+
+    def initialize(record, attribute)
+      @record = record
+      @attribute = attribute.to_s
+      super("unknown attribute: #{attribute}")
+    end
+
   end
 
   class Unimplemented < Exception
@@ -21,5 +31,8 @@ module Mock
   class IdNotNumber < Exception
   end
 
+  class Error < Exception
+  end
+
 end
 end

data/lib/active_mocker/mock/has_many.rb

@@ -16,6 +16,13 @@ module Mock
       @foreign_id     = foreign_id
       self.class.include "#{relation_class.name}::Scopes".constantize
       super(collection)
+      set_foreign_key if ActiveMocker::Mock.config.experimental
+    end
+
+    def set_foreign_key
+      collection.each do |item|
+        item.send(:write_attribute, foreign_key, foreign_id) if item.respond_to?("#{foreign_key}=")
+      end
     end
 
     private

data/lib/active_mocker/mock/hash_process.rb

@@ -1,5 +1,6 @@
 module ActiveMocker
   module Mock
+    # @api private
     class HashProcess
 
       attr_accessor :hash, :processor

data/lib/active_mocker/mock/next_id.rb

@@ -1,5 +1,6 @@
 module ActiveMocker
 module Mock
+# @api private
 class NextId
 
   def initialize(records)

data/lib/active_mocker/mock/queries.rb

@@ -9,9 +9,9 @@ module Mock
         @record = record
       end
 
-      def is_of(options={})
-        options.all? do |col, match|
-          next match.any? { |m| @record.send(col) == m } if match.class == Array
+      def is_of(conditions={})
+        conditions.all? do |col, match|
+          next match.any? { |m| @record.send(col) == m } if match.is_a? Enumerable
           @record.send(col) == match
         end
       end
@@ -25,58 +25,231 @@ module Mock
         @parent_class = parent_class
       end
 
-      def not(options={})
+      def not(conditions={})
         @parent_class.call(@collection.reject do |record|
-          Find.new(record).is_of(options)
+          Find.new(record).is_of(conditions)
         end)
       end
     end
 
-    def delete_all(options=nil)
-      if options.nil?
+    # Deletes the records matching +conditions+ by instantiating each
+    # record and calling its +delete+ method.
+    #
+    # ==== Parameters
+    #
+    # * +conditions+ - A string, array, or hash that specifies which records
+    #   to destroy. If omitted, all records are destroyed.
+    #
+    # ==== Examples
+    #
+    #   PersonMock.destroy_all(status: "inactive")
+    #   PersonMock.where(age: 0..18).destroy_all
+    #
+    # If a limit scope is supplied, +delete_all+ raises an ActiveMocker error:
+    #
+    #   Post.limit(100).delete_all
+    #   # => ActiveMocker::Mock::Error: delete_all doesn't support limit scope
+    def delete_all(conditions=nil)
+      raise ActiveMocker::Mock::Error.new("delete_all doesn't support limit scope") if from_limit?
+      if conditions.nil?
         to_a.map(&:delete)
         return to_a.clear
       end
-      where(options).map { |r| r.delete }.count
+      where(conditions).map { |r| r.delete }.count
     end
 
-    def destroy_all
-      delete_all
-    end
+    alias_method :destroy_all, :delete_all
 
-    def where(options=nil)
-      return WhereNotChain.new(all, method(:new_relation)) if options.nil?
+    # Returns a new relation, which is the result of filtering the current relation
+    # according to the conditions in the arguments.
+    #
+    # === hash
+    #
+    # #where will accept a hash condition, in which the keys are fields and the values
+    # are values to be searched for.
+    #
+    # Fields can be symbols or strings. Values can be single values, arrays, or ranges.
+    #
+    #    User.where({ name: "Joe", email: "joe@example.com" })
+    #
+    #    User.where({ name: ["Alice", "Bob"]})
+    #
+    #    User.where({ created_at: (Time.now.midnight - 1.day)..Time.now.midnight })
+    #
+    # In the case of a belongs_to relationship, an association key can be used
+    # to specify the model if an ActiveRecord object is used as the value.
+    #
+    #    author = Author.find(1)
+    #
+    #    # The following queries will be equivalent:
+    #    Post.where(author: author)
+    #    Post.where(author_id: author)
+    #
+    # This also works with polymorphic belongs_to relationships:
+    #
+    #    treasure = Treasure.create(name: 'gold coins')
+    #    treasure.price_estimates << PriceEstimate.create(price: 125)
+    #
+    #    # The following queries will be equivalent:
+    #    PriceEstimate.where(estimate_of: treasure)
+    #    PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: treasure)
+    #
+    # === no argument
+    #
+    # If no argument is passed, #where returns a new instance of WhereChain, that
+    # can be chained with #not to return a new relation that negates the where clause.
+    #
+    #    User.where.not(name: "Jon")
+    #
+    # See WhereChain for more details on #not.
+    def where(conditions=nil)
+      return WhereNotChain.new(all, method(:new_relation)) if conditions.nil?
       new_relation(to_a.select do |record|
-        Find.new(record).is_of(options)
+        Find.new(record).is_of(conditions)
       end)
     end
 
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
+    #
+    #   Person.find(1)          # returns the object for ID = 1
+    #   Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17])    # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1])        # returns an array for the object with ID = 1
+    #
+    # <tt>ActiveRecord::RecordNotFound</tt> will be raised if one or more ids are not found.
     def find(ids)
       results = [*ids].map do |id|
-        where(id: id).first
+        find_by!(id: id)
       end
       return new_relation(results) if ids.class == Array
       results.first
     end
 
-    def update_all(options)
-      all.each { |i| i.update(options) }
+    # Updates all records with details given if they match a set of conditions supplied, limits and order can
+    # also be supplied.
+    #
+    # ==== Parameters
+    #
+    # * +updates+ - A string, array, or hash.
+    #
+    # ==== Examples
+    #
+    #   # Update all customers with the given attributes
+    #   Customer.update_all wants_email: true
+    #
+    #   # Update all books with 'Rails' in their title
+    #   BookMock.where(title: 'Rails').update_all(author: 'David')
+    #
+    #   # Update all books that match conditions, but limit it to 5 ordered by date
+    #   BookMock.where(title: 'Rails').order(:created_at).limit(5).update_all(author: 'David')
+    def update_all(conditions)
+      all.each { |i| i.update(conditions) }
+    end
+
+    # Updates an object (or multiple objects) and saves it.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - This should be the id or an array of ids to be updated.
+    # * +attributes+ - This should be a hash of attributes or an array of hashes.
+    #
+    # ==== Examples
+    #
+    #   # Updates one record
+    #   Person.update(15, user_name: 'Samuel', group: 'expert')
+    #
+    #   # Updates multiple records
+    #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+    #   Person.update(people.keys, people.values)
+    def update(id, attributes)
+      if id.is_a?(Array)
+        id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
+      else
+        object = find(id)
+        object.update(attributes)
+        object
+      end
     end
 
-    def find_by(options = {})
-      send(:where, options).first
+    # Finds the first record matching the specified conditions. There
+    # is no implied ordering so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   Post.find_by name: 'Spartacus', rating: 4
+    def find_by(conditions = {})
+      send(:where, conditions).first
     end
 
-    def find_by!(options={})
-      result = find_by(options)
-      raise RecordNotFound if result.blank?
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveRecord::RecordNotFound</tt> error.
+    def find_by!(conditions={})
+      result = find_by(conditions)
+      raise RecordNotFound if result.nil?
       result
     end
 
+    # Finds the first record with the given attributes, or creates a record
+    # with the attributes if one is not found:
+    #
+    #   # Find the first user named "Penélope" or create a new one.
+    #   UserMock.find_or_create_by(first_name: 'Penélope')
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
+    #
+    #   # Find the first user named "Penélope" or create a new one.
+    #   # We already have one so the existing record will be returned.
+    #   UserMock.find_or_create_by(first_name: 'Penélope')
+    #   # => #<User id: 1, first_name: "Penélope", last_name: nil>
+    #
+    # This method accepts a block, which is passed down to +create+. The last example
+    # above can be alternatively written this way:
+    #
+    #   # Find the first user named "Scarlett" or create a new one with a
+    #   # different last name.
+    #   User.find_or_create_by(first_name: 'Scarlett') do |user|
+    #     user.last_name = 'Johansson'
+    #   end
+    #   # => #<User id: 2, first_name: "Scarlett", last_name: "Johansson">
+    #
+    def find_or_create_by(attributes, &block)
+      find_by(attributes) || create(attributes, &block)
+    end
+
+    alias_method :find_or_create_by!, :find_or_create_by
+
+    # Like <tt>find_or_create_by</tt>, but calls <tt>new</tt> instead of <tt>create</tt>.
+    def find_or_initialize_by(attributes, &block)
+      find_by(attributes) || new(attributes, &block)
+    end
+
+    # Count the records.
+    #
+    #   PersonMock.count
+    #   # => the total count of all people
+    #
+    #   PersonMock.count(:age)
+    #   # => returns the total count of all people whose age is present in database
+    def count(column_name = nil)
+      return all.size if column_name.nil?
+      where.not(column_name => nil).size
+    end
+
+    # Specifies a limit for the number of records to retrieve.
+    #
+    #   User.limit(10)
     def limit(num)
-      new_relation(all.take(num))
+      relation = new_relation(all.take(num))
+      relation.send(:set_from_limit)
+      relation
     end
 
+    # Calculates the sum of values on a given column. The value is returned
+    # with the same data type of the column, 0 if there's no row.
+    #
+    #   Person.sum(:age) # => 4562
     def sum(key)
       values = values_by_key(key)
       values.inject(0) do |sum, n|
@@ -84,24 +257,44 @@ module Mock
       end
     end
 
+    # Calculates the average value on a given column. Returns +nil+ if there's
+    # no row.
+    #
+    #   PersonMock.average(:age) # => 35.8
     def average(key)
       values = values_by_key(key)
       total = values.inject { |sum, n| sum + n }
       BigDecimal.new(total) / BigDecimal.new(values.count)
     end
 
+    # Calculates the minimum value on a given column. The value is returned
+    # with the same data type of the column, or +nil+ if there's no row.
+    #
+    #   Person.minimum(:age) # => 7
     def minimum(key)
       values_by_key(key).min_by { |i| i }
     end
 
+    # Calculates the maximum value on a given column. The value is returned
+    # with the same data type of the column, or +nil+ if there's no row.
+    #
+    #   Person.maximum(:age) # => 93
     def maximum(key)
       values_by_key(key).max_by { |i| i }
     end
 
+    # Allows to specify an order attribute:
+    #
+    #   User.order('name')
+    #
+    #   User.order(:name)
     def order(key)
       new_relation(all.sort_by { |item| item.send(key) })
     end
 
+    # Reverse the existing order clause on the relation.
+    #
+    #   User.order('name').reverse_order
     def reverse_order
       new_relation(to_a.reverse)
     end

data/lib/active_mocker/mock/relation.rb

@@ -4,6 +4,27 @@ module Mock
 
     include Queries
 
+    def initialize(collection=[])
+      super
+      @from_limit = false
+    end
+
+    def inspect
+      entries = to_a.take(11).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
+    def from_limit?
+      @from_limit
+    end
+
+    private
+
+    def set_from_limit
+      @from_limit = true
+    end
+
   end
 end
 end

data/lib/active_mocker/mock_template.erb

@@ -30,6 +30,8 @@ class <%= class_name + @mock_append_name %> < ActiveMocker::Mock::Base
       '<%= class_name %>'
     end
 
+    private :mocked_class
+
     def attribute_names
       @attribute_names ||= <%= attribute_names %>
     end
@@ -52,7 +54,7 @@ class <%= class_name + @mock_append_name %> < ActiveMocker::Mock::Base
 <% association = belongs_to_foreign_key(meth.name)  -%>
     write_attribute(:<%= meth.name %>, val)
 <% if association -%>
-    association = classes('<%= association.class_name %>').try(:find, <%= meth.name  %>)
+    association = classes('<%= association.class_name %>').try(:find_by, id: <%= meth.name  %>)
     write_association(:<%= association.name %>,association) unless association.nil?
 <% end -%>
   end
@@ -70,6 +72,10 @@ class <%= class_name + @mock_append_name %> < ActiveMocker::Mock::Base
   def <%= meth.name %>=(val)
     @associations[:<%= meth.name %>] = val
     write_attribute(:<%= meth.foreign_key %>, val.id) if val.respond_to?(:persisted?) && val.persisted?
+    if ActiveMocker::Mock.config.experimental
+      val.<%= class_name.tableize %> << self if val.respond_to?(:<%= class_name.tableize %>)
+    end
+    val
   end
 
   def build_<%= meth.name %>(attributes={}, &block)
@@ -92,11 +98,15 @@ class <%= class_name + @mock_append_name %> < ActiveMocker::Mock::Base
 <%= '# has_one' unless has_one.empty? -%>
 <% has_one.each do |meth| %>
   def <%= meth.name %>
-    @associations['<%= meth.name %>']
+    read_association('<%= meth.name %>')
   end
 
   def <%= meth.name %>=(val)
     @associations['<%= meth.name %>'] = val
+    if ActiveMocker::Mock.config.experimental
+      <%= meth.name %>.send(:write_association, <%= class_name.tableize.singularize %>,  self) if val.respond_to?(:<%= class_name.tableize.singularize %>=)
+    end
+    <%= meth.name %>
   end
 
   def build_<%= meth.name %>(attributes={}, &block)