mongo_doc 0.6.26 → 0.6.27

data/spec/associations_spec.rb

@@ -1,218 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Associations" do
-
-  context ".embed" do
-    class TestDoc
-      include MongoDoc::Document
-
-      embed :sub_doc
-    end
-
-    class SubDoc
-      include MongoDoc::Document
-
-      attr_accessor :data
-    end
-
-    class TestHasOne
-      include MongoDoc::Document
-
-      has_one :sub_doc
-    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 ".has_one is an alias for embed" do
-      MongoDoc::Associations::DocumentProxy.should === TestHasOne.new(:sub_doc => SubDoc.new).sub_doc
-    end
-
-    it "set the subdocuments root" do
-      doc.should == subdoc._root
-    end
-
-    context "validations" do
-      class EmbedValidationTest
-        include MongoDoc::Document
-
-        attr_accessor :data
-        validates_presence_of :data
-      end
-
-      it "cascades validations down" do
-        invalid = EmbedValidationTest.new
-        TestDoc.new(:sub_doc => invalid).should have(1).error_on(:sub_doc)
-      end
-    end
-  end
-
-  context ".embed_many" do
-
-    class SubEmbedManyDoc
-      include MongoDoc::Document
-
-      attr_accessor :data
-    end
-
-    class TestEmbedManyDoc
-      include MongoDoc::Document
-
-      embed_many :sub_docs, :class_name => 'SubEmbedManyDoc'
-    end
-
-    class TestEmbedManyDoc2
-      include MongoDoc::Document
-
-      embed_many :sub_docs, :class_name => :sub_embed_many_doc
-    end
-
-    class TestImplicitEmbedManyDoc
-      include MongoDoc::Document
-
-      embed_many :sub_embed_many_docs
-    end
-
-    class TestHasManyDoc
-      include MongoDoc::Document
-
-      has_many :sub_docs, :class_name => 'SubEmbedManyDoc'
-    end
-
-    let(:subdoc) { SubEmbedManyDoc.new }
-    let(:doc) { TestEmbedManyDoc.new(:sub_docs => [subdoc]) }
-
-    it "uses a proxy" do
-      MongoDoc::Associations::CollectionProxy.should === TestEmbedManyDoc.new.sub_docs
-    end
-
-    it ".has_many is an alias for .embed_many" do
-      MongoDoc::Associations::CollectionProxy.should === TestHasManyDoc.new.sub_docs
-    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
-      TestImplicitEmbedManyDoc.new.sub_embed_many_docs._assoc_class.should == SubEmbedManyDoc
-    end
-
-    it "uses class_name attribute for the children's class name" do
-      TestEmbedManyDoc.new.sub_docs._assoc_class.should == SubEmbedManyDoc
-    end
-
-    it "uses class_name attribute for the children's class name" do
-      TestEmbedManyDoc2.new.sub_docs._assoc_class.should == SubEmbedManyDoc
-    end
-
-    context "validations" do
-      class EmbedManyValidationChild
-        include MongoDoc::Document
-
-        attr_accessor :data
-        validates_presence_of :data
-      end
-
-      class EmbedManyValidationTest
-        include MongoDoc::Document
-
-        embed_many :subdocs, :class_name => 'HasManyValidationChild'
-      end
-
-      let(:invalid_child) { EmbedManyValidationChild.new }
-      let(:doc) { EmbedManyValidationTest.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
-        EmbedManyValidationTest.new(:subdocs => ['not a doc']).should be_valid
-      end
-    end
-  end
-
-  context ".embed_hash" do
-    class SubEmbedHashDoc
-      include MongoDoc::Document
-
-      attr_accessor :data
-    end
-
-    class TestEmbedHashDoc
-      include MongoDoc::Document
-
-      embed_hash :sub_docs, :class_name => 'SubEmbedHashDoc'
-    end
-
-    class TestImplicitEmbedHashDoc
-      include MongoDoc::Document
-
-      embed_hash :sub_embed_hash_docs
-    end
-
-    class TestHasHashDoc
-      include MongoDoc::Document
-
-      has_hash :sub_embed_hash_docs
-    end
-
-    let(:subdoc) { SubEmbedHashDoc.new }
-    let(:doc) { TestEmbedHashDoc.new(:sub_docs => {:key => subdoc}) }
-
-    it "uses a proxy" do
-      MongoDoc::Associations::HashProxy.should === TestEmbedHashDoc.new.sub_docs
-    end
-
-    it ".has_hash is an alias for embed_hash" do
-      MongoDoc::Associations::HashProxy.should === TestEmbedHashDoc.new.sub_docs
-    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
-      TestImplicitEmbedHashDoc.new.sub_embed_hash_docs._assoc_class.should == SubEmbedHashDoc
-    end
-
-    context "validations" do
-      class EmbedHashValidationChild
-        include MongoDoc::Document
-
-        attr_accessor :data
-        validates_presence_of :data
-      end
-
-      class EmbedHashValidationTest
-        include MongoDoc::Document
-
-        embed_hash :subdocs, :class_name => 'EmbedHashValidationChild'
-      end
-
-      let(:invalid_child) { EmbedHashValidationChild.new }
-      let(:doc) { EmbedHashValidationTest.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
-        EmbedHashValidationTest.new(:subdocs => {:key => 'data'}).should be_valid
-      end
-    end
-  end
-end

data/spec/attributes_accessor_spec.rb

@@ -1,39 +0,0 @@
-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
-
-    it "ignores a nil" do
-      expect do
-        object.attributes = nil
-      end.should_not raise_error
-    end
-  end
-end

data/spec/attributes_spec.rb

@@ -1,184 +0,0 @@
-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
-      attr_accessor :validation_context
-      attr_accessor :boolean, :type => Boolean
-    end
-
-    it "adds its arguments to _keys" do
-      TestKeys._keys.should include(:attr1, :attr2)
-    end
-
-    context "the :validation_context attribute from ActiveModel" do
-
-      it "is an attribute" do
-        TestKeys.new.should respond_to(:validation_context)
-        TestKeys.new.should respond_to(:validation_context=)
-      end
-
-      it "is not in _keys" do
-        TestKeys._keys.should_not include(:validation_context)
-      end
-    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
-
-      it "has a reader for a boolean" do
-        should respond_to(:boolean)
-      end
-
-      it "has a ? reader for a boolean" do
-        should respond_to(:boolean?)
-      end
-    end
-
-    context "default values" do
-      class TestDefault
-        include MongoDoc::Attributes
-
-        attr_accessor :with_default, :default => 'value'
-        attr_accessor :boolean_default, :type => Boolean, :default => false
-      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
-
-      it "allows a false default for booleans" do
-        object.boolean_default.should == false
-      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 cast" do
-          object.birthdate = date.to_s
-          object.birthdate.should == date
-        end
-      end
-
-      context "when a namespace collision exists" do
-        class TestType
-          attr_accessor :bson_id, :type => ::BSON::ObjectID
-        end
-
-        let(:bson_id) { ::BSON::ObjectID.new }
-        it "sets the value to the result of the cast" do
-          object.bson_id = bson_id.to_s
-          object.bson_id.should == bson_id
-        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

@@ -1,54 +0,0 @@
-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

@@ -1,196 +0,0 @@
-require '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 Contained
-      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 = Contained.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 => Contained.name, "array_of_simple" => [@simple1.to_bson, @simple2.to_bson]})
-    end
-
-    it "ignores a class hash when the :raw_json option is used" do
-      Contained.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(Contained)
-    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