massive_record 0.2.1 → 0.2.2.rc1

data/spec/orm/cases/finders_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 require 'orm/models/test_class'
 require 'orm/models/person'
@@ -27,22 +28,47 @@ describe "finders" do
       lambda { Person.find(nil) }.should raise_error MassiveRecord::ORM::RecordNotFound
     end
 
-    it "should raise an error if conditions are given to first" do
-      lambda { Person.first(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
-    end
+    describe "conditions" do
+      it "should raise an error if conditions are given to first" do
+        lambda { Person.first(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+      end
+
+      it "should raise an error if conditions are given to all" do
+        lambda { Person.all(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+      end
 
-    it "should raise an error if conditions are given to all" do
-      lambda { Person.all(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+      it "should raise an error if conditions are given to find" do
+        lambda { Person.find(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+      end
     end
 
-    it "should raise an error if conditions are given to find" do
-      lambda { Person.find(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+    describe "default select" do
+      it "applies all the known column families to finder options as a default on all()" do
+        @mocked_table.should_receive(:all).with(hash_including(:select => Person.known_column_family_names)).and_return []
+        Person.all
+      end
+
+      it "applies all the known column families to finder options as a default on first()" do
+        @mocked_table.should_receive(:all).with(hash_including(:select => Person.known_column_family_names)).and_return []
+        Person.first
+      end
+
+      it "applies all the known column families to finder options as a default on first()" do
+        @mocked_table.should_receive(:find).with("ID1", hash_including(:select => Person.known_column_family_names)).and_return(@row)
+        Person.find("ID1")
+      end
     end
 
     it "should ask the table to look up by it's id" do
       @mocked_table.should_receive(:find).with("ID1", anything).and_return(@row)
       Person.find("ID1")
     end
+
+    it "persists the raw values from table" do
+      @mocked_table.should_receive(:find).with("ID1", anything).and_return(@row)
+      person = Person.find("ID1")
+      person.raw_data.should eq @row.values_raw_data_hash
+    end
     
     it "should ask the table to fetch rows from a list of ids given as array" do
       @mocked_table.should_receive(:find).with(["ID1", "ID2"], anything).and_return([@row, @row_2])
@@ -67,9 +93,9 @@ describe "finders" do
       lambda { Person.find("ID1", "ID2") }.should raise_error MassiveRecord::ORM::RecordNotFound
     end
     
-    it "should call table's first on find(:first)" do
-      @mocked_table.should_receive(:first).and_return(@row)
-      Person.find(:first)
+    it "should call table's all with limit 1 on find(:first)" do
+      @mocked_table.should_receive(:all).with(hash_including(:limit => 1)).and_return([@row])
+      Person.find(:first).should be_instance_of Person
     end
 
     it "should call table's all on find(:all)" do
@@ -164,6 +190,12 @@ describe "finders" do
       @person.age.should == 20
     end
 
+    it "should maintain encoding of ids" do
+      id = "thorbjørn"
+      person = Person.create! id, :name => "Thorbjørn", :age => 20
+      Person.find(id).should eq person
+    end
+
     it "should find first person" do
       Person.first.should == @person
     end
@@ -186,6 +218,21 @@ describe "finders" do
     it "should return what it finds if asked to" do
       lambda { Person.find(["ID1", "not exists"], :skip_expected_result_check => true) }.should_not raise_error MassiveRecord::ORM::RecordNotFound
     end
+
+
+    describe "embedded records" do
+      subject { Person.find("ID1") }
+      let(:address) { Address.new "address-1", :street => "Asker", :number => 1 }
+
+      before do
+        subject.addresses << address
+        subject.reload
+      end
+
+      it "is able to load embeds many relations" do
+        subject.addresses.should eq [address]
+      end
+    end
   end
   
   describe "#find_in_batches" do

data/spec/orm/cases/id_factory/atomic_incrementation_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe MassiveRecord::ORM::IdFactory::AtomicIncrementation do
+  include SetUpHbaseConnectionBeforeAll
+  include SetTableNamesToTestTable
+
+  subject { described_class.instance }
+
+  it_should_behave_like "an id factory"
+
+
+  it "has table name equal to id_factories" do
+    described_class.table_name.should eq "id_factories_test"
+  end
+
+  describe "#next_for" do
+    after do
+      MassiveRecord::ORM::IdFactory::AtomicIncrementation.destroy_all
+    end
+
+    it "should increment start a new sequence on 1" do
+      subject.next_for(Person).should == 1
+    end
+
+    it "should increment value one by one" do
+      5.times do |index|
+        expected_id = index + 1
+        subject.next_for(Person).should == expected_id
+      end
+    end
+
+    it "should maintain ids separate for each table" do
+      3.times { subject.next_for(Person) }
+      subject.next_for("cars").should == 1
+    end
+
+    it "autoload ids as integers" do
+      subject.next_for(Person).should eq 1
+
+      family_for_person = subject.class.column_families.family_by_name(MassiveRecord::ORM::IdFactory::AtomicIncrementation::COLUMN_FAMILY_FOR_TABLES)
+      field_for_person = family_for_person.fields.delete_if { |f| f.name == Person.table_name }
+
+      subject.reload
+      subject.attributes_schema[Person.table_name].type.should eq :integer
+    end
+
+
+    describe "old string representation of integers" do
+      it "increments correctly when value is '1'" do
+        old_ensure = MassiveRecord::ORM::Base.backward_compatibility_integers_might_be_persisted_as_strings
+        MassiveRecord::ORM::Base.backward_compatibility_integers_might_be_persisted_as_strings = true
+
+        subject.next_for(Person)
+
+        # Enter incompatible data, number as string.
+        MassiveRecord::ORM::IdFactory::AtomicIncrementation.table.first.tap do |row|
+          row.update_column(
+            MassiveRecord::ORM::IdFactory::AtomicIncrementation::COLUMN_FAMILY_FOR_TABLES,
+            Person.table_name,
+            MassiveRecord::ORM::Base.coder.dump(1)
+          )
+          row.save
+        end
+
+        subject.next_for(Person).should eq 2
+
+        MassiveRecord::ORM::Base.backward_compatibility_integers_might_be_persisted_as_strings = old_ensure
+      end
+    end
+  end
+end

data/spec/orm/cases/id_factory/timestamp_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe MassiveRecord::ORM::IdFactory::Timestamp do
+  subject { described_class.instance }
+
+  it_should_behave_like "an id factory"
+
+
+  describe "settings" do
+    after do
+      described_class.precision = :microseconds
+      described_class.reverse_time = true
+    end
+
+    describe "#precision" do
+      it "can be set to seconds" do
+        described_class.precision = :seconds
+        subject.next_for(Person).length.should eq 10
+      end
+
+      it "can be set to milliseconds" do
+        described_class.precision = :milliseconds
+        subject.next_for(Person).length.should eq 13
+      end
+
+      it "can be set to microseconds" do
+        described_class.precision = :microseconds
+        subject.next_for(Person).length.should eq 16
+      end
+    end
+
+    describe "#reverse_time" do
+      let(:time) { mock(Time) }
+
+      before do
+        time.stub_chain(:getutc, :to_f).and_return(1)
+        Time.stub(:now).and_return time
+      end
+
+      it "can be normal time" do
+        described_class.reverse_time = false
+        described_class.precision = :seconds
+
+        subject.next_for(Person).should eq "1"
+
+        described_class.reverse_time = true
+        described_class.precision = :microseconds
+      end
+
+      it "can be reverse time" do
+        described_class.reverse_time = true
+        described_class.precision = :seconds
+
+        subject.next_for(Person).should eq "9999999998"
+
+        described_class.precision = :microseconds
+      end
+    end
+  end
+end

data/spec/orm/cases/identity_map/identity_map_spec.rb

@@ -0,0 +1,357 @@
+require 'spec_helper'
+require 'orm/models/test_class'
+require 'orm/models/friend'
+require 'orm/models/best_friend'
+
+describe MassiveRecord::ORM::IdentityMap do
+  before do
+    MassiveRecord::ORM::IdentityMap.clear
+    MassiveRecord::ORM::IdentityMap.enabled = true
+  end
+
+  after(:all) { MassiveRecord::ORM::IdentityMap.enabled = false }
+
+
+  describe "class methods" do
+    subject { described_class }
+
+    describe "confirguration" do
+      describe ".enabled" do
+        context "when disabled" do
+          before { MassiveRecord::ORM::IdentityMap.enabled = false }
+          its(:enabled) { should be_false }
+          its(:enabled?) { should be_false }
+        end
+
+        context "when enabled" do
+          before { MassiveRecord::ORM::IdentityMap.enabled = true }
+          its(:enabled) { should be_true }
+          its(:enabled?) { should be_true }
+        end
+      end
+
+      it ".use sets enabled to true, yield block and ensure to reset it to what it was" do
+        MassiveRecord::ORM::IdentityMap.enabled = false
+
+        MassiveRecord::ORM::IdentityMap.use do
+          MassiveRecord::ORM::IdentityMap.should be_enabled
+        end
+
+        MassiveRecord::ORM::IdentityMap.should_not be_enabled
+      end
+
+      it ".without sets enabled to true, yield block and ensure to reset it to what it was" do
+        MassiveRecord::ORM::IdentityMap.enabled = true
+
+        MassiveRecord::ORM::IdentityMap.without do
+          MassiveRecord::ORM::IdentityMap.should_not be_enabled
+        end
+
+        MassiveRecord::ORM::IdentityMap.should be_enabled
+      end
+    end
+
+    describe "persistence" do
+      let(:person) { Person.new "id1" }
+      let(:friend) { Friend.new "id2" }
+      let(:test_class) { TestClass.new "id2" }
+
+      describe ".repository" do
+        its(:repository) { should eq Hash.new }
+
+        it "has values as a hash by default for any key" do
+          subject.send(:repository)['some_class'].should eq Hash.new
+        end
+      end
+
+      describe ".clear" do
+        it "removes all values from repository" do
+          subject.send(:repository)['some_class']['an_id'] = Object.new
+          subject.clear
+          subject.send(:repository).should be_empty
+        end
+      end
+
+      describe ".get" do
+        it "raises error if no ids are given" do
+          expect { subject.get(person.class) }.to raise_error ArgumentError
+        end
+
+        context "when it does not has the record" do
+          it "returns nil" do
+            subject.get(person.class, person.id).should be_nil
+          end
+
+          it "returns empty array if asked for multiple records" do
+            subject.get(person.class, 1, 2).should eq []
+          end
+        end
+
+        context "when it has the record" do
+          it "returns the record" do
+            subject.add person
+            subject.get(person.class, person.id).should eq person
+          end
+
+          describe "single table inheritahce" do
+            before { subject.add friend }
+
+            it "returns the record when looked up by it's class" do
+              subject.get(friend.class, friend.id).should eq friend
+            end
+
+            it "returns the record when looked up by it's parent class" do
+              subject.get(person.class, friend.id).should eq friend
+            end
+
+            it "raises an error when you request a parent class via a descendant class" do
+              subject.add person
+              expect {
+                subject.get(friend.class, person.id)
+              }.to raise_error MassiveRecord::ORM::IdentityMap::RecordIsSuperClassOfQueriedClass
+            end
+          end
+
+          describe "get multiple" do
+            it "returns multiple records when asked for multiple ids" do
+              subject.add person
+              subject.add friend
+              subject.get(person.class, person.id, friend.id).should include person, friend
+            end
+
+            it "returns multiple records when asked for multiple ids as an array" do
+              subject.add person
+              subject.add friend
+              subject.get(person.class, [person.id, friend.id]).should include person, friend
+            end
+
+            it "returns array when get got an array, even with only one id" do
+              subject.add friend
+              subject.get(person.class, [friend.id]).should eq [friend]
+            end
+
+            it "returns nothing for unkown ids" do
+              subject.add person
+              subject.add friend
+              subject.get(person.class, person.id, friend.id, "unkown").length.should eq 2
+            end
+          end
+
+          it "returns the correct record when they have the same id" do
+            person.id = test_class.id = "same_id"
+
+            subject.add(person)
+            subject.add(test_class)
+
+            subject.get(person.class, person.id).should eq person
+            subject.get(test_class.class, "same_id").should eq test_class
+          end
+        end
+      end
+
+      describe ".add" do
+        it "does not do anything if trying to add nil" do
+          subject.add(nil).should be_nil
+        end
+
+        it "persists the record" do
+          subject.add person
+          subject.get(person.class, person.id).should eq person
+        end
+
+        it "persists a single table inheritance record" do
+          subject.add friend
+          subject.get(friend.class, friend.id).should eq friend
+        end
+      end
+
+      describe ".remove" do
+        it "returns nil if record was not found" do
+          subject.remove(person).should eq nil
+        end
+
+        it "removes the record" do
+          subject.add person
+          subject.remove person
+          subject.get(person.class, person.id).should be_nil
+        end
+
+        it "returns the removed record" do
+          subject.add person
+          subject.remove(person).should eq person
+        end
+
+        it "removes a single table inheritance record" do
+          subject.add friend
+          subject.remove friend
+          subject.get(friend.class, friend.id).should be_nil
+        end
+      end
+
+      describe ".remove_by_id" do
+        it "removes the record by it's class and id directly" do
+          subject.add person
+          subject.remove_by_id person.class, person.id
+          subject.get(person.class, person.id).should be_nil
+        end
+
+        it "returns the removed record" do
+          subject.add person
+          subject.remove_by_id(person.class, person.id).should eq person
+        end
+      end
+    end
+  end
+
+
+  describe "lifecycles on records" do
+    include SetUpHbaseConnectionBeforeAll
+    include SetTableNamesToTestTable
+
+    let(:id) { "ID1" }
+    let(:id_2) { "ID2" }
+    let(:person) { Person.create!(id, :name => "Person1", :email => "one@person.com", :age => 11, :points => 111, :status => true) }
+    let(:friend) { Friend.create!(id_2, :name => "Person1", :email => "one@person.com", :age => 11, :points => 111, :status => true) }
+
+    describe "#find" do
+      describe "one" do
+        context "when the record is not in the identity map" do
+          it "asks do find for the record" do
+            Person.should_receive(:do_find).and_return(nil)
+            Person.find(id).should be_nil
+          end
+
+          it "adds the found record" do
+            MassiveRecord::ORM::IdentityMap.without { person }
+
+            MassiveRecord::ORM::IdentityMap.get(person.class, person.id).should be_nil
+            Person.find(id)
+            MassiveRecord::ORM::IdentityMap.get(person.class, person.id).should eq person
+          end
+        end
+
+        context "when record is in identity map" do
+          before { MassiveRecord::ORM::IdentityMap.add(person) }
+
+          it "returns that record" do
+            Person.table.should_not_receive(:find)
+            Person.find(person.id).should eq person
+          end
+
+          it "returns record from database when select option is used" do
+            MassiveRecord::ORM::IdentityMap.should_not_receive(:get)
+            Person.select(:info).find(person.id).should eq person
+          end
+
+          it "returns record from identity map when you ask for a sub class by its parent class" do
+            MassiveRecord::ORM::IdentityMap.add(friend)
+            Person.table.should_not_receive(:find)
+            Person.find(friend.id).should eq friend
+          end
+
+          it "returns nil when you ask for a parent class" do
+            Friend.table.should_not_receive(:find)
+            Friend.find(person.id).should be_nil
+          end
+        end
+      end
+
+      describe "many" do
+        it "returns records from database when select option is used" do
+          MassiveRecord::ORM::IdentityMap.should_not_receive(:get)
+          Person.select(:info).find([person.id, friend.id]).should include person, friend
+        end
+
+        context "when no records are in the identity map" do
+          it "asks find for the two records" do
+            Person.should_receive(:do_find).with([id, id_2], anything).and_return []
+            Person.find([id, id_2]).should eq []
+          end
+
+          it "adds the found recods" do
+            MassiveRecord::ORM::IdentityMap.without { person; friend }
+            MassiveRecord::ORM::IdentityMap.get(person.class, person.id, friend.id).should be_empty
+
+            Person.find([id, id_2])
+            MassiveRecord::ORM::IdentityMap.get(person.class, person.id, friend.id).should include person, friend
+          end
+        end
+
+        context "when all records are in the identity map" do
+          before do
+            MassiveRecord::ORM::IdentityMap.add(person)
+            MassiveRecord::ORM::IdentityMap.add(friend)
+          end
+
+          it "returns records from identity map" do
+            Person.table.should_not_receive(:find)
+            Person.find([person.id, friend.id])
+          end
+
+          it "returns only records equal to or descendants of queried class" do
+            Friend.find([person.id, friend.id]).should eq [friend]
+          end
+        end
+
+        context "when some records are in the identity map" do
+          before do
+            MassiveRecord::ORM::IdentityMap.add(person)
+            MassiveRecord::ORM::IdentityMap.without { friend }
+          end
+
+          it "returns records from identity map" do
+            Person.should_receive(:query_hbase).with([friend.id], anything).and_return [friend]
+            Person.find([person.id, friend.id])
+          end
+        end
+      end
+    end
+
+    describe "#save" do
+      context "a new record" do
+        it "adds the record to the identity map after being created" do
+          person
+          Person.table.should_not_receive(:find)
+          Person.find(person.id).should eq person
+        end
+
+        it "does not add the record if validation fails" do
+          invalid_person = Person.create "ID2", :name => "Person2"
+          Person.should_not be_exists invalid_person.id
+        end
+      end
+    end
+
+    describe "#destroy" do
+      it "removes the record from identiy map" do
+        person.destroy
+        Person.should_not be_exists person.id
+      end
+    end
+
+    describe "#destroy_all" do
+      it "removes the record from identiy map" do
+        person
+        Person.destroy_all
+        Person.should_not be_exists person.id
+      end
+    end
+
+    describe "#delete" do
+      it "removes the record from identiy map" do
+        person.delete
+        Person.should_not be_exists person.id
+      end
+    end
+
+    describe "#reload" do
+      it "reloads it's attributes" do
+        what_it_was = person.name
+        person.name = person.name.reverse
+
+        person.reload
+        person.name.should eq what_it_was
+      end
+    end
+  end
+end