active_repository 0.0.1 → 0.0.3

data/spec/active_repository/associations_spec.rb

@@ -0,0 +1,348 @@
+require 'spec_helper'
+require 'active_repository'
+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
+      end
+    end
+
+    class City < ActiveRepository::Base
+      City.set_model_class(self)
+      City.set_save_in_memory(true)
+    end
+
+    class Author < ActiveRepository::Base
+      Author.set_model_class(self)
+      Author.set_save_in_memory(true)
+    end
+
+    class Book < ActiveRecord::Base
+      establish_connection :adapter => "sqlite3", :database => ":memory:"
+      connection.create_table(:books, :force => true) do |t|
+        t.integer :author_id
+        t.boolean :published
+      end
+
+      if Object.const_defined?(:ActiveModel)
+        scope :published, {:conditions => {:published => true}}
+      else
+        named_scope :published, {:conditions => {:published => true}}
+      end
+    end
+  end
+
+  after do
+    Object.send :remove_const, :City
+    Object.send :remove_const, :Author
+    Object.send :remove_const, :Country
+    Object.send :remove_const, :School
+    Object.send :remove_const, :Book
+  end
+
+  describe "#has_many" do
+
+    context "with ActiveRecord children" do
+      before do
+        @included_book_1 = Book.create! :author_id => 1, :published => true
+        @included_book_2 = Book.create! :author_id => 1, :published => false
+        @excluded_book = Book.create! :author_id => 2, :published => true
+      end
+
+      it "find the correct records" do
+        Author.has_many :books
+        author = Author.create :id => 1
+        author.books.should == [@included_book_1, @included_book_2]
+      end
+
+      it "return a scope so that we can apply further scopes" do
+        Author.has_many :books
+        author = Author.create :id => 1
+        author.books.published.should == [@included_book_1]
+      end
+    end
+
+    context "with ActiveHash children" do
+      before do
+        Author.field :city_id
+        @included_author_1 = Author.create :city_id => 1
+        @included_author_2 = Author.create :city_id => 1
+        @excluded_author = Author.create :city_id => 2
+      end
+
+      it "find the correct records" do
+        City.has_many :authors
+        city = City.create :id => 1
+        city.authors.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]
+      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
+      it "find the correct records" do
+        City.belongs_to :country
+        country = Country.create
+        city = City.create :country_id => country.id
+        city.country.should == country
+      end
+
+      it "returns nil when the record does not exist" do
+        City.belongs_to :country
+        city = City.create :country_id => 123
+        city.country.should be_nil
+      end
+    end
+
+    context "with an ActiveHash parent" do
+      it "find the correct records" do
+        Author.belongs_to :city
+        city = City.create
+        author = Author.create :city_id => city.id
+        author.city.should == city
+      end
+
+      it "returns nil when the record does not exist" do
+        Author.belongs_to :city
+        author = Author.create :city_id => 123
+        author.city.should be_nil
+      end
+    end
+
+    describe "#parent=" do
+      before do
+        Author.belongs_to :city
+        @city = City.create :id => 1
+      end
+
+      it "sets the underlying id of the parent" do
+        author = Author.new
+        author.city = @city
+        author.city_id.should == @city.id
+      end
+
+      it "works from hash assignment" do
+        author = Author.new :city => @city
+        author.city_id.should == @city.id
+        author.city.should == @city
+      end
+
+      it "works with nil" do
+        author = Author.new :city => @city
+        author.city_id.should == @city.id
+        author.city.should == @city
+
+        author.city = nil
+        author.city_id.should be_nil
+        author.city.should be_nil
+      end
+    end
+
+    describe "with a different foreign key" do
+      before do
+        Author.belongs_to :residence, :class_name => "City", :foreign_key => "city_id"
+        @city = City.create :id => 1
+      end
+
+      it "works" do
+        author = Author.new
+        author.residence = @city
+        author.city_id.should == @city.id
+      end
+    end
+  end
+
+  describe "#has_one" do
+    context "with ActiveRecord children" do
+      before do
+        Author.has_one :book
+      end
+
+      it "find the correct records" do
+        book = Book.create! :author_id => 1, :published => true
+        author = Author.create :id => 1
+        author.book.should == book
+      end
+
+      it "returns nil when there is no record" do
+        author = Author.create :id => 1
+        author.book.should be_nil
+      end
+    end
+
+    context "with ActiveHash children" do
+      before do
+        City.has_one :author
+        Author.field :city_id
+      end
+
+      it "find the correct records" do
+        city = City.create :id => 1
+        author = Author.create :city_id => 1
+        city.author.should == author
+      end
+
+      it "returns nil when there are no records" do
+        city = City.create :id => 1
+        city.author.should be_nil
+      end
+    end
+  end
+
+  describe "#marked_for_destruction?" do
+    it "should return false" do
+      City.new.marked_for_destruction?.should == false
+    end
+  end
+
+  describe "Multiple ORM" do
+    before do
+      Object.send :remove_const, :City
+      # Object.send :remove_const, :Author
+      Object.send :remove_const, :Country
+      # Object.send :remove_const, :School
+      # Object.send :remove_const, :Book
+
+      class Country < ActiveRepository::Base
+        Country.set_model_class(Country)
+        Country.set_save_in_memory(true)
+        has_many :states
+      end
+
+      class StateModel < ActiveRecord::Base
+        self.table_name = 'states'
+        establish_connection :adapter => "sqlite3", :database => ":memory:"
+        connection.create_table(:states) do |t|
+          t.integer :country_id
+        end
+      end
+
+      class State < ActiveRepository::Base
+        State.set_model_class(StateModel)
+        State.set_save_in_memory(false)
+        belongs_to :country
+        has_many :cities
+
+        fields :country_id, :city_id
+      end
+
+      Mongoid.load!("support/mongoid.yml", :development)
+
+      class CityModel
+        include Mongoid::Document
+        store_in collection: "countries"
+        field :state_id
+      end
+
+      class City < ActiveRepository::Base
+        City.set_model_class(CityModel)
+        City.set_save_in_memory(false)
+        belongs_to :state
+      end
+    end
+
+    after do
+      Object.send :remove_const, :CityModel
+      Object.send :remove_const, :State
+      Object.send :remove_const, :StateModel
+    end
+
+    context ActiveRepository do
+      it "relates with ActiveRecord models" do
+        country = Country.create
+        state   = State.create(:country_id => country.id)
+
+        country.states.should == [state]
+      end
+    end
+
+    context ActiveRecord do
+      it "relates with ActiveRepository objects" do
+        country = Country.create
+        state   = State.create(:country_id => country.id)
+
+        state.country.should == country
+      end
+
+      it "relates with Mongoid models" do
+        state = State.create
+        city  = City.create(:state_id => state.id)
+
+        state.cities.should == [city]
+      end
+    end
+
+    context Mongoid do
+      it "relates with ActiveRecord models" do
+        state = State.create
+        city  = City.create(:state_id => state.id)
+
+        city.state.should == state
+      end
+    end
+  end
+
+end

data/spec/active_repository/base_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 require 'support/shared_examples'
 
 require 'active_repository'
-require "active_record"
-require "mongoid"
+require 'active_record'
+require 'mongoid'
 
 describe ActiveRepository, "Base" do
 
@@ -120,4 +120,70 @@ describe ActiveRepository, "Base" do
     it_behaves_like '.transaction'
     it_behaves_like '.delete_all'
   end
+
+  context "mongoid" do
+    before do
+      Country.fields :name, :monarch, :language
+
+      Mongoid.load!("support/mongoid.yml", :development)
+
+      class CountryModel
+        include Mongoid::Document
+
+        store_in collection: "countries"
+
+        field :name
+        field :monarch
+        field :language
+        field :_id, type: Integer, default: -> { CountryModel.last ? CountryModel.last.id + 1 : 1 }
+        field :updated_at
+        field :created_at
+      end
+
+      Country.set_model_class(CountryModel)
+      Country.set_save_in_memory(false)
+
+      Country.delete_all
+
+      Country.create(:id => 1, :name => "US",     :language => 'English')
+      Country.create(:id => 2, :name => "Canada", :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 3, :name => "Mexico", :language => 'Spanish')
+      Country.create(:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England")
+      Country.create(:id => 5, :name => "Brazil")
+    end
+
+    after do
+      Object.send :remove_const, :CountryModel
+    end
+
+    it_behaves_like '.update_attributes'
+    it_behaves_like '.all'
+    it_behaves_like '.where'
+    it_behaves_like '.exists?'
+    it_behaves_like '.count'
+    it_behaves_like '.first'
+    it_behaves_like '.last'
+    it_behaves_like '.find'
+    it_behaves_like '.find_by_id'
+    it_behaves_like 'custom finders'
+    it_behaves_like '#method_missing'
+    it_behaves_like '#attributes'
+    it_behaves_like 'reader_methods'
+    it_behaves_like 'interrogator methods'
+    it_behaves_like '#id'
+    it_behaves_like '#quoted_id'
+    it_behaves_like '#to_param'
+    it_behaves_like '#persisted?'
+    it_behaves_like '#eql?'
+    it_behaves_like '#=='
+    it_behaves_like '#hash'
+    it_behaves_like '#readonly?'
+    it_behaves_like '#cache_key'
+    it_behaves_like '#save'
+    it_behaves_like '.create'
+    it_behaves_like '#valid?'
+    it_behaves_like '#new_record?'
+    it_behaves_like '.transaction'
+    it_behaves_like '.delete_all'
+  end
 end

data/spec/active_repository/sql_query_executor_spec.rb

@@ -3,7 +3,6 @@ require 'support/sql_query_shared_examples'
 
 require 'active_repository'
 require "active_record"
-require "mongoid"
 
 describe ActiveRepository, "Base" do
 

data/spec/support/shared_examples.rb

@@ -30,10 +30,9 @@ shared_examples ".all" do
 
   it "populates the data correctly" do
     records = Country.all
-    records.first.id.should == 1
-    records.first.name.should == "US"
-    records.last.id.should == 5
-    records.last.name.should == "Brazil"
+    records.should include(Country.first)
+    records.should include(Country.last)
+    records.size.should == 5
   end
 end
 
@@ -72,12 +71,13 @@ end
 
 shared_examples ".exists?" do
   it "checks if a record exists" do
-    id = Country.last.id + 1
+    id = Country.last.id
 
     Country.delete_all
     Country.exists?(id).should be_false
 
-    country = Country.create(:id => id, :name => "France")
+    country = Country.create(:name => "France")
+    id = country.id
 
     Country.exists?(id).should be_true
   end
@@ -120,7 +120,11 @@ shared_examples ".find" do
 
   context "with :all" do
     it "returns all records" do
-      Country.find(:all).should == [Country.find(1), Country.find(2), Country.find(3), Country.find(4), Country.find(5)]
+      records = Country.find(:all)
+
+      records.should include(Country.first)
+      records.should include(Country.last)
+      records.size.should == 5
     end
   end
 
@@ -446,9 +450,13 @@ shared_examples "#cache_key" do
   end
 
   it 'should use the record\'s updated_at if present' do
-    country = Country.create(:id => 6, :name => "foo")
+    country = Country.create(:name => "foo")
 
-    Country.first.cache_key.should == "countries/6-#{country.updated_at.to_s(:number)}"
+    id = Country.last.id
+
+    date_string = country.updated_at.nil? ? "" : "-#{country.updated_at.to_s(:number)}"
+
+    Country.first.cache_key.should == "countries/#{id}#{date_string}"
   end
 
   it 'should use "new" instead of the id for a new record' do
@@ -467,7 +475,16 @@ shared_examples "#save" do
     country = Country.new :id => 1, :name => "foo", :monarch => nil, :language => nil
     country.persist.should be_true
     country.reload
-    Country.all.should == [country]
+
+    countries_attributes =  Country.all.map(&:attributes)
+    countries_attributes.delete(:created_at)
+    countries_attributes.delete(:updated_at)
+
+    expected_attributes = [country].map(&:attributes)
+    expected_attributes.delete(:created_at)
+    expected_attributes.delete(:updated_at)
+
+    countries_attributes.should == expected_attributes
   end
 end
 
@@ -479,16 +496,31 @@ shared_examples ".create" do
 
   it "works with no args" do
     Country.all.should be_empty
-    country = Country.create :id => 6
-    country.id.should == 6
+    country = Country.create
+
+    country.id.should == Country.last.id
   end
 
   it "adds the new object to the data collection" do
     Country.all.should be_empty
-    country = Country.create :id => 6, :name => "foo"
-    country.id.should == 6
+    country = Country.create :name => "foo"
+    country.id.should == Country.last.id
     country.name.should == "foo"
-    Country.all.should == [country]
+
+    countries_attributes = Country.all.map(&:attributes)
+    expected_attributes  = [country].map(&:attributes)
+
+    countries_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    expected_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    countries_attributes.should == expected_attributes
   end
 
   it "adds an auto-incrementing id if the id is nil" do
@@ -509,11 +541,24 @@ shared_examples ".create" do
 
   it "adds the new object to the data collection" do
     Country.all.should be_empty
-    country = Country.create :id => 6, :name => "foo"
-    country.id.should == 6
+    country = Country.create :name => "foo"
+    country.id.should == Country.last.id
     country.name.should == "foo"
 
-    Country.all.should == [country]
+    countries_attributes = Country.all.map(&:attributes)
+    expected_attributes  = [country].map(&:attributes)
+
+    countries_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    expected_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    countries_attributes.should == expected_attributes
   end
 
   it "updates count" do
@@ -575,7 +620,21 @@ shared_examples ".delete_all" do
   it "clears out all record" do
     country1 = Country.create
     country2 = Country.create
-    Country.all.should == [country1, country2]
+
+    countries_attributes = Country.all.map(&:attributes)
+    expected_attributes  = [country1, country2].map(&:attributes)
+
+    countries_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    expected_attributes.each do |a|
+      a.delete(:created_at)
+      a.delete(:updated_at)
+    end
+
+    countries_attributes.should == expected_attributes
     Country.delete_all
     Country.all.should be_empty
   end

data/support/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: active_repository
+      hosts:
+        - localhost:27017