mongo_doc 0.6.26 → 0.6.27

data/spec/new_record_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Document _id and #new_record?" do
-  class Child
-    include MongoDoc::Document
-  end
-
-  class Parent
-    include MongoDoc::Document
-
-    embed :child
-    embed_many :children
-
-    attr_accessor :data
-
-    validates_presence_of :data
-  end
-
-  let(:id) { 'id' }
-  let(:collection) { stub('collection', :save => id) }
-  let(:child) { Child.new }
-
-  context "as a embed child" do
-    it "when added to the parent is a new record" do
-      Parent.new(:data => 'data', :child => child)
-      child.should be_new_record
-    end
-
-    context "saving" do
-      before do
-        Parent.stub(:collection).and_return(collection)
-      end
-
-      context "#save" do
-        it "when saved is not a new record" do
-          parent = Parent.new(:data => 'data', :child => child)
-          parent.save
-          child.should_not be_new_record
-        end
-
-        it "if parent is invalid, remains a new record" do
-          parent = Parent.new(:child => child)
-          parent.save
-          child.should be_new_record
-        end
-      end
-
-      context "#save!" do
-        it "when saved is not a new record" do
-          parent = Parent.new(:data => 'data', :child => child)
-          parent.save!
-          child.should_not be_new_record
-        end
-
-        it "if parent is invalid, remains a new record" do
-          parent = Parent.new(:child => child)
-          parent.save! rescue nil
-          child.should be_new_record
-        end
-
-        it "when db error is raised, remains a new record" do
-          collection.stub(:save).and_raise(Mongo::OperationFailure)
-          parent = Parent.new(:data => 'data', :child => child)
-          expect do
-            parent.save!
-          end.should raise_error(Mongo::OperationFailure)
-          child.should be_new_record
-        end
-      end
-    end
-  end
-
-  context "as a embed_many child" do
-    it "when added to the parent is a new record" do
-      parent = Parent.new(:data => 'data')
-      parent.children << child
-      child.should be_new_record
-    end
-
-    context "saving" do
-      before do
-        Parent.stub(:collection).and_return(collection)
-      end
-
-      context "#save" do
-        it "when saved is not a new record" do
-          parent = Parent.new(:data => 'data')
-          parent.children << child
-          parent.save
-          child.should_not be_new_record
-        end
-
-        it "if parent is invalid, remains a new record" do
-          parent = Parent.new
-          parent.children << child
-          parent.save
-          child.should be_new_record
-        end
-      end
-
-      context "#save!" do
-        it "when saved is not a new record" do
-          parent = Parent.new(:data => 'data')
-          parent.children << child
-          parent.save!
-          child.should_not be_new_record
-        end
-
-        it "if parent is invalid, remains a new record" do
-          parent = Parent.new
-          parent.children << child
-          parent.save! rescue nil
-          child.should be_new_record
-        end
-
-        it "when db error is raised, remains a new record" do
-          collection.stub(:save).and_raise(Mongo::OperationFailure)
-          parent = Parent.new(:data => 'data')
-          parent.children << child
-          expect do
-            parent.save!
-          end.should raise_error(Mongo::OperationFailure)
-          child.should be_new_record
-        end
-      end
-    end
-  end
-end

data/spec/polymorphic_collection_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::PolymorphicCollection do
-
-  class BaseCollectionName
-    include MongoDoc::Document
-
-    attr_accessor :base
-  end
-
-  class SubCollectionName < BaseCollectionName
-    attr_accessor :sub
-  end
-
-  class OverriddenCollectionName < BaseCollectionName
-    collection_name :overridden
-    attr_accessor :over
-  end
-
-  class TwoSubCollectionName < OverriddenCollectionName
-    attr_accessor :two_sub
-  end
-
-  describe BaseCollectionName do
-    it "uses the default collection_name for base doc" do
-      BaseCollectionName.collection_name.should == BaseCollectionName.to_s.tableize.gsub('/', '.')
-    end
-  end
-
-  describe SubCollectionName do
-    it "uses the base's collection_name for the derived doc" do
-      SubCollectionName.collection_name.should == BaseCollectionName.to_s.tableize.gsub('/', '.')
-    end
-  end
-
-  describe OverriddenCollectionName do
-    it "sets the collection_name to the overridden name" do
-      OverriddenCollectionName.collection_name.should == 'overridden'
-    end
-  end
-
-  describe TwoSubCollectionName do
-    it "climbs the inheritance chain looking for the collection name" do
-      TwoSubCollectionName.collection_name.should == 'overridden'
-    end
-  end
-end

data/spec/references_many_spec.rb

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::ReferencesMany do
-  class PostalAddress
-    include MongoDoc::Document
-
-    attr_accessor :state
-  end
-
-  context "Simple Reference" do
-    class PersonSimple
-      include MongoDoc::Document
-
-      references_many :postal_addresses
-    end
-
-    let(:person) { PersonSimple.new }
-    subject { person }
-
-    context "Object accessor" do
-      it { should respond_to(:postal_addresses) }
-      it { should respond_to(:postal_addresses=) }
-
-      it "is not part of the persistent key set" do
-        PersonSimple._keys.should_not include('postal_addresses')
-      end
-    end
-
-    context "Object Id accessor" do
-      it { should respond_to(:postal_address_ids) }
-      it { should respond_to(:postal_address_ids=) }
-
-      it "is part of the persistent key set" do
-        PersonSimple._keys.should include('postal_address_ids')
-      end
-    end
-
-    context "setting the ids" do
-      let(:postal_address) { PostalAddress.new(:_id => BSON::ObjectID.new) }
-
-      before do
-        person.postal_addresses = [postal_address]
-      end
-
-      context "to nil" do
-        before do
-          person.postal_address_ids = nil
-        end
-
-        its(:postal_address_ids) { should == [] }
-        its(:postal_addresses) { should == [] }
-      end
-
-      context "to []" do
-        before do
-          person.postal_address_ids = []
-        end
-
-        its(:postal_addresses) { should == [] }
-      end
-
-      context "to strings" do
-        before do
-          person.postal_address_ids = [postal_address._id.to_s]
-        end
-
-        its(:postal_address_ids) { should == [postal_address._id] }
-      end
-    end
-  end
-
-  context "Named Reference" do
-    class PersonNamed
-      include MongoDoc::Document
-
-      references_many :postal_addresses, :as => :known_addresses
-    end
-
-    let(:person) { PersonNamed.new }
-
-    subject { person }
-
-    context "Object accessor" do
-      it { should respond_to(:known_addresses) }
-      it { should respond_to(:known_addresses=) }
-
-      it "is not part of the persistent key set" do
-        PersonNamed._keys.should_not include('known_addresses')
-      end
-    end
-
-    context "Object Id accessor" do
-      it { should respond_to(:known_address_ids) }
-      it { should respond_to(:known_address_ids=) }
-
-      it "is part of the persistent key set" do
-        PersonNamed._keys.should include('known_address_ids')
-      end
-    end
-
-    context "setting the ids" do
-      let(:address) { PostalAddress.new(:_id => BSON::ObjectID.new) }
-
-      before do
-        person.known_addresses = [address]
-      end
-
-      context "to nil" do
-        before do
-          person.known_address_ids = nil
-        end
-
-        its(:known_address_ids) { should == [] }
-        its(:known_addresses) { should == [] }
-      end
-
-      context "to []" do
-        before do
-          person.known_address_ids = []
-        end
-
-        its(:known_addresses) { should == [] }
-      end
-
-      context "to strings" do
-        before do
-          person.known_address_ids = [address._id.to_s]
-        end
-
-        its(:known_address_ids) { should == [address._id] }
-      end
-    end
-  end
-
-  context "DBRef reference" do
-    class PersonDBRef
-      include MongoDoc::Document
-
-      references_many :as_ref => :addresses
-    end
-
-    let(:address) { PostalAddress.new(:_id => BSON::ObjectID.new) }
-    let(:person) { PersonDBRef.new }
-
-    subject { person }
-
-    context "Object accessor" do
-      it { should respond_to(:addresses) }
-      it { should respond_to(:addresses=) }
-
-      it "is not part of the persistent key set" do
-        PersonDBRef._keys.should_not include('addresses')
-      end
-    end
-
-    context "DBRef accessor" do
-      it { should respond_to(:address_refs) }
-      it { should respond_to(:address_refs=) }
-
-      it "is part of the persistent key set" do
-        PersonDBRef._keys.should include('address_refs')
-      end
-    end
-
-    context "setting the collection" do
-      before do
-        person.addresses = [address]
-      end
-
-      it "sets the refs to an array of refs]" do
-        person.address_refs.first.namespace.should == PostalAddress.collection_name
-        person.address_refs.first.object_id.should == address._id
-      end
-    end
-
-    context "setting the refs" do
-      before do
-        person.addresses = [address]
-      end
-
-      context "to nil" do
-        before do
-          person.address_refs = nil
-        end
-
-        it "sets the refs to []" do
-          person.address_refs.should == []
-        end
-
-        its(:addresses) { should == [] }
-      end
-
-      context "to []" do
-        before do
-          person.address_refs = []
-        end
-
-        its(:addresses) { should == [] }
-      end
-
-      context "to an array of references" do
-        let(:dbref) { ::BSON::DBRef.new(PostalAddress.collection_name, address._id) }
-
-        before do
-          person.address_refs = [dbref]
-        end
-
-        it "sets the addresses to nil" do
-          person.instance_variable_get('@addresses').should be_nil
-        end
-      end
-    end
-  end
-end

data/spec/references_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::References do
-  class PostalAddress
-    include MongoDoc::Document
-
-    attr_accessor :state
-  end
-
-  context "Simple Reference" do
-    class SimplePerson
-      include MongoDoc::Document
-
-      references :postal_address
-    end
-
-    subject { SimplePerson.new }
-
-    context "Object accessor" do
-      it { should respond_to(:postal_address) }
-      it { should respond_to(:postal_address=) }
-
-      it "is not part of the persistent key set" do
-        SimplePerson._keys.should_not include(:postal_address)
-      end
-    end
-
-    context "Object Id accessor" do
-      it { should respond_to(:postal_address_id) }
-      it { should respond_to(:postal_address_id=) }
-
-      it "is part of the persistent key set" do
-        SimplePerson._keys.should include(:postal_address_id)
-      end
-    end
-
-    context "setting the id" do
-      let(:postal_address) { PostalAddress.new(:_id => BSON::ObjectID.new) }
-
-      it "resets the object to nil" do
-        subject.postal_address = postal_address
-        subject.postal_address_id = nil
-        subject.postal_address.should be_nil
-      end
-    end
-  end
-
-  context "Named Reference" do
-    class NamedPerson
-      include MongoDoc::Document
-
-      references :postal_address, :as => :work_address
-    end
-
-    subject { NamedPerson.new }
-
-    context "Object accessor" do
-      it { should respond_to(:work_address) }
-      it { should respond_to(:work_address=) }
-
-      it "is not part of the persistent key set" do
-        NamedPerson._keys.should_not include(:work_address)
-      end
-    end
-
-    context "Object Id accessor" do
-      it { should respond_to(:work_address_id) }
-      it { should respond_to(:work_address_id=) }
-
-      it "is part of the persistent key set" do
-        NamedPerson._keys.should include(:work_address_id)
-      end
-    end
-  end
-
-  context "DBRef Reference" do
-    class DBRefPerson
-      include MongoDoc::Document
-
-      references :as_ref => :address
-    end
-
-    let(:address) { PostalAddress.new(:_id => BSON::ObjectID.new) }
-    subject { DBRefPerson.new }
-
-    context "Object accessor" do
-      it { should respond_to(:address) }
-      it { should respond_to(:address=) }
-
-      it "is not part of the persistent key set" do
-        DBRefPerson._keys.should_not include(:address)
-      end
-    end
-
-    context "DBRef accessor" do
-      it { should respond_to(:address_ref) }
-      it { should respond_to(:address_ref=) }
-
-      it "is part of the persistent key set" do
-        DBRefPerson._keys.should include(:address_ref)
-      end
-    end
-
-    context "setting the object" do
-      it "sets the reference" do
-        subject.address = address
-        subject.address_ref.namespace.should == PostalAddress.collection_name
-        subject.address_ref.object_id.should == address._id
-      end
-    end
-
-    context "setting the reference" do
-
-      it "resets the object to nil" do
-        subject.address = address
-        subject.address_ref = nil
-        subject.address.should be_nil
-      end
-    end
-  end
-end

data/spec/root_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Root" do
-  class RootTest
-    include MongoDoc::Root
-    attr_accessor_with_default(:_associations) {[]}
-    attr_accessor :association
-  end
-
-  let(:doc) { RootTest.new }
-
-  context "cascade properties" do
-    let(:prop_val) { stub }
-
-    %w(_modifier_path _root _selector_path).each do |prop|
-      it "sets the #{prop}" do
-        doc.send("#{prop}=", prop_val)
-        doc.send(prop).should == prop_val
-      end
-
-      it "sets the prop on any associations" do
-        doc.association = stub
-        doc.association.should_receive("#{prop}=").with(prop_val)
-        doc._associations = ['association']
-        doc.send("#{prop}=", prop_val)
-      end
-    end
-  end
-
-  describe "#_selector_path" do
-    it "defaults to ''" do
-      doc._selector_path.should == ''
-    end
-  end
-
-  describe "#_modifier_path" do
-    it "defaults to ''" do
-      doc._modifier_path.should == ''
-    end
-  end
-end

data/spec/scope_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::Scope do
-
-  module Extension
-    def extension_module_method
-      "extension module method"
-    end
-  end
-
-  class ScopeTest
-    include MongoDoc::Document
-
-    attr_accessor :active
-    attr_accessor :count
-
-    scope :active, where(:active => true)
-    scope :count_lte_one, where(:count.lte => 1) do
-      def extension_method
-        "extension method"
-      end
-    end
-    scope :count_gt_one, where(:count.gt => 1), :extend => Extension
-    scope :at_least_count, lambda {|count| where(:count.gt => count)}
-  end
-
-  context ".scope" do
-    it "adds the named scope to the hash of scopes" do
-      ScopeTest.scopes.should have_key(:active)
-    end
-
-    it "creates a class method for the named scope" do
-      ScopeTest.should respond_to(:active)
-    end
-  end
-
-  context "accessing a named scope" do
-    it "is a criteria proxy" do
-      MongoDoc::Scope::CriteriaProxy.should === ScopeTest.active
-    end
-
-    it "responds like a criteria" do
-      ScopeTest.active.should respond_to(:selector)
-    end
-
-    it "has set the conditions on the criteria" do
-      ScopeTest.active.selector.should has_entry(:active => true)
-    end
-
-    it "sets the association extension by block" do
-      ScopeTest.count_lte_one.extension_method.should == "extension method"
-    end
-
-    it "sets the association extension by :extend" do
-      ScopeTest.count_gt_one.extension_module_method.should == "extension module method"
-    end
-
-    context "when using a lambda" do
-      it "accepts parameters to the criteria" do
-        ScopeTest.at_least_count(3).selector.should has_entry(:count => {'$gt' => 3})
-      end
-    end
-  end
-
-  context "chained scopes" do
-    it "is a criteria proxy" do
-      MongoDoc::Scope::CriteriaProxy.should === ScopeTest.active.count_gt_one
-    end
-
-    it "responds like a criteria" do
-      ScopeTest.active.count_gt_one.should respond_to(:selector)
-    end
-
-    it "merges the criteria" do
-      ScopeTest.active.count_gt_one.selector.should have_entries(:count => {'$gt' => 1}, :active => true)
-    end
-
-    it "chains with other criteria" do
-      ScopeTest.active.where(:count => 1).selector.should have_entries(:count => 1, :active => true)
-    end
-
-    let(:id) { BSON::ObjectID.new }
-    it "chains with id" do
-      ScopeTest.active.id(id).selector.should have_entries(:active => true, :_id => id)
-    end
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,16 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mongo_doc'
-require 'rspec'
-require 'rspec/autorun'
-require 'bson_matchers'
-require 'hash_matchers'
-require 'array_including_argument_matcher'
-require 'active_model_behavior'
-require 'document_ext'
-
-RSpec.configure do |config|
-  config.include(BsonMatchers)
-  config.include(HashMatchers)
-  config.include(ActiveModelBehavior)
-end