mongo_doc_rails2 0.6.1

data/spec/associations/document_proxy_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..',  'spec_helper'))
+
+describe "MongoDoc::Associations::DocumentProxy" do
+  class Parent
+    include MongoDoc::Document
+  end
+
+  class Child
+    include MongoDoc::Document
+  end
+
+  let(:parent) { Parent.new }
+  let(:name) {'association_name'}
+
+  subject do
+    MongoDoc::Associations::DocumentProxy.new(:assoc_name => name, :root => parent, :parent => parent, :assoc_class => Child)
+  end
+
+  describe "#build" do
+    it "#build builds a new object" do
+      Child.should === subject.build({})
+    end
+  end
+
+  context "delegated to the document" do
+    %w(id to_bson).each do |method|
+      it "delegates #{method} to the document" do
+        subject.stub(:document => stub)
+        subject.document.should_receive(method)
+        subject.send(method)
+      end
+    end
+  end
+
+  %w(_modifier_path= _selector_path=).each do |setter|
+    describe "##{setter}" do
+      it "delegates to the document with our assoc name" do
+        subject.stub(:document => stub)
+        subject.document.should_receive(setter).with("new.path.#{name}")
+        MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
+        subject.send("#{setter}", 'new.path')
+      end
+    end
+  end
+end

data/spec/associations/hash_proxy_spec.rb

@@ -0,0 +1,181 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+
+describe MongoDoc::Associations::HashProxy do
+  class HashProxyTest
+    include MongoDoc::Document
+
+    attr_accessor :name
+  end
+
+  let(:name) { 'embed_hash_name' }
+  let(:root) { HashProxyTest.new }
+  let(:proxy) { MongoDoc::Associations::HashProxy.new(:assoc_name => name, :assoc_class => HashProxyTest, :root => root, :parent => root) }
+  let(:item) { HashProxyTest.new }
+  let(:other_item) {[1,2]}
+
+  %w(_modifier_path= _selector_path=).each do |setter|
+    describe "##{setter}" do
+      it "delegates to the document with our assoc name and the key" do
+        document = stub
+        proxy.stub(:hash).and_return(:key => document)
+        document.should_receive(setter).with("new.path.#{name}.key")
+        MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
+        proxy.send("#{setter}", 'new.path')
+      end
+    end
+  end
+
+  context "#[]=" do
+    it "adds the item to the hash" do
+      proxy['new'] = item
+      proxy['new'].should == item
+    end
+
+    context "key names must be a string or symbol constrained by BSON element name" do
+      ['$invalid', 'in.valid', :_id, 'query', 1, Object.new].each do |name|
+        it "#{name} is invalid" do
+          expect do
+            proxy[name] = other_item
+          end.to raise_error(MongoDoc::InvalidEmbeddedHashKey)
+        end
+      end
+
+      [:key, 'key'].each do |name|
+        it "#{name} is a valid name" do
+          expect do
+            proxy[name] = other_item
+          end.to_not raise_error(MongoDoc::InvalidEmbeddedHashKey)
+        end
+      end
+    end
+
+    context "when the item is not a MongoDoc::Document" do
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy['new'] = other_item
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy['new'] = other_item
+      end
+    end
+
+    context "when the item is a MongoDoc::Document" do
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy['new'] = item
+      end
+
+      it "sets the root" do
+        proxy['new'] = item
+        item._root.should == root
+      end
+
+      it "adds the item through a document proxy" do
+        proxy['new'] = item
+        MongoDoc::Associations::DocumentProxy.should === proxy['new']
+      end
+    end
+  end
+
+  context "#merge!" do
+    context "when the key value is not a MongoDoc::Document" do
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy.merge!(:new => other_item)
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy.merge!(:new => other_item)
+      end
+    end
+
+    context "when the key value is a MongoDoc::Document" do
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy.merge!(:new => item)
+      end
+
+      it "sets the root" do
+        proxy.merge!(:new => item)
+        item._root.should == root
+      end
+    end
+
+    context "with a block" do
+      it "calls into the block" do
+        proxy.merge!(:new => other_item) {|k, v1, v2| @result = v2}
+        @result.should == other_item
+      end
+
+      context "when the key value is not a MongoDoc::Document" do
+
+        it "does not register a save observer" do
+          root.should_not_receive(:register_save_observer)
+          proxy.merge!(:new => other_item) {|k, v1, v2| v2}
+        end
+
+        it "does not set the root" do
+          other_item.should_not_receive(:_root=)
+          proxy.merge!(:new => other_item) {|k, v1, v2| v2}
+        end
+      end
+
+      context "when the key value is a MongoDoc::Document" do
+        it "registers a save observer" do
+          root.should_receive(:register_save_observer)
+          proxy.merge!(:new => item) {|k, v1, v2| v2}
+        end
+
+        it "sets the root" do
+          proxy.merge!(:new => item) {|k, v1, v2| v2}
+          item._root.should == root
+        end
+      end
+    end
+  end
+
+  context "#replace" do
+    it "clears any existing data" do
+      proxy.should_receive(:clear)
+      proxy.replace(:new => other_item)
+    end
+
+    context "when the key value is not a MongoDoc::Document" do
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy.replace(:new => other_item)
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy.replace(:new => other_item)
+      end
+    end
+
+    context "when the key value is a MongoDoc::Document" do
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy.replace(:new => item)
+      end
+
+      it "sets the root" do
+        proxy.replace(:new => item)
+        item._root.should == root
+      end
+    end
+
+  end
+
+  context "#build" do
+    it "builds an object of the collection class from the hash attrs" do
+      name = 'built'
+      proxy.build(:key, {:name => name}).name.should == name
+    end
+  end
+end

data/spec/associations/proxy_base_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe "MongoDoc::Associations::ProxyBase" do
+  class ProxyBaseTest
+    include MongoDoc::Associations::ProxyBase
+  end
+
+  let(:_assoc_class) { 'ClassOfAssociation' }
+  let(:_assoc_name) { 'name_of_association' }
+  let(:_root) { 'root of document' }
+  let(:path) { 'root.parent' }
+
+  subject do
+    ProxyBaseTest.new({ :path => path, :assoc_class => _assoc_class, :assoc_name => _assoc_name, :root => _root })
+  end
+
+  %w(_assoc_class _assoc_name _modifier_path _root _selector_path).each do |attr|
+    it "defines #{attr}" do
+      should respond_to(attr)
+    end
+  end
+
+  describe "#initialize" do
+    %w(_assoc_class _assoc_name _root).each do |attr|
+      its(attr) { should == send(attr) }
+    end
+  end
+
+  describe "#_modifier_path" do
+    its(:_modifier_path) { should == path + '.' + _assoc_name }
+  end
+
+  describe "#_modifier_path=" do
+    it "sets the modifier path to the path + '.' + the assoc name" do
+      subject._modifier_path = 'new_path'
+      subject._modifier_path.should == "new_path.#{_assoc_name}"
+    end
+  end
+
+  describe "#_selector_path" do
+    its(:_selector_path) { should == path + '.' + _assoc_name }
+  end
+
+  describe "#_selector_path=" do
+    it "sets the selector path to the path + '.' + the assoc name" do
+      subject._selector_path = 'new_path'
+      subject._selector_path.should == "new_path.#{_assoc_name}"
+    end
+  end
+
+  describe ".is_document" do
+    class TestIsDocument
+      include MongoDoc::Document
+    end
+
+    it "returns false for any non-Document" do
+      MongoDoc::Associations::ProxyBase.is_document?(Object.new).should be_false
+    end
+
+    it "returns true for any Document" do
+      MongoDoc::Associations::ProxyBase.is_document?(TestIsDocument.new).should be_true
+    end
+  end
+
+  describe "#attach" do
+    class AttachDocument
+      include MongoDoc::Document
+    end
+
+    let(:doc) { AttachDocument.new }
+    let(:object) { Object.new }
+    let(:proxy) { ProxyBaseTest.new(:assoc_class => _assoc_class, :assoc_name => _assoc_name, :root => _root) }
+
+    it "returns the attached object" do
+      proxy.send(:attach, object).should == object
+    end
+
+    context "when a Document" do
+      it "attaches the Document" do
+        proxy.should_receive(:attach_document)
+        proxy.send(:attach, doc)
+      end
+    end
+
+    context "when not a Document" do
+      it "does not attach the Document" do
+        proxy.should_not_receive(:attach_document)
+        proxy.send(:attach, object)
+      end
+    end
+  end
+end

data/spec/associations_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe "MongoDoc::Associations" do
+
+  context ".embed" do
+    class TestDoc
+      include MongoDoc::Document
+
+      embed :sub_doc
+    end
+
+    class SubDoc
+      include MongoDoc::Document
+
+      attr_accessor :data
+    end
+
+    class TestHasOne
+      include MongoDoc::Document
+
+      has_one :sub_doc
+    end
+
+    let(:subdoc) { SubDoc.new }
+    let(:doc) { TestDoc.new(:sub_doc => subdoc) }
+
+    it "uses a proxy" do
+      MongoDoc::Associations::DocumentProxy.should === doc.sub_doc
+    end
+
+    it ".has_one is an alias for embed" do
+      MongoDoc::Associations::DocumentProxy.should === TestHasOne.new(:sub_doc => SubDoc.new).sub_doc
+    end
+
+    it "set the subdocuments root" do
+      doc.should == subdoc._root
+    end
+
+    context "validations" do
+      class EmbedValidationTest
+        include MongoDoc::Document
+
+        attr_accessor :data
+        validates_presence_of :data
+      end
+
+      it "cascades validations down" do
+        invalid = EmbedValidationTest.new
+        TestDoc.new(:sub_doc => invalid).should have(1).error_on(:sub_doc)
+      end
+    end
+  end
+
+  context ".embed_many" do
+
+    class SubEmbedManyDoc
+      include MongoDoc::Document
+
+      attr_accessor :data
+    end
+
+    class TestEmbedManyDoc
+      include MongoDoc::Document
+
+      embed_many :sub_docs, :class_name => 'SubEmbedManyDoc'
+    end
+
+    class TestEmbedManyDoc2
+      include MongoDoc::Document
+
+      embed_many :sub_docs, :class_name => :sub_embed_many_doc
+    end
+
+    class TestImplicitEmbedManyDoc
+      include MongoDoc::Document
+
+      embed_many :sub_embed_many_docs
+    end
+
+    class TestHasManyDoc
+      include MongoDoc::Document
+
+      has_many :sub_docs, :class_name => 'SubEmbedManyDoc'
+    end
+
+    let(:subdoc) { SubEmbedManyDoc.new }
+    let(:doc) { TestEmbedManyDoc.new(:sub_docs => [subdoc]) }
+
+    it "uses a proxy" do
+      MongoDoc::Associations::CollectionProxy.should === TestEmbedManyDoc.new.sub_docs
+    end
+
+    it ".has_many is an alias for .embed_many" do
+      MongoDoc::Associations::CollectionProxy.should === TestHasManyDoc.new.sub_docs
+    end
+
+    it "set the subdocuments root to the root" do
+      doc.should == subdoc._root
+    end
+
+    it "uses the association name to find the children's class name" do
+      TestImplicitEmbedManyDoc.new.sub_embed_many_docs._assoc_class.should == SubEmbedManyDoc
+    end
+
+    it "uses class_name attribute for the children's class name" do
+      TestEmbedManyDoc.new.sub_docs._assoc_class.should == SubEmbedManyDoc
+    end
+
+    it "uses class_name attribute for the children's class name" do
+      TestEmbedManyDoc2.new.sub_docs._assoc_class.should == SubEmbedManyDoc
+    end
+
+    context "validations" do
+      class EmbedManyValidationChild
+        include MongoDoc::Document
+
+        attr_accessor :data
+        validates_presence_of :data
+      end
+
+      class EmbedManyValidationTest
+        include MongoDoc::Document
+
+        embed_many :subdocs, :class_name => 'HasManyValidationChild'
+      end
+
+      let(:invalid_child) { EmbedManyValidationChild.new }
+      let(:doc) { EmbedManyValidationTest.new(:subdocs => [invalid_child]) }
+
+      it "cascades validations and marks it in the parent" do
+        doc.should have(1).error_on(:subdocs)
+      end
+
+      it "cascades validations and marks it in the child" do
+        invalid_child.should have(1).error_on(:data)
+      end
+
+      it "ignores non-document children" do
+        EmbedManyValidationTest.new(:subdocs => ['not a doc']).should be_valid
+      end
+    end
+  end
+
+  context ".embed_hash" do
+    class SubEmbedHashDoc
+      include MongoDoc::Document
+
+      attr_accessor :data
+    end
+
+    class TestEmbedHashDoc
+      include MongoDoc::Document
+
+      embed_hash :sub_docs, :class_name => 'SubEmbedHashDoc'
+    end
+
+    class TestImplicitEmbedHashDoc
+      include MongoDoc::Document
+
+      embed_hash :sub_embed_hash_docs
+    end
+
+    class TestHasHashDoc
+      include MongoDoc::Document
+
+      has_hash :sub_embed_hash_docs
+    end
+
+    let(:subdoc) { SubEmbedHashDoc.new }
+    let(:doc) { TestEmbedHashDoc.new(:sub_docs => {:key => subdoc}) }
+
+    it "uses a proxy" do
+      MongoDoc::Associations::HashProxy.should === TestEmbedHashDoc.new.sub_docs
+    end
+
+    it ".has_hash is an alias for embed_hash" do
+      MongoDoc::Associations::HashProxy.should === TestEmbedHashDoc.new.sub_docs
+    end
+
+    it "set the subdocuments root to the root" do
+      doc.should == subdoc._root
+    end
+
+    it "uses the association name to find the children's class name" do
+      TestImplicitEmbedHashDoc.new.sub_embed_hash_docs._assoc_class.should == SubEmbedHashDoc
+    end
+
+    context "validations" do
+      class EmbedHashValidationChild
+        include MongoDoc::Document
+
+        attr_accessor :data
+        validates_presence_of :data
+      end
+
+      class EmbedHashValidationTest
+        include MongoDoc::Document
+
+        embed_hash :subdocs, :class_name => 'EmbedHashValidationChild'
+      end
+
+      let(:invalid_child) { EmbedHashValidationChild.new }
+      let(:doc) { EmbedHashValidationTest.new(:subdocs => {:key => invalid_child}) }
+
+      it "cascades validations and marks it in the parent" do
+        doc.should have(1).error_on(:subdocs)
+      end
+
+      it "cascades validations and marks it in the child" do
+        invalid_child.should have(1).error_on(:data)
+      end
+
+      it "ignores non-document children" do
+        EmbedHashValidationTest.new(:subdocs => {:key => 'data'}).should be_valid
+      end
+    end
+  end
+end