mongodoc 0.0.0

data/spec/base_ext.rb

@@ -0,0 +1,9 @@
+module MongoDoc
+  class Base
+    def errors_on(attribute)
+      self.valid?
+      [self.errors.on(attribute)].flatten.compact
+    end
+    alias :error_on :errors_on
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,273 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MongoDoc::Base" do
+
+  context "satisfies form_for requirements" do
+    before do
+      @address = Address.new
+      @address._id = '1'
+    end
+    
+    it "#id returns the _id" do
+      @address.id.should == @address._id
+    end
+    
+    it "#to_param returns the _id" do
+      @address.to_param.should == @address._id
+    end
+    
+    context "#new_record?" do
+      it "is true when the object does not have an _id" do
+        @address._id = nil
+        @address.new_record?.should be_true
+      end
+      
+      it "is false when the object has an id" do
+        @address.new_record?.should be_false
+      end
+    end
+  end
+
+  context "validations" do
+    class SimpleValidationTest < MongoDoc::Base
+      key :data
+      validates_presence_of :data
+    end
+
+    it "are part of Base" do
+      Validatable.should === MongoDoc::Base.new
+    end
+
+    it "valid? fails when a document is invalid" do
+      doc = SimpleValidationTest.new
+      doc.should_not be_valid
+      doc.should have(1).error_on(:data)
+    end
+  end
+
+  context "#save" do
+    before do
+      @id = Mongo::ObjectID.new([1])
+      @address = Address.new
+      @collection = stub('collection')
+      Address.stub(:collection).and_return(@collection)
+    end
+
+    it "saves a #to_bson on the collection" do
+      bson = stub('bson')
+      @address.should_receive(:to_bson).and_return(bson)
+      @collection.should_receive(:save).with(bson, anything).and_return(Mongo::ObjectID.new([1]))
+      @address.save
+    end
+
+    it "sets the _id of the document" do
+      @collection.stub(:save).and_return(@id)
+      @address.save
+      @address._id.should == @id
+    end
+
+    it "returns the _id of the document" do
+      @collection.stub(:save).and_return(@id)
+      @address.save.should == @id
+    end
+
+    it "ignores validates if asked to" do
+      @address.stub(:valid?).and_return(false)
+      @collection.stub(:save).and_return(@id)
+      @address.save(false).should == @id
+    end
+
+    it "returns false if the object is not valid" do
+      @address.stub(:valid?).and_return(false)
+      @address.save.should be_false
+    end
+  end
+
+  context ".create" do
+    it "calls insert with the :safe => false option" do
+      collection = stub('collection')
+      Address.stub(:collection).and_return(collection)
+      collection.should_receive(:insert).with(anything, hash_including(:safe => false))
+      Address.create
+    end
+
+    it "is false if the object is not valid" do
+      class CreateValidationTest < MongoDoc::Base
+        key :data
+        validates_presence_of :data
+      end
+
+      CreateValidationTest.create.should be_false
+    end
+  end
+
+  context "#bang methods!" do
+    before do
+      @address = Address.new
+      @collection = stub('collection')
+      Address.stub(:collection).and_return(@collection)
+    end
+
+    it "create! calls insert with the :safe => true option" do
+      @collection.should_receive(:insert).with(anything, hash_including(:safe => true))
+      Address.create!
+    end
+
+    it "create! raises if not valid" do
+      class CreateBangValidationTest < MongoDoc::Base
+        key :data
+        validates_presence_of :data
+      end
+
+      expect do
+        CreateBangValidationTest.create!
+      end.should raise_error(MongoDoc::Document::DocumentInvalidError)
+    end
+
+    it "save! call insert with the :safe => true option" do
+      @collection.should_receive(:save).with(anything, hash_including(:safe => true))
+      @address.save!
+    end
+
+    it "save! raises if not valid" do
+      @address.stub(:valid?).and_return(false)
+      expect do
+        @address.save!
+      end.should raise_error(MongoDoc::Document::DocumentInvalidError)
+    end
+  end
+
+  context "#update_attributes" do
+    before do
+      @attrs = {:state => 'FL'}
+      @spec = {'_id' => 1}
+      @address = Address.new(@spec)
+      @address.stub(:_update_attributes).and_return(true)
+    end
+
+    it "returns true on success" do
+      @address.update_attributes(@attrs).should be_true
+    end
+
+    it "sets the attributes" do
+      @address.update_attributes(@attrs)
+      @address.state.should == 'FL'
+    end
+
+    it "calls _update_attributes" do
+      @address.should_receive(:_update_attributes).with(@attrs, false)
+      @address.update_attributes(@attrs)
+    end
+
+    it "returns false if the object is not valid" do
+      @address.stub(:valid?).and_return(false)
+      @address.update_attributes(@attrs).should be_false
+    end
+
+    context "with a bang" do
+      it "with a bang, updates the document with the :safe => true option" do
+        @address.should_receive(:_update_attributes).with(@attrs, true)
+        @address.update_attributes!(@attrs)
+      end
+
+      it "raises if not valid" do
+        @address.stub(:valid?).and_return(false)
+        expect do
+          @address.update_attributes!(@attrs)
+        end.should raise_error(MongoDoc::Document::DocumentInvalidError)
+      end
+    end
+  end
+
+  context "from a nested document" do
+    class NestedDocsRoot < MongoDoc::Base
+      has_many :nested_children
+    end
+
+    class NestedChild < MongoDoc::Base
+      has_one :leaf
+    end
+
+    class LeafDoc < MongoDoc::Base
+      key :data
+    end
+
+    context "#save" do
+      before do
+        @leaf = LeafDoc.new
+        @root = NestedDocsRoot.new(:nested_children => [NestedChild.new(:leaf => @leaf)])
+      end
+
+      it "calls the root document's save" do
+        @root.should_receive(:save).with(true)
+        @leaf.save
+      end
+
+      it "(with bang!) calls the root documents save!" do
+        @root.should_receive(:save!)
+        @leaf.save!
+      end
+    end
+
+    context "with no has_many, update_attributes" do
+      before do
+        @leaf = LeafDoc.new
+        @root = NestedChild.new(:leaf => @leaf)
+      end
+
+      it "calls the root document's _update_attributes with a full attribute path and not safe" do
+        @root.should_receive(:_update_attributes).with({'leaf.data' => 'data'}, false)
+        @leaf.update_attributes(:data => 'data')
+      end
+
+      it "(with bang!) calls the root document's _update_attributes with a full attribute path and safe" do
+        @root.should_receive(:_update_attributes).with({'leaf.data' => 'data'}, true)
+        @leaf.update_attributes!(:data => 'data')
+      end
+    end
+    
+    context "with has_many, update_attributes" do
+      before do
+        @leaf = LeafDoc.new
+        NestedDocsRoot.new(:nested_children => [NestedChild.new(:leaf => @leaf)])
+      end
+
+      it "returns false" do
+        @leaf.update_attributes(:data => 'data').should be_false
+      end
+
+      it "sets an error on base" do
+        @leaf.update_attributes(:data => 'data')
+        @leaf.errors[:base].should_not be_nil
+      end
+
+      it "(with bang!) returns false" do
+        @leaf.update_attributes!(:data => 'data').should be_false
+      end
+
+      it "(with bang!) sets an error on base" do
+        @leaf.update_attributes(:data => 'data')
+        @leaf.errors[:base].should_not be_nil
+      end
+    end
+
+  end
+
+  it ".count calls the collection count" do
+    collection = stub('collection')
+    MongoDoc::Base.stub(:collection).and_return(collection)
+    collection.should_receive(:count).and_return(1)
+    MongoDoc::Base.count
+  end
+
+  it ".collection_name returns the name of the collection for this class" do
+    Address.collection_name.should == Address.to_s.tableize.gsub('/', '.')
+  end
+
+  it ".collection calls through MongoDoc.database using the class name" do
+    db = stub('db')
+    db.should_receive(:collection).with(MongoDoc::Base.to_s.tableize.gsub('/', '.'))
+    MongoDoc.should_receive(:database).and_return(db)
+    MongoDoc::Base.collection
+  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,316 @@
+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, Mongo::RegexpOfHolding.new('a', 'i', 'g')].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
+    before do
+      @movie = Movie.new
+      @movie.title = 'Gone with the Wind'
+      @movie.director = 'Victor Fleming'
+      @movie.writers = ['Sidney Howard']
+      @director = Director.new
+      @director.name = 'Victor Fleming'
+      @director.awards = ['1940 - Best Director']
+      @movie.director = @director
+    end
+
+    it "renders a json representation of a simple object" do
+      @director.to_bson.should be_bson_eql({"name" => "Victor Fleming", MongoDoc::BSON::CLASS_KEY => "Director", "awards" => ["1940 - Best Director"]})
+    end
+    
+    it "renders a json representation of an object with embedded objects" do
+      @movie.to_bson.should be_bson_eql({"title" => "Gone with the Wind", MongoDoc::BSON::CLASS_KEY => "Movie", "writers" => ["Sidney Howard"], "director" => {"name" => "Victor Fleming", MongoDoc::BSON::CLASS_KEY => "Director", "awards" => ["1940 - Best Director"]}})
+    end
+
+    it "ignores a class hash when the :raw_json option is used" do
+      Movie.bson_create(@movie.to_bson.except(MongoDoc::BSON::CLASS_KEY), :raw_json => true).director.should == @director.to_bson
+    end
+
+    it "roundtrips the object" do
+      MongoDoc::BSON.decode(@movie.to_bson).should be_kind_of(Movie)
+    end
+
+    it "allows for embedded objects" do
+      movie_from_bson = MongoDoc::BSON.decode(@movie.to_bson)
+      movie_from_bson.director.should be_kind_of(Director)
+    end
+
+    it "allows for embedded arrays of objects" do
+      award = AcademyAward.new
+      award.year = '1940'
+      award.category = 'Best Director'
+      @director.awards = [award]
+      director_from_bson = MongoDoc::BSON.decode(@director.to_bson)
+      director_from_bson.awards.each {|award| award.should be_kind_of(AcademyAward)}
+    end
+  end
+  
+  describe "MongoDoc::Base" do
+    before do
+      @address = Address.new
+      @address.street = '320 1st Street North'
+      @address.city = 'Jacksonville Beach'
+      @address.state = 'FL'
+      @address.zip_code = '32250'
+      @location = Location.new
+      @location.address = @address
+    end
+
+    it "encodes the class for the object" do
+      atom = Automobile::Ariel.new
+      atom.to_bson[MongoDoc::BSON::CLASS_KEY].should == Automobile::Ariel.name
+    end
+    
+    it "renders a json representation of the object" do
+      @location.to_bson.should be_bson_eql({MongoDoc::BSON::CLASS_KEY => "Location", "website" => nil, "address" => {"state" => "FL", MongoDoc::BSON::CLASS_KEY => "Address", "zip_code" => "32250", "street" => "320 1st Street North", "city" => "Jacksonville Beach"}})
+    end
+
+    it "includes the _id of the object" do
+      @location._id = Mongo::ObjectID.new
+      @location.to_bson.should be_bson_eql({MongoDoc::BSON::CLASS_KEY => "Location", "_id" => @location._id.to_bson, "website" => nil, "address" => {"state" => "FL", MongoDoc::BSON::CLASS_KEY => "Address", "zip_code" => "32250", "street" => "320 1st Street North", "city" => "Jacksonville Beach"}})
+    end
+
+    it "roundtrips the object" do
+      MongoDoc::BSON.decode(@location.to_bson).should be_kind_of(Location)
+    end
+
+    it "ignores the class hash when the :raw_json option is used" do
+      MongoDoc::BSON.decode(@location.to_bson.except(MongoDoc::BSON::CLASS_KEY), :raw_json => true)['address'].should == @address.to_bson
+    end
+
+    it "allows for embedded MongoDoc objects" do
+      company_from_bson = MongoDoc::BSON.decode(@location.to_bson)
+      company_from_bson.should be_kind_of(Location)
+      company_from_bson.address.should be_kind_of(Address)
+    end
+
+    it "allows for derived classes" do
+      wifi = WifiAccessible.new
+      wifi.address = @address
+      wifi.network_name = 'hashrocket'
+      wifi_from_bson = MongoDoc::BSON.decode(wifi.to_bson)
+      wifi_from_bson.should be_kind_of(WifiAccessible)
+      wifi_from_bson.address.should be_kind_of(Address)
+    end
+
+    it "allows for embedded ruby objects" do
+      website = WebSite.new
+      website.url = 'http://hashrocket.com'
+      wifi = WifiAccessible.new
+      wifi.website = website
+      wifi_from_bson = MongoDoc::BSON.decode(wifi.to_bson)
+      wifi_from_bson.should be_kind_of(WifiAccessible)
+      wifi_from_bson.website.should be_kind_of(WebSite)
+    end
+
+    context "associations" do
+      context "has_one" do
+        class TestHasOneBsonDoc < MongoDoc::Base
+          has_one :subdoc
+        end
+
+        class SubHasOneBsonDoc < MongoDoc::Base
+          key :attr
+        end
+
+        it "#to_bson renders a bson representation of the document" do
+          doc = TestHasOneBsonDoc.new
+          subdoc = SubHasOneBsonDoc.new(:attr => "value")
+          bson = doc.to_bson
+          bson["subdoc"] = subdoc.to_bson
+          doc.subdoc = subdoc
+          doc.to_bson.should == bson
+        end
+
+        it "roundtrips" do
+          doc = TestHasOneBsonDoc.new
+          subdoc = SubHasOneBsonDoc.new(:attr => "value")
+          doc.subdoc = subdoc
+          MongoDoc::BSON.decode(doc.to_bson).should == doc
+        end
+      end
+
+      context "has_many" do
+
+        class SubHasManyBsonDoc < MongoDoc::Base
+          key :attr
+        end
+
+        class TestHasManyBsonDoc < MongoDoc::Base
+          has_many :subdoc, :class_name => 'SubHasManyBsonDoc'
+        end
+
+        it "#to_bson renders a bson representation of the document" do
+          doc = TestHasManyBsonDoc.new
+          subdoc = SubHasManyBsonDoc.new(:attr => "value")
+          bson = doc.to_bson
+          bson["subdoc"] = [subdoc].to_bson
+          doc.subdoc = subdoc
+          doc.to_bson.should == bson
+        end
+
+        it "roundtrips" do
+          doc = TestHasManyBsonDoc.new
+          subdoc = SubHasManyBsonDoc.new(:attr => "value")
+          doc.subdoc = subdoc
+          MongoDoc::BSON.decode(doc.to_bson).should == doc
+        end
+
+        it "roundtrips the proxy" do
+          doc = TestHasManyBsonDoc.new(:subdoc => SubHasManyBsonDoc.new(:attr => "value"))
+          MongoDoc::Document::Proxy.should === MongoDoc::BSON.decode(doc.to_bson).subdoc
+        end
+      end
+    end
+  end
+end