active_mocker 1.2.4 → 1.3

data/sample_app_rails_4/spec/compare_mocker_and_record_spec.rb

@@ -19,8 +19,6 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
     Micropost.destroy_all
   end
 
- USER_CLASSES = [User, UserMock]
-
 
   let(:attributes) { {name: 'Dustin Zeisler', email: 'dustin@example.com'} }
   let(:attributes_with_admin) { {name: 'Dustin Zeisler', email: 'dustin@example.com', admin: true} }
@@ -46,6 +44,52 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
       UserMock.create(create_attributes)
     end
 
+    context 'new with block' do
+
+      def create_with_block(klass)
+        user = klass.new do |u|
+          u.name = "David"
+          u.admin = true
+        end
+
+        expect(user.name).to eq 'David'
+        expect(user.admin).to eq true
+
+      end
+
+      it 'User' do
+        create_with_block(User)
+      end
+
+      it 'UserMock' do
+        create_with_block(UserMock)
+      end
+
+    end
+
+    context 'create with block' do
+
+      def create_with_block(klass)
+        user = klass.create do |u|
+          u.name = "David"
+          u.admin = true
+        end
+
+        expect(user.name).to eq 'David'
+        expect(user.admin).to eq true
+
+      end
+
+      it 'User' do
+        create_with_block(User)
+      end
+
+      it 'UserMock' do
+        create_with_block(UserMock)
+      end
+
+    end
+
   end
 
   describe '#attributes' do
@@ -63,6 +107,74 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
   end
 
+  describe '::all' do
+
+    def klass_all(klass)
+      array = [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+      expect(klass.all).to eq array
+    end
+
+    it 'User' do
+      klass_all(User)
+    end
+
+    it 'UserMock' do
+      klass_all(UserMock)
+    end
+
+  end
+
+  describe '::average' do
+
+    def klass_method_average(klass)
+      [klass.create!(credits: 12, email: '1'), klass.create!(credits: 2, email: '2'), klass.create!(credits: 8, email: '3'), klass.create!(credits: 4, email: '4')]
+      expect(klass.average(:credits).to_s).to eq "6.5"
+    end
+
+    it 'User' do
+      klass_method_average(User)
+    end
+
+    it 'UserMock' do
+      klass_method_average(UserMock)
+    end
+
+  end
+
+  describe '::minimum' do
+
+    def klass_method_minimum(klass)
+      [klass.create!(credits: 12, email: '1'), klass.create!(credits: 2, email: '2'), klass.create!(credits: 8, email: '3'), klass.create!(credits: 4, email: '4')]
+      expect(klass.minimum(:credits).to_s).to eq "2.0"
+    end
+
+    it 'User' do
+      klass_method_minimum(User)
+    end
+
+    it 'UserMock' do
+      klass_method_minimum(UserMock)
+    end
+
+  end
+
+  describe '::maximum' do
+
+    def klass_method_maximum(klass)
+      [klass.create!(credits: 12, email: '1'), klass.create!(credits: 2, email: '2'), klass.create!(credits: 8, email: '3'), klass.create!(credits: 4, email: '4')]
+      expect(klass.maximum(:credits).to_s).to eq "12.0"
+    end
+
+    it 'User' do
+      klass_method_maximum(User)
+    end
+
+    it 'UserMock' do
+      klass_method_maximum(UserMock)
+    end
+
+  end
+
   describe 'associations' do
 
     let(:micropost){ Micropost.create(content: 'post')}
@@ -91,6 +203,14 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
   end
 
+  describe 'attribute_names' do
+
+    it 'they are the same' do
+      expect(UserMock.attribute_names).to eq User.attribute_names
+    end
+
+  end
+
   describe '::find_by' do
 
     let!(:ar_record){User.create(attributes)}
@@ -108,16 +228,16 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
   describe '::where' do
 
-    let(:ar_record){User.create(attributes)}
-    let(:mock_record){UserMock.create(attributes)}
-    let(:mock_record_2){UserMock.create(attributes_with_admin)}
+    let!(:ar_record){User.create(attributes)}
+    let!(:mock_record){UserMock.create(attributes)}
+    let!(:mock_record_2){UserMock.create(attributes_with_admin)}
 
     it 'AR' do
       expect([ar_record]).to eq User.where(attributes)
     end
 
     it 'Mock' do
-      expect([mock_record]).to eq UserMock.where(attributes)
+      expect(UserMock.where(attributes)).to eq [mock_record, mock_record_2]
     end
 
     it 'Mock will not take sql string needs to be mocked' do
@@ -125,6 +245,94 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
       expect{UserMock.where("name = 'Dustin Zeisler'")}.to raise_error
     end
 
+    context 'by association not only attribute'do
+
+      def where_by_association(user_class, micropost_class)
+        user = user_class.create!(email: '1')
+        micropost = micropost_class.create(user: user)
+        expect(micropost_class.where(user: user)).to eq [micropost]
+      end
+
+      it 'User' do
+        where_by_association(User, Micropost)
+      end
+
+      it 'UserMock' do
+        where_by_association(UserMock, MicropostMock)
+      end
+
+
+    end
+
+    context 'will return all if no options passed' do
+
+      def where_no_options(klass, where_klass)
+        records = [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+        expect(klass.where.class).to eq(where_klass)
+      end
+
+      it 'User' do
+        where_no_options(User, ActiveRecord::QueryMethods::WhereChain)
+      end
+
+      it 'UserMock' do
+        where_no_options(UserMock, ActiveMocker::Collection::Queries::WhereNotChain)
+      end
+
+    end
+
+    context 'multiple wheres' do
+
+      def where_where(klass)
+        records = [klass.create!(email: '1', name: 'fred', admin: true), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+        expect(klass.where(name: 'fred').where(admin: true)).to eq([records[0]])
+      end
+
+      it 'User' do
+        where_where(User)
+      end
+
+      it 'UserMock' do
+        where_where(UserMock)
+      end
+
+    end
+
+  end
+
+  describe '::where.not' do
+
+    def where_not(klass)
+      records = [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+      expect(klass.where.not(name: 'fred')).to eq([records[2]])
+    end
+
+    it 'User' do
+      where_not(User)
+    end
+
+    it 'UserMock' do
+      where_not(UserMock)
+    end
+
+  end
+
+  describe '::update_all' do
+
+    def klass_update_all(klass)
+      [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+      klass.update_all(name: 'John')
+      expect(klass.all.map{|a| a.name}).to eq(['John', 'John', 'John'])
+    end
+
+    it 'User' do
+      klass_update_all(User)
+    end
+
+    it 'UserMock' do
+      klass_update_all(UserMock)
+    end
+
   end
 
   describe 'type coercion' do
@@ -160,33 +368,246 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
     let(:support_array_methods) { [:<<, :take, :push, :clear, :first, :last, :concat, :replace, :distinct, :uniq, :count, :size, :length, :empty?, :any?, :include?] }
 
-    it 'supported array methods' do
-      mp1 = Micropost.create!(content: 'text')
-      mp2 = Micropost.create!(content: 'text')
-      user = User.create(microposts: [mp1, mp2])
+    context 'supported array methods' do
+
+      def supported_array_methods(user_class, micropost, collection_klass)
+        mp1 = micropost.create!(content: 'text')
+        mp2 = micropost.create!(content: 'text')
+        user = user_class.create(microposts: [mp1, mp2])
+        expect(user.microposts.take(1).count).to eq(1)
+        expect(user.microposts.class).to eq(collection_klass)
+        expect(user.microposts.methods).to include *support_array_methods
+      end
+
+      it 'User' do
+        supported_array_methods(User, Micropost, Micropost::ActiveRecord_Associations_CollectionProxy)
+      end
+
+      it 'UserMock' do
+        supported_array_methods(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+      end
+
+    end
+
+    describe '#find' do
+
+      context 'single id passed' do
+
+        def collection_find(user_class, micropost, collection_klass)
+          microposts = [micropost.create, micropost.create]
+          user = user_class.create!(email: '1', name: 'fred', microposts: microposts)
+          expect(user.microposts.find(microposts.first.id)).to eq microposts.first
+        end
+
+        it 'User' do
+          collection_find(User, Micropost, Micropost::ActiveRecord_Associations_CollectionProxy)
+        end
+
+        it 'UserMock' do
+          collection_find(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+        end
 
-      mpm1 = MicropostMock.create
-      mpm2 = MicropostMock.create
-      user_mock = UserMock.create(microposts: [mpm1, mpm2])
+      end
 
-      expect(user.microposts.methods).to include *support_array_methods
-      expect(user_mock.microposts.methods).to include *support_array_methods
-      expect(user.microposts.take(1).count).to eq(1)
-      expect(user_mock.microposts.take(1).count).to eq(1)
+      context 'multiple ids passed' do
+
+        def collection_finds(user_class, micropost, collection_klass)
+          microposts = [micropost.create(id: 1), micropost.create(id: 2)]
+          user = user_class.create!(email: '1', name: 'fred', microposts: microposts)
+          expect(user.microposts.find([microposts.first.id, microposts.last.id])).to include *microposts.first, microposts.last
+        end
+
+        it 'User' do
+          collection_finds(User, Micropost, Micropost::ActiveRecord_Associations_CollectionProxy)
+        end
+
+        it 'UserMock' do
+          collection_finds(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+        end
+
+      end
 
     end
 
-    it '#sum' do
-      mp1 = Micropost.create!(content: 'text')
-      mp2 = Micropost.create!(content: 'text')
-      user = User.create(microposts: [mp1, mp2])
-      expect(user.microposts.sum(:user_id)).to eq 2
+    describe '#sum' do
+
+      def collection_association_sum(user_class, micropost)
+        mpm1 = micropost.create!(up_votes: 5)
+        mpm2 = micropost.create!(up_votes: 5)
+        user_mock = user_class.create!(microposts: [mpm1, mpm2])
+        expect(user_mock.microposts.sum(:up_votes)).to eq 10
+      end
 
-      mpm1 = MicropostMock.create(user_id: 1)
-      mpm2 = MicropostMock.create(user_id: 2)
-      user_mock = UserMock.create(microposts: [mpm1, mpm2])
+      it 'User' do
+        collection_association_sum(User, Micropost)
+      end
 
-      expect(user_mock.microposts.sum(:user_id)).to eq 3
+      it 'UserMock' do
+        collection_association_sum(UserMock, MicropostMock)
+      end
+
+    end
+
+    context 'can delete unsaved object from collection' do
+
+      def delete_object(klasses)
+        mp1 = klasses.first.create!(content: 'text')
+        mp2 = klasses.first.create!(content: 'text')
+        user = klasses.last.new(microposts: [mp1, mp2])
+        user.microposts.delete(mp1)
+        expect(user.microposts).to eq [mp2]
+      end
+
+      it 'UserMock' do
+        delete_object([MicropostMock, UserMock])
+      end
+
+      it 'User' do
+        delete_object([Micropost, User])
+      end
+
+    end
+
+  end
+
+  describe 'Collections'do
+
+    context 'delete_all' do
+
+      context 'deletes all records from result' do
+
+        def collections_delete_all(klass)
+          [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          klass.where(name: 'fred').delete_all
+          expect(klass.count).to eq 1
+        end
+
+        it 'User' do
+          collections_delete_all(User)
+        end
+
+        it 'UserMock' do
+          collections_delete_all(UserMock)
+        end
+
+      end
+
+      context 'deletes all records association' do
+
+        def association_collections_delete_all(user_class, micropost)
+          user = user_class.create!(email: '1', name: 'fred', microposts: [micropost.create, micropost.create])
+          user.microposts.delete_all
+          expect(user_class.count).to eq 1
+        end
+
+        it 'User' do
+          association_collections_delete_all(User, Micropost)
+        end
+
+        it 'UserMock' do
+          association_collections_delete_all(UserMock, MicropostMock)
+        end
+
+      end
+
+    end
+
+    context 'where' do
+
+      context 'all.where' do
+
+        def collections_all_where(klass)
+          records = [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          expect(klass.all.where(name: 'fred')).to eq([records[0], records[1]])
+        end
+
+        it 'User' do
+          collections_all_where(User)
+        end
+
+        it 'UserMock' do
+          collections_all_where(UserMock)
+        end
+
+      end
+
+    end
+
+    context 'order' do
+
+      context 'where.order' do
+
+        def collections_where_order(klass)
+          records = [klass.create!(email: '2', name: 'fred'), klass.create!(email: '1', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          expect(klass.where(name: 'fred').order(:email)).to eq([records[1], records[0]])
+        end
+
+        it 'User' do
+          collections_where_order(User)
+        end
+
+        it 'UserMock' do
+          collections_where_order(UserMock)
+        end
+
+      end
+
+      context 'where.order.reverse_order' do
+
+        def collections_where_order_reverse_order(klass)
+          records = [klass.create!(email: '2', name: 'fred'), klass.create!(email: '1', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          expect(klass.where(name: 'fred').order(:email).reverse_order).to eq([records[0], records[1]])
+        end
+
+        it 'User' do
+          collections_where_order_reverse_order(User)
+        end
+
+        it 'UserMock' do
+          collections_where_order_reverse_order(UserMock)
+        end
+
+      end
+
+    end
+
+    context 'update_all' do
+
+      context 'where.update_all' do
+
+        def collection_where_update_all(klass)
+          [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          klass.where(name: 'fred' ).update_all(name: 'John')
+          expect(klass.all.map { |a| a.name }).to eq(['John', 'John', 'Sam'])
+        end
+
+        it 'User' do
+          collection_where_update_all(User)
+        end
+
+        it 'UserMock' do
+          collection_where_update_all(UserMock)
+        end
+
+      end
+
+      context 'all.update_all' do
+
+        def collection_all_update_all(klass)
+          [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'fred'), klass.create!(email: '3', name: 'Sam')]
+          klass.all.update_all(name: 'John')
+          expect(klass.all.map { |a| a.name }).to eq(['John', 'John', 'John'])
+        end
+
+        it 'User' do
+          collection_all_update_all(User)
+        end
+
+        it 'UserMock' do
+          collection_all_update_all(UserMock)
+        end
+
+      end
 
     end
 
@@ -240,7 +661,6 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
       end
 
-
   end
 
   describe 'delete' do
@@ -355,23 +775,57 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
   end
 
-  describe '::where(conditions = nil).delete_all', pending: true do
-    it "User" do
-    pending{ 'new feature implement ActiveMocker::Relation array' }
-      user2 = User.create(email: '1')
-      user1 = User.create(email: '2')
-      expect(User.where(id: user1.id).delete_all).to eq 1
-      expect(User.where(id: user1.id).class).to eq User::ActiveRecord_Relation
-      expect(User.count).to eq 1
+  describe  '::limit' do
+
+    def klass_limit(klass)
+      records = [klass.create!(email: '1', name: 'fred'), klass.create!(email: '2', name: 'Dan'), klass.create!(email: '3', name: 'Sam')]
+      expect(klass.limit(2)).to eq [records[0], records[1]]
+      expect(klass.limit(2).where(name: 'fred')).to eq [records[0]]
     end
 
-    it "UserMock" do
-      pending { 'new feature implement ActiveMocker::Relation array' }
-      user2 = UserMock.create(email: '1')
-      user1 = UserMock.create(email: '2')
-      expect(UserMock.where(id: user1.id).class.name).to eq 'ActiveMocker::Relation'
-      expect(UserMock.where(id: user1.id).delete_all).to eq 1
-      expect(UserMock.count).to eq 1
+    it 'User' do
+      klass_limit(User)
+    end
+
+    it 'UserMock' do
+      klass_limit(UserMock)
+    end
+
+  end
+
+  describe '::find_by!' do
+
+    context 'will raise exception if not found' do
+
+      def find_by_exception(user_class, error)
+        expect{user_class.find_by!(name: 'Matz')}.to raise_error(error)
+      end
+
+      it 'User' do
+        find_by_exception(User, ActiveRecord::RecordNotFound)
+      end
+
+      it 'UserMock' do
+        find_by_exception(UserMock, ActiveMocker::RecordNotFound)
+      end
+
+    end
+
+    context 'will find one record by conditions' do
+
+      def find_by_one_result(user_class)
+        user = user_class.create!(email: '1', name: 'fred')
+        expect(user_class.find_by!(name: 'fred') ).to eq user
+      end
+
+      it 'User' do
+        find_by_one_result(User)
+      end
+
+      it 'UserMock' do
+        find_by_one_result(UserMock)
+      end
+
     end
 
   end