couchbase-model-relationship 0.1

data/spec/dirty_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+class DirtyTest < Couchbase::Model
+  attribute :name
+  attribute :complex
+end
+
+describe "Dirty" do
+  subject { DirtyTest.new }
+
+  it "should mark the fields as dirty" do
+    subject.name = 'abc'
+    subject.should be_name_changed
+  end
+
+  it "should mark complex fields" do
+    inner = []
+    outer = [inner]
+
+    subject.complex = outer
+    subject.send :clean!
+
+    subject.complex_will_change!
+    subject.complex[0].push 'abc'
+
+    subject.should be_complex_changed
+    subject.complex.should eq([['abc']])
+    subject.complex_was.should eq([[]])
+  end
+
+  it "should not mark the field dirty when the value is the same" do
+    subject.name = "abc"
+    subject.send :clean!
+
+    subject.name = "abc"
+
+    subject.should_not be_name_changed
+  end
+
+  it "doesn't mark any fields as dirty when the model is loaded" do
+    DirtyTest.stubs(bucket: stub)
+    DirtyTest.bucket.expects(:get).with(['abc123'], quiet: false, extended: true).returns({'name' => "Bob"}, {}, 123)
+
+    DirtyTest.find('abc123').should_not be_changed
+  end
+
+  describe "creating" do
+    describe "successfully" do
+      before do
+        subject.stubs(create_without_dirty: true)
+        subject.name = "creating"
+        subject.create
+      end
+
+      it "captures changes" do
+        subject.name.should eq("creating")
+        subject.should_not be_name_changed
+        subject.previous_changes['name'].should eq([nil, 'creating'])
+      end
+
+      it "clears current changes" do
+        subject.changes.should be_blank
+      end
+    end
+
+    describe "failing" do
+      before do
+        subject.stubs(create_without_dirty: false)
+        subject.name = "creating"
+        subject.create
+      end
+
+      it "doesn't capture changes" do
+        subject.previous_changes.should be_blank
+      end
+
+      it "doesn't clear current changes" do
+        subject.changed.should eq(["name"]) 
+      end
+
+      it "doesn't have a previous change" do
+        subject.previous_name.should be_nil
+      end
+    end
+  end
+
+  describe "saving" do
+    it "doesn't saves if not changed on request" do
+      subject.stubs(changed?: false)
+      subject.expects(:save).never
+
+      subject.save_if_changed
+    end
+
+    it "saves if changed on request" do
+      subject.stubs(changed?: true)
+      subject.expects(:save)
+
+      subject.save_if_changed
+    end
+
+    describe "successfully" do
+      before do
+        subject.stubs(save_without_dirty: true)
+        subject.name = "save"
+        subject.id = 123
+        subject.save
+      end
+
+      it "captures changes" do
+        subject.name.should eq("save")
+        subject.should_not be_name_changed
+        subject.previous_changes['name'].should eq([nil, 'save'])
+        subject.previous_name.should eq(nil)
+      end
+
+      it "clears current changes" do
+        subject.changes.should be_blank
+      end
+    end
+
+    describe "failing" do
+      before do
+        subject.stubs(save_without_dirty: false)
+        subject.name = "save"
+        subject.id = 123
+        subject.save
+      end
+
+      it "doesn't capture changes" do
+        subject.previous_changes.should be_blank
+      end
+
+      it "doesn't clear current changes" do
+        subject.changed.should eq(["name"]) 
+      end
+    end
+  end
+end

data/spec/id_prefix_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class IdPrefixTest < Couchbase::Model
+end
+
+describe "IdPrefix" do
+  subject { IdPrefixTest.new }
+
+  it "knows the proper prefix" do
+    subject.class.id_prefix.should eq("id_prefix_test")
+  end
+
+  it "prefixes an id properly" do
+    subject.class.prefixed_id(123).should eq("id_prefix_test:123")
+  end
+
+  it "unprefixes an id properly" do
+    subject.class.unprefixed_id("klass:123").should eq("123")
+  end
+
+  it "gets the prefix for an id properly" do
+    subject.class.prefix_from_id("class:abc").should eq("class")
+  end
+
+  it "gets the class for an id prperly" do
+    subject.class.class_from_id("id_prefix_test").should eq(IdPrefixTest)
+  end
+
+  describe "creating" do 
+    before do
+      subject.stubs(create_without_id_prefix: true)
+    end
+
+    it "doesn't set the id if present" do
+      subject.id = 123
+      subject.create
+      subject.id.should eq(123)
+    end
+
+    it "creates a uid with a prefix" do
+      subject.create
+      subject.id.should match(/^id_prefix_test:/)
+    end
+  end
+end

data/spec/parent_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+class Child < Couchbase::Model
+  attribute :age
+
+  has_parent
+end
+
+class Brother < Couchbase::Model
+  has_parent
+end
+
+class Sister < Couchbase::Model
+  has_parent
+end
+
+class ParentTest < Couchbase::Model
+  attribute :name
+
+  child :child
+  child :dont_load, auto_load: false
+end
+
+class AutoSaveTest < Couchbase::Model
+  include ActiveModel::Validations
+
+  attribute :name
+  validates_length_of :name, maximum: 5
+
+  child :child, auto_save: true
+  child :brother, auto_delete: true
+end
+
+class MultipleChildTest < Couchbase::Model
+  children :brother, :sister
+end
+
+class InvalidTest < Couchbase::Model
+  include ActiveModel::Validations
+
+  attribute :name
+  validates_length_of :name, maximum: 5
+  child :brother
+end
+
+describe "parent" do
+  subject { ParentTest.new }
+
+  it "has a setter" do
+    subject.should respond_to(:child=)
+  end
+
+  it "has a getter" do
+    subject.should respond_to(:child)
+  end
+
+  context "the getter" do
+    let(:association) { ParentTest.child_association_for :child }
+
+    it "returns the value is present" do
+      subject.child = (brother = Brother.new)
+      subject.child.should eq(brother)
+    end
+
+    it "tries to load from the db if not loaded" do
+      subject.expects(:build_child).never
+      association.expects(:load).returns((child = Child.new)).once
+
+      subject.child.should eq(child)
+      subject.child.should eq(child)
+    end
+
+    it "builds a new child if child doesn't exist in the db" do
+      association.expects(:load).returns(nil).once
+
+      subject.child.should be_a(Child)
+      subject.child.should be_a(Child)
+    end
+  end
+
+  it "can reload itself and all it's children" do
+    subject.child = stub(reload: true)
+    subject.dont_load = stub(reload: true)
+    subject.expects(:reload)
+
+    subject.reload_all
+  end
+
+  it "knows if the child is loaded or not" do
+    subject.should_not be_child_loaded
+    subject.send :child_loaded!
+    subject.should be_child_loaded
+  end
+
+  it "handles multiple children" do
+    MultipleChildTest.new.should respond_to(:brother, :brother=, :sister, :sister=)
+  end
+
+  it "saves dirty children if we want to save them" do
+    subject = MultipleChildTest.new
+    subject.brother = Brother.new
+    subject.brother.stubs(changed?: true)
+    subject.brother.expects(:save)
+    subject.sister = Sister.new
+    subject.sister.stubs(changed?: false)
+    subject.sister.expects(:save).never
+
+    subject.stubs(save: :saved)
+
+    subject.save_with_children.should eq(:saved)
+  end
+
+  it "doesn't save children if the main object isn't valid" do
+    subject = InvalidTest.new
+    subject.brother = Brother.new
+    subject.brother.stubs(changed?: true)
+    subject.brother.expects(:save).never
+
+    subject.name = "123456"
+
+    subject.save_with_children
+  end
+
+  it "auto-saves children marked as autosaved" do
+    subject = AutoSaveTest.new name: "Test"
+    subject.child = Child.new age: 5
+    subject.brother = Brother.new
+
+    subject.stubs(save_without_autosave_children: true)
+
+    subject.child.expects(:save_if_changed)
+    subject.brother.expects(:save_if_changed).never
+
+    subject.save
+  end
+
+  it "doesn't auto-save children if we fail to save" do
+    subject = AutoSaveTest.new name: "Test abc"
+    subject.child = Child.new age: 5
+    subject.brother = Brother.new
+
+    subject.child.expects(:save_if_changed).never
+    subject.brother.expects(:save_if_changed).never
+
+    subject.save
+  end
+
+  it "auto-deletes children marked as auto-delete" do
+    subject = AutoSaveTest.new name: "Test"
+    subject.child = Child.new age: 5
+    subject.brother = Brother.new
+
+    subject.stubs(delete_without_autodelete_children: true)
+
+    subject.child.expects(:delete).never
+    subject.brother.expects(:delete)
+
+    subject.delete
+  end
+
+  it "deletes children when we're deleted" do
+    subject = MultipleChildTest.new
+    subject.brother = Brother.new
+    subject.brother.expects(:delete)
+    subject.sister = Sister.new
+    subject.sister.expects(:delete)
+
+    subject.stubs(delete: :deleted)
+
+    subject.delete_with_children.should eq(:deleted)
+  end
+
+  it "builds a new object properly" do
+    subject.id = "parent_test:123"
+    child = subject.build_child age: 6
+
+    child.should eq(subject.child)
+    child.age.should eq(6)
+    child.parent.should eq(subject)
+  end
+
+  describe "finding objects with children" do
+    subject { ParentTest }
+    let(:bucket) { stub }
+
+    before do
+      subject.stubs(bucket: bucket)
+    end
+
+    it "finds and returns the proper objects" do
+      bucket.expects(:get).with(
+        ["parent:1", "child:1"],
+        quiet: true,
+        extended: true
+      ).returns({
+        "parent:1" => [{name: "abc"}, 0, :cas],
+        "child:1" => [{age: 5}, 0, :cas]
+      })
+
+      parent = subject.find_with_children("parent:1")
+      parent.name.should eq("abc")
+      parent.child.age.should eq(5)
+    end
+
+    it "finds and returns all the proper objects" do
+      bucket.expects(:get).with(
+        ["parent:1", "parent:2", 'child:1', 'child:2'],
+        quiet: true,
+        extended: true
+      ).returns({
+        "parent:1" => [{name: "abc"}, 0, :cas],
+        "child:2" => [{age: 5}, 0, :cas],
+        "parent:2" => [{name: "def"}, 0, :cas],
+        "child:1" => [{age: 7}, 0, :cas]
+      })
+
+      objects = subject.find_all_with_children(["parent:1", "parent:2"])
+      objects.size.should eq(2)
+      
+      objects.first.id.should eq("parent:1")
+      objects.first.name.should eq("abc")
+      objects.first.child.id.should eq("child:1")
+      objects.first.child.age.should eq(7)
+
+      objects.last.id.should eq("parent:2")
+      objects.last.name.should eq('def')
+      objects.last.child.id.should eq("child:2")
+      objects.last.child.age.should eq(5)
+    end
+
+    it "only finds valid children" do
+      bucket.expects(:get).with(
+        ["parent:1"],
+        quiet: true,
+        extended: true
+      ).returns({
+        "parent:1" => [{name: "abc"}, 0, :cas],
+      })
+
+      subject.find_with_children "parent:1", :invalid
+    end
+
+    it "raises an error when the parent object isn't found" do
+      bucket.expects(:get).with(
+        ["parent:1", "child:1"],
+        quiet: true,
+        extended: true
+      ).returns({
+        "child:1" => [{age: 5}, 0, :cas]
+      })
+
+      expect { subject.find_with_children("parent:1") }.to raise_error(Couchbase::Error::NotFound)
+    end
+
+    it "marks all children as loaded even if they're not found" do
+      bucket.expects(:get).with(
+        ["parent:1", "child:1"],
+        quiet: true,
+        extended: true
+      ).returns({
+        "parent:1" => [{name: "abc"}, 0, :cas],
+      })
+
+      parent = subject.find_with_children("parent:1")
+      parent.should be_child_loaded
+      parent.child.should be_new
+    end
+
+    it "doesn't raise an error when the child object isn't found" do
+      bucket.expects(:get).with(
+        ["parent:1", "child:1"],
+        quiet: true,
+        extended: true
+      ).returns({
+        "parent:1" => [{name: "abc"}, 0, :cas],
+      })
+
+      parent = subject.find_with_children("parent:1")
+      parent.name.should eq("abc")
+    end
+  end
+end