mongo_doc 0.3.0

data/spec/associations/document_proxy_spec.rb

@@ -0,0 +1,42 @@
+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'}
+
+  subject do
+    MongoDoc::Associations::DocumentProxy.new(:assoc_name => name, :root => parent, :parent => parent, :assoc_class => Child)
+  end
+
+  it "has the association name" do
+    subject.assoc_name.should == name
+  end
+
+  it "has the parent" do
+    subject._parent.should == parent
+  end
+
+  it "has the root" do
+    subject._root.should == parent
+  end
+
+  it "has the association class" do
+    subject.assoc_class.should == Child
+  end
+
+  it "inserts the association name the _path_to_root" do
+    subject._path_to_root(Child.new, :name1 => 'value1', :name2 => 'value2').should == {"#{name}.name1" => 'value1', "#{name}.name2" => "value2"}
+  end
+
+  it "#build builds a new object" do
+    Child.should === subject.build({})
+  end
+end

data/spec/associations/hash_proxy_spec.rb

@@ -0,0 +1,163 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+
+describe MongoDoc::Associations::HashProxy do
+  class HashProxyTest
+    include MongoDoc::Document
+
+    key :name
+  end
+
+  let(:root) { stub('root', :register_save_observer => nil) }
+  let(:proxy) { MongoDoc::Associations::HashProxy.new(:assoc_name => 'has_many_name', :assoc_class => HashProxyTest, :root => root, :parent => root) }
+  let(:item) { HashProxyTest.new }
+  let(:other_item) {[1,2]}
+
+  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
+    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/attributes_spec.rb

@@ -0,0 +1,273 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MongoDoc::Attributes" do
+  class AttributesTest
+    include MongoDoc::Attributes
+  end
+
+  it "defines _id attribute" do
+    AttributesTest.new.should respond_to(:_id)
+    AttributesTest.new.should respond_to(:_id=)
+  end
+
+  context ".key" do
+    class TestKeys
+      include MongoDoc::Document
+    end
+
+    it "adds its arguments to _keys" do
+      TestKeys.key :attr1, :attr2
+      TestKeys._keys.should == [:attr1, :attr2]
+    end
+
+    describe "accessors" do
+      before do
+        TestKeys.key :attr1
+      end
+
+      subject do
+        TestKeys.new
+      end
+      it "has an attr1 reader" do
+        should respond_to(:attr1)
+      end
+
+      it "has an attr1 writer" do
+        should respond_to(:attr1=)
+      end
+    end
+
+    describe "used with inheritance" do
+      class TestParent
+        include MongoDoc::Document
+
+        key :parent_attr
+      end
+
+      class TestChild < TestParent
+        key :child_attr
+      end
+
+      it "has its own keys" do
+        TestChild._keys.should include(:child_attr)
+      end
+
+      it "has the keys from the parent class" do
+        TestChild._keys.should include(*TestParent._keys)
+      end
+
+      it "does not add keys to the parent class" do
+        TestParent._keys.should_not include(:child_attr)
+      end
+    end
+  end
+
+  context ".has_one" do
+    class TestDoc
+      include MongoDoc::Document
+
+      has_one :sub_doc
+    end
+
+    class SubDoc
+      include MongoDoc::Document
+
+      key :data
+    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 "sets the subdocuments parent to the proxy" do
+      doc.sub_doc.should == subdoc._parent
+    end
+
+    it "set the subdocuments root" do
+      doc.should == subdoc._root
+    end
+
+    context "validations" do
+      class HasOneValidationTest
+        include MongoDoc::Document
+
+        key :data
+        validates_presence_of :data
+      end
+
+      it "cascades validations down" do
+        invalid = HasOneValidationTest.new
+        TestDoc.new(:sub_doc => invalid).should have(1).error_on(:sub_doc)
+      end
+    end
+  end
+
+  context "._attributes" do
+    class TestHasOneDoc
+      include MongoDoc::Document
+
+      key :key
+      has_one :has_one
+    end
+
+    it "is _keys + _associations" do
+      TestHasOneDoc._attributes.should == TestHasOneDoc._keys + TestHasOneDoc._associations
+    end
+  end
+
+  context ".has_many" do
+
+    class SubHasManyDoc
+      include MongoDoc::Document
+
+      key :data
+    end
+
+    class TestHasManyDoc
+      include MongoDoc::Document
+
+      has_many :sub_docs, :class_name => 'SubHasManyDoc'
+    end
+
+    class TestHasManyDoc2
+      include MongoDoc::Document
+
+      has_many :sub_docs, :class_name => :sub_has_many_doc
+    end
+
+    class TestImplicitHasManyDoc
+      include MongoDoc::Document
+
+      has_many :sub_has_many_docs
+    end
+
+    let(:subdoc) { SubHasManyDoc.new }
+    let(:doc) { TestHasManyDoc.new(:sub_docs => [subdoc]) }
+
+    it "uses a proxy" do
+      MongoDoc::Associations::CollectionProxy.should === TestHasManyDoc.new.sub_docs
+    end
+
+    it "sets the subdocuments parent to the proxy" do
+      doc.sub_docs.should == subdoc._parent
+    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
+      TestImplicitHasManyDoc.new.sub_has_many_docs.assoc_class.should == SubHasManyDoc
+    end
+
+    it "uses class_name attribute for the children's class name" do
+      TestHasManyDoc.new.sub_docs.assoc_class.should == SubHasManyDoc
+    end
+
+    it "uses class_name attribute for the children's class name" do
+      TestHasManyDoc2.new.sub_docs.assoc_class.should == SubHasManyDoc
+    end
+
+    context "validations" do
+      class HasManyValidationChild
+        include MongoDoc::Document
+
+        key :data
+        validates_presence_of :data
+      end
+
+      class HasManyValidationTest
+        include MongoDoc::Document
+
+        has_many :subdocs, :class_name => 'HasManyValidationChild'
+      end
+
+      let(:invalid_child) { HasManyValidationChild.new }
+      let(:doc) { HasManyValidationTest.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
+        HasManyValidationTest.new(:subdocs => ['not a doc']).should be_valid
+      end
+    end
+  end
+
+  context ".has_hash" do
+    class SubHasHashDoc
+      include MongoDoc::Document
+
+      key :data
+    end
+
+    class TestHasHashDoc
+      include MongoDoc::Document
+
+      has_hash :sub_docs, :class_name => 'SubHasHashDoc'
+    end
+
+    class TestImplicitHasHashDoc
+      include MongoDoc::Document
+
+      has_hash :sub_has_hash_docs
+    end
+
+    let(:subdoc) { SubHasHashDoc.new }
+    let(:doc) { TestHasHashDoc.new(:sub_docs => {:key => subdoc}) }
+
+    it "uses a proxy" do
+      MongoDoc::Associations::HashProxy.should === TestHasHashDoc.new.sub_docs
+    end
+
+    it "sets the subdocuments parent to the proxy" do
+      doc.sub_docs.should == subdoc._parent
+    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
+      TestImplicitHasHashDoc.new.sub_has_hash_docs.assoc_class.should == SubHasHashDoc
+    end
+
+    context "validations" do
+      class HasHashValidationChild
+        include MongoDoc::Document
+
+        key :data
+        validates_presence_of :data
+      end
+
+      class HasHashValidationTest
+        include MongoDoc::Document
+
+        has_hash :subdocs, :class_name => 'HasHashValidationChild'
+      end
+
+      let(:invalid_child) { HasHashValidationChild.new }
+      let(:doc) { HasHashValidationTest.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
+        HasHashValidationTest.new(:subdocs => {:key => 'data'}).should be_valid
+      end
+    end
+  end
+end

data/spec/bson_matchers.rb

@@ -0,0 +1,54 @@
+module BsonMatchers
+  class BeBsonEql
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(target)
+      @target = target
+      @target == @expected
+    end
+
+    def failure_message
+      "expected\...#{@target.inspect}\n" +
+      "to be BSON code equivalent to\...#{@expected.inspect}\n" +
+      "Difference:\...#{@expected.diff(@target).inspect}"
+    end
+
+    def negative_failure_message
+      "expected\...#{@target.inspect}\n" +
+      "to be BSON code different from\...#{@expected.inspect}"
+    end
+  end
+
+  class BeMongoEql
+    def initialize(expected, include_id)
+      @include_id = include_id
+      @expected = include_id ? expected : expected.except('_id')
+    end
+
+    def matches?(target)
+      @target = @include_id ? target : target.except('_id')
+      @target == @expected
+    end
+
+    def failure_message
+      "expected\...#{@target.inspect}\n" +
+      "to be BSON code equivalent to\...#{@expected.inspect}\n" +
+      "Difference:\...#{@expected.diff(@target).inspect}"
+    end
+
+    def negative_failure_message
+      "expected\...#{@target.inspect}\n" +
+      "to be BSON code different from\...#{@expected.inspect}"
+    end
+  end
+
+  def be_bson_eql(expected)
+    BeBsonEql.new(expected)
+  end
+
+  def be_mongo_eql(expected, include_id = true)
+    BeMongoEql.new(expected, include_id)
+  end
+end