mongodoc 0.2.1 → 0.2.2

data/spec/criteria_spec.rb

@@ -121,6 +121,7 @@ describe MongoDoc::Criteria do
 
       before do
         @count = 27
+        @collection = mock
         @cursor = stub('cursor', :count => @count)
         Person.stub(:collection).and_return(@collection)
       end
@@ -339,9 +340,9 @@ describe MongoDoc::Criteria do
       @criteria.selector.should == { :_id => id }
     end
 
-    it "adds the string as the _id query to the selector" do
-      id = Mongo::ObjectID.new.to_s
-      @criteria.id(id)
+    it "when a string adds ObjectID as the _id query to the selector" do
+      id = Mongo::ObjectID.new
+      @criteria.id(id.to_s)
       @criteria.selector.should == { :_id => id }
     end
 

data/spec/cursor_spec.rb

@@ -1,85 +1,91 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "MongoDoc::Cursor" do
-  before do
-    @mongo_cursor = stub('cursor')
-    @cursor = MongoDoc::Cursor.new(@mongo_cursor)
-  end
+  let(:mongo_cursor) { stub('cursor') }
+
+  let(:collection) { stub('collection') }
+
+  let(:cursor) { MongoDoc::Cursor.new(collection, mongo_cursor) }
 
   it "is Enumerable" do
-    Enumerable.should === @cursor
+    Enumerable.should === cursor
   end
 
   it ".new wraps a Mongo::Cursor" do
-    @cursor._cursor.should == @mongo_cursor
+    cursor._cursor.should == mongo_cursor
+  end
+
+  it "#collection returns the MongoDoc::Collection for this cursor" do
+    cursor.collection.should == collection
+    cursor._collection.should == collection
   end
 
   context "with the underlying cursor" do
-    %w(close closed? count explain limit query_options_hash query_opts skip sort).each do |delegated_method|
+    %w(admin close closed? count explain fields full_collection_name hint limit order query_options_hash query_opts selector skip snapshot sort timeout).each do |delegated_method|
       it "delegates #{delegated_method} to the Mongo::Cursor" do
-        @mongo_cursor.should_receive(delegated_method)
-        @cursor.send(delegated_method)
+        mongo_cursor.should_receive(delegated_method)
+        cursor.send(delegated_method)
       end
     end
   end
 
   context "#each" do
     it "delegates to the cursor" do
-      @mongo_cursor.should_receive(:each)
-      @cursor.each
+      mongo_cursor.should_receive(:each)
+      cursor.each
     end
 
     it "decodes the return from the delegate" do
       bson = stub('bson')
-      @cursor.stub(:_cursor).and_return([bson])
+      cursor.stub(:_cursor).and_return([bson])
       MongoDoc::BSON.should_receive(:decode).with(bson)
-      @cursor.each {}
+      cursor.each {}
     end
 
     it "calls the block with the decoded return" do
       result = stub('bson')
-      @cursor.stub(:_cursor).and_return([result])
+      cursor.stub(:_cursor).and_return([result])
       MongoDoc::BSON.stub(:decode).and_return(result)
-      @cursor.each {|obj| @obj = obj}
+      cursor.each {|obj| @obj = obj}
       @obj.should == result
     end
   end
 
   context "#next_document" do
     it "delegates to the cursor" do
-      @mongo_cursor.should_receive(:next_document)
-      @cursor.next_document
+      mongo_cursor.should_receive(:next_document)
+      cursor.next_document
     end
 
     it "decodes the return from the delegate" do
       bson = stub('bson')
-      @mongo_cursor.stub(:next_document).and_return(bson)
+      mongo_cursor.stub(:next_document).and_return(bson)
       MongoDoc::BSON.should_receive(:decode).with(bson)
-      @cursor.next_document
+      cursor.next_document
     end
 
     it "returns nil if the delegate returns nil" do
-      @mongo_cursor.stub(:next_document)
-      @cursor.next_document.should be_nil
+      mongo_cursor.stub(:next_document)
+      cursor.next_document.should be_nil
     end
   end
 
   context "#to_a" do
     it "delegates to the cursor" do
-      @mongo_cursor.should_receive(:to_a)
-      @cursor.to_a
+      mongo_cursor.should_receive(:to_a)
+      cursor.to_a
     end
 
     it "decodes the return from the delegate" do
       array = stub('array')
-      @mongo_cursor.stub(:to_a).and_return(array)
+      mongo_cursor.stub(:to_a).and_return(array)
       MongoDoc::BSON.should_receive(:decode).with(array)
-      @cursor.to_a
+      cursor.to_a
     end
 
     it "returns [] if the delegate returns []" do
-      @mongo_cursor.stub(:to_a).and_return([])
-      @cursor.to_a.should == []
+      mongo_cursor.stub(:to_a).and_return([])
+      cursor.to_a.should == []
     end
   end
 end

data/spec/document_spec.rb

@@ -18,8 +18,8 @@ describe "MongoDoc::Document" do
       @doc.id.should == @doc._id
     end
 
-    it "#to_param returns the _id" do
-      @doc.to_param.should == @doc._id
+    it "#to_param returns the string of the _id" do
+      @doc.to_param.should == @doc._id.to_s
     end
 
     context "#new_record?" do
@@ -219,109 +219,64 @@ describe "MongoDoc::Document" do
       validates_presence_of :data
     end
 
+    let(:data) { 'data' }
+    let(:instance) { CreateTest.new(:data => data) }
+
     before do
-      @value = 'value'
-      CreateTest.stub(:_create).and_return(true)
+      instance.stub(:save)
+      instance.stub(:save!)
     end
 
     context ".create" do
-      it "creates a new document" do
-        obj = CreateTest.new
-        CreateTest.should_receive(:new).and_return(obj)
-        CreateTest.create
-      end
-
-      it "delegates to _create with safe => false" do
-        obj = CreateTest.new(:data => @value)
-        CreateTest.stub(:new).and_return(obj)
-        CreateTest.should_receive(:_create).with(obj, false).and_return(true)
-        CreateTest.create(:data => @value)
-      end
-
-      it "sets the passed attributes" do
-        CreateTest.create(:data => @value).data.should == @value
+      it "creates a new document with the attributes" do
+        CreateTest.should_receive(:new).with(:data => data).and_return(instance)
+        CreateTest.create(:data => data)
       end
 
-      it "returns a valid document" do
-        CreateTest.should === CreateTest.create(:data => @value)
-      end
+      context "with the new document" do
+        before do
+          CreateTest.stub(:new).and_return(instance)
+        end
 
-      it "validates" do
-        CreateTest.create.errors.should_not be_empty
-      end
+        it "calls save on the instance with safe => false" do
+          instance.should_receive(:save).with(false)
+          CreateTest.create(:data => data)
+        end
 
-      it "returns an invalid document" do
-        CreateTest.should === CreateTest.create
+        it "returns the new object" do
+          CreateTest.create(:data => data).should == instance
+        end
       end
     end
 
     context ".create!" do
-      it "creates a new document" do
-        obj = CreateTest.new
-        CreateTest.should_receive(:new).and_return(obj)
-        CreateTest.create! rescue nil
+      it "creates a new document with the attributes" do
+        CreateTest.should_receive(:new).with(:data => data).and_return(instance)
+        CreateTest.create!(:data => data)
       end
 
-      it "delegates to _create with safe => true" do
-        obj = CreateTest.new(:data => @value)
-        CreateTest.stub(:new).and_return(obj)
-        CreateTest.should_receive(:_create).with(obj, true).and_return(true)
-        CreateTest.create!(:data => @value)
-      end
-
-      it "sets the passed attributes" do
-        CreateTest.create!(:data => @value).data.should == @value
-      end
+      context "with the new document" do
+        before do
+          CreateTest.stub(:new).and_return(instance)
+        end
 
-      it "returns a valid document" do
-        CreateTest.should === CreateTest.create!(:data => @value)
-      end
+        it "calls save! on the instance" do
+          instance.should_receive(:save!)
+          CreateTest.create!(:data => data)
+        end
 
-      it "raises when invalid" do
-        expect do
-          CreateTest.create!
-        end.should raise_error(MongoDoc::DocumentInvalidError)
+        it "returns the new object" do
+          CreateTest.create!(:data => data).should == instance
+        end
       end
     end
   end
 
-  context "#_create" do
-    class CreateTest
-      include MongoDoc::Document
-    end
-
-    before do
-      @collection = stub('collection')
-      @collection.stub(:insert)
-      @doc = CreateTest.new
-      CreateTest.stub(:collection).and_return(@collection)
-    end
-
-    it "delegates to the collection insert with safe" do
-      safe = true
-      @collection.should_receive(:insert).with(@doc, hash_including(:safe => safe))
-      CreateTest.send(:_create, @doc, safe)
-    end
-
-    it "sets the _id of the document" do
-      id = 'id'
-      @collection.stub(:insert).and_return(id)
-      CreateTest.send(:_create, @doc, false)
-      @doc._id.should == id
-    end
-
-    it "returns the _id" do
-      id = 'id'
-      @collection.stub(:insert).and_return(id)
-      CreateTest.send(:_create, @doc, false).should == id
-    end
-  end
-
   context "updating attributes" do
     class UpdateAttributesRoot
       include MongoDoc::Document
 
-      has_one :update_attribute_child
+      has_one :update_attributes_child
     end
 
     class UpdateAttributesChild
@@ -330,104 +285,127 @@ describe "MongoDoc::Document" do
       key :data
     end
 
+    let(:data) {'data'}
+
+    let(:attrs) {{:data => data}}
+
+    let(:path_attrs) {{'update_attributes_child.data' => data}}
+
+    let(:doc) do
+      doc = UpdateAttributesChild.new
+      doc._id = 'id'
+      doc.stub(:_naive_update_attributes)
+      doc
+    end
+
     before do
-      @data = 'data'
-      @doc = UpdateAttributesChild.new
-      UpdateAttributesRoot.new.update_attribute_child = @doc
-      @attrs = {:data => @data}
-      @path_attrs = {'update_attribute_child.data' => @data}
-      @doc.stub(:_naive_update_attributes)
+      root = UpdateAttributesRoot.new
+      root.update_attributes_child = doc
+      root._id = 'id'
     end
 
     context "#update_attributes" do
+      it "delegates to save if the object is a new record" do
+        check = 'check'
+        doc.stub(:new_record?).and_return(true)
+        doc.should_receive(:save).and_return(check)
+        doc.update_attributes(attrs).should == check
+      end
 
       it "sets the attributes" do
-        @doc.update_attributes(@attrs)
-        @doc.data.should == @data
+        doc.update_attributes(attrs)
+        doc.data.should == data
       end
 
       it "normalizes the attributes to the parent" do
-        @doc.should_receive(:_path_to_root)
-        @doc.update_attributes(@attrs)
+        doc.should_receive(:_path_to_root)
+        doc.update_attributes(attrs)
       end
 
       it "validates" do
-        @doc.should_receive(:valid?)
-        @doc.update_attributes(@attrs)
+        doc.should_receive(:valid?)
+        doc.update_attributes(attrs)
       end
 
       it "returns false if the object is not valid" do
-        @doc.stub(:valid?).and_return(false)
-        @doc.update_attributes(@attrs).should be_false
+        doc.stub(:valid?).and_return(false)
+        doc.update_attributes(attrs).should be_false
       end
 
       context "if valid" do
         context "and strict" do
           it "delegates to _strict_update_attributes" do
-            strict_attrs = @attrs.merge(:__strict__ => true)
-            @doc.should_receive(:_strict_update_attributes).with(@path_attrs, false)
-            @doc.update_attributes(strict_attrs)
+            strict_attrs = attrs.merge(:__strict__ => true)
+            doc.should_receive(:_strict_update_attributes).with(path_attrs, false)
+            doc.update_attributes(strict_attrs)
           end
         end
 
         context "and naive" do
           it "delegates to _naive_update_attributes" do
-            @doc.should_receive(:_naive_update_attributes).with(@path_attrs, false)
-            @doc.update_attributes(@attrs)
+            doc.should_receive(:_naive_update_attributes).with(path_attrs, false)
+            doc.update_attributes(attrs)
           end
         end
 
         it "returns the result of _naive_update_attributes" do
           result = 'check'
-          @doc.stub(:_naive_update_attributes).and_return(result)
-          @doc.update_attributes(@attrs).should == result
+          doc.stub(:_naive_update_attributes).and_return(result)
+          doc.update_attributes(attrs).should == result
         end
       end
     end
 
     context "#update_attributes!" do
+      it "delegates to save! if the object is a new record" do
+        check = 'check'
+        doc.stub(:new_record?).and_return(true)
+        doc.should_receive(:save!).and_return(check)
+        doc.update_attributes!(attrs).should == check
+      end
+
       it "sets the attributes" do
-        @doc.update_attributes!(@attrs)
-        @doc.data.should == @data
+        doc.update_attributes!(attrs)
+        doc.data.should == data
       end
 
       it "normalizes the attributes to the parent" do
-        @doc.should_receive(:_path_to_root)
-        @doc.update_attributes!(@attrs)
+        doc.should_receive(:_path_to_root)
+        doc.update_attributes!(attrs)
       end
 
       it "validates" do
-        @doc.should_receive(:valid?).and_return(true)
-        @doc.update_attributes!(@attrs)
+        doc.should_receive(:valid?).and_return(true)
+        doc.update_attributes!(attrs)
       end
 
       it "raises if not valid" do
-        @doc.stub(:valid?).and_return(false)
+        doc.stub(:valid?).and_return(false)
         expect do
-          @doc.update_attributes!(@attrs)
+          doc.update_attributes!(attrs)
         end.should raise_error(MongoDoc::DocumentInvalidError)
       end
 
       context "if valid" do
         context "and strict" do
           it "delegates to _strict_update_attributes with safe == true" do
-            strict_attrs = @attrs.merge(:__strict__ => true)
-            @doc.should_receive(:_strict_update_attributes).with(@path_attrs, true)
-            @doc.update_attributes!(strict_attrs)
+            strict_attrs = attrs.merge(:__strict__ => true)
+            doc.should_receive(:_strict_update_attributes).with(path_attrs, true)
+            doc.update_attributes!(strict_attrs)
           end
         end
 
         context "and naive" do
           it "delegates to _naive_update_attributes with safe == true" do
-            @doc.should_receive(:_naive_update_attributes).with(@path_attrs, true)
-            @doc.update_attributes!(@attrs)
+            doc.should_receive(:_naive_update_attributes).with(path_attrs, true)
+            doc.update_attributes!(attrs)
           end
         end
 
         it "returns the result of _naive_update_attributes" do
           result = 'check'
-          @doc.stub(:_naive_update_attributes).and_return(result)
-          @doc.update_attributes!(@attrs).should == result
+          doc.stub(:_naive_update_attributes).and_return(result)
+          doc.update_attributes!(attrs).should == result
         end
       end
     end
@@ -438,27 +416,29 @@ describe "MongoDoc::Document" do
       include MongoDoc::Document
     end
 
-    before do
-      @id = 'id'
-      @attrs = {:data => 'data'}
-      @safe = false
-      @doc = NaiveUpdateAttributes.new
-      @doc.stub(:_id).and_return(@id)
-      @collection = stub('collection')
-      @collection.stub(:update)
-      @doc.stub(:_collection).and_return(@collection)
+
+    let(:id) { 'id' }
+
+    let(:attrs) { {:data => 'data'} }
+
+    let(:safe) { false }
+
+    let(:doc) do
+      doc = NaiveUpdateAttributes.new
+      doc.stub(:_id).and_return(id)
+      doc
     end
 
-    it "calls update on the collection without a root" do
-      @collection.should_receive(:update).with({'_id' => @id}, MongoDoc::Query.set_modifier(@attrs), {:safe => @safe})
-      @doc.send(:_naive_update_attributes, @attrs, @safe)
+    it "without a root delegates to _update" do
+      doc.should_receive(:_update).with({}, attrs, safe)
+      doc.send(:_naive_update_attributes, attrs, safe)
     end
 
     it "with a root, calls _naive_update_attributes on the root" do
       root = NaiveUpdateAttributes.new
-      @doc.stub(:_root).and_return(root)
-      root.should_receive(:_naive_update_attributes).with(@attrs, @safe)
-      @doc.send(:_naive_update_attributes, @attrs, @safe)
+      doc.stub(:_root).and_return(root)
+      root.should_receive(:_naive_update_attributes).with(attrs, safe)
+      doc.send(:_naive_update_attributes, attrs, safe)
     end
   end
 
@@ -467,41 +447,45 @@ describe "MongoDoc::Document" do
       include MongoDoc::Document
     end
 
-    before do
-      @id = 'id'
-      @attrs = {:data => 'data'}
-      @selector = {'selector' => 'selector'}
-      @safe = false
-      @doc = StrictUpdateAttributes.new
-      @doc.stub(:_id).and_return(@id)
-      @collection = stub('collection')
-      @collection.stub(:update)
-      @doc.stub(:_collection).and_return(@collection)
+    let(:id) { 'id' }
+
+    let(:attrs) { {:data => 'data'} }
+
+    let(:selector) { {:selector => 'selector'} }
+
+    let(:safe) { false }
+
+    let(:doc) do
+      doc = StrictUpdateAttributes.new
+      doc.stub(:_id).and_return(id)
+      doc
     end
 
     context "without a root" do
-      it "calls update on the collection" do
-        @collection.should_receive(:update).with({'_id' => @id}.merge(@selector), MongoDoc::Query.set_modifier(@attrs), :safe => @safe)
-        @doc.send(:_strict_update_attributes, @attrs, @safe, @selector)
+      it "without a root delegates to _update" do
+        doc.should_receive(:_update).with(selector, attrs, safe)
+        doc.send(:_strict_update_attributes, attrs, safe, selector)
       end
     end
 
     context "with a root" do
+      let(:root) { StrictUpdateAttributes.new }
+
       before do
-        @root = StrictUpdateAttributes.new
-        @root.stub(:_collection).and_return(@collection)
-        @doc.stub(:_root).and_return(@root)
-        @doc.stub(:_selector_path_to_root).and_return({'path._id' => @id})
+        doc.stub(:_root).and_return(root)
       end
 
-      it "calls _selector_path_to_root on our id" do
-        @doc.should_receive(:_selector_path_to_root).with('_id' => @id).and_return({'path._id' => @id})
-        @doc.send(:_strict_update_attributes, @attrs, @safe)
+      it "calls _path_to_root on our id" do
+        root.stub(:_strict_update_attributes)
+        doc.should_receive(:_path_to_root).with(doc, '_id' => id)
+        doc.send(:_strict_update_attributes, attrs, safe)
       end
 
       it "calls _strict_update_attributes on the root with our selector" do
-        @root.should_receive(:_strict_update_attributes).with(@attrs, @safe, 'path._id' => @id)
-        @doc.send(:_strict_update_attributes, @attrs, @safe)
+        selector = {'path._id' => id}
+        doc.stub(:_path_to_root).with(doc, '_id' => id).and_return(selector)
+        root.should_receive(:_strict_update_attributes).with(attrs, safe, selector)
+        doc.send(:_strict_update_attributes, attrs, safe)
       end
     end
   end
@@ -622,12 +606,45 @@ describe "MongoDoc::Document" do
 
         it "roundtrips the proxy" do
           doc = TestHasManyBsonDoc.new(:subdoc => SubHasManyBsonDoc.new(:attr => "value"))
-          MongoDoc::Proxy.should === MongoDoc::BSON.decode(doc.to_bson).subdoc
+          MongoDoc::Associations::CollectionProxy.should === MongoDoc::BSON.decode(doc.to_bson).subdoc
         end
       end
     end
   end
 
+  context "removing documents" do
+    class RemoveDocument
+      include MongoDoc::Document
+    end
+
+    let(:doc) { RemoveDocument.new }
+
+    context "#remove" do
+      it "when called on a embedded document with a _root raises UnsupportedOperation" do
+        doc._root = RemoveDocument.new
+        expect { doc.remove }.to raise_error(MongoDoc::UnsupportedOperation)
+      end
+
+      it "delegates to remove document" do
+        doc.should_receive(:remove_document)
+        doc.remove
+      end
+    end
+
+    context "#remove_document" do
+      it "when the document is the root, removes the document" do
+        doc.should_receive(:_remove)
+        doc.remove_document
+      end
+
+      it "when the document is not the root, calls remove_document on the root" do
+        doc._root = root = RemoveDocument.new
+        root.should_receive(:remove_document)
+        doc.remove_document
+      end
+    end
+  end
+
   context "misc class methods" do
     class ClassMethods
       include MongoDoc::Document
@@ -640,7 +657,7 @@ describe "MongoDoc::Document" do
     it ".collection returns a wrapped MongoDoc::Collection" do
       db = stub('db')
       db.should_receive(:collection).with(ClassMethods.to_s.tableize.gsub('/', '.'))
-      MongoDoc.should_receive(:database).and_return(db)
+      MongoDoc::Connection.should_receive(:database).and_return(db)
       MongoDoc::Collection.should === ClassMethods.collection
     end
   end