active_repository 0.2.7 → 0.3.0

data/spec/active_repository/associations_spec.rb

@@ -4,16 +4,13 @@ require 'active_record'
 require 'mongoid'
 
 describe ActiveRepository::Base, "associations" do
-
   before do
     class Country < ActiveRecord::Base
-      extend ActiveRepository::Associations::ActiveRecordExtensions
       establish_connection :adapter => "sqlite3", :database => ":memory:"
       connection.create_table(:countries, :force => true) {}
     end
 
     class School < ActiveRecord::Base
-      extend ActiveRepository::Associations::ActiveRecordExtensions
       establish_connection :adapter => "sqlite3", :database => ":memory:"
       connection.create_table(:schools, :force => true) do |t|
         t.integer :city_id
@@ -34,9 +31,9 @@ describe ActiveRepository::Base, "associations" do
       end
 
       if Object.const_defined?(:ActiveModel)
-        scope :published, {:conditions => {:published => true}}
+        scope :published, -> { where(published: true) }
       else
-        named_scope :published, {:conditions => {:published => true}}
+        named_scope :published, -> { where(:published => true) }
       end
     end
   end
@@ -82,60 +79,18 @@ describe ActiveRepository::Base, "associations" do
       it "find the correct records" do
         City.has_many :authors
         city = City.create :id => 1
-        city.authors.should == [@included_author_1, @included_author_2]
+        city.authors.all.should == [@included_author_1, @included_author_2]
       end
 
       it "uses the correct class name when passed" do
         City.has_many :writers, :class_name => "Author"
         city = City.create :id => 1
-        city.writers.should == [@included_author_1, @included_author_2]
+        city.writers.all.should == [@included_author_1, @included_author_2]
       end
     end
 
   end
 
-  describe ActiveRepository::Associations::ActiveRecordExtensions do
-
-    describe "#belongs_to_active_repository" do
-      context "setting by id" do
-        it "finds the correct records" do
-          School.belongs_to_active_repository :city
-          city = City.create
-          school = School.create :city_id => city.id
-          school.city.should == city
-        end
-
-        it "returns nil when the record does not exist" do
-          School.belongs_to_active_repository :city
-          school = School.create! :city_id => nil
-          school.city.should be_nil
-        end
-      end
-
-      context "setting by association" do
-        it "finds the correct records" do
-          School.belongs_to_active_repository :city
-          city = City.create
-          school = School.create :city => city
-          school.city.should == city
-        end
-
-        it "returns nil when the record does not exist" do
-          School.belongs_to_active_repository :city
-          school = School.create! :city => nil
-          school.city.should be_nil
-        end
-      end
-
-      it "finds active record metadata for this association" do
-        School.belongs_to_active_repository :city
-        association = School.reflect_on_association(:city)
-        association.should_not be_nil
-        association.klass.name.should == City.name
-      end
-    end
-  end
-
   describe "#belongs_to" do
 
     context "with an ActiveRecord parent" do
@@ -297,6 +252,9 @@ describe ActiveRepository::Base, "associations" do
     end
 
     after do
+      City.delete_all
+      State.delete_all
+
       Object.send :remove_const, :CityModel
       Object.send :remove_const, :State
       Object.send :remove_const, :StateModel
@@ -307,7 +265,7 @@ describe ActiveRepository::Base, "associations" do
         country = Country.create
         state   = State.create(:country_id => country.id)
 
-        country.states.should == [state]
+        country.states.all.should == [state]
       end
     end
 
@@ -323,7 +281,8 @@ describe ActiveRepository::Base, "associations" do
         state = State.create
         city  = City.create(:state_id => state.id)
 
-        state.cities.should == [city]
+
+        state.cities.all.should == [city]
       end
     end
 

data/spec/active_repository/base_spec.rb

@@ -29,6 +29,9 @@ describe ActiveRepository, "Base" do
       Country.create(:id => 5, :name => "Brazil")
     end
 
+    it_behaves_like '.constantize'
+    it_behaves_like '.serialized_attributes'
+    it_behaves_like '.update_attribute'
     it_behaves_like '.update_attributes'
     it_behaves_like '.all'
     it_behaves_like '.where'
@@ -37,7 +40,8 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.first'
     it_behaves_like '.last'
     it_behaves_like '.find'
-    it_behaves_like '.find_by_id'
+    it_behaves_like '.find_by'
+    it_behaves_like '.find_by!'
     it_behaves_like 'custom finders'
     it_behaves_like '#method_missing'
     it_behaves_like '#attributes'
@@ -58,6 +62,7 @@ describe ActiveRepository, "Base" do
     it_behaves_like '#new_record?'
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
+    it_behaves_like '#delete'
   end
 
   context "active_record", :active_record do
@@ -90,6 +95,9 @@ describe ActiveRepository, "Base" do
       Object.send :remove_const, :CountryModel
     end
 
+    it_behaves_like '.constantize'
+    it_behaves_like '.serialized_attributes'
+    it_behaves_like '.update_attribute'
     it_behaves_like '.update_attributes'
     it_behaves_like '.all'
     it_behaves_like '.where'
@@ -98,7 +106,8 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.first'
     it_behaves_like '.last'
     it_behaves_like '.find'
-    it_behaves_like '.find_by_id'
+    it_behaves_like '.find_by'
+    it_behaves_like '.find_by!'
     it_behaves_like 'custom finders'
     it_behaves_like '#method_missing'
     it_behaves_like '#attributes'
@@ -119,6 +128,7 @@ describe ActiveRepository, "Base" do
     it_behaves_like '#new_record?'
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
+    it_behaves_like '#delete'
   end
 
   context "mongoid", :mongoid do
@@ -156,6 +166,9 @@ describe ActiveRepository, "Base" do
       Object.send :remove_const, :CountryModel
     end
 
+    it_behaves_like '.constantize'
+    it_behaves_like '.serialized_attributes'
+    it_behaves_like '.update_attribute'
     it_behaves_like '.update_attributes'
     it_behaves_like '.all'
     it_behaves_like '.where'
@@ -164,7 +177,8 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.first'
     it_behaves_like '.last'
     it_behaves_like '.find'
-    it_behaves_like '.find_by_id'
+    it_behaves_like '.find_by'
+    it_behaves_like '.find_by!'
     it_behaves_like 'custom finders'
     it_behaves_like '#method_missing'
     it_behaves_like '#attributes'
@@ -185,5 +199,6 @@ describe ActiveRepository, "Base" do
     it_behaves_like '#new_record?'
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
+    it_behaves_like '#delete'
   end
 end

data/spec/active_repository/result_set_spec.rb

@@ -0,0 +1,366 @@
+require 'spec_helper'
+require 'active_repository'
+require 'active_repository/result_set'
+require 'pry'
+
+describe ActiveRepository::ResultSet, :result_set do
+  before do
+    class Country < ActiveRepository::Base
+      fields :name, :continent
+    end
+  end
+
+  describe 'initialize' do
+    context 'with class only' do
+      subject { ActiveRepository::ResultSet.new(Country) }
+
+      it 'must not be nil' do
+        expect(subject).not_to be_nil
+      end
+    end
+
+    context 'with class and attributes' do
+      subject { ActiveRepository::ResultSet.new(Country, {a: 'a'}) }
+
+      it 'must not be nil' do
+        expect(subject).not_to be_nil
+      end
+    end
+  end
+
+  describe '#count' do
+    after do
+      Country.delete_all
+    end
+
+    context 'without query' do
+      it 'returns total records in data store' do
+        Country.create
+        Country.create
+        Country.create
+        Country.create
+
+        expect(Country.count).to eq 4
+      end
+    end
+
+    context 'without query' do
+      it 'returns total records in data store' do
+        Country.create(name: 'A')
+        Country.create
+        Country.create(name: 'B')
+        Country.create
+
+        expect(Country.where(name: { '$ne' => nil}).count).to eq 2
+      end
+    end
+  end
+
+  describe '#where' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    it "returns a ResultSet object" do
+      expect(subject.where(name: 'Canada')).to be_a(ActiveRepository::ResultSet)
+    end
+
+    it 'creates another ResultSet object' do
+      result = subject.where(continent: 'America')
+
+      expect(result).not_to eq subject
+    end
+
+    context 'nested ResultSets' do
+      it 'returns a new ResultSet' do
+        result = subject.where(name: 'Canada').where(continent: 'America')
+
+        expect(result).to be_a(ActiveRepository::ResultSet)
+      end
+
+      it 'returns a new ResultSet' do
+        result = subject.where(name: 'Canada').where("continent = 'America'")
+
+        expect(result).to be_a(ActiveRepository::ResultSet)
+      end
+    end
+  end
+
+  describe '#and' do
+    it 'is a alias for #where' do
+      expect(described_class.instance_method(:and)).to eq described_class.instance_method(:where)
+    end
+  end
+
+  describe '#or' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    it "returns a ResultSet object" do
+      expect(subject.or(name: 'Canada')).to be_a(ActiveRepository::ResultSet)
+    end
+
+    it 'creates another ResultSet object' do
+      result = subject.or(continent: 'America')
+
+      expect(result).not_to eq subject
+    end
+
+    context 'nested ResultSets' do
+      it 'returns a new ResultSet' do
+        result = subject.or(name: 'Canada').or(continent: 'America')
+
+        expect(result).to be_a(ActiveRepository::ResultSet)
+      end
+    end
+  end
+
+  describe '#all' do
+    before do
+      Country.delete_all
+      Country.create(name: 'Canada', continent: 'America')
+      Country.create(name: 'Russia', continent: 'Europe')
+      Country.create(name: 'USA', continent: 'America')
+      Country.create(name: 'Brazil', continent: 'America')
+    end
+
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    context 'when result_set is not empty' do
+      context 'single ResultSet' do
+        it 'returns an array of objects' do
+          objects = subject.where(continent: 'America').all
+
+          expect(objects.class).to eq Array
+        end
+
+        it 'returns a collection of Countries' do
+          objects = subject.where(continent: 'America').all
+
+          expect(objects.map(&:class).uniq).to eq [Country]
+        end
+
+        it 'returns filtered objects' do
+          objects = subject.where(continent: 'America').all
+
+          expect(objects).to eq (Country.all - [Country.find(2)])
+        end
+      end
+
+      context 'nested ResultSets' do
+        it 'returns an array of objects' do
+          objects = subject.where(continent: 'America').where(name: 'Canada').all
+
+          expect(objects.class).to eq Array
+        end
+
+        it 'returns a collection of Countries' do
+          objects = subject.where(continent: 'America').where(name: 'Canada').all
+
+          expect(objects.map(&:class).uniq).to eq [Country]
+        end
+
+        it 'returns filtered objects' do
+          objects = subject.where(continent: 'America').where(name: 'Canada').all
+
+          expect(objects).to eq ([Country.first])
+        end
+
+        it 'returns filtered objects' do
+          objects = subject.where(continent: 'America').where("name = 'Canada'").all
+
+          expect(objects).to eq ([Country.first])
+        end
+      end
+    end
+
+    context 'when result_set is empty' do
+      it 'returns nil' do
+        expect(subject.where('').all).to be_empty
+      end
+    end
+  end
+
+  describe '#first' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    context 'when result_set is not empty' do
+      it 'returns first object from filtered objects' do
+        objects = subject.where(name: 'Russia').or(name: 'USA').first
+
+        expect(objects).to eq Country.find(2)
+      end
+    end
+
+    context 'when result_set is empty' do
+      it 'returns nil' do
+        objects = subject.where(name: 'Russia').and(name: 'USA').first
+
+        expect(objects).to be_nil
+      end
+    end
+  end
+
+  describe '#last' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    context 'when result_set is not empty' do
+      it 'returns first object from filtered objects' do
+        objects = subject.where(name: 'Russia').or(name: 'USA').last
+
+        expect(objects).to eq Country.find(3)
+      end
+    end
+
+    context 'when result_set is empty' do
+      it 'returns nil' do
+        objects = subject.where(name: 'Russia').and(name: 'USA').first
+
+        expect(objects).to be_nil
+      end
+    end
+  end
+
+  describe '#first_or_initialize' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    context 'single query' do
+      context 'when result_set is not empty' do
+        it 'returns first filtered object' do
+          object = subject.where(name: 'Russia').first_or_initialize
+
+          expect(object).to eq Country.find(2)
+        end
+      end
+
+      context 'when result_set is empty' do
+        context 'query is a Hash' do
+          it 'returns an object with specified attributes' do
+            object = subject.where(name: 'Poland').first_or_initialize
+
+            expect(object.attributes).to eq(name: 'Poland')
+          end
+        end
+
+        context 'query is not a Hash' do
+          it 'returns a new object with specified attributes' do
+            object = subject.where("name = 'Poland'").first_or_initialize
+
+            expect(object.attributes).to eq({})
+          end
+        end
+      end
+    end
+
+    context 'nested _query' do
+      context 'when result_set is not empty' do
+        it 'returns first filtered object' do
+          object = subject.where(name: 'Russia').and(continent: 'Europe').first_or_initialize
+
+          expect(object).to eq Country.find(2)
+        end
+      end
+
+      context 'when result_set is empty' do
+        context 'all queries are Hashes' do
+          it 'returns a new object with specified attributes' do
+            object = subject.where(name: 'Poland').and(continent: 'Europe').first_or_initialize
+
+            expect(object.attributes).to eq(name: 'Poland', continent: 'Europe')
+          end
+        end
+
+        context 'not all queries are Hashes' do
+          it 'returns a new object with all Hashes as attributes' do
+            object = subject.where(name: 'Poland').and("continent = 'Europe'").first_or_initialize
+
+            expect(object.attributes).to eq(name: 'Poland')
+          end
+
+          it 'returns a new object with all Hashes as attributes' do
+            object = subject.where("name = 'Poland'").and("continent = 'Europe'").first_or_initialize
+
+            expect(object.attributes).to eq({})
+          end
+        end
+      end
+    end
+  end
+
+  describe '#first_or_create' do
+    subject { ActiveRepository::ResultSet.new(Country) }
+
+    before do
+      Country.delete_all
+      Country.create(name: 'Canada', continent: 'America')
+      Country.create(name: 'Russia', continent: 'Europe')
+      Country.create(name: 'USA', continent: 'America')
+      Country.create(name: 'Brazil', continent: 'America')
+    end
+
+    context 'single query' do
+      context 'when result_set is not empty' do
+        it 'returns first filtered object' do
+          object = subject.where(name: 'Russia').first_or_create
+
+          expect(object).to eq Country.find(2)
+        end
+      end
+
+      context 'when result_set is empty' do
+        context 'query is a Hash' do
+          it 'returns an object with id not nil' do
+            object = subject.where(name: 'Poland').first_or_create
+
+            expect(object.id).to eq Country.last.id
+          end
+
+          it 'returns an object with specified attributes' do
+            object = subject.where(name: 'Poland').first_or_create
+
+            expect(object.attributes).to eq(id: 5, name: 'Poland')
+          end
+        end
+
+        context 'query is not a Hash' do
+          it 'returns a new object with specified attributes' do
+            object = subject.where("name = 'Poland'").first_or_create
+
+            expect(object.attributes).to eq(id: 5)
+          end
+        end
+      end
+    end
+
+    context 'nested _query' do
+      context 'when result_set is not empty' do
+        it 'returns first filtered object' do
+          object = subject.where(name: 'Russia').and(continent: 'Europe').first_or_create
+
+          expect(object).to eq Country.find(2)
+        end
+      end
+
+      context 'when result_set is empty' do
+        context 'all queries are Hashes' do
+          it 'returns a new object with specified attributes' do
+            object = subject.where(name: 'Poland').and(continent: 'Europe').first_or_create
+
+            expect(object.attributes).to eq(id: 5, name: 'Poland', continent: 'Europe')
+          end
+        end
+
+        context 'not all queries are Hashes' do
+          it 'returns a new object with all Hashes as attributes' do
+            object = subject.where(name: 'Poland').and("continent = 'Europe'").first_or_create
+
+            expect(object.attributes).to eq(id: 5, name: 'Poland')
+          end
+
+          it 'returns a new object with all Hashes as attributes' do
+            object = subject.where("name = 'Poland'").and("continent = 'Europe'").first_or_create
+
+            expect(object.attributes).to eq(id: 5)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,12 @@
-require 'rspec'
-require 'rspec/autorun'
 require 'coveralls'
 Coveralls.wear!
+# require 'simplecov'
+# SimpleCov.start do
+#   add_filter "/spec/"
+# end
+
+require 'rspec'
+require 'rspec/autorun'
 
 RSpec.configure do |c|
   c.treat_symbols_as_metadata_keys_with_true_values = true