massive_record 0.2.1 → 0.2.2.rc1

data/spec/orm/persistence/operations/reload_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Reload do
+  include MockMassiveRecordConnection
+
+  let(:record) { TestClass.new("id-1") }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+  it_should_behave_like "a persistence table operation class"
+
+  before { record.save! }
+
+  describe "#execute" do
+    context "new record" do
+      before { record.stub(:persisted?).and_return false }
+
+      its(:execute) { should be_false }
+
+      it "does no find" do
+        subject.klass.should_not_receive(:find)
+        subject.execute
+      end
+    end
+
+    context "persisted" do
+      its(:execute) { should be_true }
+
+      it "asks class to find it's id" do
+        subject.klass.should_receive(:find).with(record.id).and_return(record)
+        subject.execute
+      end
+
+      it "reinit record with found record's attributes and raw_data" do
+        subject.klass.should_receive(:find).with(record.id).and_return(record)
+        record.should_receive(:attributes).and_return('attributes' => {})
+        record.should_receive(:raw_data).and_return('raw_data' => {})
+        record.should_receive(:reinit_with).with({
+          'attributes' => {'attributes' => {}},
+          'raw_data' => {'raw_data' => {}}
+        })
+        subject.execute
+      end
+    end
+  end
+end
+

data/spec/orm/persistence/operations/suppress_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Suppress do
+  include MockMassiveRecordConnection
+
+  let(:record) { TestClass.new("id-1") }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+
+  describe "#execute" do
+    it "returns true" do
+      subject.execute.should be_true
+    end
+  end
+end

data/spec/orm/persistence/operations/table_operation_helpers_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+
+
+        class TestTableOperationHelpers
+          include Operations, TableOperationHelpers
+        end
+
+
+        describe TableOperationHelpers do
+          include MockMassiveRecordConnection
+
+          let(:person) { Person.new("id-1", :name => "Thorbjorn", :age => 30) }
+          let(:address) { Address.new "address-1", :street => "Asker", :number => 1 }
+          let(:options) { {:this => 'hash', :has => 'options'} }
+          
+          subject { TestTableOperationHelpers.new(person, options) }
+
+          before do
+            person.addresses << address
+          end
+
+          
+          describe "#row_for_record" do
+            it "raises an error if id for person is blank" do
+              person.id = nil
+              expect { subject.row_for_record }.to raise_error MassiveRecord::ORM::IdMissing
+            end
+
+            it "returns a row with id and table set" do
+              row = subject.row_for_record
+              row.id.should eq person.id
+              row.table.should eq person.class.table
+            end
+          end
+
+          describe "#attributes_to_row_values_hash" do
+            before { person.addresses.parent_will_be_saved! }
+
+            it "should include the 'pts' field in the database which has 'points' as an alias" do
+              subject.attributes_to_row_values_hash["base"].keys.should include("pts")
+              subject.attributes_to_row_values_hash["base"].keys.should_not include("points")
+            end
+
+            it "should include integer value, even if it is set as string" do
+              person.age = "20"
+              subject.attributes_to_row_values_hash["info"]["age"].should == 20
+            end
+
+            describe "embedded attributes" do
+              it "includes the column family for the embedded relation" do
+                subject.attributes_to_row_values_hash.keys.should include "addresses"
+              end
+
+              it "asks the proxy for update hash and uses whatever it delivers" do
+                dummy_hash = {:foo => {:bar => :dummy}}
+                person.addresses.should_receive(:proxy_targets_update_hash).any_number_of_times.and_return(dummy_hash)
+                subject.attributes_to_row_values_hash["addresses"].should eq dummy_hash
+              end
+
+              it "merges embedded collections in to existing column families" do
+                attributes_from_person = subject.attributes_to_row_values_hash["info"]
+                attributes_from_cars = {:foo => {:bar => :dummy}}
+                person.cars.should_receive(:proxy_targets_update_hash).any_number_of_times.and_return(attributes_from_cars)
+                subject.attributes_to_row_values_hash["info"].should eq attributes_from_person.merge(attributes_from_cars)
+              end
+            end
+          end
+
+
+
+          describe "#store_record_to_database" do
+            let(:row) { mock(Object, :save => true, :values= => true) }
+
+            before { subject.should_receive(:row_for_record).and_return(row) }
+
+            it "assigns row it's values from what attributes_to_row_values_hash returns" do
+              row.should_receive(:values=).with(subject.attributes_to_row_values_hash)
+              subject.store_record_to_database('create')
+            end
+
+            it "calls save on the row" do
+              row.should_receive(:save)
+              subject.store_record_to_database('create')
+            end
+          end
+        end
+
+
+
+      end
+    end
+  end
+end

data/spec/orm/persistence/operations/update_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Update do
+  include MockMassiveRecordConnection
+
+  let(:record) { TestClass.new("id-1") }
+  let(:options) { {:attribute_names_to_update => ['foo']} }
+  
+  subject { described_class.new(record, options) }
+
+  it_should_behave_like "a persistence table operation class"
+
+
+  describe "#execute" do
+    it "ensures that we have table and column families" do
+      subject.should_receive(:ensure_that_we_have_table_and_column_families!)
+      subject.execute
+    end
+
+    it "calls upon store_record_to_database for help with actually update job" do
+      subject.should_receive(:store_record_to_database).with('update', ['foo'])
+      subject.execute
+    end
+  end
+end

data/spec/orm/persistence/operations_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'orm/models/test_class'
+
+describe MassiveRecord::ORM::Persistence::Operations do
+  let(:options) { {:this => 'hash', :has => 'options'} }
+
+  describe "factory method" do
+    context "table record" do
+      let(:record) { TestClass.new }
+
+      [:insert, :update, :destroy, :atomic_operation, :reload].each do |method|
+        describe "##{method}" do
+          subject { described_class.send(method, record, options) }
+
+          its(:record) { should eq record }
+          its(:klass) { should eq record.class }
+          its(:options) { should eq options }
+
+          it "is an instance of Persistence::Operations::#{method.to_s.classify}" do
+            klass = "MassiveRecord::ORM::Persistence::Operations::#{method.to_s.classify}".constantize
+            should be_instance_of klass
+          end
+
+          it "is possible to suppress" do
+             MassiveRecord::ORM::Persistence::Operations.suppress do
+               subject.should be_instance_of MassiveRecord::ORM::Persistence::Operations::Suppress
+             end
+          end
+        end
+      end
+    end
+
+    context "embedded record" do
+      let(:record) { Address.new }
+
+      [:insert, :update, :destroy, :reload].each do |method|
+        describe "##{method}" do
+          subject { described_class.send(method, record, options) }
+
+          its(:record) { should eq record }
+          its(:klass) { should eq record.class }
+          its(:options) { should eq options }
+
+          it "is an instance of Persistence::Operations::#{method.to_s.classify}" do
+            klass = "MassiveRecord::ORM::Persistence::Operations::Embedded::#{method.to_s.classify}".constantize
+            should be_instance_of klass
+          end
+
+          it "is possible to suppress" do
+             MassiveRecord::ORM::Persistence::Operations.suppress do
+               subject.should be_instance_of MassiveRecord::ORM::Persistence::Operations::Suppress
+             end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/orm/relations/interface_spec.rb

@@ -221,4 +221,192 @@ describe MassiveRecord::ORM::Relations::Interface do
       end
     end
   end
+
+
+  describe "embeds many" do
+    context "inside of it's own column family" do
+      describe "relation's meta data" do
+        subject { Person.relations.detect { |relation| relation.name == "addresses" } }
+
+        it "stores the relation on the class" do
+          Person.relations.detect { |relation| relation.name == "addresses" }.should_not be_nil
+        end
+
+        it "has correct type on relation" do
+          subject.relation_type.should == "embeds_many"
+        end
+
+        it "raises error if relation defined twice" do
+          expect { Person.embeds_many :addresses }.to raise_error MassiveRecord::ORM::RelationAlreadyDefined
+        end
+      end
+
+      describe "instance" do
+        subject { Person.new :name => "Thorbjorn", :email => "thhermansen@skalar.no", :age => 30 }
+        let(:address) { Address.new :street => "Asker" }
+        let(:proxy) { subject.send(:relation_proxy, "addresses") }
+
+        it { should respond_to :addresses }
+
+        it "should be empty when no addresses has been added" do
+          subject.addresses.should be_empty
+        end
+
+        it "has a known column family for the embedded records" do
+          subject.column_families.collect(&:name).should include "addresses"
+        end
+
+        it "is assignable" do
+          subject.addresses = [address]
+          subject.addresses.should == [address]
+        end
+
+        it "is assignable in initializer" do
+          person = Person.new :addresses => [address]
+          person.addresses.should == [address]
+        end
+
+        it "parent is invalid when one of embedded records is" do
+          subject.addresses << address
+          subject.save!
+          address.street = nil
+          subject.should_not be_valid
+        end
+      end
+    end
+
+    context "inside of a shared column family" do
+      describe "relation's meta data" do
+        subject { Person.relations.detect { |relation| relation.name == "cars" } }
+
+        it "stores the relation on the class" do
+          Person.relations.detect { |relation| relation.name == "cars" }.should_not be_nil
+        end
+
+        it "has correct type on relation" do
+          subject.relation_type.should == "embeds_many"
+        end
+
+        it "raises error if relation defined twice" do
+          expect { Person.embeds_many :cars }.to raise_error MassiveRecord::ORM::RelationAlreadyDefined
+        end
+      end
+
+      describe "instance" do
+        subject { Person.new :name => "Thorbjorn", :email => "thhermansen@skalar.no", :age => 30 }
+        let(:car) { Car.new :color => "blue" }
+        let(:proxy) { subject.send(:relation_proxy, "cars") }
+
+        it { should respond_to :cars }
+
+        it "should be empty when no cars has been added" do
+          subject.cars.should be_empty
+        end
+
+        it "has a known column family for the embedded records" do
+          subject.column_families.collect(&:name).should include "info"
+        end
+
+        it "is assignable" do
+          subject.cars = [car]
+          subject.cars.should == [car]
+        end
+
+        it "is assignable in initializer" do
+          person = Person.new :cars => [car]
+          person.cars.should == [car]
+        end
+
+        it "is persistable" do
+          subject.cars << car
+          subject.save!
+          from_database = Person.find subject.id
+
+          from_database.name.should eq subject.name
+          from_database.email.should eq subject.email
+          from_database.age.should eq subject.age
+
+          from_database.cars.should eq subject.cars
+        end
+      end
+    end
+  end
+
+
+  describe "embedded in" do
+    describe "non polymorphism" do
+      describe "metadata" do
+        subject { Address.relations.detect { |relation| relation.name == "person" } }
+
+        it "stores the relation on the class" do
+          subject.should_not be_nil
+        end
+
+        it "has correct type on relation" do
+          subject.relation_type.should == "embedded_in"
+        end
+
+        it "raises error if relation defined twice" do
+          expect { Address.embedded_in :person }.to raise_error MassiveRecord::ORM::RelationAlreadyDefined
+        end
+      end
+
+      describe "instance" do
+        subject { Address.new "id1", :street => "Asker" }
+        let(:person) { Person.new "person-id-1", :name => "Test", :age => 29 }
+        let(:proxy) { subject.send(:relation_proxy, "person") }
+
+        it "sets and gets the person" do
+          subject.person = person
+          subject.person.should eq person
+        end
+
+        it "adds itself to the collection within the target's class" do
+          person.stub(:valid?).and_return true
+          subject.person = person
+          person.addresses.should include subject
+        end
+
+        it "assigns embedded in attributes with initialize" do
+          address = Address.new "id1", :person => person, :street => "Asker"
+          address.person.should eq person
+          person.addresses.should include address
+        end
+      end
+    end
+
+    describe "polymorphism" do
+      describe "metadata" do
+        subject { Address.relations.detect { |relation| relation.name == "addressable" } }
+
+        it "stores the relation on the class" do
+          subject.should_not be_nil
+        end
+
+        it "has correct type on relation" do
+          subject.relation_type.should == "embedded_in_polymorphic"
+        end
+
+        it "raises error if relation defined twice" do
+          expect { Address.embedded_in :addressable }.to raise_error MassiveRecord::ORM::RelationAlreadyDefined
+        end
+      end
+
+      describe "instance" do
+        subject { Address.new "id1", :street => "Asker" }
+        let(:test_class) { TestClass.new }
+        let(:proxy) { subject.send(:relation_proxy, "addressable") }
+
+        it "sets and gets the test class" do
+          subject.addressable = test_class
+          subject.addressable.should eq test_class
+        end
+
+        it "adds itself to the collection within the target's class" do
+          subject.addressable = test_class
+          test_class.addresses.should include subject
+        end
+      end
+    end
+  end
 end

data/spec/orm/relations/metadata_spec.rb

@@ -4,19 +4,23 @@ require 'orm/models/person'
 describe MassiveRecord::ORM::Relations::Metadata do
   subject { MassiveRecord::ORM::Relations::Metadata.new(nil) }
 
-  %w(name foreign_key class_name relation_type find_with polymorphic records_starts_from).each do |attr|
+  %w(name foreign_key class_name relation_type find_with polymorphic records_starts_from inverse_of).each do |attr|
     it { should respond_to attr }
     it { should respond_to attr+"=" }
   end
 
 
   it "should be setting values by initializer" do
-    metadata = subject.class.new :car, :foreign_key => :my_car_id, :class_name => "Vehicle", :store_in => :info, :polymorphic => true, :records_starts_from => :records_starts_from
+    metadata = subject.class.new(:car, {
+      :foreign_key => :my_car_id, :class_name => "Vehicle", :store_in => :info,
+      :polymorphic => true, :records_starts_from => :records_starts_from, :inverse_of => :inverse_of
+    })
     metadata.name.should == "car"
     metadata.foreign_key.should == "my_car_id"
     metadata.class_name.should == "Vehicle"
     metadata.store_in.should == "info"
     metadata.records_starts_from.should == :records_starts_from
+    metadata.inverse_of.should eq 'inverse_of'
     metadata.should be_polymorphic
   end
 
@@ -91,26 +95,99 @@ describe MassiveRecord::ORM::Relations::Metadata do
     end
   end
 
+  describe "#embedded?" do
+    %w(references_one references_one_polymorphic, references_many).each do |type|
+      context type do
+        before { subject.relation_type = type }
 
+        its(:embedded?) { should be_false }
+      end
+    end
+
+    %w(embeds_many).each do |type|
+      context type do
+        before { subject.relation_type = type }
+
+        its(:embedded?) { should be_true }
+      end
+    end
+  end
 
   describe "#store_in" do
-    its(:store_in) { should be_nil }
+    context "references" do
+      before { subject.relation_type = :references_many }
+
+      its(:store_in) { should be_nil }
 
-    it "should be able to set column family to store foreign key in" do
-      subject.store_in = :info
-      subject.store_in.should == "info"
+      it "should be able to set column family to store foreign key in" do
+        subject.store_in = :info
+        subject.store_in.should == "info"
+      end
+
+      it "should know its persisting foreign key if foreign key stored in has been set" do
+        subject.store_in = :info
+        should be_persisting_foreign_key
+      end
+
+      it "should not be storing the foreign key if records_starts_from is defined" do
+        subject.store_in = :info
+        subject.records_starts_from = :method_which_returns_a_starting_point
+        should_not be_persisting_foreign_key
+      end
+    end
+
+    context "embedded" do
+      before do
+        subject.name = :addresses
+        subject.relation_type = :embeds_many
+      end
+
+      its(:store_in) { should eq "addresses" }
+      its(:persisting_foreign_key?) { should be_false }
     end
   end
 
-  it "should know its persisting foreign key if foreign key stored in has been set" do
-    subject.store_in = :info
-    should be_persisting_foreign_key
+
+  describe "owner_class" do
+    it "is settable" do
+      subject.owner_class = Address
+    end
+
+    it "is readable" do
+      subject.owner_class = Address
+      subject.owner_class.should == Address
+    end
   end
 
-  it "should not be storing the foreign key if records_starts_from is defined" do
-    subject.store_in = :info
-    subject.records_starts_from = :method_which_returns_a_starting_point
-    should_not be_persisting_foreign_key
+  describe "#inverse_of" do
+    it "returns whatever it is set to" do
+      subject.inverse_of = :addresses
+      subject.inverse_of.should eq 'addresses'
+    end
+
+    it "calculates inverse of from the owner_class for embedded_in" do
+      subject.relation_type = :embedded_in
+      subject.owner_class = Address
+      subject.inverse_of.should eq 'addresses'
+    end
+
+    it "calculates inverse of from the owner_class for embedded_in" do
+      subject.relation_type = :embedded_in
+      subject.owner_class = AddressWithTimestamp
+      subject.inverse_of.should eq 'address_with_timestamps'
+    end
+
+    it "calculates inverse of from the owner_class for embeds_many" do
+      subject.relation_type = :embeds_many
+      subject.owner_class = Person
+      subject.inverse_of.should eq 'person'
+    end
+
+    it "raises an error if not set nor owner class" do
+      subject.inverse_of = nil
+      subject.owner_class = nil
+      expect { subject.inverse_of }.to raise_error "Can't return inverse of without it being explicitly set or without an owner_class"
+    end
   end
 
 
@@ -189,12 +266,12 @@ describe MassiveRecord::ORM::Relations::Metadata do
       end
 
       it "should call proxy_target class with all, start with proxy_owner's start from id response" do
-        Person.should_receive(:all).with(hash_including(:start => proxy_owner.friends_records_starts_from_id))
+        Person.should_receive(:all).with(hash_including(:starts_with => proxy_owner.friends_records_starts_from_id))
         find_with_proc.call(proxy_owner)
       end
 
       it "should be possible to send in options to the proc" do
-        Person.should_receive(:all).with(hash_including(:limit => 10, :start => proxy_owner.friends_records_starts_from_id))
+        Person.should_receive(:all).with(hash_including(:limit => 10, :starts_with => proxy_owner.friends_records_starts_from_id))
         find_with_proc.call(proxy_owner, {:limit => 10})
       end
     end