active_mocker 1.3.2 → 1.4.1

data/sample_app_rails_4/spec/mocks/user_mock.rb

@@ -1,24 +1,46 @@
-require 'active_mocker/mock_requires'
-Object.send(:remove_const, "UserMock") if ActiveMocker.class_exists?("UserMock")
+require 'active_mocker/active_mock'
+Object.send(:remove_const, "UserMock") if Object.const_defined?("UserMock")
 
-class UserMock < ::ActiveHash::Base
-  include ActiveMocker::ActiveHash::ARApi
-  include ActiveMocker::MockInstanceMethods
-  extend  ActiveMocker::MockClassMethods
+class UserMock < ActiveMock::Base
 
-  def initialize(attributes={}, &block)
-    @attributes = HashWithIndifferentAccess.new({"id"=>nil, "name"=>nil, "email"=>"", "credits"=>nil, "created_at"=>nil, "updated_at"=>nil, "password_digest"=>nil, "remember_token"=>true, "admin"=>false})
-    @associations = HashWithIndifferentAccess.new({:microposts=>nil, :relationships=>nil, :followed_users=>nil, :reverse_relationships=>nil, :followers=>nil})
-    super(attributes, &block)
-  end
+  class << self
 
+    def attributes
+      @attributes ||= HashWithIndifferentAccess.new({"id"=>nil, "name"=>nil, "email"=>"", "credits"=>nil, "created_at"=>nil, "updated_at"=>nil, "password_digest"=>nil, "remember_token"=>true, "admin"=>false})
+    end
 
-  def self.column_names
-    ["id", "name", "email", "credits", "created_at", "updated_at", "password_digest", "remember_token", "admin"]
-  end
+    def types
+      @types ||= { id: build_type(Fixnum), name: build_type(String), email: build_type(String), credits: build_type(BigDecimal), created_at: build_type(DateTime), updated_at: build_type(DateTime), password_digest: build_type(String), remember_token: build_type(Axiom::Types::Boolean), admin: build_type(Axiom::Types::Boolean) }
+    end
+
+    def associations
+      @associations ||= {:microposts=>nil, :relationships=>nil, :followed_users=>nil, :reverse_relationships=>nil, :followers=>nil}
+    end
+
+    def model_instance_methods
+      @model_instance_methods ||= {"feed"=>:not_implemented, "following?"=>:not_implemented, "follow!"=>:not_implemented, "unfollow!"=>:not_implemented}
+    end
+
+    def model_class_methods
+      @model_class_methods ||= {"new_remember_token"=>:not_implemented, "digest"=>:not_implemented}
+    end
+
+    def mocked_class
+      'User'
+    end
+
+    def column_names
+      attribute_names
+    end
+
+    def attribute_names
+      @attribute_names ||= ["id", "name", "email", "credits", "created_at", "updated_at", "password_digest", "remember_token", "admin"]
+    end
+
+    def primary_key
+      "id"
+    end
 
-  def self.attribute_names
-    @attribute_names = ["id", "name", "email", "credits", "created_at", "updated_at", "password_digest", "remember_token", "admin"]
   end
 
   ##################################
@@ -26,150 +48,127 @@ class UserMock < ::ActiveHash::Base
   ##################################
 
   def id
-    @attributes['id']
+    read_attribute(:id)
   end
 
   def id=(val)
-    type = (types[:id] ||= Virtus::Attribute.build(Fixnum))
-    @attributes['id'] = type.coerce(val)
+    write_attribute(:id, val)
   end
 
   def name
-    @attributes['name']
+    read_attribute(:name)
   end
 
   def name=(val)
-    type = (types[:name] ||= Virtus::Attribute.build(String))
-    @attributes['name'] = type.coerce(val)
+    write_attribute(:name, val)
   end
 
   def email
-    @attributes['email']
+    read_attribute(:email)
   end
 
   def email=(val)
-    type = (types[:email] ||= Virtus::Attribute.build(String))
-    @attributes['email'] = type.coerce(val)
+    write_attribute(:email, val)
   end
 
   def credits
-    @attributes['credits']
+    read_attribute(:credits)
   end
 
   def credits=(val)
-    type = (types[:credits] ||= Virtus::Attribute.build(BigDecimal))
-    @attributes['credits'] = type.coerce(val)
+    write_attribute(:credits, val)
   end
 
   def created_at
-    @attributes['created_at']
+    read_attribute(:created_at)
   end
 
   def created_at=(val)
-    type = (types[:created_at] ||= Virtus::Attribute.build(DateTime))
-    @attributes['created_at'] = type.coerce(val)
+    write_attribute(:created_at, val)
   end
 
   def updated_at
-    @attributes['updated_at']
+    read_attribute(:updated_at)
   end
 
   def updated_at=(val)
-    type = (types[:updated_at] ||= Virtus::Attribute.build(DateTime))
-    @attributes['updated_at'] = type.coerce(val)
+    write_attribute(:updated_at, val)
   end
 
   def password_digest
-    @attributes['password_digest']
+    read_attribute(:password_digest)
   end
 
   def password_digest=(val)
-    type = (types[:password_digest] ||= Virtus::Attribute.build(String))
-    @attributes['password_digest'] = type.coerce(val)
+    write_attribute(:password_digest, val)
   end
 
   def remember_token
-    @attributes['remember_token']
+    read_attribute(:remember_token)
   end
 
   def remember_token=(val)
-    type = (types[:remember_token] ||= Virtus::Attribute.build(Virtus::Attribute::Boolean))
-    @attributes['remember_token'] = type.coerce(val)
+    write_attribute(:remember_token, val)
   end
 
   def admin
-    @attributes['admin']
+    read_attribute(:admin)
   end
 
   def admin=(val)
-    type = (types[:admin] ||= Virtus::Attribute.build(Virtus::Attribute::Boolean))
-    @attributes['admin'] = type.coerce(val)
+    write_attribute(:admin, val)
   end
 
   ##################################
-  #   Association getter/setters   #
+  #         Associations           #
   ##################################
 
-  def self.association_names
-    @association_names = [:microposts, :relationships, :followed_users, :reverse_relationships, :followers]
-  end
 
+# has_many
   def microposts
-    associations['microposts'] ||= ActiveMocker::Collection::Association.new
+    @associations[:microposts] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('Micropost'))
   end
 
   def microposts=(val)
-    associations['microposts'] = ActiveMocker::Collection::Association.new(val)
+    @associations[:microposts] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('Micropost'))
   end
 
   def relationships
-    associations['relationships'] ||= ActiveMocker::Collection::Association.new
+    @associations[:relationships] ||= ActiveMock::HasMany.new([],'follower_id', @attributes['id'], classes('Relationship'))
   end
 
   def relationships=(val)
-    associations['relationships'] = ActiveMocker::Collection::Association.new(val)
+    @associations[:relationships] ||= ActiveMock::HasMany.new(val,'follower_id', @attributes['id'], classes('Relationship'))
   end
 
   def followed_users
-    associations['followed_users'] ||= ActiveMocker::Collection::Association.new
+    @associations[:followed_users] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('FollowedUser'))
   end
 
   def followed_users=(val)
-    associations['followed_users'] = ActiveMocker::Collection::Association.new(val)
+    @associations[:followed_users] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('FollowedUser'))
   end
 
   def reverse_relationships
-    associations['reverse_relationships'] ||= ActiveMocker::Collection::Association.new
+    @associations[:reverse_relationships] ||= ActiveMock::HasMany.new([],'followed_id', @attributes['id'], classes('Relationship'))
   end
 
   def reverse_relationships=(val)
-    associations['reverse_relationships'] = ActiveMocker::Collection::Association.new(val)
+    @associations[:reverse_relationships] ||= ActiveMock::HasMany.new(val,'followed_id', @attributes['id'], classes('Relationship'))
   end
 
   def followers
-    associations['followers'] ||= ActiveMocker::Collection::Association.new
+    @associations[:followers] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('Follower'))
   end
 
   def followers=(val)
-    associations['followers'] = ActiveMocker::Collection::Association.new(val)
+    @associations[:followers] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('Follower'))
   end
 
   ##################################
   #  Model Methods getter/setters  #
   ##################################
 
-  def self.model_instance_methods
-    @model_instance_methods ||= {"feed"=>:not_implemented, "following?"=>:not_implemented, "follow!"=>:not_implemented, "unfollow!"=>:not_implemented}
-  end
-
-  def self.model_class_methods
-    @model_class_methods ||= {"new_remember_token"=>:not_implemented, "digest"=>:not_implemented}
-  end
-
-  def self.clear_mock
-    @model_class_methods, @model_instance_methods = nil, nil
-    delete_all
-  end
 
   def feed()
     block =  model_instance_methods['feed']
@@ -207,10 +206,10 @@ class UserMock < ::ActiveHash::Base
     instance_exec(*[token], &block)
   end
 
+  private
+
   def self.reload
     load __FILE__
   end
 
-end
-
-ActiveMocker::LoadedMocks.add(UserMock)
+end

data/sample_app_rails_4/spec/reload_spec.rb

@@ -11,7 +11,7 @@ RSpec.configure do |config|
 end
 
 $:.unshift File.expand_path('../../', __FILE__)
-APP_ROOT = File.expand_path('../../', __FILE__)
+APP_ROOT = File.expand_path('../../', __FILE__) unless defined? APP_ROOT
 require 'config/initializers/active_mocker.rb'
 load 'mocks/user_mock.rb'
 

data/sample_app_rails_4/spec/user_mock_spec.rb

@@ -1,9 +1,10 @@
 require 'rspec'
 $:.unshift File.expand_path('../../', __FILE__)
-    load 'spec/mocks/user_mock.rb'
-APP_ROOT =  File.expand_path('../../', __FILE__)
+require 'active_support'
+require 'spec/mocks/user_mock.rb'
+APP_ROOT =  File.expand_path('../../', __FILE__) unless defined? APP_ROOT
 require 'config/initializers/active_mocker.rb'
-
+require 'forwardable'
 
 describe 'UserMock' do
 
@@ -12,6 +13,23 @@ describe 'UserMock' do
     UserMock.clear_mock
   }
 
+  describe '::mocked_class' do
+
+    it 'returns the name of the class being mocked' do
+      expect(UserMock.mocked_class).to eq 'User'
+    end
+
+  end
+
+  describe 'ActiveMocker::LoadedMocks' do
+
+    it 'will be added when sub classed' do
+      expect(ActiveMocker::LoadedMocks.all.keys.include?('UserMock')).to eq true
+    end
+
+  end
+
+
   describe '::column_names' do
 
     it 'returns an array of column names found from the schema.rb file' do
@@ -29,7 +47,7 @@ describe 'UserMock' do
     end
 
     it 'will raise error if not an attribute or association' do
-      expect{UserMock.new(baz: "Hello")}.to raise_error(ActiveMocker::RejectedParams, '{:baz=>"Hello"} for UserMock')
+      expect{UserMock.new(baz: "Hello")}.to raise_error(ActiveMock::RejectedParams, '{:baz=>"Hello"} for UserMock')
     end
 
   end
@@ -106,10 +124,10 @@ describe 'UserMock' do
 
   end
 
-  context 'active_hash' do
+  context 'active_mock' do
 
-    it 'uses active_hash::base as superclass' do
-      expect(UserMock.superclass.name).to eq 'ActiveHash::Base'
+    it 'uses active_mock::base as superclass' do
+      expect(UserMock.superclass.name).to eq 'ActiveMock::Base'
     end
 
     it 'can save to class and then find instance by attribute' do

data/spec/lib/acitve_mock/queriable_spec.rb

@@ -0,0 +1,207 @@
+require 'rspec'
+$:.unshift File.expand_path('../../', __FILE__)
+require 'active_support/all'
+require 'active_mock/queries'
+require 'active_mock/collection'
+require 'ostruct'
+
+describe ActiveMock::Queries do
+
+  before do
+
+    class Queriable < ActiveMock::Collection
+      include ActiveMock::Queries
+    end
+
+  end
+
+  subject{ Queriable.new }
+
+  describe '#sum' do
+
+    it 'sum values by attribute name' do
+      subject << [OpenStruct.new(value: 1), OpenStruct.new(value: 1)]
+      expect(subject.sum(:value)).to eq 2
+    end
+
+  end
+
+  describe '#limit' do
+
+    let!(:given_collection){ [OpenStruct.new(value: 1),
+                              OpenStruct.new(value: 2),
+                              OpenStruct.new(value: 3)]}
+
+    it 'will return only the n-number of items' do
+      subject << given_collection
+      expect(subject.limit(1).count).to eq 1
+    end
+
+  end
+
+  describe '#<<' do
+
+    it 'will add a single item to the array' do
+
+      subject << "item"
+      expect(subject.count).to eq 1
+      expect(subject.first).to eq 'item'
+
+    end
+
+    it 'will add a many item to the array' do
+
+      subject << ['item1', 'item2', 'item3']
+      expect(subject.count).to eq 3
+      expect(subject).to eq ['item1', 'item2', 'item3']
+
+    end
+
+  end
+
+  describe 'new' do
+
+    it 'take optional item and adds to collection' do
+
+      subject = Queriable.new(1)
+
+      expect(subject.first).to eq 1
+
+    end
+
+    it 'can take an array' do
+
+      subject = Queriable.new([1])
+
+      expect(subject.first).to eq 1
+
+      subject = Queriable.new([1,2])
+
+      expect(subject.last).to eq 2
+
+    end
+
+  end
+
+  describe 'empty?' do
+
+    it 'returns true if collection is empty' do
+      expect(subject.empty?).to eq true
+    end
+
+    it 'returns false if collection is not empty' do
+      subject << 1
+      expect(subject.empty?).to eq false
+    end
+
+  end
+
+  describe 'each' do
+
+    it 'can iterate over array' do
+      sum = 0
+      Queriable.new([1, 2]).each { |a| sum += a }
+      expect(sum).to eq 3
+    end
+
+  end
+
+  describe 'map' do
+
+    it 'return a new array' do
+      expect(Queriable.new([1, 2]).map { |a| a + a }).to eq [2, 4]
+    end
+
+    it 'return an instance of the class' do
+      expect(Queriable.new([1, 2]).map { |a| a + a }).to be_a_kind_of Array
+    end
+
+  end
+
+  describe 'delete_all' do
+
+    let!(:given_collection) { [double(delete: true),
+                               double(delete: true),
+                               double(delete: true)] }
+
+    before do
+      given_collection.each do |item|
+        expect(item).to receive(:delete)
+      end
+      subject << given_collection
+    end
+
+    it 'calls delete on every item in the collection' do
+      subject.delete_all
+    end
+
+    context 'alias destroy_all' do
+
+      it 'calls delete on every item in the collection' do
+        subject.destroy_all
+      end
+
+    end
+
+  end
+
+  describe '#all' do
+    subject{ Queriable.new(given_collection)}
+
+    let(:given_collection) { [1,1,1] }
+
+    it 'return the collection' do
+      expect(subject.all).to eq given_collection
+    end
+
+    it 'returns an instance of the class' do
+      expect(subject.all).to be_a_kind_of Queriable
+    end
+
+  end
+
+  describe 'where' do
+
+    context 'with condition' do
+
+      subject{ Queriable.new(given_collection)}
+
+      let(:given_collection) { [OpenStruct.new(value: 1),
+                                 OpenStruct.new(value: 2),
+                                 OpenStruct.new(value: 3)] }
+
+      it 'returns array of values that meet the condition' do
+        expect(subject.where(value: 1)).to eq [given_collection.first]
+      end
+
+      it 'returns an instance of the class' do
+        expect(subject.where(value: 1)).to be_a_kind_of(Queriable)
+      end
+
+    end
+
+    context 'without condition' do
+
+      subject { Queriable.new(given_collection) }
+
+      it 'return a WhereNotChain' do
+        expect(subject.where).to be_a_kind_of(ActiveMock::Queries::WhereNotChain)
+      end
+
+      let(:given_collection) { [OpenStruct.new(value: 1),
+                                OpenStruct.new(value: 2),
+                                OpenStruct.new(value: 3)] }
+
+      it 'takes .not(condition)' do
+        expect(subject.where.not(value: 1)).to eq [given_collection[1], given_collection[2]]
+      end
+
+      it '.not(condition) return the class' do
+        expect(subject.where.not(value: 1)).to be_a_kind_of(Queriable)
+      end
+
+    end
+
+  end
+
+end