massive_record 0.1.1 → 0.2.0.beta

data/spec/orm/relations/proxy/references_one_polymorphic_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+class TestReferencesOnePolymorphicProxy < MassiveRecord::ORM::Relations::Proxy::ReferencesOnePolymorphic; end
+
+describe TestReferencesOnePolymorphicProxy do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:proxy_owner) { TestClass.new }
+  let(:proxy_target) { Person.new }
+  let(:metadata) { subject.metadata }
+
+  subject { proxy_owner.send(:relation_proxy, 'attachable') }
+
+  describe "normal proxy behaviour" do
+    before do
+      proxy_owner.attachable_type = "person"
+    end
+
+    it_should_behave_like "relation proxy"
+    it_should_behave_like "singular proxy"
+  end
+
+
+  describe "#find_proxy_target" do
+    it "should be able to find proxy_target if foreign_key and type is present in proxy_owner" do
+      person = Person.new
+      proxy_owner.attachable_id = "ID1"
+      proxy_owner.attachable_type = "person"
+      Person.should_receive(:find).and_return(person)
+      proxy_owner.attachable.should == person
+    end
+
+    it "should not be able to find proxy_target if foreign_key is nil" do
+      proxy_owner.attachable_id = nil
+      proxy_owner.attachable_type = "person"
+      Person.should_not_receive(:find)
+      proxy_owner.attachable
+    end
+
+    it "should not be able to find proxy_target if type is nil" do
+      proxy_owner.attachable_id = "ID1"
+      proxy_owner.attachable_type = nil
+      Person.should_not_receive(:find)
+      proxy_owner.attachable
+    end
+  end
+
+
+  describe "setting proxy_target object" do
+    it "should set the proxy_target's id as the foreign key in proxy_owner" do
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_id.should == proxy_target.id
+    end
+
+    it "should set the proxy_target's type in proxy_owner" do
+      proxy_owner.attachable_type = nil
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_type.should == proxy_target.class.to_s.underscore
+    end
+
+    it "should reset the proxy_targets foreign key if proxy_target is nil" do
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable = nil
+      proxy_owner.attachable_id.should be_nil
+    end
+
+    it "should reset the proxy_target's type in proxy_owner if proxy_target is nil" do
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable = nil
+      proxy_owner.attachable_type.should be_nil
+    end
+
+    it "should not set the proxy_target's id as the foreign key if we are not persisting the foreign key" do
+      proxy_owner.stub(:respond_to?).and_return(false)
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_id.should be_nil
+    end
+
+    it "should not set the proxy_target's type if proxy_owner is not responding to type setter" do
+      proxy_owner.attachable_type = nil
+      proxy_owner.stub(:respond_to?).and_return(false)
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_type.should be_nil
+    end
+
+    it "should not set the proxy_target's id as the foreign key if the owner has been destroyed" do
+      proxy_owner.should_receive(:destroyed?).and_return true
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_id.should be_nil
+    end
+
+    it "should not set the proxy_target's type as the foreign key if the owner has been destroyed" do
+      proxy_owner.should_receive(:destroyed?).and_return true
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_type.should be_nil
+    end
+
+
+
+    it "should set the proxy_target's id as the foreign key even if we are not persisting it if the record responds to setter method" do
+      proxy_owner.attachable = proxy_target
+      proxy_owner.attachable_id.should == proxy_target.id
+    end
+  end
+end

data/spec/orm/relations/proxy/references_one_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+class TestReferencesOneProxy < MassiveRecord::ORM::Relations::Proxy::ReferencesOne; end
+
+describe TestReferencesOneProxy do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:proxy_owner) { Person.new }
+  let(:proxy_target) { PersonWithTimestamp.new }
+  let(:metadata) { subject.metadata }
+
+  subject { proxy_owner.send(:relation_proxy, 'boss') }
+
+  it_should_behave_like "relation proxy"
+  it_should_behave_like "singular proxy"
+
+  it "should be possible to assign relation in new" do
+    lambda { Person.new(:boss => PersonWithTimestamp.new) }.should_not raise_error
+  end
+
+  describe "#find_proxy_target" do
+    it "should not try to find anything if foreign key is nil" do
+      proxy_owner.boss_id = nil
+      PersonWithTimestamp.should_not_receive(:find)
+      subject.load_proxy_target.should be_nil
+    end
+
+    it "should try to find the proxy_target if foreign key is set" do
+      proxy_owner.boss_id = "id"
+      PersonWithTimestamp.should_receive(:find).with("id").and_return(proxy_target)
+      subject.load_proxy_target.should == proxy_target
+    end
+  end
+
+  describe "find with proc" do
+    let(:person) { Person.new }
+
+    before do
+      subject.metadata.find_with = Proc.new { |proxy_target| Person.find("testing-123") }
+      proxy_owner.boss_id = nil
+    end
+
+    after do
+      subject.metadata.find_with = nil
+    end
+
+    it "should not call find_proxy_target" do
+      should_not_receive :find_proxy_target
+      subject.load_proxy_target
+    end
+
+    it "should load by given proc" do
+      Person.should_receive(:find).with("testing-123").and_return(person)
+      subject.load_proxy_target.should == person
+    end
+  end
+
+  describe "setting proxy_target object" do
+    it "should set the proxy_target's id as the foreign key in proxy_owner" do
+      proxy_owner.boss = proxy_target
+      proxy_owner.boss_id.should == proxy_target.id
+    end
+
+    it "should reset the proxy_targets foreign key if proxy_target is nil" do
+      proxy_owner.boss = proxy_target
+      proxy_owner.boss = nil
+      proxy_owner.boss_id.should be_nil
+    end
+
+    it "should not set the proxy_target's id as the foreign key if we are not persisting the foreign key" do
+      proxy_owner.stub(:respond_to?).and_return(false)
+      proxy_owner.boss = proxy_target
+      proxy_owner.boss_id.should be_nil
+    end
+
+    it "should not set the proxy_target's id as the foreign key if the owner has been destroyed" do
+      proxy_owner.should_receive(:destroyed?).and_return true
+      proxy_owner.boss = proxy_target
+      proxy_owner.boss_id.should be_nil
+    end
+
+    it "should set the proxy_target's id as the foreign key even if we are not persisting it if the record responds to setter method" do
+      proxy_owner.boss = proxy_target
+      proxy_owner.boss_id.should == proxy_target.id
+    end
+
+    it "should raise an error if there is a type mismatch" do
+      lambda { proxy_owner.boss = Person.new }.should raise_error MassiveRecord::ORM::RelationTypeMismatch
+    end
+  end
+
+
+  describe "type checking of proxy_targets" do
+    let(:metadata) { MassiveRecord::ORM::Relations::Metadata.new 'person' }
+    let(:person) { Person.new }
+    let(:person_with_timestamp) { PersonWithTimestamp.new }
+
+    before do
+      subject.metadata = metadata
+    end
+
+    it "should not raise error if metadata's class corresponds to given proxy_target" do
+      lambda { subject.send :raise_if_type_mismatch, person }.should_not raise_error MassiveRecord::ORM::RelationTypeMismatch
+    end
+
+    it "should not raise error if metadata's class corresponds to given proxy_target" do
+      lambda { subject.send :raise_if_type_mismatch, person_with_timestamp }.should raise_error MassiveRecord::ORM::RelationTypeMismatch
+    end
+  end
+end

data/spec/orm/relations/proxy_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class TestProxy < MassiveRecord::ORM::Relations::Proxy; end
+
+describe TestProxy do
+  let(:metadata) { MassiveRecord::ORM::Relations::Metadata.new :person }
+  
+  before do
+    subject.metadata = metadata
+  end
+
+  it_should_behave_like "relation proxy"
+end

data/spec/orm/schema/field_spec.rb

@@ -29,6 +29,11 @@ describe MassiveRecord::ORM::Schema::Field do
       field.type.should == :integer
     end
 
+    it "should take type as an option" do
+      field = MassiveRecord::ORM::Schema::Field.new_with_arguments_from_dsl("info", :type => :integer)
+      field.type.should == :integer
+    end
+
     it "should take the rest as options" do
       field = MassiveRecord::ORM::Schema::Field.new_with_arguments_from_dsl("info", "integer", :default => 0)
       field.default.should == 0
@@ -115,9 +120,25 @@ describe MassiveRecord::ORM::Schema::Field do
       @subject.decode(nil).should be_nil
     end
 
+    it "should cast symbols to strings" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :string)
+      @subject.decode(:value).should == "value"
+    end
+
+    it "should decode string null correctly" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :string)
+      @subject.decode(@subject.encode("null")).should == "null"
+    end
+
+    it "should decode string with value nil correctly" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :string)
+      @subject.decode(@subject.encode(nil)).should == nil
+    end
+
     it "should decode an integer value" do
       @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :integer)
       @subject.decode("1").should == 1
+      @subject.decode(1).should == 1
       @subject.decode("").should be_nil
       @subject.decode(nil).should be_nil
     end
@@ -132,18 +153,96 @@ describe MassiveRecord::ORM::Schema::Field do
     it "should decode a date type" do
       today = Date.today
       @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :date)
-      @subject.decode(today.to_s) == today
+      @subject.decode(today.to_s).should == today
       @subject.decode("").should be_nil
       @subject.decode(nil).should be_nil
     end
+
+    it "should set date to nil if date could not be parsed" do
+      today = "foobar"
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :date)
+      @subject.decode(today).should be_nil
+    end
     
     it "should decode a time type" do
       today = Time.now
       @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :time)
-      @subject.decode(today.to_s) == today
+      @subject.decode(@subject.coder.dump(today)).to_i.should == today.to_i
       @subject.decode("").should be_nil
       @subject.decode(nil).should be_nil
     end
+
+    it "should set time to nil if date could not be parsed" do
+      today = "foobar"
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :time)
+      @subject.decode(today).should be_nil
+    end
+
+    it "should deserialize array" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :array)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+      @subject.decode(nil).should == nil
+      @subject.decode("").should == nil
+      @subject.decode("[]").should == []
+      @subject.decode([1, 2].to_json).should == [1, 2]
+    end
+
+    it "should deserialize hash" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :hash)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+      @subject.decode(nil).should == nil
+      @subject.decode("").should == nil
+      @subject.decode("{}").should == {}
+      @subject.decode({:foo => 'bar'}.to_json).should == {'foo' => 'bar'}
+    end
+
+    it "should raise an argument if expecting array but getting something else" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :array)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+      lambda { @subject.decode("false") }.should raise_error MassiveRecord::ORM::SerializationTypeMismatch
+    end
+
+    it "should raise an argument if expecting hash but getting something else" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :hash)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+      lambda { @subject.decode("[]") }.should raise_error MassiveRecord::ORM::SerializationTypeMismatch
+    end
+
+    it "should not raise an argument if expecting hash getting nil" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :hash)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+      lambda { @subject.decode("null") }.should_not raise_error MassiveRecord::ORM::SerializationTypeMismatch
+    end
+  end
+
+  describe "#encode" do
+    before do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status)
+      @subject.coder = MassiveRecord::ORM::Coders::JSON.new
+    end
+
+    it "should encode normal strings" do
+      @subject.type = :string
+      @subject.encode("fooo").should == "fooo"
+    end
+
+    it "should encode string if value is null" do
+      @subject.type = :string
+      @subject.encode("null").should == @subject.coder.dump("null")
+    end
+
+    it "should encode string if value is nil" do
+      @subject.type = :string
+      @subject.encode(nil).should == "null"
+    end
+
+    (MassiveRecord::ORM::Schema::Field::TYPES - [:string]).each do |type|
+      it "should ask coder to dump value when type is #{type}" do
+        @subject.type = type
+        @subject.coder.should_receive(:dump)
+        @subject.encode("{}")
+      end
+    end
   end
 
   describe "#unique_name" do

data/spec/shared/orm/coders/an_orm_coder.rb

@@ -0,0 +1,14 @@
+shared_examples_for "an orm coder" do
+  it { should respond_to :load }
+  it { should respond_to :dump }
+
+  [1, "1", nil, ["foo"], {'foo' => 'bar', "1" => 3}, {'nested' => {'inner' => 'secret'}}].each do |value|
+    it "should dump a #{value.class} correctly" do
+      subject.dump(value).should == code_with.call(value)
+    end
+
+    it "should load a #{value.class} correctly" do
+      subject.load(code_with.call(value)).should == value
+    end
+  end
+end

data/spec/shared/orm/relations/proxy.rb

@@ -0,0 +1,154 @@
+shared_examples_for "relation proxy" do
+  let(:proxy_target) { mock(Object).as_null_object }
+  let(:find_proxy_target_returns) { subject.represents_a_collection? ? [proxy_target] : proxy_target }
+
+  before do
+    subject.metadata = mock(MassiveRecord::ORM::Relations::Metadata, :find_with => nil).as_null_object if subject.metadata.nil?
+  end
+
+  %w(proxy_owner proxy_target metadata).each do |method|
+    it "should respond to #{method}" do
+      should respond_to method
+    end
+  end
+
+  it "should be setting values by initializer" do
+    proxy = MassiveRecord::ORM::Relations::Proxy.new(:proxy_owner => "proxy_owner", :proxy_target => proxy_target, :metadata => "metadata")
+    proxy.proxy_owner.should == "proxy_owner"
+    proxy.proxy_target.should == proxy_target
+    proxy.metadata.should == "metadata"
+  end
+
+  describe "#loaded" do
+    it "should be true when loaded" do
+      subject.instance_variable_set :@loaded, true
+      should be_loaded
+    end
+
+    it "should be false when not loaded" do
+      subject.instance_variable_set :@loaded, false
+      should_not be_loaded
+    end
+
+    it "should be loaded when loaded! is called" do
+      subject.instance_variable_set :@loaded, false
+      subject.loaded!
+      should be_loaded
+    end
+  end
+
+
+  describe "#reset" do
+    it "should not be loaded after reset" do
+      subject.loaded!
+      subject.reset
+      should_not be_loaded
+    end
+
+    it "should reset the proxy_target" do
+      subject.proxy_target = proxy_target
+      subject.reset
+      subject.stub(:find_proxy_target?).and_return(false)
+      subject.proxy_target.should be_blank
+    end
+  end
+
+  describe "#reload" do
+    before do
+      subject.stub!(:find_proxy_target)
+    end
+
+    it "should reset the proxy" do
+      subject.should_receive :reset
+      subject.reload
+    end
+
+    it "should call load_proxy_target" do
+      subject.should_receive :load_proxy_target
+      subject.reload
+    end
+
+    it "should return proxy_target if loaded successfully" do
+      subject.should_receive(:can_find_proxy_target?).and_return true
+      subject.should_receive(:find_proxy_target) { find_proxy_target_returns }
+      subject.reload.should == find_proxy_target_returns
+    end
+
+    it "should return nil if loading of proxy_target failed" do
+      subject.stub(:can_find_proxy_target?).and_return true
+      subject.should_receive(:find_proxy_target).and_raise MassiveRecord::ORM::RecordNotFound
+      subject.reload.should be_blank
+    end
+  end
+
+
+
+
+  describe "proxy_target" do
+    it "should return the proxy_target if it is present" do
+      subject.proxy_target = proxy_target
+      subject.proxy_target.should == proxy_target
+    end
+
+    it "should be consodered loaded if a proxy_target has been set" do
+      subject.proxy_target = proxy_target
+      should be_loaded
+    end
+
+    it "should not try to load proxy_target if it has been loaded" do
+      subject.loaded!
+      should_not_receive :find_proxy_target
+      subject.load_proxy_target.should be_blank
+    end
+
+    it "should try to load the proxy_target if it has not been loaded" do
+      subject.stub(:can_find_proxy_target?).and_return true
+      subject.should_receive(:find_proxy_target) { find_proxy_target_returns }
+      subject.load_proxy_target
+      subject.proxy_target.should == find_proxy_target_returns
+    end
+
+    it "should reset proxy if proxy_target's record was not found" do
+      subject.stub(:can_find_proxy_target?).and_return true
+      subject.should_receive(:find_proxy_target).and_raise MassiveRecord::ORM::RecordNotFound
+      subject.load_proxy_target.should be_blank
+    end
+  end
+
+
+  describe "replace" do
+    let(:old_proxy_target) { subject.represents_a_collection? ? [subject.proxy_target_class.new] : subject.proxy_target_class.new }
+    let(:new_proxy_target) { subject.represents_a_collection? ? [subject.proxy_target_class.new] : subject.proxy_target_class.new }
+
+    before do
+      subject.proxy_target = old_proxy_target
+    end
+
+    it "should replace the old proxy_target with the new one" do
+      subject.replace(new_proxy_target)
+      subject.proxy_target.should == new_proxy_target
+    end
+
+    it "should reset the proxy if asked to replace with nil" do
+      subject.should_receive(:reset)
+      subject.replace(nil)
+    end
+  end
+
+  describe "find_with" do
+    let(:metadata) { MassiveRecord::ORM::Relations::Metadata.new 'person', :find_with => Proc.new { |proxy_target| Person.find("testing-123") }}
+    let(:person) { Person.new }
+
+    before do
+      subject.metadata = metadata
+      subject.stub(:can_find_proxy_target?).and_return(true)
+    end
+
+    it "should use metadata's find with if exists" do
+      Person.should_receive(:find).with("testing-123").and_return(person)
+
+      should_not_receive :find_proxy_target
+      subject.load_proxy_target 
+    end
+  end
+end