mongo_doc 0.3.0

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
+    [Mongo::ObjectID.new, Mongo::DBRef.new('ns', 1), Mongo::Code.new('code'), Mongo::Binary.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,161 @@
+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
+
+    %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

data/spec/connection_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# Resets for testing
+module MongoDoc
+  module Connection
+
+    def reset
+      @config_path = nil
+      @configuration = nil
+      @connection = nil
+      @database = nil
+      @host = nil
+      @name = nil
+      @options = nil
+      @port = nil
+      @strict = nil
+    end
+
+  end
+end
+
+describe "MongoDoc::Connection.Connections" do
+
+  context "Non-rails environment" do
+
+    it "does not see Rails" do
+      Object.const_defined?('Rails').should be_false
+    end
+
+    it "default the configuration location to './mongodb.yml'" do
+      MongoDoc::Connection.config_path.should == './mongodb.yml'
+    end
+
+    context "without a configuration" do
+      let(:connection) { stub('connection') }
+
+      before do
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
+      end
+
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
+      end
+
+      it "creates a default database with strict false" do
+        connection.should_receive(:db).with("mongo_doc", :strict => false)
+        MongoDoc::Connection.database
+      end
+    end
+  end
+
+  context "Rails environment" do
+
+    module FauxRails
+      extend self
+
+      def env
+        'development'
+      end
+
+      def root
+        Pathname.new('rails_root')
+      end
+    end
+
+    before do
+      Object.const_set('Rails', FauxRails)
+    end
+
+    after do
+      Object.send(:remove_const, 'Rails')
+    end
+
+    it "sees Rails" do
+      Object.const_defined?('Rails').should be_true
+    end
+
+    it "default the configuration location to Rails.root + '/config/mongodb.yml'" do
+      MongoDoc::Connection.config_path.should == FauxRails.root + 'config/mongodb.yml'
+    end
+
+    context "without a configuration" do
+      let(:connection) { stub('connection') }
+
+      before do
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
+      end
+
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
+      end
+
+      it "creates a default database with strict false" do
+        connection.should_receive(:db).with("rails_root_development", :strict => false)
+        MongoDoc::Connection.database
+      end
+    end
+  end
+
+  context ".verify_server_version" do
+    let(:connection) { stub('connection') }
+
+    it "raises when the server version is unsupported" do
+      connection.stub(:server_version).and_return(Mongo::ServerVersion.new('1.3.1'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
+
+    it "returns when the server version is supported" do
+      connection.stub(:server_version).and_return(Mongo::ServerVersion.new('1.3.2'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should_not raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
+  end
+
+  describe ".connect" do
+    let(:connection) { stub('connection') }
+
+    before do
+      MongoDoc::Connection.stub(:verify_server_version)
+    end
+
+    it "creates a Mongo::Connection" do
+      host = 'host'
+      port = 'port'
+      options = 'options'
+      MongoDoc::Connection.stub(:host).and_return(host)
+      MongoDoc::Connection.stub(:port).and_return(port)
+      MongoDoc::Connection.stub(:options).and_return(options)
+      Mongo::Connection.should_receive(:new).with(host, port, options).and_return(connection)
+      MongoDoc::Connection.send(:connect)
+    end
+
+    it "raises NoConnectionError if the connection fails" do
+      Mongo::Connection.stub(:new).and_return(nil)
+      lambda { MongoDoc::Connection.send(:connect) }.should raise_error(MongoDoc::NoConnectionError)
+    end
+
+    it "verifies the connection version" do
+      Mongo::Connection.stub(:new).and_return(connection)
+      MongoDoc::Connection.should_receive(:verify_server_version)
+      MongoDoc::Connection.send(:connect)
+    end
+  end
+end