mongoid 1.2.14 → 1.9.0

data/spec/integration/mongoid/associations_spec.rb

@@ -1,340 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Associations do
-
-  before do
-    Person.delete_all
-    Game.delete_all
-    Post.delete_all
-  end
-
-  context "anonymous extensions" do
-
-    before do
-      @person = Person.new(:title => "Dr")
-      @address_one = Address.new(:street => "Oxford")
-      @address_two = Address.new(:street => "Bond")
-      @name = Name.new(:first_name => "Richard", :last_name => "Dawkins")
-      @person.addresses << [ @address_one, @address_two ]
-      @person.name = @name
-      @person.save
-    end
-
-    context "when defined on a has_many" do
-
-      it "applies the extension" do
-        addresses = @person.addresses.find_by_street("Oxford")
-        addresses.size.should == 1
-        addresses.first.should == @address_one
-      end
-
-    end
-
-    context "when defined on a has_one" do
-
-      it "applies the extension" do
-        name = @person.name
-        name.dawkins?.should be_true
-      end
-
-    end
-
-    context "when defined on a belongs_to" do
-
-      it "applies the extension" do
-        @address_two.addressable.doctor?.should be_true
-      end
-
-    end
-
-  end
-
-  context "creation of an embedded association on a callback" do
-
-    it "allows the use of create!" do
-      artist = Artist.create!(:name => "Depeche Mode")
-      artist.songs.size.should == 2
-      artist.songs.first.title.should == "0"
-      artist.songs.last.title.should == "1"
-    end
-  end
-
-  context "criteria on has many embedded associations" do
-
-    before do
-      @person = Person.new(:title => "Sir")
-      @sf_apartment = Address.new(:street => "Genoa Pl", :state => "CA", :address_type => "Apartment")
-      @la_home = Address.new(:street => "Rodeo Dr", :state => "CA", :address_type => "Home")
-      @sf_home = Address.new(:street => "Pacific", :state => "CA", :address_type => "Home")
-      @person.addresses << [ @sf_apartment, @la_home, @sf_home ]
-    end
-
-    it "handles a single criteria" do
-      cas = @person.addresses.california
-      cas.size.should == 3
-      cas.should == [ @sf_apartment, @la_home, @sf_home ]
-    end
-
-    it "handles chained criteria" do
-      ca_homes = @person.addresses.california.homes
-      ca_homes.size.should == 2
-      ca_homes.should == [ @la_home, @sf_home ]
-    end
-
-    it "handles chained criteria with named scopes" do
-      ca_homes = @person.addresses.california.homes.rodeo
-      ca_homes.size.should == 1
-      ca_homes.should == [ @la_home ]
-    end
-
-  end
-
-  context "one-to-one relational associations" do
-
-    before do
-      @person = Person.new(:title => "Sir")
-      @game = Game.new(:score => 1)
-      @person.game = @game
-      @person.save
-    end
-
-    it "sets the association on save" do
-      @from_db = Person.find(@person.id)
-      @from_db.game.should == @game
-    end
-
-    it "sets the reverse association before save" do
-      @game.person.should == @person
-    end
-
-    it "sets the reverse association after save" do
-      @from_db = Game.find(@game.id)
-      @game.person.should == @person
-    end
-
-  end
-
-  context "one-to-many relational associations" do
-
-    before do
-      @person = Person.new(:title => "Sir")
-      @post = Post.new(:title => "Testing")
-      @person.posts = [@post]
-      @person.save
-    end
-
-    it "sets the association on save" do
-      from_db = Person.find(@person.id)
-      from_db.posts.should == [@post]
-    end
-
-    context "when adding a new association" do
-
-      before do
-        @new_post = Post.new(:title => "New")
-        @person.posts << @new_post
-      end
-
-      it "rememoizes the new association" do
-        @person.posts.should == [ @post, @new_post ]
-      end
-    end
-
-    context "when building" do
-
-      before do
-        @person = Person.new(:title => "Mr")
-        @post = @person.posts.build(:title => "First")
-      end
-
-      it "sets the reverse association" do
-        @post.person.should == @person
-      end
-
-    end
-
-    context "finding associated objects" do
-
-      before do
-        @extra_post = Post.create(:title => "Orphan")
-        @from_db = Person.find(@person.id)
-      end
-
-      context "finding all" do
-
-        it "returns only those objects scoped to the parent" do
-          Post.all.size.should == 2
-          @from_db.posts.all.size.should == 1
-        end
-
-      end
-
-      context "finding with conditions" do
-
-        context "finding all" do
-
-          it "returns only those objects scoped to the parent" do
-            posts = @from_db.posts.find(:all, :conditions => { :title => "Testing" })
-            posts.size.should == 1
-          end
-
-        end
-
-        context "finding first" do
-
-          it "returns only those objects scoped to the parent" do
-            post = @from_db.posts.find(:first, :conditions => { :title => "Testing" })
-            post.should == @post
-          end
-
-        end
-
-        context "finding last" do
-
-          it "returns only those objects scoped to the parent" do
-            post = @from_db.posts.find(:last, :conditions => { :title => "Testing" })
-            post.should == @post
-          end
-
-        end
-
-        context "using a named scope" do
-
-          before do
-            @post.created_at = 15.days.ago
-            @post.save
-          end
-
-          it "returns only those scoped to the parent plus the named scope" do
-            posts = @from_db.posts.recent
-            posts.size.should == 1
-          end
-
-        end
-
-        context "using a criteria class method" do
-
-          before do
-            @post.created_at = 45.days.ago
-            @post.save
-          end
-
-          it "returns only those scoped to the parent plus the named scope" do
-            posts = @from_db.posts.old
-            posts.size.should == 1
-          end
-
-        end
-
-        context "calling criteria methods" do
-
-          before do
-            @post.title = "New Title"
-            @post.save
-          end
-
-          it "returns the proper object for the criteria" do
-            posts = @from_db.posts.where(:title => "New Title")
-            posts.size.should == 1
-          end
-
-          context "when calling with a new criteria" do
-
-            before do
-              @from_db.posts.create(:title => "Other Title")
-            end
-
-            it "does not retain the old criteria" do
-              @from_db.posts.where(:title => "New Title").size.should == 1
-              @from_db.posts.size.should == 2
-              @from_db.posts.where(:title => "Other Title").size.should == 1
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "nested embedded associations" do
-
-    before do
-      @person = Person.create(:title => "Mr")
-    end
-
-    context "one level nested" do
-
-      before do
-        @address = @person.addresses.create(:street => "Oxford St")
-        @name = @person.create_name(:first_name => "Gordon")
-      end
-
-      it "persists all the associations properly" do
-        @name.last_name = "Brown"
-        @person.name.last_name.should == "Brown"
-      end
-
-      it "sets the new_record values properly" do
-        from_db = Person.find(@person.id)
-        new_name = from_db.create_name(:first_name => "Flash")
-        new_name.new_record?.should be_false
-      end
-
-    end
-
-    context "multiple levels nested" do
-
-      context "when a has-many to has_one" do
-
-        before do
-          @person.phone_numbers.create(:number => "4155551212")
-        end
-
-        it "persists all the associations properly" do
-          from_db = Person.find(@person.id)
-          phone = from_db.phone_numbers.first
-          phone.create_country_code(:code => 1)
-          from_db.phone_numbers.first.country_code.code.should == 1
-        end
-
-      end
-
-      context "when a has-one to has-many" do
-
-        before do
-          @person = Person.new(:title => "Sir", :ssn => "1")
-          @name = Name.new(:first_name => "Syd")
-          @person.name = @name
-          @person.save
-        end
-
-        it "persists all the associations properly" do
-          from_db = Person.find(@person.id)
-          translation = Translation.new(:language => "fr")
-          from_db.name.translations << translation
-          from_db.attributes[:name][:translations].should_not be_nil
-        end
-
-      end
-
-      context "when a has-many to has-many" do
-
-        before do
-          @address = Address.new(:street => "Upper Street")
-          @person.addresses << @address
-        end
-
-        it "bubbles the child association up to root" do
-          location = Location.new(:name => "Home")
-          @address.locations << location
-          location.stubs(:valid?).returns(false)
-          @person.save
-          @person.addresses.first.locations.first.should == location
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/integration/mongoid/attributes_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Attributes do
-
-  context "when persisting nil attributes" do
-
-    before do
-      @person = Person.create(:score => nil, :ssn => "555-66-7777")
-    end
-
-    after do
-      Person.delete_all
-    end
-
-    it "the field should exist with a nil value" do
-      from_db = Person.find(@person.id)
-      from_db.attributes.has_key?(:score).should be_true
-    end
-
-  end
-
-end

data/spec/integration/mongoid/commands_spec.rb

@@ -1,218 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Commands do
-
-  before do
-    @person = Person.new(:title => "Sir", :ssn => "6969696", :pets => true)
-  end
-
-  after do
-    @person.delete
-  end
-
-  describe ".create" do
-
-    it "saves and returns the document" do
-      person = Person.create(:title => "Sensei", :ssn => "666-66-6666")
-      person.should be_a_kind_of(Person)
-      person.should_not be_a_new_record
-    end
-
-  end
-
-  describe ".create!" do
-
-    context "inserting with a field that is not unique" do
-
-      context "when a unique index exists" do
-
-        after do
-          Person.delete_all
-        end
-
-        it "raises an error" do
-          Person.create!(:ssn => "555-55-9999")
-          lambda { Person.create!(:ssn => "555-55-9999") }.should raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#delete" do
-
-    context "deleting a root document" do
-
-      before do
-        @person.save
-      end
-
-      it "deletes the document" do
-        @person.delete
-        lambda { Person.find(@person.id) }.should raise_error
-      end
-
-      it "returns true" do
-        @person.delete.should be_true
-      end
-
-    end
-
-    context "deleting an embedded document" do
-
-      before do
-        @address = Address.new(:street => "Bond Street")
-        @person.addresses << @address
-      end
-
-      context "when the document is not yet saved" do
-
-        it "removes the document from the parent" do
-          @address.delete
-          @person.addresses.should be_empty
-          @person.attributes[:addresses].should be_empty
-        end
-
-      end
-
-      context "when the document has been saved" do
-
-        before do
-          @address.save
-        end
-
-        it "removes the object from the parent and database" do
-          @address.delete
-          from_db = Person.find(@person.id)
-          from_db.addresses.should be_empty
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#destroy" do
-
-    context "destroying a root document" do
-
-      before do
-        @person.save
-      end
-
-      it "destroys the document" do
-        @person.destroy
-        lambda { Person.find(@person.id) }.should raise_error
-      end
-
-      it "returns true" do
-        @person.destroy.should be_true
-      end
-
-    end
-
-    context "deleting an embedded document" do
-
-      before do
-        @address = Address.new(:street => "Bond Street")
-        @person.addresses << @address
-      end
-
-      context "when the document is not yet saved" do
-
-        it "removes the document from the parent" do
-          @address.destroy
-          @person.addresses.should be_empty
-          @person.attributes[:addresses].should be_empty
-        end
-
-      end
-
-      context "when the document has been saved" do
-
-        before do
-          @address.save
-        end
-
-        it "removes the object from the parent and database" do
-          @address.destroy
-          from_db = Person.find(@person.id)
-          from_db.addresses.should be_empty
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#save" do
-
-    context "when validation passes" do
-
-      it "returns true" do
-        @person.save.should be_true
-      end
-
-    end
-
-  end
-
-  describe "save!" do
-
-    context "inserting with a field that is not unique" do
-
-      context "when a unique index exists" do
-
-        it "raises an error" do
-          Person.create!(:ssn => "555-55-9999")
-          person = Person.new(:ssn => "555-55-9999")
-          lambda { person.save!(:ssn => "555-55-9999") }.should raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#update_attributes" do
-
-    context "when validation passes" do
-
-      it "returns true" do
-        @person.update_attributes(:ssn => "555-55-1234").should be_true
-      end
-
-      it "saves the attributes" do
-        @person.update_attributes(:ssn => "555-55-1235", :pets => false, :title => nil)
-        @from_db = Person.find(@person.id)
-        @from_db.ssn.should == "555-55-1235"
-        @from_db.pets.should == false
-        @from_db.title.should be_nil
-      end
-
-    end
-
-  end
-
-  describe ".delete_all" do
-
-    it "returns true" do
-      Person.delete_all.should == true
-    end
-
-  end
-
-  describe ".destroy_all" do
-
-    it "returns true" do
-      Person.destroy_all.should == true
-    end
-
-  end
-
-end