massive_record 0.1.0

data/spec/orm/cases/dirty_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe "dirty" do
+  describe "dry run" do
+    include MockMassiveRecordConnection
+
+    before do
+      @person = Person.new :id => 1, :name => "Alice", :age => 20, :email => "foo@bar.com"
+    end
+
+    it "should not be changed after created" do
+      @person.should_not be_changed
+    end
+
+    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 "should notice changes" do
+      @person.name = "Bob"
+      @person.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 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 "should return what name was" do
+      @person.name = "Bob"
+      @person.name_was.should == "Alice"
+    end
+
+
+    describe "should reset changes" do
+      it "on save" do
+        @person.name = "Bob"
+        @person.save
+        @person.should_not be_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
+      end
+
+      it "on save!" do
+        @person.name = "Bob"
+        @person.save!
+        @person.should_not be_changed
+      end
+
+      it "on reload" do
+        @person.name = "Bob"
+        @person.reload
+        @person.should_not be_changed
+      end
+    end
+
+    describe "previous changes" do
+      it "should be blank before save" do
+        @person.previous_changes.should be_blank
+      end
+
+      it "should equal to changes before save" do
+        @person.name = "Bob"
+        changes_before_save = @person.changes
+
+        @person.save
+
+        @person.changes.should be_empty
+        @person.previous_changes.should == changes_before_save
+      end
+
+      it "should equal to changes before save!" do
+        @person.name = "Bob"
+        changes_before_save = @person.changes
+
+        @person.save!
+
+        @person.changes.should be_empty
+        @person.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
+      end
+    end
+  end
+
+
+  describe "database run" do
+    include SetUpHbaseConnectionBeforeAll
+    include SetTableNamesToTestTable
+
+    before do
+      @person = Person.new
+      @person.id = "test"
+      @person.points = "25"
+      @person.date_of_birth = "19850730"
+      @person.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 == {}
+    end
+  end
+end

data/spec/orm/cases/encoding_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+require 'orm/models/person'
+
+describe "encoding" do
+
+  describe "with ORM" do
+    include SetUpHbaseConnectionBeforeAll
+    include SetTableNamesToTestTable
+
+    before do
+      @person = Person.create! :id => "new_id", :name => "Thorbjørn", :age => "22"
+      @person_from_db = Person.find(@person.id)
+    end
+
+    it "should be able to store UTF-8 encoded strings" do
+      @person_from_db.should == @person
+      @person_from_db.name.should == "Thorbjørn"
+    end
+
+    it "should return string as UTF-8 encoded strings" do
+      @person_from_db.name.encoding.should == Encoding::UTF_8
+    end
+  end
+
+  describe "without ORM" do
+    include CreatePersonBeforeEach
+
+    before do
+      @id = "ID-encoding-test"
+
+      @row = MassiveRecord::Wrapper::Row.new
+      @row.table = @table
+      @row.id = @id
+      @row.values = {:info => {:name => "Thorbjørn", :email => "john@base.com", :age => "20"}}
+      @row.save
+
+      @row_from_db = @table.find(@id) 
+    end
+
+    it "should be able to store UTF-8 encoded strings" do
+      @row_from_db.values["info:name"].should == "Thorbjørn"
+    end
+
+    it "should return string as UTF-8 encoded strings" do
+      @row_from_db.values["info:name"].encoding.should == Encoding::UTF_8
+    end
+  end
+end

data/spec/orm/cases/finders_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+require 'orm/models/test_class'
+require 'orm/models/person'
+
+describe "finders" do
+  describe "#find dry test" do
+    include MockMassiveRecordConnection
+
+    before do
+      @mocked_table = mock(MassiveRecord::Wrapper::Table).as_null_object
+      Person.stub(:table).and_return(@mocked_table)
+      
+      @row = MassiveRecord::Wrapper::Row.new
+      @row.id = "ID1"
+      @row.values = { :info => { :name => "John Doe", :age => "29" } }
+
+      @row_2 = MassiveRecord::Wrapper::Row.new
+      @row_2.id = "ID2"
+      @row_2.values = { :info => { :name => "Bob", :age => "18" } }
+    end
+
+    it "should have at least one argument" do
+      lambda { Person.find }.should raise_error ArgumentError
+    end
+
+    it "should simply return nil on first if table does not exists" do
+      Person.table.should_receive(:exists?).and_return false
+      Person.first.should be_nil
+    end
+
+    it "should simply return nil on find if table does not exists" do
+      Person.table.should_receive(:exists?).and_return false
+      Person.find(1).should be_nil
+    end
+
+    it "should simply return empty array if table does not exists" do
+      Person.table.should_receive(:exists?).and_return false
+      Person.all.should == []
+    end
+
+    it "should raise RecordNotFound if id is nil" 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
+
+    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 find" do
+      lambda { Person.find(:conditions => "foo = 'bar'") }.should raise_error ArgumentError
+    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 "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])
+      people = Person.find(["ID1", "ID2"])
+      people.should be_instance_of Array
+      people.first.should be_instance_of Person
+      people.first.id.should == "ID1"
+      people.last.id.should == "ID2"
+    end
+    
+    it "should ask table to fetch rows from a list of ids given as arguments" do
+      @mocked_table.should_receive(:find).with(["ID1", "ID2"], anything).and_return([@row, @row_2])
+      people = Person.find("ID1", "ID2")
+      people.should be_instance_of Array
+      people.first.should be_instance_of Person
+      people.first.id.should == "ID1"
+      people.last.id.should == "ID2"
+    end
+
+    it "should raise error if not all multiple ids are found" do
+      @mocked_table.should_receive(:find).with(["ID1", "ID2"], anything).and_return([@row])
+      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)
+    end
+
+    it "should call table's all on find(:all)" do
+      @mocked_table.should_receive(:all).and_return([@row])
+      Person.find(:all)
+    end
+
+    it "should return empty array on all if no results was found" do
+      @mocked_table.should_receive(:all).and_return([])
+      Person.all.should == []
+    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
+
+    it "should raise an error if not exactly the id is found" do
+      @mocked_table.should_receive(:find).and_return(@row)
+      lambda { Person.find("ID") }.should raise_error(MassiveRecord::ORM::RecordNotFound)
+    end
+
+    it "should raise error if not all ids are found" do
+      @mocked_table.should_receive(:find).and_return([@row, @row_2])
+      lambda { Person.find("ID", "ID2") }.should raise_error(MassiveRecord::ORM::RecordNotFound)
+    end
+  end
+
+  %w(first all).each do |method|
+    it "should respond to #{method}" do
+      TestClass.should respond_to method
+    end
+
+    it "should delegate #{method} to find with first argument as :#{method}" do
+      TestClass.should_receive(:find).with(method.to_sym)
+      TestClass.send(method)
+    end
+
+    it "should delegate #{method}'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)
+    end
+  end
+
+
+
+
+  describe "#find database test" do
+    include CreatePersonBeforeEach
+
+    before do
+      @person = Person.find("ID1")
+
+      @row = MassiveRecord::Wrapper::Row.new
+      @row.id = "ID2"
+      @row.values = {:info => {:name => "Bob", :email => "bob@base.com", :age => "26"}}
+      @row.table = @table
+      @row.save
+
+      @bob = Person.find("ID2")
+    end
+
+    it "should return nil if id is not found" do
+      lambda { Person.find("not_found") }.should raise_error MassiveRecord::ORM::RecordNotFound
+    end
+
+    it "should return the person object when found" do
+      @person.name.should == "John Doe"
+      @person.email.should == "john@base.com"
+      @person.age.should == 20
+    end
+
+    it "should find first person" do
+      Person.first.should == @person
+    end
+
+    it "should find all" do
+      all = Person.all
+      all.should include @person, @bob
+      all.length.should == 2
+    end
+  end
+  
+  describe "#find_in_batches" do
+    include CreatePeopleBeforeEach
+        
+    it "should iterate through a collection of group of rows using a batch process" do
+      group_number = 0
+      batch_size = 3
+      Person.find_in_batches(:batch_size => batch_size) do |rows|
+        group_number += 1
+        rows.each do |row|
+          row.id.should_not be_nil
+        end
+      end        
+      group_number.should == @table_size / 3
+    end
+    
+    it "should iterate through a collection of rows using a batch process" do
+      rows_number = 0
+      Person.find_each(:batch_size => 3) do |row|
+        row.id.should_not be_nil
+        rows_number += 1
+      end
+      rows_number.should == @table_size
+    end
+  end
+
+  describe "#exists?" do
+    include CreatePersonBeforeEach
+
+    it "should return true if a row exists with given id" do
+      Person.exists?("ID1").should be_true
+    end
+
+    it "should return false if a row does not exists with given id" do
+      Person.exists?("unkown").should be_false
+    end
+  end
+end

data/spec/orm/cases/hbase/connection_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "connection" do
+  
+  describe "a new connection" do
+    
+    before do
+      @connection ||= MassiveRecord::Wrapper::Connection.new(:host => MR_CONFIG['host'], :port => MR_CONFIG['port'])
+    end
+    
+  end
+  
+end

data/spec/orm/cases/i18n_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe "translation and naming" do
+  before do
+    I18n.backend = I18n::Backend::Simple.new
+  end
+
+  describe "of an attribute" do
+    before do
+      I18n.backend.store_translations 'en', :activemodel => {:attributes => {:person => {:name => "person's name"} } }
+    end
+
+    it "should look up an by a string" do
+      Person.human_attribute_name("name").should == "person's name"
+    end
+
+    it "should look up an by a symbol" do
+      Person.human_attribute_name(:name).should == "person's name"
+    end
+  end
+
+  describe "of a model" do
+    before do
+      I18n.backend.store_translations 'en', :activemodel => {:models => {:person => 'A person object'}}
+    end
+
+    it "should return it's human name" do
+      Person.model_name.human.should == "A person object"
+    end
+  end
+end

data/spec/orm/cases/id_factory_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe "id factory" do
+  it "should be a singleton" do
+    MassiveRecord::ORM::IdFactory.included_modules.should include(Singleton)
+  end
+
+  describe "#next_for" do
+    describe "dry" do
+      include MockMassiveRecordConnection
+
+      before do
+        @factory = MassiveRecord::ORM::IdFactory.instance
+      end
+
+      it "should respond to next_for" do
+        @factory.should respond_to :next_for
+      end
+
+      it "should use incomming table name if it's a string" do
+        @factory.should_receive(:next_id).with(hash_including(:table => "test_table"))
+        @factory.next_for "test_table"
+      end
+
+      it "should use incomming table name if it's a symbol" do
+        @factory.should_receive(:next_id).with(hash_including(:table => "test_table"))
+        @factory.next_for :test_table
+      end
+
+      it "should ask object for it's table name if it responds to that" do
+        Person.should_receive(:table_name).and_return("people")
+        @factory.should_receive(:next_id).with(hash_including(:table => "people"))
+        @factory.next_for(Person)
+      end
+
+      it "should have class method next_for and delegate it to it's instance" do
+        @factory.should_receive(:next_for).with("cars")
+        MassiveRecord::ORM::IdFactory.next_for("cars")
+      end
+    end
+
+
+
+    describe "database" do
+      include SetUpHbaseConnectionBeforeAll
+      include SetTableNamesToTestTable
+
+      before do
+        @factory = MassiveRecord::ORM::IdFactory.instance
+      end
+
+      after do
+        MassiveRecord::ORM::IdFactory.destroy_all
+        MassiveRecord::ORM::IdFactory.instance_variable_set(:@instance, nil)
+      end
+
+      it "should increment start a new sequence on 1" do
+        @factory.next_for(Person).should == 1
+      end
+
+      it "should increment value one by one" do
+        5.times do |index|
+          expected_id = index + 1
+          @factory.next_for(Person).should == expected_id
+        end
+      end
+
+      it "should maintain ids separate for each table" do
+        3.times { @factory.next_for(Person) }
+        @factory.next_for("cars").should == 1
+      end
+    end
+  end
+end