mongoid 2.0.0.alpha → 2.0.0.beta.5

data/spec/unit/mongoid/factory_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Factory do
-
-  describe ".build" do
-
-    context "when the _type attribute is present" do
-
-      before do
-        @attributes = { "_type" => "Person", "title" => "Sir" }
-      end
-
-      it "instantiates based on the type" do
-        person = Mongoid::Factory.build(Person, @attributes)
-        person.title.should == "Sir"
-      end
-    end
-
-    context "when _type is not preset" do
-
-      before do
-        @attributes = { "title" => "Sir" }
-      end
-
-      it "instantiates based on the type" do
-        person = Mongoid::Factory.build(Person, @attributes)
-        person.title.should == "Sir"
-      end
-    end
-  end
-end

data/spec/unit/mongoid/field_spec.rb

@@ -1,143 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Field do
-
-  describe "#accessible?" do
-
-    context "when value is not set" do
-
-      before do
-        @field = Mongoid::Field.new(:name)
-      end
-
-      it "defaults to true" do
-        @field.accessible?.should be_true
-      end
-    end
-
-    context "when set to true" do
-
-      before do
-        @field = Mongoid::Field.new(:name, :accessible => true)
-      end
-
-      it "returns true" do
-        @field.accessible?.should be_true
-      end
-    end
-
-    context "when set to false" do
-
-      before do
-        @field = Mongoid::Field.new(:name, :accessible => false)
-      end
-
-      it "returns false" do
-        @field.accessible?.should be_false
-      end
-    end
-  end
-
-  describe "#default" do
-
-    before do
-      @field = Mongoid::Field.new(:score, :default => 0)
-    end
-
-    it "returns the default option" do
-      @field.default.should == 0
-    end
-
-    context "when the field is an array" do
-
-      before do
-        @field = Mongoid::Field.new(:vals, :type => Array, :default => [ "first" ])
-      end
-
-      it "dups the array" do
-        array = @field.default
-        array << "second"
-        @field.default.should == [ "first" ]
-      end
-    end
-
-    context "when the field is a hash" do
-
-      before do
-        @field = Mongoid::Field.new(:vals, :type => Hash, :default => { :key => "value" })
-      end
-
-      it "dups the hash" do
-        hash = @field.default
-        hash[:key_two] = "value2"
-        @field.default.should == { :key => "value" }
-      end
-    end
-
-  end
-
-  describe "#name" do
-
-    before do
-      @field = Mongoid::Field.new(:score, :default => 0)
-    end
-
-    it "returns the name" do
-      @field.name.should == :score
-    end
-
-  end
-
-  describe "#type" do
-
-    before do
-      @field = Mongoid::Field.new(:name)
-    end
-
-    it "defaults to String" do
-      @field.type.should == String
-    end
-
-  end
-
-  describe "#set" do
-
-    before do
-      @type = mock
-      @field = Mongoid::Field.new(:score, :default => 10, :type => @type)
-    end
-
-    context "nil is provided" do
-
-      it "returns the default value" do
-        @field.set(nil).should == 10
-      end
-
-    end
-
-    context "value is provided" do
-
-      it "sets the value" do
-        @type.expects(:set).with("30").returns(30)
-        @field.set("30").should == 30
-      end
-
-    end
-
-  end
-
-  describe "#get" do
-
-    before do
-      @type = mock
-      @field = Mongoid::Field.new(:score, :default => 10, :type => @type)
-    end
-
-    it "returns the value" do
-      @type.expects(:get).with(30).returns(30)
-      @field.get(30).should == 30
-    end
-
-  end
-
-end

data/spec/unit/mongoid/fields_spec.rb

@@ -1,181 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Fields do
-
-  describe ".defaults" do
-
-    it "returns a hash of all the default values" do
-      Game.defaults.should == { "high_score" => 500, "score" => 0 }
-    end
-
-  end
-
-  describe "#defaults" do
-
-    context "with defaults specified as a non-primitive" do
-
-      before do
-        Person.field(:hash_testing, :type => Hash, :default => {})
-        Person.field(:array_testing, :type => Array, :default => [])
-        @first_person = Person.new
-        @second_person = Person.new
-      end
-
-      after do
-        Person.fields.delete("hash_testing")
-        Person.fields.delete("array_testing")
-      end
-
-      it "should not return the same object when calling defaults with a default hash" do
-        @first_person.hash_testing.object_id.should_not == @second_person.hash_testing.object_id
-      end
-
-      it "should not return the same object when calling defaults with a default array" do
-        @first_person.array_testing.object_id.should_not == @second_person.array_testing.object_id
-      end
-    end
-
-    context "on parent classes" do
-
-      before do
-        @shape = Shape.new
-      end
-
-      it "does not return subclass defaults" do
-        @shape.defaults.should == { "x" => 0, "y" => 0 }
-      end
-
-    end
-
-    context "on subclasses" do
-
-      before do
-        @circle = Circle.new
-      end
-
-      it "has the parent and child defaults" do
-        @circle.defaults.should == { "x" => 0, "y" => 0, "radius" => 0 }
-      end
-
-    end
-
-  end
-
-  describe ".field" do
-
-    context "with no options" do
-
-      before do
-        Person.field(:testing)
-      end
-
-      it "adds a reader for the fields defined" do
-        @person = Person.new(:testing => "Test")
-        @person.testing.should == "Test"
-      end
-
-      it "adds a writer for the fields defined" do
-        @person = Person.new(:testing => "Test")
-        @person.testing = "Testy"
-        @person.testing.should == "Testy"
-      end
-
-      it "adds an reader method with a question mark" do
-        @person = Person.new(:testing => "Test")
-        @person.testing?.should be_true
-        Person.new.testing?.should be_false
-      end
-
-    end
-
-    context "when type is an object" do
-
-      before do
-        @person = Person.new
-        @drink = MixedDrink.new(:name => "Jack and Coke")
-        @person.mixed_drink = @drink
-      end
-
-      it "allows proper access to the object" do
-        @person.mixed_drink.should == @drink
-        @person.attributes[:mixed_drink].except(:_id).except(:_type).should ==
-          { "name" => "Jack and Coke" }
-      end
-
-      it "adds an reader method with a question mark" do
-        @person.mixed_drink?.should be_true
-      end
-
-    end
-
-    context "when type is a boolean" do
-
-      before do
-        @person = Person.new(:terms => true)
-      end
-
-      it "adds an accessor method with a question mark" do
-        @person.terms?.should be_true
-      end
-
-    end
-
-    context "when as is specified" do
-
-      before do
-        Person.field :aliased, :as => :alias, :type => Boolean
-        @person = Person.new(:alias => true)
-      end
-
-      it "uses the alias to write the attribute" do
-        @person.expects(:write_attribute).with("aliased", true)
-        @person.alias = true
-      end
-
-      it "uses the alias to read the attribute" do
-        @person.expects(:read_attribute).with("aliased")
-        @person.alias
-      end
-
-      it "uses the alias for the query method" do
-        @person.expects(:read_attribute).with("aliased")
-        @person.alias?
-      end
-
-    end
-
-  end
-
-  describe "#fields" do
-
-    context "on parent classes" do
-
-      before do
-        @shape = Shape.new
-      end
-
-      it "does not return subclass fields" do
-        @shape.fields.keys.should include("x")
-        @shape.fields.keys.should include("y")
-        @shape.fields.keys.should_not include("radius")
-      end
-
-    end
-
-    context "on subclasses" do
-
-      before do
-        @circle = Circle.new
-      end
-
-      it "has the parent and child fields" do
-        @circle.fields.keys.should include("x")
-        @circle.fields.keys.should include("y")
-        @circle.fields.keys.should include("radius")
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/mongoid/finders_spec.rb

@@ -1,404 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Finders do
-
-  before do
-    @collection = stub(:name => "people")
-    @database = stub(:collection => @collection)
-    Mongoid.stubs(:database).returns(@database)
-  end
-
-  after do
-    Person.instance_variable_set(:@collection, nil)
-    @database = nil
-    @collection = nil
-  end
-
-  describe ".all" do
-
-    before do
-      @conditions = { :conditions => { :test => "Test" } }
-    end
-
-    context "when a selector is provided" do
-
-      it "finds from the collection and instantiate objects for each returned" do
-        Mongoid::Criteria.expects(:translate).with(Person, @conditions)
-        Person.all(@conditions)
-      end
-
-    end
-
-    context "when a selector is not provided" do
-
-      it "finds from the collection and instantiate objects for each returned" do
-        Mongoid::Criteria.expects(:translate).with(Person, nil)
-        Person.all
-      end
-
-    end
-
-  end
-
-  describe ".all_in" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.all_in(:aliases => [ "Bond", "007" ])
-      criteria.selector.should == { :aliases => { "$all" => [ "Bond", "007" ] } }
-    end
-
-  end
-
-  describe ".any_in" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.any_in(:aliases => [ "Bond", "007" ])
-      criteria.selector.should == { :aliases => { "$in" => [ "Bond", "007" ] } }
-    end
-
-  end
-
-  describe ".count" do
-
-    before do
-      @conditions = { :conditions => { :title => "Sir" } }
-      @criteria = mock
-    end
-
-    it "delegates to the criteria api" do
-      Mongoid::Criteria.expects(:translate).with(Person, @conditions).returns(@criteria)
-      @criteria.expects(:count).returns(10)
-      Person.count(@conditions).should == 10
-    end
-
-    context "when no options provided" do
-
-      it "adds in the default parameters" do
-        Mongoid::Criteria.expects(:translate).with(Person, nil).returns(@criteria)
-        @criteria.expects(:count).returns(10)
-        Person.count.should == 10
-      end
-
-    end
-
-  end
-
-  describe ".excludes" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.excludes(:title => "Sir")
-      criteria.selector.should == { :title => { "$ne" => "Sir" } }
-    end
-
-  end
-
-  describe ".find" do
-
-    before do
-      @attributes = {}
-      @criteria = mock
-    end
-
-    context "when an id is passed in" do
-
-      before do
-        @id = Mongo::ObjectID.new.to_s
-      end
-
-      it "delegates to criteria" do
-        Mongoid::Criteria.expects(:translate).with(Person, @id.to_s).returns(Person.new)
-        Person.find(@id.to_s)
-      end
-
-      context "when no document is found" do
-
-        it "raises an error" do
-          @error = Mongoid::Errors::DocumentNotFound.new(Person, @id.to_s)
-          Mongoid::Criteria.expects(:translate).with(Person, @id.to_s).raises(@error)
-          lambda { Person.find(@id.to_s) }.should raise_error
-        end
-
-      end
-
-    end
-
-    context "when an array of ids is passed in" do
-
-      before do
-        @ids = []
-        3.times { @ids << Mongo::ObjectID.new.to_s }
-      end
-
-      it "delegates to the criteria" do
-
-      end
-
-    end
-
-    context "when nil passed in" do
-
-      it "raises an error" do
-        lambda { Person.find(nil) }.should raise_error
-      end
-
-    end
-
-    context "when finding first" do
-
-      it "delegates to criteria" do
-        Mongoid::Criteria.expects(:translate).with(Person, :conditions => { :test => "Test" }).returns(@criteria)
-        @criteria.expects(:one).returns(@attributes)
-        Person.find(:first, :conditions => { :test => "Test" })
-      end
-
-    end
-
-    context "when finding all" do
-
-      before do
-        @conditions = { :conditions => { :test => "Test" } }
-      end
-
-      it "delegates to find_all" do
-        Mongoid::Criteria.expects(:translate).with(Person, @conditions).returns(@criteria)
-        Person.find(:all, @conditions)
-      end
-
-    end
-
-    context "when sorting" do
-
-      before do
-        @conditions = { :conditions => { :test => "Test" }, :sort => { :test => -1 } }
-      end
-
-      it "adds the sort parameters for the collection call" do
-        Mongoid::Criteria.expects(:translate).with(Person, @conditions).returns(@criteria)
-        Person.find(:all, @conditions)
-      end
-    end
-
-  end
-
-  describe ".find_or_create_by" do
-
-    before do
-      @person = Person.new(:age => 30)
-      @criteria = mock
-    end
-
-    context "when the document is found" do
-
-      it "returns the document" do
-        Mongoid::Criteria.expects(:translate).with(
-          Person, :conditions => { :age => 30 }
-        ).returns(@criteria)
-        @criteria.expects(:one).returns(@person)
-        Person.find_or_create_by(:age => 30).should == @person
-      end
-
-    end
-
-    context "when the document is not found" do
-
-      it "creates a new document" do
-        Mongoid::Criteria.expects(:translate).with(
-          Person, :conditions => { :age => 30 }
-        ).returns(@criteria)
-        @criteria.expects(:one).returns(nil)
-        Person.expects(:create).returns(@person)
-        person = Person.find_or_create_by(:age => 30)
-        person.should be_a_kind_of(Person)
-        person.age.should == 30
-      end
-
-    end
-
-  end
-
-  describe ".find_or_initialize_by" do
-
-    before do
-      @person = Person.new(:age => 30)
-      @criteria = mock
-    end
-
-    context "when the document is found" do
-
-      it "returns the document" do
-        Mongoid::Criteria.expects(:translate).with(
-          Person, :conditions => { :age => 30 }
-        ).returns(@criteria)
-        @criteria.expects(:one).returns(@person)
-        Person.find_or_initialize_by(:age => 30).should == @person
-      end
-
-    end
-
-    context "when the document is not found" do
-
-      it "returns a new document with the conditions" do
-        Mongoid::Criteria.expects(:translate).with(
-          Person, :conditions => { :age => 30 }
-        ).returns(@criteria)
-        @criteria.expects(:one).returns(nil)
-        person = Person.find_or_initialize_by(:age => 30)
-        person.should be_a_kind_of(Person)
-        person.should be_a_new_record
-        person.age.should == 30
-      end
-
-    end
-
-  end
-
-  describe ".first" do
-
-    before do
-      @criteria = mock
-      @conditions = { :conditions => { :test => "Test" } }
-    end
-
-    context "when a selector is provided" do
-
-      it "finds the first document from the collection and instantiates it" do
-        Mongoid::Criteria.expects(:translate).with(Person, @conditions).returns(@criteria)
-        @criteria.expects(:one)
-        Person.first(@conditions)
-      end
-
-    end
-
-    context "when a selector is not provided" do
-
-      it "finds the first document from the collection and instantiates it" do
-        Mongoid::Criteria.expects(:translate).with(Person, nil).returns(@criteria)
-        @criteria.expects(:one)
-        Person.first
-      end
-
-    end
-
-  end
-
-  describe ".last" do
-
-    before do
-      @criteria = mock
-    end
-
-    it "finds the last document by the id" do
-      Mongoid::Criteria.expects(:translate).with(Person, nil).returns(@criteria)
-      @criteria.expects(:last)
-      Person.last
-    end
-
-  end
-
-  describe ".max" do
-
-    before do
-      @criteria = mock
-    end
-
-    it "returns the sum of a new criteria" do
-      Mongoid::Criteria.expects(:new).returns(@criteria)
-      @criteria.expects(:max).with(:age).returns(50.0)
-      Person.max(:age).should == 50.0
-    end
-
-  end
-
-  describe ".min" do
-
-    before do
-      @criteria = mock
-    end
-
-    it "returns the sum of a new criteria" do
-      Mongoid::Criteria.expects(:new).returns(@criteria)
-      @criteria.expects(:min).with(:age).returns(50.0)
-      Person.min(:age).should == 50.0
-    end
-
-  end
-
-  describe ".not_in" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.not_in(:aliases => [ "Bond", "007" ])
-      criteria.selector.should == { :aliases => { "$nin" => [ "Bond", "007" ] } }
-    end
-
-  end
-
-  describe ".paginate" do
-
-    before do
-      @criteria = stub(:page => 1, :per_page => "20", :count => 100)
-    end
-
-    context "when pagination parameters are passed" do
-
-      before do
-        @params = { :conditions => { :test => "Test" }, :page => 2, :per_page => 20 }
-      end
-
-      it "delegates to will paginate with the results" do
-        Mongoid::Criteria.expects(:translate).with(Person, @params).returns(@criteria)
-        @criteria.expects(:paginate).returns([])
-        Person.paginate(@params)
-      end
-
-    end
-
-    context "when pagination parameters are not passed" do
-
-      before do
-        @params = { :conditions => { :test => "Test" }}
-      end
-
-      it "delegates to will paginate with default values" do
-        Mongoid::Criteria.expects(:translate).with(Person, @params).returns(@criteria)
-        @criteria.expects(:paginate).returns([])
-        Person.paginate(:conditions => { :test => "Test" })
-      end
-
-    end
-
-  end
-
-  describe ".only" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.only(:title, :age)
-      criteria.options.should == { :fields => [ :title, :age ] }
-    end
-
-  end
-
-  describe ".sum" do
-
-    before do
-      @criteria = mock
-    end
-
-    it "returns the sum of a new criteria" do
-      Mongoid::Criteria.expects(:new).returns(@criteria)
-      @criteria.expects(:sum).with(:age).returns(50.0)
-      sum = Person.sum(:age)
-      sum.should == 50.0
-    end
-
-  end
-
-  describe ".where" do
-
-    it "returns a new criteria with select conditions added" do
-      criteria = Person.where(:title => "Sir")
-      criteria.selector.should == { :title => "Sir" }
-    end
-
-  end
-
-end