mongo_doc 0.6.26 → 0.6.27

data/spec/active_model_behavior.rb

@@ -1,64 +0,0 @@
-module ActiveModelBehavior
-  share_as :AnActiveModel do
-    def be_a_boolean
-      ::Rspec::Matchers::Matcher.new :be_a_boolean do
-        match do |value|
-          [ true, false ].include?( value )
-        end
-      end
-    end
-
-    it { should respond_to(:to_model) }
-    it { should respond_to(:to_key) }
-    it { should respond_to(:to_param) }
-
-    it { should respond_to(:valid?) }
-    its(:valid?) { should be_a_boolean }
-
-    it { should respond_to(:persisted?) }
-    its(:persisted?) { should be_a_boolean }
-
-    its(:class) { should respond_to(:model_name) }
-
-    context "the model name" do
-      subject do
-        described_class.model_name
-      end
-
-      it                  { should be_kind_of(String) }
-      its(:human)         { should be_kind_of(String) }
-      its(:partial_path)  { should be_kind_of(String) }
-      its(:singular)      { should be_kind_of(String) }
-      its(:plural)        { should be_kind_of(String) }
-    end
-
-    context "when its not persisted" do
-      subject do
-        obj = described_class.new
-        obj.stub!(:persisted?).and_return(false)
-        obj
-      end
-
-      its(:to_key)   { should be_nil }
-      its(:to_param) { should be_nil }
-    end
-
-    it { should respond_to(:errors) }
-
-    context "errors" do
-      subject do
-        described_class.new.errors
-      end
-
-      it { should respond_to(:[]) }
-      it { should respond_to(:full_messages) }
-
-      context "[:hello]" do
-        it { subject[:hello].should be_an_instance_of(Array) }
-
-        its(:full_messages) { should be_an_instance_of(Array) }
-      end
-    end
-  end
-end
-

data/spec/array_including_argument_matcher.rb

@@ -1,62 +0,0 @@
-# From http://gist.github.com/62943
-# Author http://github.com/trotter
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-
-      class ArrayIncludingMatcher
-        # We'll allow an array of arguments to be passed in, so that you can do
-        # things like obj.should_receive(:blah).with(array_including('a', 'b'))
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        # actual is the array (hopefully) passed to the method by the user.
-        # We'll check that it includes all the expected values, and return false
-        # if it doesn't or if we blow up because #include? is not defined.
-        def ==(actual)
-          @expected.each do |expected|
-            return false unless actual.include?(expected)
-          end
-          true
-        rescue NoMethodError => ex
-          return false
-        end
-
-        def description
-          "array_including(#{@expected.join(', ')})"
-        end
-      end
-
-      class ArrayNotIncludingMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.each do |expected|
-            return false if actual.include?(expected)
-          end
-          true
-        rescue NoMethodError => ex
-          return false
-        end
-
-        def description
-          "array_not_including(#{@expected.join(', ')})"
-        end
-      end
-
-      # array_including is a helpful wrapper that allows us to actually type
-      # #with(array_including(...)) instead of ArrayIncludingMatcher.new(...)
-      def array_including(*args)
-        ArrayIncludingMatcher.new(*args)
-      end
-
-      def array_not_including(*args)
-        ArrayNotIncludingMatcher.new(*args)
-      end
-
-    end
-  end
-end

data/spec/associations/collection_proxy_spec.rb

@@ -1,233 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::Associations::CollectionProxy do
-  class CollectionProxyTest
-    include MongoDoc::Document
-
-    attr_accessor :name
-  end
-
-  let(:name) { 'embed_many_name' }
-  let(:root) { CollectionProxyTest.new }
-  let(:proxy) { MongoDoc::Associations::CollectionProxy.new(:assoc_name => name, :assoc_class => CollectionProxyTest, :root => root, :parent => root) }
-  let(:item) { CollectionProxyTest.new }
-
-  describe "#_modifier_path" do
-    it "cascades to child documents with our assoc name and $" do
-      document = stub
-      proxy.stub(:collection => [document])
-      document.should_receive(:_modifier_path=).with("new.path.#{name}.$")
-      MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
-      proxy._modifier_path = 'new.path'
-    end
-  end
-
-  describe "#_selector_path=" do
-    it "cascades to child documents" do
-      document = stub
-      proxy.stub(:collection => [document])
-      document.should_receive("_selector_path=").with("new.path.#{name}")
-      MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
-      proxy._selector_path = 'new.path'
-    end
-  end
-
-  context "#attach_document" do
-    it "sets the Document's modifier path to our modifier path" do
-      item.should_receive(:_modifier_path=).with('embed_many_name.$')
-      proxy.send(:attach_document, item)
-    end
-
-    it "sets the Document's selector path to our selector path" do
-      item.should_receive(:_selector_path=).with('embed_many_name')
-      proxy.send(:attach_document, item)
-    end
-  end
-
-  context "#<<" do
-    it "appends the item to the collection" do
-      (proxy << item).should include(item)
-    end
-
-    context "when the item is a Hash" do
-      let(:hash) {{:name => 'hash'}}
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy << hash
-      end
-
-      it "does not set the root" do
-        hash.should_not_receive(:_root=)
-        proxy << hash
-      end
-
-      it "adds the hash to the collection" do
-        proxy << hash
-        proxy.should include(hash)
-      end
-    end
-
-    context "when the item is not a MongoDoc::Document" do
-      let(:other_item) {'not a doc'}
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy << other_item
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy << other_item
-      end
-
-      it "adds the item to the collection" do
-        proxy << other_item
-        proxy.should include(other_item)
-      end
-    end
-
-    context "when the item is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy << item
-      end
-
-      it "sets the root" do
-        proxy << item
-        item._root.should == root
-      end
-    end
-
-    context "when the item is an array" do
-      it "adds the array" do
-        array = ['something else']
-        proxy << array
-        proxy.should include(array)
-      end
-    end
-  end
-
-  context "#[]=" do
-    it "sets the item at the index" do
-      proxy[1] = item
-      proxy[1].should == item
-    end
-
-    context "when the item is not a MongoDoc::Document" do
-      let(:other_item) {'not a doc'}
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy[1] = other_item
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy[1] = other_item
-      end
-
-      it "adds the item to the collection" do
-        proxy[1] = other_item
-        proxy.should include(other_item)
-      end
-    end
-
-    context "when the item is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy[1] = item
-      end
-
-      it "sets the root" do
-        proxy[1] = item
-        item._root.should == root
-      end
-    end
-  end
-
-  context "#concat" do
-    it "appends the items from the array to self" do
-      proxy.concat([item])
-      proxy.should include(item)
-    end
-  end
-
-  context "#replace" do
-    it "clears the existing collection" do
-      proxy.should_receive(:clear)
-      proxy.replace([item])
-    end
-
-    it "concats the other onto self" do
-      other = [item]
-      proxy.should_receive(:concat).with(other)
-      proxy.replace(other)
-    end
-  end
-
-  context "#unshift" do
-    let(:proxy_with_item) { proxy << 'other' }
-
-    it "adds the item to the front of the collection" do
-      proxy_with_item.unshift(item)
-      proxy_with_item[0].should == item
-    end
-
-    context "when the item is not a MongoDoc::Document" do
-      let(:other_item) {'not a doc'}
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy_with_item.unshift(other_item)
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy_with_item.unshift(other_item)
-      end
-
-      it "adds the item to the front of the collection" do
-        proxy_with_item.unshift(other_item)
-        proxy_with_item[0].should == other_item
-      end
-    end
-
-    context "when the item is a MongoDoc::Document" do
-      let(:new_item) { CollectionProxyTest.new }
-
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy_with_item.unshift(new_item)
-      end
-
-      it "sets the root" do
-        proxy_with_item.unshift(new_item)
-        new_item._root.should == root
-      end
-
-      it "adds the item to the front of the collection" do
-        proxy_with_item.unshift(new_item)
-        proxy_with_item[0].should == new_item
-      end
-    end
-  end
-
-  context "#build" do
-    let(:name) {'built'}
-
-    it "adds a built item to the collection" do
-      proxy.build({:name => name}).last.name.should == name
-    end
-
-    it "registers a save observer" do
-      root.should_receive(:register_save_observer)
-      proxy.build({:name => name})
-    end
-
-    it "sets the root" do
-      proxy.build({:name => name})
-      proxy.last._root.should == root
-    end
-  end
-end

data/spec/associations/document_proxy_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Associations::DocumentProxy" do
-  class Parent
-    include MongoDoc::Document
-  end
-
-  class Child
-    include MongoDoc::Document
-  end
-
-  let(:parent) { Parent.new }
-  let(:name) {'association_name'}
-
-  subject do
-    MongoDoc::Associations::DocumentProxy.new(:assoc_name => name, :root => parent, :parent => parent, :assoc_class => Child)
-  end
-
-  describe "#build" do
-    it "#build builds a new object" do
-      Child.should === subject.build({})
-    end
-  end
-
-  context "delegated to the document" do
-    %w(id to_bson).each do |method|
-      it "delegates #{method} to the document" do
-        subject.stub(:document => stub)
-        subject.document.should_receive(method)
-        subject.send(method)
-      end
-    end
-  end
-
-  %w(_modifier_path= _selector_path=).each do |setter|
-    describe "##{setter}" do
-      it "delegates to the document with our assoc name" do
-        subject.stub(:document => stub)
-        subject.document.should_receive(setter).with("new.path.#{name}")
-        MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
-        subject.send("#{setter}", 'new.path')
-      end
-    end
-  end
-end

data/spec/associations/hash_proxy_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-describe MongoDoc::Associations::HashProxy do
-  class HashProxyTest
-    include MongoDoc::Document
-
-    attr_accessor :name
-  end
-
-  let(:name) { 'embed_hash_name' }
-  let(:root) { HashProxyTest.new }
-  let(:proxy) { MongoDoc::Associations::HashProxy.new(:assoc_name => name, :assoc_class => HashProxyTest, :root => root, :parent => root) }
-  let(:item) { HashProxyTest.new }
-  let(:other_item) {[1,2]}
-
-  %w(_modifier_path= _selector_path=).each do |setter|
-    describe "##{setter}" do
-      it "delegates to the document with our assoc name and the key" do
-        document = stub
-        proxy.stub(:hash).and_return(:key => document)
-        document.should_receive(setter).with("new.path.#{name}.key")
-        MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
-        proxy.send("#{setter}", 'new.path')
-      end
-    end
-  end
-
-  context "#[]=" do
-    it "adds the item to the hash" do
-      proxy['new'] = item
-      proxy['new'].should == item
-    end
-
-    context "key names must be a string or symbol constrained by BSON element name" do
-      ['$invalid', 'in.valid', :_id, 'query', 1, Object.new].each do |name|
-        it "#{name} is invalid" do
-          expect do
-            proxy[name] = other_item
-          end.to raise_error(MongoDoc::InvalidEmbeddedHashKey)
-        end
-      end
-
-      [:key, 'key'].each do |name|
-        it "#{name} is a valid name" do
-          expect do
-            proxy[name] = other_item
-          end.to_not raise_error(MongoDoc::InvalidEmbeddedHashKey)
-        end
-      end
-    end
-
-    context "when the item is not a MongoDoc::Document" do
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy['new'] = other_item
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy['new'] = other_item
-      end
-    end
-
-    context "when the item is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy['new'] = item
-      end
-
-      it "sets the root" do
-        proxy['new'] = item
-        item._root.should == root
-      end
-
-      it "adds the item through a document proxy" do
-        proxy['new'] = item
-        MongoDoc::Associations::DocumentProxy.should === proxy['new']
-      end
-    end
-  end
-
-  context "#merge!" do
-    context "when the key value is not a MongoDoc::Document" do
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy.merge!(:new => other_item)
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy.merge!(:new => other_item)
-      end
-    end
-
-    context "when the key value is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy.merge!(:new => item)
-      end
-
-      it "sets the root" do
-        proxy.merge!(:new => item)
-        item._root.should == root
-      end
-    end
-
-    context "with a block" do
-      it "calls into the block" do
-        proxy.merge!(:new => other_item) {|k, v1, v2| @result = v2}
-        @result.should == other_item
-      end
-
-      context "when the key value is not a MongoDoc::Document" do
-
-        it "does not register a save observer" do
-          root.should_not_receive(:register_save_observer)
-          proxy.merge!(:new => other_item) {|k, v1, v2| v2}
-        end
-
-        it "does not set the root" do
-          other_item.should_not_receive(:_root=)
-          proxy.merge!(:new => other_item) {|k, v1, v2| v2}
-        end
-      end
-
-      context "when the key value is a MongoDoc::Document" do
-        it "registers a save observer" do
-          root.should_receive(:register_save_observer)
-          proxy.merge!(:new => item) {|k, v1, v2| v2}
-        end
-
-        it "sets the root" do
-          proxy.merge!(:new => item) {|k, v1, v2| v2}
-          item._root.should == root
-        end
-      end
-    end
-  end
-
-  context "#replace" do
-    it "clears any existing data" do
-      proxy.should_receive(:clear)
-      proxy.replace(:new => other_item)
-    end
-
-    context "when the key value is not a MongoDoc::Document" do
-
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy.replace(:new => other_item)
-      end
-
-      it "does not set the root" do
-        other_item.should_not_receive(:_root=)
-        proxy.replace(:new => other_item)
-      end
-    end
-
-    context "when the key value is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy.replace(:new => item)
-      end
-
-      it "sets the root" do
-        proxy.replace(:new => item)
-        item._root.should == root
-      end
-    end
-
-  end
-
-  context "#build" do
-    it "builds an object of the collection class from the hash attrs" do
-      name = 'built'
-      proxy.build(:key, {:name => name}).name.should == name
-    end
-  end
-end

data/spec/associations/proxy_base_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Associations::ProxyBase" do
-  class ProxyBaseTest
-    include MongoDoc::Associations::ProxyBase
-  end
-
-  let(:_assoc_class) { 'ClassOfAssociation' }
-  let(:_assoc_name) { 'name_of_association' }
-  let(:_root) { 'root of document' }
-  let(:path) { 'root.parent' }
-
-  subject do
-    ProxyBaseTest.new({ :path => path, :assoc_class => _assoc_class, :assoc_name => _assoc_name, :root => _root })
-  end
-
-  %w(_assoc_class _assoc_name _modifier_path _root _selector_path).each do |attr|
-    it "defines #{attr}" do
-      should respond_to(attr)
-    end
-  end
-
-  describe "#initialize" do
-    %w(_assoc_class _assoc_name _root).each do |attr|
-      its(attr) { should == send(attr) }
-    end
-  end
-
-  describe "#_modifier_path" do
-    its(:_modifier_path) { should == path + '.' + _assoc_name }
-  end
-
-  describe "#_modifier_path=" do
-    it "sets the modifier path to the path + '.' + the assoc name" do
-      subject._modifier_path = 'new_path'
-      subject._modifier_path.should == "new_path.#{_assoc_name}"
-    end
-  end
-
-  describe "#_selector_path" do
-    its(:_selector_path) { should == path + '.' + _assoc_name }
-  end
-
-  describe "#_selector_path=" do
-    it "sets the selector path to the path + '.' + the assoc name" do
-      subject._selector_path = 'new_path'
-      subject._selector_path.should == "new_path.#{_assoc_name}"
-    end
-  end
-
-  describe ".is_document" do
-    class TestIsDocument
-      include MongoDoc::Document
-    end
-
-    it "returns false for any non-Document" do
-      MongoDoc::Associations::ProxyBase.is_document?(Object.new).should be_false
-    end
-
-    it "returns true for any Document" do
-      MongoDoc::Associations::ProxyBase.is_document?(TestIsDocument.new).should be_true
-    end
-  end
-
-  describe "#attach" do
-    class AttachDocument
-      include MongoDoc::Document
-    end
-
-    let(:doc) { AttachDocument.new }
-    let(:object) { Object.new }
-    let(:proxy) { ProxyBaseTest.new(:assoc_class => _assoc_class, :assoc_name => _assoc_name, :root => _root) }
-
-    it "returns the attached object" do
-      proxy.send(:attach, object).should == object
-    end
-
-    context "when a Document" do
-      it "attaches the Document" do
-        proxy.should_receive(:attach_document)
-        proxy.send(:attach, doc)
-      end
-    end
-
-    context "when not a Document" do
-      it "does not attach the Document" do
-        proxy.should_not_receive(:attach_document)
-        proxy.send(:attach, object)
-      end
-    end
-  end
-end