dm-mongo-adapter 0.2.0.pre3 → 0.6.0

data/spec/public/types/df_ref_spec.rb

@@ -1,6 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Types::DBRef do
-  before(:all) { @type_class = DataMapper::Mongo::Types::DBRef }
-  it_should_behave_like 'An ObjectID Type'
-end

data/spec/public/types/discriminator_spec.rb

@@ -1,118 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Types::Discriminator do
-  before :all do
-    class Article
-      include DataMapper::Mongo::Resource
-
-      property :id,    ObjectID
-      property :title, String, :required => true
-      property :type,  Discriminator
-    end
-
-    class Announcement < Article; end
-    class Release < Announcement; end
-
-    Article.all.destroy!
-
-    @article_model      = Article
-    @announcement_model = Announcement
-    @release_model      = Release
-  end
-
-  it 'should typecast to a Model' do
-    @article_model.properties[:type].typecast('Release').should equal(@release_model)
-  end
-
-  describe 'Model#new' do
-    describe 'when provided a String discriminator in the attributes' do
-      before :all do
-        @resource = @article_model.new(:type => 'Release')
-      end
-
-      it 'should return a Resource' do
-        @resource.should be_kind_of(DataMapper::Resource)
-      end
-
-      it 'should be an descendant instance' do
-        @resource.should be_instance_of(Release)
-      end
-    end
-
-    describe 'when provided a Class discriminator in the attributes' do
-      before :all do
-        @resource = @article_model.new(:type => Release)
-      end
-
-      it 'should return a Resource' do
-        @resource.should be_kind_of(DataMapper::Resource)
-      end
-
-      it 'should be an descendant instance' do
-        @resource.should be_instance_of(Release)
-      end
-    end
-
-    describe 'when not provided a discriminator in the attributes' do
-      before :all do
-        @resource = @article_model.new
-      end
-
-      it 'should return a Resource' do
-        @resource.should be_kind_of(DataMapper::Resource)
-      end
-
-      it 'should be a base model instance' do
-        @resource.should be_instance_of(@article_model)
-      end
-    end
-  end
-
-  describe 'Model#descendants' do
-    it 'should set the descendants for the grandparent model' do
-      @article_model.descendants.to_a.should == [ @article_model, @announcement_model, @release_model ]
-    end
-
-    it 'should set the descendants for the parent model' do
-      @announcement_model.descendants.to_a.should == [ @announcement_model, @release_model ]
-    end
-
-    it 'should set the descendants for the child model' do
-      @release_model.descendants.to_a.should == [ @release_model ]
-    end
-  end
-
-  describe 'Model#default_scope' do
-    it 'should set the default scope for the grandparent model' do
-      @article_model.default_scope[:type].should equal(@article_model.descendants)
-    end
-
-    it 'should set the default scope for the parent model' do
-      @announcement_model.default_scope[:type].should equal(@announcement_model.descendants)
-    end
-
-    it 'should set the default scope for the child model' do
-      @release_model.default_scope[:type].should equal(@release_model.descendants)
-    end
-  end
-
-  before :all do
-    @announcement = @announcement_model.create(:title => 'Announcement')
-  end
-
-  it 'should persist the type' do
-    @announcement.model.get(*@announcement.key).type.should equal(@announcement_model)
-  end
-
-  it 'should be retrieved as an instance of the correct class' do
-    @announcement.model.get(*@announcement.key).should be_instance_of(@announcement_model)
-  end
-
-  it 'should include descendants in finders' do
-    @article_model.first.should eql(@announcement)
-  end
-
-  it 'should not include ancestors' do
-    @release_model.first.should be_nil
-  end
-end

data/spec/public/types/embedded_array_spec.rb

@@ -1,55 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Types::EmbeddedArray do
-  describe '.load' do
-    it 'should return nil when given nil' do
-      DataMapper::Mongo::Types::EmbeddedArray.load(nil, nil).should be_nil
-    end
-
-    it 'should return the argument when given an Array' do
-      loaded = DataMapper::Mongo::Types::EmbeddedArray.load([1, 2], nil)
-      loaded.should == [1, 2]
-    end
-
-    it 'should raise an error when given anything else' do
-      pending "EmbeddedArray should not be able to load arbitrary objects" do
-        [ 0, 1, Object.new, true, false, {} ].each do |value|
-          lambda {
-            DataMapper::Mongo::Types::EmbeddedArray.load(value, nil)
-          }.should raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  describe '.dump' do
-    it 'should return nil when given nil' do
-      DataMapper::Mongo::Types::EmbeddedArray.dump(nil, nil).should == nil
-    end
-
-    it 'should return the argument when given an Array' do
-      dumped = DataMapper::Mongo::Types::EmbeddedArray.dump([1, 2], nil)
-      dumped.should == [1, 2]
-    end
-
-    it 'should return an Array when given a Set' do
-      pending do
-        dumped = DataMapper::Mongo::Types::EmbeddedArray.dump(Set.new(1, 2), nil)
-        dumped.should be_kind_of(Array)
-        dumped.should == [1, 2]
-      end
-    end
-
-    it 'should raise an error when given anything else' do
-      pending "EmbeddedArray should not be able to dump objects which " \
-              "can't later be loaded" do
-        [ 0, 1, Object.new, true, false, {} ].each do |value|
-          lambda {
-            DataMapper::Mongo::Types::EmbeddedArray.dump(value, nil)
-          }.should raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-end

data/spec/public/types/embedded_hash_spec.rb

@@ -1,83 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Types::EmbeddedHash do
-  EHash = DataMapper::Mongo::Types::EmbeddedHash
-
-  describe '.load' do
-    it 'should return nil when given nil' do
-      EHash.load(nil, nil).should be_nil
-    end
-
-    it 'should return an empty Hash when given an empty Hash' do
-      loaded = EHash.load({}, nil)
-      loaded.should == {}
-    end
-
-    it 'should return a Hash with values when given a Hash with values' do
-      loaded = EHash.load({ :hello => 'World' }, nil)
-      loaded.should == { :hello => 'World' }
-    end
-
-    it 'should return a Hash with symbolized keys' do
-      loaded = EHash.load({ 'hello' => 'World' }, nil)
-      loaded.should == { :hello => 'World' }
-    end
-
-    it 'should return an empty Hash when given an Array with no values' do
-      loaded = EHash.load([], nil)
-      loaded.should == {}
-    end
-
-    it 'should return an empty Hash with values when given an Array with values' do
-      loaded = EHash.load([:hello, 'World'], nil)
-      loaded.should == { :hello => 'World' }
-    end
-
-    it 'should raise an error when given anything else' do
-      pending "EmbeddedHash should not be able to load arbitrary objects" do
-        lambda { EHash.load(0, nil) }.should          raise_error(ArgumentError)
-        lambda { EHash.load(1, nil) }.should          raise_error(ArgumentError)
-        lambda { EHash.load(Object.new, nil) }.should raise_error(ArgumentError)
-        lambda { EHash.load(true, nil) }.should       raise_error(ArgumentError)
-        lambda { EHash.load(false, nil) }.should      raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '.dump' do
-    it 'should return nil when given nil' do
-      EHash.dump(nil, nil).should be_nil
-    end
-
-    it 'should return an empty Hash when given an empty Hash' do
-      EHash.dump({}, nil).should == {}
-    end
-
-    it 'should return a Hash with values when given a Hash with values' do
-      EHash.dump({ :hello => 'World' }, nil).should == { :hello => 'World' }
-    end
-
-    it 'should return an empty Hash when given an empty Mash' do
-      EHash.dump(Mash.new, nil).should == {}
-    end
-
-    it 'should return a Hash with values when given a Mash with values' do
-      dumped = EHash.dump(Mash.new('hello' => 'World'), nil)
-      dumped.should == { 'hello' => 'World' }
-    end
-
-    it 'should raise an error when given anything else' do
-      pending "EmbeddedHash should not be able to dump objects which " \
-              "can't later be loaded" do
-        lambda { EHash.dump(0, nil) }.should          raise_error(ArgumentError)
-        lambda { EHash.dump(1, nil) }.should          raise_error(ArgumentError)
-        lambda { EHash.dump(Object.new, nil) }.should raise_error(ArgumentError)
-        lambda { EHash.dump(true, nil) }.should       raise_error(ArgumentError)
-        lambda { EHash.dump(false, nil) }.should      raise_error(ArgumentError)
-        lambda { EHash.dump([], nil) }.should         raise_error(ArgumentError)
-      end
-    end
-
-  end
-
-end

data/spec/public/types/object_id_spec.rb

@@ -1,6 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Types::ObjectID do
-  before(:all) { @type_class = DataMapper::Mongo::Types::ObjectID }
-  it_should_behave_like 'An ObjectID Type'
-end

data/spec/semipublic/embedded_model_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Resource do
-
-  before(:all) do
-    class ::CarType
-      include DataMapper::Mongo::EmbeddedResource
-      property :name, String
-    end
-
-    class ::Car
-      include DataMapper::Mongo::Resource
-      property :model, String
-    end
-
-    class ::DMCar
-      include DataMapper::Resource
-      property :type, String
-    end
-  end
-
-  #
-  # descendants
-  #
-
-  describe '#descendants' do
-    before(:all) do
-      @descendants = DataMapper::Mongo::EmbeddedModel.descendants
-    end
-
-    it 'should include Mongo embedment models' do
-      @descendants.should include(CarType)
-    end
-
-    it 'should not include Mongo models' do
-      @descendants.should_not include(Car)
-    end
-
-    it 'should not include DataMapper models' do
-      @descendants.should_not include(DMCar)
-    end
-  end
-end

data/spec/semipublic/model/embedment_spec.rb

@@ -1,42 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Model::Embedment do
-
-  before(:all) do
-    class ::Address
-      include DataMapper::Mongo::EmbeddedResource
-      property :street, String
-      property :city,   String, :field => 'conurbation'
-    end
-
-    class ::User
-      include DataMapper::Mongo::Resource
-      property :id, ObjectID
-      embeds 1, :address
-      embeds n, :locations, Address
-    end
-  end
-
-  describe '#embedments' do
-    before(:all) do
-      @embedments = User.embedments
-    end
-
-    it 'should return a hash' do
-      @embedments.should be_kind_of(Hash)
-    end
-
-    it 'should include OneToOne embedments' do
-      @embedments.should have_key(:address)
-      @embedments[:address].should \
-        be_kind_of(DataMapper::Mongo::Embedments::OneToOne::Relationship)
-    end
-
-    it 'should include OneToMany embedments' do
-      @embedments.should have_key(:locations)
-      @embedments[:locations].should \
-        be_kind_of(DataMapper::Mongo::Embedments::OneToMany::Relationship)
-    end
-  end
-
-end

data/spec/semipublic/resource_spec.rb

@@ -1,70 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Mongo::Resource do
-
-  before(:all) do
-    class ::Address
-      include DataMapper::Mongo::EmbeddedResource
-      property :city, String
-    end
-
-    class ::User
-      include DataMapper::Mongo::Resource
-      property  :id,        ObjectID
-      property  :name,      String
-      property  :tags,      Array
-      property  :metadata,  Hash
-      embeds 1, :address,   :model => Address
-      embeds n, :locations, :model => Address
-    end
-  end
-
-  #
-  # dirty_attributes
-  #
-
-  describe '#dirty_attributes' do
-    describe 'when the resource has a change' do
-      it 'should return true' do
-        dirty = User.new(:name => 'Mongo').dirty_attributes
-        dirty.should == { User.properties[:name] => 'Mongo' }
-      end
-    end
-
-    describe 'when the resource has no changes' do
-      it 'should return true if a one-to-one embedment has a change' do
-        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-        user.dirty_attributes.should == {
-          User.embedments[:address] => {
-            Address.properties[:city] => 'Rock Ridge'
-          }
-        }
-      end
-
-      it 'should return false having just been saved' do
-        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-        user.save
-        user.dirty_attributes.should == {}
-        user.dirty_attributes.should be_empty
-      end
-
-      it 'should return true if a one-to-many embedment has a change' do
-        user = User.new
-        user.locations << Address.new(:city => 'Rock Ridge')
-        user.dirty_attributes.should == {
-          User.embedments[:locations] => [{
-            Address.properties[:city] => 'Rock Ridge'
-          }]
-        }
-      end
-
-      it 'should return false if no embedments have changes' do
-        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
-        user.locations << Address.new(:city => 'Rock Ridge')
-        user.save
-        user.dirty_attributes.should be_empty
-      end
-    end
-  end # dirty_attributes
-
-end