mongo_doc_rails2 0.6.1

data/spec/attributes_accessor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "MongoDoc::Attributes attributes accessor" do
+  class AttributesTest
+    include MongoDoc::Attributes
+
+    attr_accessor :name
+    attr_accessor :age
+    attr_accessor :birthdate, :type => Date
+  end
+
+  context "#attributes" do
+    subject do
+      AttributesTest.new.attributes
+    end
+
+    it "returns a hash of the given attributes" do
+      should have_key(:name)
+      should have_key(:age)
+      should have_key(:birthdate)
+    end
+  end
+
+  context "#attributes=" do
+    let(:object) { AttributesTest.new }
+
+    it "sets attributes from a hash" do
+      name = 'name'
+      object.attributes = {:name => name}
+      object.name.should == name
+    end
+  end
+end

data/spec/attributes_spec.rb

@@ -0,0 +1,145 @@
+require '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 AttributeAccessorTest
+      include MongoDoc::Attributes
+
+      key :date, :default => Date.today, :type => Date
+    end
+
+    it "is an alias for attr_accessor" do
+      AttributeAccessorTest._keys.should include(:date)
+    end
+  end
+
+  context ".attr_accessor" do
+    class TestKeys
+      include MongoDoc::Attributes
+
+      attr_accessor :attr1, :attr2
+    end
+
+    it "adds its arguments to _keys" do
+      TestKeys._keys.should == [:attr1, :attr2]
+    end
+
+    describe "accessors" do
+      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
+
+    context "default values" do
+      class TestDefault
+        include MongoDoc::Attributes
+
+        attr_accessor :with_default, :default => 'value'
+      end
+
+      let(:object) { TestDefault.new }
+
+      it "uses the default value" do
+        object.with_default.should == 'value'
+      end
+
+      it "only uses the default value once" do
+        object.with_default.should == 'value'
+        class << object
+          def _default_with_default
+            'other value'
+          end
+        end
+        object.with_default.should == 'value'
+      end
+
+      it "does not set the default value if the setter is invoked first" do
+        object.with_default = nil
+        object.with_default.should be_nil
+      end
+    end
+
+    context "specified type" do
+      class TestType
+        include MongoDoc::Attributes
+
+        attr_accessor :birthdate, :type => Date
+      end
+
+      let(:object) { TestType.new }
+
+      it "does not call Type.cast_from_string when the set value is not a string" do
+        Date.should_not_receive :cast_from_string
+        object.birthdate = Date.today
+      end
+
+      context "when the accessor is set with a string" do
+        let(:date) { Date.today }
+
+        it "delegates to Type.cast_from_string to set the value" do
+          Date.should_receive(:cast_from_string).with(date.to_s)
+          object.birthdate = date.to_s
+        end
+
+        it "sets the value to the result of the case" do
+          object.birthdate = date.to_s
+          object.birthdate.should == date
+        end
+      end
+    end
+
+    describe "used with inheritance" do
+      class TestParent
+        include MongoDoc::Attributes
+
+        attr_accessor :parent_attr
+      end
+
+      class TestChild < TestParent
+        attr_accessor :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 "._attributes" do
+    class TestHasOneDoc
+      include MongoDoc::Document
+
+      attr_accessor :key
+      embed :embed
+    end
+
+    it "is _keys + _associations" do
+      TestHasOneDoc._attributes.should == TestHasOneDoc._keys + TestHasOneDoc._associations
+    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

data/spec/bson_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "BSON for Mongo (BSON)" do
+  describe "#decode" do
+    it "just returns the json if the :raw_json option is used" do
+      hash = {}
+      MongoDoc::BSON.should_not_receive(:bson_create)
+      MongoDoc::BSON.decode(hash, :raw_json => true).should == hash
+    end
+
+    it "calls bson_create if parameter is a hash" do
+      hash = {}
+      options = {:option => true}
+      MongoDoc::BSON.should_receive(:bson_create).with(hash, options)
+      MongoDoc::BSON.decode(hash, options)
+    end
+
+    it "if parameter is an array, it calls array_create" do
+      array = []
+      options = {:option => true}
+      MongoDoc::BSON.should_receive(:array_create).with(array, options)
+      MongoDoc::BSON.decode(array, options)
+    end
+
+    it "returns the json value as is if the parameter is not a hash or array" do
+      ["", 1, 1.5, true, false, nil].each do |type_value|
+        MongoDoc::BSON.decode(type_value).should == type_value
+      end
+    end
+  end
+
+  describe "#array_create" do
+    it "calls decode for each element" do
+      first = 1
+      array = [first]
+      options = {:option => true}
+      MongoDoc::BSON.should_receive(:decode).with(first, options)
+      MongoDoc::BSON.array_create(array, options)
+    end
+
+    it "just returns the array if the :raw_json option is used" do
+      hash = {'key' => 'value', MongoDoc::BSON::CLASS_KEY => 'Date'}
+      array = [hash]
+      MongoDoc::BSON.should_not_receive(:decode)
+      MongoDoc::BSON.array_create(array, :raw_json => true).should == array
+    end
+  end
+
+  describe "#bson_create" do
+    it "leaves a simple hash intact" do
+      hash = {}
+      MongoDoc::BSON.bson_create(hash).should == hash
+    end
+
+    it "a class hash extracts the class, and calls class.bson_create" do
+      base_hash = {'key' => 'value'}
+      bson_hash = base_hash.merge(MongoDoc::BSON::CLASS_KEY => 'Date')
+      Date.should_receive(:bson_create).with(base_hash, {})
+      MongoDoc::BSON.bson_create(bson_hash)
+    end
+
+    it "ignores a class hash when the :raw_json option is used" do
+      hash = {'key' => 'value', MongoDoc::BSON::CLASS_KEY => 'Date'}
+      MongoDoc::BSON.bson_create(hash, :raw_json => true).should == hash
+    end
+  end
+
+  describe "Hash" do
+    it "#to_bson returns the hash" do
+      hash = {'key' => 1}
+      hash.to_bson.should == hash
+    end
+
+    it "#to_bson returns the hash with symbol keys as strings" do
+      {:key => 1}.to_bson.should == {"key" => 1}
+    end
+
+    it "decodes to a hash" do
+      hash = {'key' => 1}
+      MongoDoc::BSON.decode(hash.to_bson).should == hash
+    end
+
+    it "decodes the values of the hash" do
+      hash = {'key' => {'subkey' => Date.today}}
+      MongoDoc::BSON.decode(hash.to_bson).should == hash
+    end
+  end
+
+  describe "Array" do
+    it "#to_bson returns the array" do
+      array = ['string', 1]
+      array.to_bson.should == array
+    end
+
+    it "#to_bson iterates over its elements" do
+      array = []
+      array.should_receive(:map)
+      array.to_bson
+    end
+
+    it "decodes to an array" do
+      array = ['string', 1]
+      MongoDoc::BSON.decode(array.to_bson).should == array
+    end
+  end
+
+  describe "Extensions to core classes" do
+    it "#to_bson for objects that are BSON native return themselves" do
+      [true, false, nil, 1.0, 1, /regexp/, 'string', :symbol, Time.now].each do |native|
+        native.to_bson.should == native
+      end
+    end
+
+    it "objects that are BSON native decode to themselves" do
+      [true, false, nil, 1.0, 1, /regexp/, 'string', :symbol, Time.now].each do |native|
+        hash = {'native' => native}
+        MongoDoc::BSON.decode(hash.to_bson).should == hash
+      end
+    end
+
+    it "Date#to_bson returns a date hash" do
+      date = Date.today
+      date.to_bson.should == {MongoDoc::BSON::CLASS_KEY => "Date", "dt" => date.strftime, "sg"  => date.respond_to?(:start) ? date.start : date.sg}
+    end
+
+    it "roundtrips Date" do
+      date = Date.today
+      MongoDoc::BSON.decode(date.to_bson).should == date
+    end
+
+    it "DateTime#to_bson returns a datetime hash" do
+      datetime = DateTime.now
+      datetime.to_bson.should == {MongoDoc::BSON::CLASS_KEY => "DateTime", "dt" => datetime.strftime, "sg"  => datetime.respond_to?(:start) ? datetime.start : datetime.sg}
+    end
+
+    it "roundtrips DateTime" do
+      datetime = DateTime.now
+      MongoDoc::BSON.decode(datetime.to_bson).to_s.should == datetime.to_s
+    end
+  end
+
+  describe "Mongo Classes" do
+    [BSON::ObjectID.new, BSON::DBRef.new('ns', 1), BSON::Code.new('code'), BSON::Binary.new, BSON::MinKey.new, BSON::MaxKey.new].each do |obj|
+      it "#to_bson for #{obj.class.name} returns self" do
+        obj.to_bson.should == obj
+      end
+
+      it "objects of type #{obj.class.name} decode to themselves" do
+        hash = {"mongo" => obj}
+        MongoDoc::BSON.decode(hash.to_bson)["mongo"].should == obj
+      end
+    end
+  end
+
+  describe "Extensions to Object" do
+    class Simple
+      attr_accessor :value
+    end
+
+    class Complex
+      attr_accessor :array_of_simple
+    end
+
+    before do
+      @value1 = 'value1'
+      @simple1 = Simple.new
+      @simple1.value = @value1
+      @value2 = 'value2'
+      @simple2 = Simple.new
+      @simple2.value = @value2
+      @complex = Complex.new
+      @complex.array_of_simple = [@simple1, @simple2]
+    end
+
+    it "renders a json representation of a simple object" do
+      @simple1.to_bson.should be_bson_eql({MongoDoc::BSON::CLASS_KEY => Simple.name, "value" => @value1})
+    end
+
+    it "renders a json representation of an object with embedded objects" do
+      @complex.to_bson.should be_bson_eql({MongoDoc::BSON::CLASS_KEY => Complex.name, "array_of_simple" => [@simple1.to_bson, @simple2.to_bson]})
+    end
+
+    it "ignores a class hash when the :raw_json option is used" do
+      Complex.bson_create(@complex.to_bson.except(MongoDoc::BSON::CLASS_KEY), :raw_json => true).array_of_simple.first.should == @simple1.to_bson
+    end
+
+    it "roundtrips the object" do
+      MongoDoc::BSON.decode(@complex.to_bson).should be_kind_of(Complex)
+    end
+
+    it "allows for embedded arrays of objects" do
+      obj = MongoDoc::BSON.decode(@complex.to_bson)
+      obj.array_of_simple.each {|o| o.should be_kind_of(Simple)}
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,169 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MongoDoc::Collection" do
+
+  let(:mongo_collection) { stub('collection') }
+
+  it ".new delegates to .mongo_collection" do
+    name = 'collection_name'
+    MongoDoc::Collection.should_receive(:mongo_collection).with(name).and_return(mongo_collection)
+    MongoDoc::Collection.new(name)
+  end
+
+  context "with the underlying Mongo::Collection" do
+
+    let(:collection) do
+      MongoDoc::Collection.stub(:mongo_collection).and_return(mongo_collection)
+      MongoDoc::Collection.new('collection_name')
+    end
+
+    it "has Criteria mixed in" do
+      MongoDoc::Criteria.should === collection
+    end
+
+    it "#collection references self for Mongo context" do
+      collection.send(:collection).should == collection
+    end
+
+    %w([] clear count create_index db distinct drop drop_index drop_indexes group hint index_information map_reduce mapreduce name options pk_factory remove rename size).each do |delegated_method|
+      it "delegates #{delegated_method} to the Mongo::Collection" do
+        mongo_collection.should_receive(delegated_method)
+        collection.send(delegated_method)
+      end
+    end
+
+    context "#find" do
+      let(:cursor) { MongoDoc::Cursor.new(collection, stub('cursor', :close => nil)) }
+
+      before do
+        collection.stub(:wrapped_cursor).and_return(cursor)
+      end
+
+      it "wraps the cursor" do
+        query = {'sample' => 'data'}
+        options = { :limit => 1}
+        collection.should_receive(:wrapped_cursor).with(query, options).and_return(cursor)
+        collection.find(query, options)
+      end
+
+      it "calls the block with a wrapped cursor" do
+        collection.find {|c| @result = c}
+        @result.should == cursor
+      end
+    end
+
+    context "#find_one" do
+      let(:bson) { stub('bson') }
+
+      before do
+        mongo_collection.stub(:find_one).and_return(bson)
+      end
+
+      it "delegates to the Mongo::Collection" do
+        spec = { 'sample' => 'data' }
+        options = {:limit => 1}
+        mongo_collection.should_receive(:find_one).with(spec, options)
+        collection.find_one(spec, options)
+      end
+
+      it "converts the result back from bson" do
+        MongoDoc::BSON.should_receive(:decode).with(bson)
+        collection.find_one({ 'sample' => 'data' })
+      end
+
+      it "returns the converted result" do
+        obj = stub('obj')
+        MongoDoc::BSON.stub(:decode).and_return(obj)
+        collection.find_one({ 'sample' => 'data' }).should == obj
+      end
+
+      it "returns nil if the delegate returns nil" do
+        mongo_collection.stub(:find_one)
+        collection.find_one({ 'sample' => 'data' }).should be_nil
+      end
+    end
+
+    context "#insert" do
+      let(:doc) { {'sample' => 'data'} }
+
+      it "delegates to the Mongo::Collection" do
+        options = {:safe => false}
+        mongo_collection.should_receive(:insert).with(doc, options)
+        collection.insert(doc, options)
+      end
+
+      it "converts the doc_or_docs to bson" do
+        doc.should_receive(:to_bson)
+        mongo_collection.stub(:insert)
+        collection.insert(doc, options)
+      end
+
+      it "returns the delegates result" do
+        result = 'result'
+        mongo_collection.stub(:insert).and_return(result)
+        collection.insert(doc).should == result
+      end
+    end
+
+    context "#save" do
+      let(:doc) { {'sample' => 'data'} }
+
+      it "delegates to the Mongo::Collection" do
+        options = {:safe => false}
+        mongo_collection.should_receive(:save).with(doc, options)
+        collection.save(doc, options)
+      end
+
+      it "converts the doc to bson" do
+        doc.should_receive(:to_bson)
+        mongo_collection.stub(:save)
+        collection.save(doc)
+      end
+
+      it "returns the delegates result" do
+        result = 'result'
+        mongo_collection.stub(:save).and_return(result)
+        collection.save(doc).should == result
+      end
+    end
+
+    context "#update" do
+      let(:spec) { {'sample' => 'old'} }
+
+      let(:doc) { {'sample' => 'data'} }
+
+      let(:options) { {:safe => false} }
+
+      before do
+        collection.stub(:last_error).and_return('updatedExisting' => true)
+        mongo_collection.stub(:update)
+      end
+
+      it "delegates to the Mongo::Collection" do
+        mongo_collection.should_receive(:update).with(spec, doc, options)
+        collection.update(spec, doc, options)
+      end
+
+      it "converts the doc to bson" do
+        doc.should_receive(:to_bson)
+        collection.update(spec, doc, options)
+      end
+
+      it "gets the last error from the database" do
+        collection.should_receive(:last_error)
+        collection.update(spec, doc, options)
+      end
+
+      it "returns the updateExisting value of get last error" do
+        result = 'check'
+        collection.stub(:last_error).and_return({'updatedExisting' => result})
+        collection.update(spec, doc, options).should == result
+      end
+
+      it "returns false otherwise" do
+        collection.stub(:last_error)
+        collection.update(spec, doc, options).should be_false
+      end
+    end
+  end
+end