massive_record 0.2.1 → 0.2.2.rc1

data/spec/orm/models/test_class.rb

@@ -1,5 +1,6 @@
 class TestClass < MassiveRecord::ORM::Table
   
+  embeds_many :addresses, :inverse_of => :addressable
   references_one :attachable, :polymorphic => true, :store_in => :test_family
 
   column_family :test_family do

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::AtomicOperation do
+  include MockMassiveRecordConnection
+
+  let(:record) { Person.new("id-1") }
+  let(:options) { {:operation => :increment, :attr_name => 'age', :by => 1} }
+  
+  subject { described_class.new(record, options) }
+
+  it_should_behave_like "a persistence table operation class"
+
+
+  describe "#execute" do
+    it "raises NotNumericalFieldError if field is not numerical" do
+      options[:attr_name] = :name
+      expect { subject.execute }.to raise_error MassiveRecord::ORM::NotNumericalFieldError
+    end
+
+    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 "ensures that we have binary representation of integer value" do
+      subject.should_receive(:ensure_proper_binary_integer_representation)
+      subject.execute
+    end
+
+    it "asks adapter's row to do the atomic operation" do
+      row = mock(Object)
+      row.should_receive(:atomic_increment).and_return(1)
+      subject.should_receive(:row_for_record).and_return row
+      subject.execute
+    end
+
+    it "assigns the attribute in record with whatever row for record atomic operation returns" do
+      row = mock(Object)
+      row.should_receive(:atomic_increment).and_return(111)
+      subject.should_receive(:row_for_record).and_return row
+      subject.execute
+      record.age.should eq 111
+    end
+
+    it "sets record's @new_record flag to false" do
+      record.instance_variable_set(:@new_record, true)
+      subject.execute
+      record.instance_variable_get(:@new_record).should be_false
+    end
+
+    it "returns the new state of attribute updated" do
+      row = mock(Object)
+      row.should_receive(:atomic_increment).and_return(123)
+      subject.should_receive(:row_for_record).and_return row
+      subject.execute.should eq 123
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Destroy 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"
+
+
+  describe "#execute" do
+    it "asks row_for_record to destroy itself" do
+      row = mock(Object)
+      row.should_receive(:destroy).and_return true
+      subject.should_receive(:row_for_record).and_return(row) 
+      subject.execute
+    end
+  end
+end

data/spec/orm/persistence/operations/embedded/destroy_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Embedded::Destroy do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:another_address) { Address.new("addresss-id-2", :street => "Asker too", :number => 5) }
+  let(:record) { Address.new("addresss-id", :street => "Asker", :number => 5) }
+  let(:person) { Person.new "person-id", :name => "Thorbjorn", :age => "22" }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+  describe "generic behaviour" do
+    before { record.person = person }
+    it_should_behave_like "a persistence embedded operation class"
+  end
+
+
+  describe "#execute" do
+    before do
+      record.person = person
+      person.save
+    end
+
+    context "not embedded" do
+      before { record.person = nil }
+
+      it "returns true" do
+        subject.execute.should eq true
+      end
+
+      it "does not call destroy" do
+        subject.execute
+        subject.should_not_receive(:update_embedded)
+      end
+    end
+
+    context "embedded" do
+      context "collection owner new record" do
+        before { record.person = person }
+
+        it "returns true" do
+          subject.execute.should eq true
+        end
+
+        it "does not call destroy" do
+          subject.execute
+          subject.should_not_receive(:update_embedded)
+        end
+      end
+
+      context "collection owner persisted" do
+        before do
+          record.person = person
+          person.save!
+        end
+        
+        it "removes record from collection owher" do
+          subject.execute
+          person.addresses.should be_empty
+        end
+
+        it "persists the removal of record from collection owner" do
+          subject.execute
+          person.reload.addresses.should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/orm/persistence/operations/embedded/insert_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Embedded::Insert do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:record) { Address.new("addresss-id", :street => "Asker", :number => 5) }
+  let(:person) { Person.new "person-id", :name => "Thorbjorn", :age => "22" }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+  describe "generic behaviour" do
+    before { record.person = person }
+    it_should_behave_like "a persistence embedded operation class"
+  end
+
+
+  describe "#execute" do
+    before { record.person = nil }
+
+    context "not embedded" do
+      it "raises an error" do
+        expect { subject.execute }.to raise_error MassiveRecord::ORM::NotAssignedToEmbeddedCollection
+      end
+    end
+
+    context "embedded" do
+      context "but embedded in is not saved" do
+        before { record.person = person }
+
+        it "calls save on embedded owner when it is a new record" do
+          person.should_receive(:save).and_return true
+          subject.execute
+        end
+
+        it "returns false if none of the embedded_in_proxy_targets returned true" do
+          person.should_receive(:save).and_return false
+          subject.execute.should be_false
+        end
+
+        it "is changed when reloading" do
+          subject.execute
+          Person.find(person.id).addresses.first.should eq record
+        end
+      end
+
+      context "and embedded in is already saved and now needs to be updated" do
+        # Not gonna get into this situation as far as I can see now.
+        # Reason for it is we are auto-saving when pushing new records
+        # on to an embeds many collection where it's owner has been persisted.
+        # But, it might be something we want to handle in the future if we have
+        # an auto_save option on the relation. In which case I think we should
+        # ensure that only the one embedded record which receives save are actually
+        # updated in the embeds many collection owner's record.
+      end
+    end
+  end
+end

data/spec/orm/persistence/operations/embedded/operation_helpers_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          class TestEmbeddedOperationHelpers
+            include Operations, OperationHelpers
+          end
+
+          describe TestEmbeddedOperationHelpers do
+            include SetUpHbaseConnectionBeforeAll 
+            include SetTableNamesToTestTable
+
+            let(:address) { Address.new("addresss-id", :street => "Asker", :number => 5) }
+            let(:person) { Person.new "person-id", :name => "Thorbjorn", :age => "22" }
+            let(:options) { {:this => 'hash', :has => 'options'} }
+
+
+            let(:proxy_for_person) { address.send(:relation_proxy, :person) }
+
+            let(:row) do
+              MassiveRecord::Wrapper::Row.new({
+                :id => person.id,
+                :table => person.class.table
+              })
+            end
+
+
+            subject { TestEmbeddedOperationHelpers.new(address, options) }
+
+            before { address.person = person }
+
+
+            describe "#embedded_in_proxies" do
+              it "returns some proxies" do
+                subject.embedded_in_proxies.should_not be_empty
+              end
+
+              it "returns proxies which represents embedded in relations" do
+                subject.embedded_in_proxies.all? { |p| p.metadata.embedded_in? }.should be_true
+              end
+            end
+
+            describe "#embedded_in_proxy_targets" do
+              its(:embedded_in_proxy_targets) { should include person }
+            end
+
+            describe "#row_for_record" do
+              it "returns row for given record" do
+                row = subject.row_for_record(person)
+                row.id.should eq person.id
+                row.table.should eq person.class.table
+              end
+            end
+
+
+
+            describe "update_embedded" do
+              before { subject.stub(:row_for_record).and_return(row) }
+
+              it "ask for record's row" do
+                subject.should_receive(:row_for_record).with(person).and_return(row)
+                subject.update_embedded(proxy_for_person, "new_value")
+              end
+
+              it "sets value on row" do
+                row.should_receive(:values=).with(
+                  'addresses' => {
+                    address.database_id => "new_value"
+                  }
+                ) 
+                subject.update_embedded(proxy_for_person, "new_value")
+              end
+
+              it "asks row to be saved" do
+                row.should_receive(:save)
+                subject.update_embedded(proxy_for_person, "new_value")
+              end
+            end
+          end
+
+
+
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,67 @@
+
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Embedded::Reload do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:record) { Address.new("addresss-id", :street => "Asker", :number => 5) }
+  let(:person) { Person.new "person-id", :name => "Thorbjorn", :age => "22" }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+  before { record.person = person; record.save! }
+
+  describe "generic behaviour" do
+    it_should_behave_like "a persistence embedded operation class"
+  end
+
+
+  describe "#execute" do
+    context "new record" do
+      before { record.stub(:persisted?).and_return false }
+
+      its(:execute) { should be_false }
+    end
+
+    context "persisted" do
+      let(:inverse_proxy) { mock(Object, :reload => true, :find => record) }
+      let(:embedded_in_proxy) { subject.embedded_in_proxies.first }
+
+      before do
+        subject.stub(:inverse_proxy_for).and_return(inverse_proxy)
+      end
+
+      it "just returns false if no not embedded in any proxies" do
+        subject.should_receive(:embedded_in_proxies).any_number_of_times.and_return []
+        subject.execute.should be_false
+      end
+
+      it "asks for inverse proxy" do
+        subject.should_receive(:inverse_proxy_for).with(embedded_in_proxy).and_return(inverse_proxy)
+        subject.execute
+      end
+
+      it "reloads inverse proxy" do
+        inverse_proxy.should_receive :reload
+        subject.execute
+      end
+
+      it "finds the record asked to be reloaded" do
+        inverse_proxy.should_receive(:find).with(record.id).and_return record
+        subject.execute
+      end
+
+      it "reinit record with found record's attributes and raw_data" do
+        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/embedded/update_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Embedded::Update do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:another_address) { Address.new("addresss-id-2", :street => "Asker too", :number => 5) }
+  let(:record) { Address.new("addresss-id", :street => "Asker", :number => 5) }
+  let(:person) { Person.new "person-id", :name => "Thorbjorn", :age => "22" }
+  let(:options) { {:this => 'hash', :has => 'options'} }
+  
+  subject { described_class.new(record, options) }
+
+  describe "generic behaviour" do
+    before { record.person = person }
+    it_should_behave_like "a persistence embedded operation class"
+  end
+
+
+  describe "#execute" do
+    before do
+      record.person = person
+      person.save
+    end
+
+    context "not embedded" do
+      it "raises an error" do
+        record.person = nil
+        expect { subject.execute }.to raise_error MassiveRecord::ORM::NotAssignedToEmbeddedCollection
+      end
+    end
+
+    context "embedded" do
+      it "do persist the changes" do
+        record.street = "Oslogata"
+        subject.execute
+        person.reload.addresses.first.street.should eq "Oslogata"
+      end
+
+      it "does not update other embedded records" do
+        person.addresses << another_address
+        record.street = "Oslogata"
+        another_address.street = "FooBar"
+
+        subject.execute
+
+        person.reload.addresses.find(another_address.id).street.should eq "Asker too"
+      end
+
+      it "does not update attributes on the record it is embedded in" do
+        person.name += "_NEW"
+        record.street = "Oslogata"
+
+        subject.execute
+
+        person.reload.name.should eq "Thorbjorn"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Persistence::Operations::Insert 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"
+
+
+  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 "raises a RecordNotUnique error if we should check it" do
+      record.class.should_receive(:check_record_uniqueness_on_create).and_return true 
+      record.class.should_receive(:exists?).with(record.id).and_return true
+      expect { subject.execute }.to raise_error MassiveRecord::ORM::RecordNotUnique
+    end
+
+    it "calls upon store_record_to_database for help with actually insert job" do
+      subject.should_receive(:store_record_to_database).with('create')
+      subject.execute
+    end
+  end
+end