massive_record 0.1.1 → 0.2.0.beta

data/spec/orm/cases/finders_spec.rb

@@ -7,7 +7,7 @@ describe "finders" do
     include MockMassiveRecordConnection
 
     before do
-      @mocked_table = mock(MassiveRecord::Wrapper::Table).as_null_object
+      @mocked_table = mock(MassiveRecord::Wrapper::Table, :to_ary => []).as_null_object
       Person.stub(:table).and_return(@mocked_table)
       
       @row = MassiveRecord::Wrapper::Row.new
@@ -28,9 +28,9 @@ describe "finders" do
       Person.first.should be_nil
     end
 
-    it "should simply return nil on find if table does not exists" do
+    it "should raise record not found error on find if table does not exists" do
       Person.table.should_receive(:exists?).and_return false
-      Person.find(1).should be_nil
+      lambda { Person.find(1) }.should raise_error MassiveRecord::ORM::RecordNotFound
     end
 
     it "should simply return empty array if table does not exists" do
@@ -98,7 +98,6 @@ describe "finders" do
     end
 
     it "should return nil on first if no results was found" do
-      @mocked_table.should_receive(:first).and_return(nil)
       Person.first.should be_nil
     end
 
@@ -113,20 +112,37 @@ describe "finders" do
     end
   end
 
-  %w(first all).each do |method|
-    it "should respond to #{method}" do
-      TestClass.should respond_to method
+  describe "all" do
+    it "should respond to all" do
+      TestClass.should respond_to :all
     end
 
-    it "should delegate #{method} to find with first argument as :#{method}" do
-      TestClass.should_receive(:find).with(method.to_sym)
-      TestClass.send(method)
+    it "should call find with :all" do
+      TestClass.should_receive(:do_find).with(:all, anything)
+      TestClass.all
     end
 
-    it "should delegate #{method}'s call to find with it's args as second argument" do
+    it "should delegate all's call to find with it's args as second argument" do
       options = {:foo => :bar}
-      TestClass.should_receive(:find).with(anything, options)
-      TestClass.send(method, options)
+      TestClass.should_receive(:do_find).with(anything, options)
+      TestClass.all options
+    end
+  end
+
+  describe "first" do
+    it "should respond to first" do
+      TestClass.should respond_to :first
+    end
+
+    it "should call find with :first" do
+      TestClass.should_receive(:do_find).with(:all, {:limit => 1}).and_return([])
+      TestClass.first
+    end
+
+    it "should delegate first's call to find with it's args as second argument" do
+      options = {:foo => :bar}
+      TestClass.should_receive(:do_find).with(anything, hash_including(options)).and_return([])
+      TestClass.first options
     end
   end
 
@@ -167,6 +183,19 @@ describe "finders" do
       all.should include @person, @bob
       all.length.should == 2
     end
+
+    it "should find all persons, even if it is more than 10" do
+      15.times { |i| Person.create! :id => "id-#{i}", :name => "Going to die :-(", :age => i + 20 }
+      Person.all.length.should > 10
+    end
+
+    it "should raise error if not all requested records was found" do
+      lambda { Person.find(["ID1", "not exists"]) }.should raise_error MassiveRecord::ORM::RecordNotFound
+    end
+
+    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
   end
   
   describe "#find_in_batches" do
@@ -183,6 +212,20 @@ describe "finders" do
       end        
       group_number.should == @table_size / 3
     end
+
+    it "should not do a thing if table does not exist" do
+      Person.table.should_receive(:exists?).and_return false
+
+      counter = 0
+
+      Person.find_in_batches(:batch_size => 3) do |rows|
+        rows.each do |row|
+          counter += 1
+        end
+      end
+
+      counter.should == 0
+    end
     
     it "should iterate through a collection of rows using a batch process" do
       rows_number = 0

data/spec/orm/cases/persistence_spec.rb

@@ -76,8 +76,9 @@ describe "persistence" do
       @person.reload.should == @person
     end
 
-    it "should raise error on new record" do
-      lambda { Person.new.reload }.should raise_error MassiveRecord::ORM::RecordNotFound
+    it "should not do anything on reload when record is not persisted" do
+      Person.should_not_receive :find
+      Person.new.reload
     end
   end
 
@@ -104,8 +105,8 @@ describe "persistence" do
     end
     
     it "should include the 'pts' field in the database which has 'points' as an alias" do
-      @person.send(:attributes_to_row_values_hash)["info"].keys.should include("pts")
-      @person.send(:attributes_to_row_values_hash)["info"].keys.should_not include("points")
+      @person.send(:attributes_to_row_values_hash)["base"].keys.should include("pts")
+      @person.send(:attributes_to_row_values_hash)["base"].keys.should_not include("points")
     end
   end
 
@@ -181,6 +182,9 @@ describe "persistence" do
               column_family :bar do
                 field :foo
               end
+
+              column_family :empty_family do
+              end
             end
 
             @new_instance = @new_class.new :id => "id_of_foo", :foo => "bar"
@@ -202,7 +206,7 @@ describe "persistence" do
 
           it "should create correct column families" do
             @new_instance.save
-            @new_class.table.fetch_column_families.collect(&:name).should == ["bar"]
+            @new_class.table.fetch_column_families.collect(&:name).should include "bar", "empty_family"
           end
 
           it "should store the new instance" do
@@ -343,6 +347,11 @@ describe "persistence" do
         @person.should be_destroyed
         Person.all.length.should == 0
       end
+      
+      it "should be able to call destroy on new records" do
+        person = Person.new
+        person.destroy
+      end
 
       describe "#destroy_all" do
         it "should remove all when calling remove_all" do
@@ -354,6 +363,12 @@ describe "persistence" do
         it "should return an array of all removed objects" do
           Person.destroy_all.should == [@person]
         end
+
+        it "should destroy all even if it is above 10 rows (obviously)" do
+          15.times { |i| Person.create! :id => "id-#{i}", :name => "Going to die :-(", :age => i + 20 }
+          Person.destroy_all
+          Person.all.length.should == 0
+        end
       end
     end
   end

data/spec/orm/cases/single_table_inheritance_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'orm/models/friend'
+require 'orm/models/best_friend'
+
+describe "Single table inheritance" do
+  include SetUpHbaseConnectionBeforeAll
+  include SetTableNamesToTestTable
+
+  [Friend, BestFriend, BestFriend::SuperBestFriend].each do |klass|
+    describe klass do
+      let(:subject) { klass.new(:id => "ID1", :name => "Person1", :email => "one@person.com", :age => 11, :points => 111, :status => true) }
+
+      its(:type) { should == klass.to_s }
+
+      it "should instantiate correct class when reading from database" do
+        subject.save!
+        Person.find(subject.id).should == subject
+      end
+    end
+  end
+
+  it "should not set type if record being saved is base class" do
+    person = Person.new :id => "ID1", :name => "Person1", :email => "one@person.com", :age => 11, :points => 111, :status => true
+    person.type.should be_nil
+  end
+end

data/spec/orm/cases/table_spec.rb

@@ -52,7 +52,7 @@ describe "Person which is a table" do
   end
 
   it "should keep different column families per sub class" do
-    Person.column_families.collect(&:name).should == ["info"]
+    Person.column_families.collect(&:name).should include "info", "base"
     TestClass.column_families.collect(&:name).should == ["test_family"]
   end
   

data/spec/orm/cases/timestamps_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'orm/models/person'
-require 'orm/models/person_with_timestamps'
+require 'orm/models/person_with_timestamp'
 
 describe "timestamps" do
   include CreatePersonBeforeEach
@@ -56,11 +56,11 @@ describe "timestamps" do
 
   describe "#created_at" do
     before do
-      @person_with_timestamps = PersonWithTimestamps.create! :name => "John Doe", :email => "john@base.com", :age => "20"
+      @person_with_timestamp = PersonWithTimestamp.create! :name => "John Doe", :email => "john@base.com", :age => "20"
     end
 
     it "should have created at" do
-      @person_with_timestamps.should be_set_created_at_on_create
+      @person_with_timestamp.should be_set_created_at_on_create
     end
 
     it "should not have created at on create if model does not have created at" do
@@ -68,13 +68,13 @@ describe "timestamps" do
     end
 
     it "should have updated at equal to nil on new records" do
-      PersonWithTimestamps.new.created_at.should be_nil
+      PersonWithTimestamp.new.created_at.should be_nil
     end
 
     it "should not be possible to set updated at" do
-      lambda { @person_with_timestamps.created_at = Time.now }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
-      lambda { @person_with_timestamps['created_at'] = Time.now }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
-      lambda { @person_with_timestamps.write_attribute(:created_at, Time.now) }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
+      lambda { @person_with_timestamp.created_at = Time.now }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
+      lambda { @person_with_timestamp['created_at'] = Time.now }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
+      lambda { @person_with_timestamp.write_attribute(:created_at, Time.now) }.should raise_error MassiveRecord::ORM::CantBeManuallyAssigned
     end
 
     it "should not raise cant-set-error if object has no timestamps" do
@@ -82,24 +82,24 @@ describe "timestamps" do
     end
 
     it "should have created_at on a persisted record" do
-      @person_with_timestamps.created_at.should be_a_kind_of Time
+      @person_with_timestamp.created_at.should be_a_kind_of Time
     end
 
     it "should not alter created at on update" do
-      created_at_was = @person_with_timestamps.created_at
+      created_at_was = @person_with_timestamp.created_at
 
       sleep(1)
 
-      @person_with_timestamps.update_attribute :name, @person_with_timestamps.name + "NEW"
-      @person_with_timestamps.created_at.should == created_at_was
+      @person_with_timestamp.update_attribute :name, @person_with_timestamp.name + "NEW"
+      @person_with_timestamp.created_at.should == created_at_was
     end
 
     it "should be included in the list of known_attribute_names_for_inspect" do
-      @person_with_timestamps.send(:known_attribute_names_for_inspect).should include 'created_at'
+      @person_with_timestamp.send(:known_attribute_names_for_inspect).should include 'created_at'
     end
 
     it "should include created_at in inspect" do
-      @person_with_timestamps.inspect.should include(%q{created_at:})
+      @person_with_timestamp.inspect.should include(%q{created_at:})
     end
 
     it "should not include created_at if object does not have it" do
@@ -107,11 +107,11 @@ describe "timestamps" do
     end
 
     it "should raise error if created_at is not time" do
-      PersonWithTimestamps.attributes_schema['created_at'].type = :string
+      PersonWithTimestamp.attributes_schema['created_at'].type = :string
 
-      lambda { PersonWithTimestamps.create! }.should raise_error "created_at must be of type time"
+      lambda { PersonWithTimestamp.create! }.should raise_error "created_at must be of type time"
 
-      PersonWithTimestamps.attributes_schema['created_at'].type = :time
+      PersonWithTimestamp.attributes_schema['created_at'].type = :time
     end
   end
 end

data/spec/orm/coders/chained_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Coders::Chained do
+  describe "initialize" do
+    it "should be able to assign coder to load- and dump with" do
+      coders = MassiveRecord::ORM::Coders::JSON.new
+      coder = MassiveRecord::ORM::Coders::Chained.new(coders)
+      coder.loaders.should include coders
+      coder.dumpers.should include coders
+    end
+
+    it "should be able to assign array of coders to load- and dump with" do
+      coders = [MassiveRecord::ORM::Coders::JSON.new, MassiveRecord::ORM::Coders::YAML.new]
+      coder = MassiveRecord::ORM::Coders::Chained.new(coders)
+      coder.loaders.should include *coders
+      coder.dumpers.should include *coders
+    end
+
+    it "should be possible to assign load_with explicitly" do
+      coders = MassiveRecord::ORM::Coders::JSON.new
+      load_with = MassiveRecord::ORM::Coders::YAML.new
+      coder = MassiveRecord::ORM::Coders::Chained.new(coders, :load_with => load_with)
+      coder.loaders.should include load_with
+      coder.dumpers.should include coders
+    end
+
+    it "should be possible to assign dump_with explicitly" do
+      coders = MassiveRecord::ORM::Coders::JSON.new
+      dump_with = MassiveRecord::ORM::Coders::YAML.new
+      coder = MassiveRecord::ORM::Coders::Chained.new(coders, :dump_with => dump_with)
+      coder.loaders.should include coders
+      coder.dumpers.should include dump_with
+    end
+  end
+
+
+
+  describe "one coder in chain" do
+    let(:subject) { MassiveRecord::ORM::Coders::Chained.new(MassiveRecord::ORM::Coders::JSON.new) }
+    let(:code_with) { lambda { |value| ActiveSupport::JSON.encode(value) } }
+    
+    it_should_behave_like "an orm coder"
+  end
+
+
+
+  describe "two loaders in chain" do
+    let(:subject) do
+      MassiveRecord::ORM::Coders::Chained.new({
+        :load_with => [MassiveRecord::ORM::Coders::JSON.new, MassiveRecord::ORM::Coders::YAML.new],
+        :dump_with => MassiveRecord::ORM::Coders::YAML.new
+      })
+    end
+
+    let(:code_with) { lambda { |value| YAML.dump(value) } }
+    
+    it_should_behave_like "an orm coder"
+
+    it "it should try the next loader in the line if the first one fails" do
+      data = {:foo => {'sdf' => "wef"}} # Will make the json encoder fail when YAML serialized
+      subject.load(YAML.dump(data)).should == data
+    end
+
+    it "should raise ParseError if all fails" do
+      lambda { subject.load("{{}]") }.should raise_error MassiveRecord::ORM::Coders::ParseError
+    end
+
+    it "should raise EncodeError if all fails" do
+      subject.dumpers.first.should_receive(:dump).and_raise(StandardError)
+      lambda { subject.dump("unable to dump") }.should raise_error MassiveRecord::ORM::Coders::EncodeError
+    end
+  end
+end

data/spec/orm/coders/json_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Coders::JSON do
+  let(:code_with) { lambda { |value| ActiveSupport::JSON.encode(value) } }
+  it_should_behave_like "an orm coder"
+end

data/spec/orm/coders/yaml_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Coders::YAML do
+  let(:code_with) { lambda { |value| value.to_yaml } }
+  it_should_behave_like "an orm coder"
+end

data/spec/orm/models/best_friend.rb

@@ -0,0 +1,7 @@
+require 'orm/models/friend'
+
+class BestFriend < Friend
+  class SuperBestFriend < BestFriend
+  end
+end
+

data/spec/orm/models/friend.rb

@@ -0,0 +1,4 @@
+require 'orm/models/person'
+
+class Friend < Person
+end

data/spec/orm/models/person.rb

@@ -1,15 +1,29 @@
 class Person < MassiveRecord::ORM::Table
-  validates_presence_of :name, :age
-  validates_numericality_of :age, :greater_than_or_equal_to => 0
-  validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :allow_blank => true
-
   column_family :info do
     field :name
     field :email
     field :age, :integer
-    field :points, :integer, :default => 1, :column => :pts
     field :date_of_birth, :date
-    field :status, :boolean, :default => false
     field :addresses, :hash, :default => {}
+    field :type
+  end
+
+  column_family :base do
+    field :points, :integer, :default => 1, :column => :pts
+    field :status, :boolean, :default => false
+  end
+
+
+  references_one :boss, :class_name => "PersonWithTimestamp", :store_in => :info
+  references_many :test_classes, :store_in => :info
+  references_many :friends, :class_name => "Person", :records_starts_from => :friends_records_starts_from_id
+
+  validates_presence_of :name, :age
+  validates_numericality_of :age, :greater_than_or_equal_to => 0
+  validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :allow_blank => true
+
+
+  def friends_records_starts_from_id
+    id+'-'
   end
 end

data/spec/orm/models/{person_with_timestamps.rb → person_with_timestamp.rb}

@@ -1,4 +1,4 @@
-class PersonWithTimestamps < MassiveRecord::ORM::Table
+class PersonWithTimestamp < MassiveRecord::ORM::Table
   column_family :info do
     field :name
     field :email