massive_record 0.2.1 → 0.2.2.rc1

data/spec/orm/cases/auto_generate_id_spec.rb

@@ -45,7 +45,7 @@ describe "auto setting of ids" do
         end
       end
 
-      MassiveRecord::ORM::IdFactory.should_receive(:next_for).with(Person).and_return(1)
+      MassiveRecord::ORM::IdFactory::AtomicIncrementation.should_receive(:next_for).with(Person).and_return(1)
       @person.id.should == "1"
 
       Person.class_eval { undef_method :default_id }

data/spec/orm/cases/change_id_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Table do
+  include SetUpHbaseConnectionBeforeAll
+  include SetTableNamesToTestTable
+
+  let(:old_id) { "old_id" }
+  let(:new_id) { "new_id" }
+
+  subject do
+    Person.create!(old_id, {
+      :name => "Thorbjorn",
+      :age => 22,
+      :points => 1
+    })
+  end
+
+  describe "#change_id!" do
+    describe "successfully" do
+      before do
+        subject.change_id! new_id
+      end
+
+      its(:id) { should eq new_id }
+
+      it "saves itself with new id" do
+        Person.find(new_id).should eq subject
+      end
+
+      it "has same attributes" do
+        Person.find(new_id).attributes.should eq subject.attributes
+      end
+
+      it "deletes the old id from the database" do
+        Person.should_not be_exists old_id
+      end
+
+      describe "with identity map" do
+        it "works as expected" do
+          MassiveRecord::ORM::IdentityMap.use do
+            person = Person.create!("id", {:name => "Thorbjorn", :age => 22, :points => 1})
+            person.change_id! "id-2"
+            Person.find("id-2").should eq person
+            Person.should_not be_exists "id"
+          end
+        end
+      end
+    end
+
+    describe "unsuccessfully" do
+      it "raises error if unable to save new id" do
+        subject.should_receive(:save).and_return false
+        expect { subject.change_id! new_id }.to raise_error
+      end
+
+      it "raises error if unable to destroy old record" do
+        Person.any_instance.stub(:destroy).and_return false
+        expect { subject.change_id! new_id }.to raise_error
+      end
+    end
+  end
+end

data/spec/orm/cases/default_id_spec.rb

@@ -8,31 +8,50 @@ describe ModelWithoutDefaultId do
 
   context "with auto increment id" do
     its(:id) { be_nil }
-    its(:auto_increment_id) { be_true }
+    its(:set_id_from_factory_before_create) { be_true }
 
     it "sets id to what next_id returns" do
-      subject.should_receive(:next_id).and_return 1
+      MassiveRecord::ORM::IdFactory::AtomicIncrementation.should_receive(:next_for).and_return 1
       subject.save
       subject.id.should eq "1"
     end
 
     it "does nothing if the id is set before create" do
       subject.id = 2
-      subject.should_not_receive(:next_id)
+      MassiveRecord::ORM::IdFactory::AtomicIncrementation.should_not_receive(:next_for)
       subject.save
       subject.id.should eq "2"
     end
+
+    it "is configurable which factory to use" do
+      id_factory_was = ModelWithoutDefaultId.id_factory
+      ModelWithoutDefaultId.id_factory = MassiveRecord::ORM::IdFactory::Timestamp
+
+      MassiveRecord::ORM::IdFactory::Timestamp.should_receive(:next_for).and_return 123
+      subject.save
+      subject.id.should eq "123"
+
+      ModelWithoutDefaultId.id_factory = MassiveRecord::ORM::IdFactory::AtomicIncrementation
+    end
   end
 
   context "without auto increment id" do
-    before(:all) { subject.class.auto_increment_id = false }
-    after(:all) { subject.class.auto_increment_id = true }
+    before(:all) { subject.class.set_id_from_factory_before_create = false }
+    after(:all) { subject.class.set_id_from_factory_before_create = true }
 
     its(:id) { be_nil }
-    its(:auto_increment_id) { be_false }
+    its(:set_id_from_factory_before_create) { be_false }
 
     it "raises error as expected when id is missing" do
       expect { subject.save }.to raise_error MassiveRecord::ORM::IdMissing
     end
   end
+
+  it "is AtomicIncrementation on ORM::Table" do
+    Person.id_factory.instance.should be_instance_of MassiveRecord::ORM::IdFactory::AtomicIncrementation
+  end
+
+  it "is Timestamp on ORM::Embedded" do
+    Address.id_factory.instance.should be_instance_of MassiveRecord::ORM::IdFactory::Timestamp
+  end
 end

data/spec/orm/cases/default_values_spec.rb

@@ -13,25 +13,28 @@ describe "default values" do
   end
 
   context "new record" do
-    its(:addresses) { should eq Hash.new }
+    its(:dictionary) { should eq Hash.new }
     its(:points) { should eq 1 }
     its(:status) { should eq false }
+    its(:positive_as_default) { should eq true }
     its(:phone_numbers) { should eq [] }
   end
 
   context "persisted record" do
     before do
-      subject.addresses = nil
+      subject.dictionary = nil
       subject.points = nil
       subject.status = nil
+      subject.positive_as_default = false
       subject.phone_numbers = nil
       subject.save!
       subject.reload
     end
 
-    its(:addresses) { should be_nil }
+    its(:dictionary) { should be_nil }
     its(:points) { should be_nil }
     its(:status) { should be_nil }
+    its(:positive_as_default) { should be_false }
     its(:phone_numbers) { should eq [] }
   end
 end

data/spec/orm/cases/dirty_spec.rb

@@ -3,126 +3,173 @@ require 'spec_helper'
 describe "dirty" do
   describe "dry run" do
     include MockMassiveRecordConnection
+    include TimeZoneHelper
 
-    before do
-      @person = Person.new '1', :name => "Alice", :age => 20, :email => "foo@bar.com"
-    end
-
-    it "should not be changed after created" do
-      @person.should_not be_changed
-    end
+    context "new record" do
+      subject { Person.new '1', :name => "Alice", :age => 20, :email => "foo@bar.com" }
+      let(:address) { Address.new("id1", :street => "foo") }
 
-    it "should not be changed if attribute is set to what it currently is" do
-      @person.name = "Alice"
-      @person.should_not be_changed
-    end
+      it "is not changed when first created" do
+        Person.new.should_not be_changed
+      end
 
-    it "should notice changes" do
-      @person.name = "Bob"
-      @person.should be_changed
-    end
+      it "initial values are changed" do
+        subject.should be_email_changed
+      end
 
-    it "should notice changes in boolean values from false to true" do
-      @person.status = !@person.status
-      @person.should be_status_changed
-    end
 
-    it "should notice changes in boolean values from true to false" do
-      @person.status = true
-      @person.save
-      @person.status = false
-      @person.should be_status_changed
+      describe "changes in embedded relations" do
+        before { subject.addresses << address }
+
+        it "iterates over embedded relations and asks them if they have changes" do
+          should be_changed
+        end
+
+        it "includes addresses in changed" do
+          subject.changed.should include "addresses"
+        end
+
+        it "includes knowledge of changes" do
+          address.street = address.street + "_NEW"
+          subject.name = subject.name + "_NEW"
+          subject.changes.should eq({
+            "name" => [nil, "Alice_NEW"],
+            "age" => [nil, 20],
+            "email" => [nil, "foo@bar.com"],
+            "addresses" => {
+              "id1" => {
+                "street" => [nil, "foo_NEW"]
+              }
+            }
+          })
+        end
+      end
     end
 
-    it "should not consider age set as string to the same as integer a change" do
-      @person.age = "20"
-      @person.should_not be_age_changed
-    end
+    context "persisted" do
+      subject { Person.create '1', :name => "Alice", :age => 20, :email => "foo@bar.com" }
 
-    it "should not consider age set as string back to original value a change" do
-      @person.age = 30
-      @person.age = "20"
-      @person.should_not be_age_changed
-    end
+      it "should not be changed if attribute is set to what it currently is" do
+        subject.name = "Alice"
+        should_not be_changed
+      end
 
+      it "should notice changes" do
+        subject.name = "Bob"
+        should be_changed
+      end
 
-    it "should know when a attribute is set to it's original value" do
-      original_name = @person.name
-      @person.name = "Bob"
-      @person.name = original_name
-      @person.should_not be_changed
-    end
+      it "should notice changes in boolean values from false to true" do
+        subject.status = !subject.status
+        should be_status_changed
+      end
 
-    it "should always keep the objects original value as _was" do
-      original_name = @person.name
-      @person.name = "Bob"
-      @person.name = "Foo"
-      @person.name_was.should == original_name
-    end
+      it "notices changes in time attributes" do
+        in_time_zone "utc" do
+          test = TestClass.new
+          test.tested_at = Time.now
+          test.should be_tested_at_changed
+        end
+      end
 
-    it "should return what name was" do
-      @person.name = "Bob"
-      @person.name_was.should == "Alice"
-    end
+      it "should notice changes in boolean values from true to false" do
+        subject.status = true
+        subject.save
+        subject.status = false
+        should be_status_changed
+      end
 
+      it "should not consider age set as string to the same as integer a change" do
+        subject.age = "20"
+        should_not be_age_changed
+      end
 
-    describe "should reset changes" do
-      it "on save" do
-        @person.name = "Bob"
-        @person.save
-        @person.should_not be_changed
+      it "should not consider age set as string back to original value a change" do
+        subject.age = 30
+        subject.age = "20"
+        should_not be_age_changed
       end
 
-      it "on save, but don't do it if save fails validation" do
-        @person.should_receive(:valid?).and_return(false)
-        @person.name = "Bob"
-        @person.save
-        @person.should be_changed
+
+      it "should know when a attribute is set to it's original value" do
+        original_name = subject.name
+        subject.name = "Bob"
+        subject.name = original_name
+        should_not be_changed
       end
 
-      it "on save!" do
-        @person.name = "Bob"
-        @person.save!
-        @person.should_not be_changed
+      it "should always keep the objects original value as _was" do
+        original_name = subject.name
+        subject.name = "Bob"
+        subject.name = "Foo"
+        subject.name_was.should == original_name
       end
 
-      it "on reload" do
-        @person.name = "Bob"
-        @person.reload
-        @person.should_not be_changed
+      it "should return what name was" do
+        subject.name = "Bob"
+        subject.name_was.should == "Alice"
       end
-    end
 
-    describe "previous changes" do
-      it "should be blank before save" do
-        @person.previous_changes.should be_blank
+
+      describe "should reset changes" do
+        it "on save" do
+          subject.name = "Bob"
+          subject.save
+          should_not be_changed
+        end
+
+        it "on save, but don't do it if save fails validation" do
+          subject.should_receive(:valid?).and_return(false)
+          subject.name = "Bob"
+          subject.save
+          should be_changed
+        end
+
+        it "on save!" do
+          subject.name = "Bob"
+          subject.save!
+          should_not be_changed
+        end
+
+        it "on reload" do
+          subject.name = "Bob"
+          subject.reload
+          should_not be_changed
+        end
       end
 
-      it "should equal to changes before save" do
-        @person.name = "Bob"
-        changes_before_save = @person.changes
+      describe "previous changes" do
+        it "should be blank before after reload" do
+          subject.reload
+          subject.previous_changes.should be_blank
+        end
 
-        @person.save
+        it "should equal to changes before save" do
+          subject.name = "Bob"
+          changes_before_save = subject.changes
 
-        @person.changes.should be_empty
-        @person.previous_changes.should == changes_before_save
-      end
+          subject.save
 
-      it "should equal to changes before save!" do
-        @person.name = "Bob"
-        changes_before_save = @person.changes
+          subject.changes.should be_empty
+          subject.previous_changes.should == changes_before_save
+        end
 
-        @person.save!
+        it "should equal to changes before save!" do
+          subject.name = "Bob"
+          changes_before_save = subject.changes
 
-        @person.changes.should be_empty
-        @person.previous_changes.should == changes_before_save
-      end
+          subject.save!
+
+          subject.changes.should be_empty
+          subject.previous_changes.should == changes_before_save
+        end
 
-      it "should be nil after a reload" do
-        @person.name = "Bob"
-        @person.save
-        @person.reload
-        @person.previous_changes.should be_blank
+        it "should be nil after a reload" do
+          subject.name = "Bob"
+          subject.save
+          subject.reload
+          subject.previous_changes.should be_blank
+        end
       end
     end
   end
@@ -132,22 +179,23 @@ describe "dirty" do
     include SetUpHbaseConnectionBeforeAll
     include SetTableNamesToTestTable
 
+    subject { Person.new }
+
     before do
-      @person = Person.new
-      @person.id = "test"
-      @person.points = "25"
-      @person.date_of_birth = "19850730"
-      @person.status = "0"
+      subject.id = "test"
+      subject.points = "25"
+      subject.date_of_birth = "19850730"
+      subject.status = "0"
     end
 
     it "should update dirty status correctly after a reload" do
-      @person.addresses = {:something => "strage"}
-      @person.save! :validate => false
-      @person.reload
-      @person.addresses = {}
-      @person.save! :validate => false
-      @person.reload
-      @person.addresses.should == {}
+      subject.dictionary = {:something => "strage"}
+      subject.save! :validate => false
+      subject.reload
+      subject.dictionary = {}
+      subject.save! :validate => false
+      subject.reload
+      subject.dictionary.should == {}
     end
   end
 end