mongoid-locomotive 2.0.0.beta9

data/spec/unit/mongoid/collections_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Mongoid::Collections do
+
+  describe ".collection" do
+
+    before do
+      @person = Person.new
+    end
+
+    it "sets the collection name to the class pluralized" do
+      Person.collection.name.should == "people"
+    end
+
+    context "when document is embedded" do
+
+      before do
+        @address = Address.new
+      end
+
+      it "raises an error" do
+        lambda { Address.collection }.should raise_error
+      end
+    end
+  end
+
+  describe ".collection_name=" do
+
+    context "on a parent class" do
+
+      it "sets the collection name on the document class" do
+        Patient.collection_name = "pats"
+        Patient.collection_name.should == "pats"
+      end
+    end
+
+    context "on a subclass" do
+
+      after do
+        Canvas.collection_name = "canvases"
+      end
+
+      it "sets the collection name for the entire hierarchy" do
+        Firefox.collection_name = "browsers"
+        Canvas.collection_name.should == "browsers"
+      end
+    end
+  end
+
+  describe ".index_information" do
+
+    it "returns index information from the collection" do
+      Person.index_information["title_1"].should_not be_nil
+    end
+  end
+
+  describe ".logger=" do
+
+    before do
+      @logger = stub.quacks_like(Logger.allocate)
+      Person.logger = @logger
+    end
+
+    after do
+      Person.logger = nil
+    end
+
+    it "sets the logger on the connection" do
+      Person.db.connection.logger.should == @logger
+    end
+  end
+
+  describe ".store_in" do
+
+    context "on a parent class" do
+
+      it "sets the collection name and collection for the document" do
+        Mongoid::Collection.expects(:new).with(Patient, "population").returns(@collection)
+        Patient.store_in :population
+        Patient.collection_name.should == "population"
+      end
+    end
+
+    context "on a subclass" do
+
+      after do
+        Mongoid::Collection.expects(:new).with(Firefox, "canvases")
+        Firefox.store_in :canvases
+      end
+
+      it "changes the collection name for the entire hierarchy" do
+        Mongoid::Collection.expects(:new).with(Firefox, "browsers").returns(@collection)
+        Firefox.store_in :browsers
+        Canvas.collection_name.should == "browsers"
+      end
+    end
+  end
+end

data/spec/unit/mongoid/config_spec.rb

@@ -0,0 +1,298 @@
+require "spec_helper"
+
+describe Mongoid::Config do
+  let(:config) { Mongoid::Config.instance }
+
+  after do
+    config.reset
+  end
+
+  describe "#database=" do
+
+    context "when object provided is not a Mongo::DB" do
+
+      it "raises an error" do
+        lambda { config.database = "Test" }.should
+          raise_error(Mongoid::Errors::InvalidDatabase)
+      end
+    end
+  end
+
+  describe "#destructive_fields" do
+
+    it "returns an array of bad field names" do
+      config.destructive_fields.should include("collection")
+    end
+  end
+
+  describe "#from_hash" do
+    context "regular mongoid.yml" do
+      before do
+        file_name = File.join(File.dirname(__FILE__), "..", "..", "config", "mongoid.yml")
+        @settings = YAML.load(ERB.new(File.new(file_name).read).result)
+        config.from_hash(@settings["test"])
+      end
+
+      after { config.reset }
+
+      it "sets the master db" do
+        config.master.name.should == "mongoid_config_test"
+      end
+
+      it "sets allow_dynamic_fields" do
+        config.allow_dynamic_fields.should == false
+      end
+
+      it "sets reconnect_time" do
+        config.reconnect_time.should == 5
+      end
+
+      it "sets parameterize keys" do
+        config.parameterize_keys.should == false
+      end
+
+      it "sets persist_in_safe_mode" do
+        config.persist_in_safe_mode.should == false
+      end
+
+      it "sets raise_not_found_error" do
+        config.raise_not_found_error.should == false
+      end
+
+      it "sets use_object_ids" do
+        config.use_object_ids.should == true
+      end
+
+      it "returns nil, which is interpreted as the local time_zone" do
+        config.use_utc.should be_false
+      end
+    end
+
+    context "mongoid_with_utc.yml" do
+      before do
+        file_name = File.join(File.dirname(__FILE__), "..", "..", "config", "mongoid_with_utc.yml")
+        file = File.new(file_name)
+        @settings = YAML.load(file.read)["test"]
+        config.from_hash(@settings)
+      end
+
+      after { config.reset }
+
+      it "sets time_zone" do
+        config.use_utc.should be_true
+      end
+    end
+
+  end
+
+  describe "#master=" do
+
+    context "when object provided is not a Mongo::DB" do
+
+      it "raises an error" do
+        lambda { config.master = "Test" }.should
+          raise_error(Mongoid::Errors::InvalidDatabase)
+      end
+    end
+
+    context "when the database version is not supported" do
+
+      let(:database) do
+        stub.quacks_like(Mongo::DB.allocate)
+      end
+
+      let(:connection) do
+        stub.quacks_like(Mongo::Connection.allocate)
+      end
+
+      let(:version) do
+        Mongo::ServerVersion.new("1.3.0")
+      end
+
+      before do
+        database.stubs(:kind_of?).returns(true)
+        database.stubs(:connection).returns(connection)
+        connection.stubs(:server_version).returns(version)
+      end
+
+      it "raises an error" do
+        lambda { config.master = database }.should
+          raise_error(Mongoid::Errors::UnsupportedVersion)
+      end
+    end
+  end
+
+  describe "#parameterize_keys" do
+
+    it "defaults to true" do
+      config.parameterize_keys.should == true
+    end
+  end
+
+  describe "#persist_in_safe_mode=" do
+
+    context "when setting to true" do
+
+      before do
+        config.persist_in_safe_mode = true
+      end
+
+      it "sets the value" do
+        config.persist_in_safe_mode.should == true
+      end
+
+    end
+
+    context "when setting to false" do
+
+      before do
+        config.persist_in_safe_mode = false
+      end
+
+      after do
+        config.persist_in_safe_mode = true
+      end
+
+      it "sets the value" do
+        config.persist_in_safe_mode.should == false
+      end
+
+    end
+
+  end
+
+  describe "#raise_not_found_error=" do
+
+    context "when setting to true" do
+
+      before do
+        config.raise_not_found_error = true
+      end
+
+      it "sets the value" do
+        config.raise_not_found_error.should == true
+      end
+
+    end
+
+    context "when setting to false" do
+
+      before do
+        config.raise_not_found_error = false
+      end
+
+      it "sets the value" do
+        config.raise_not_found_error.should == false
+      end
+
+    end
+
+  end
+
+  describe "#reconnect!" do
+
+    before do
+      @connection = mock
+      @master = mock
+      config.expects(:master).returns(@master)
+      @master.expects(:connection).returns(@connection)
+    end
+
+    it "reconnects on the master connection" do
+      @connection.expects(:connect_to_master).returns(true)
+      config.reconnect!
+    end
+  end
+
+  describe "#reconnect_time" do
+
+    it "defaults to 3" do
+      config.reconnect_time.should == 3
+    end
+
+  end
+
+  describe "#reconnect_time=" do
+
+    after do
+      config.reconnect_time = 3
+    end
+
+    it "sets the time" do
+      config.reconnect_time = 5
+      config.reconnect_time.should == 5
+    end
+  end
+
+  describe "#slaves=" do
+
+    context "when object provided is not a Mongo::DB" do
+
+      it "raises an error" do
+        lambda { config.slaves = ["Test"] }.should raise_error
+      end
+    end
+
+    context "when the database version is not supported" do
+
+      let(:database) do
+        stub.quacks_like(Mongo::DB.allocate)
+      end
+
+      let(:connection) do
+        stub.quacks_like(Mongo::Connection.allocate)
+      end
+
+      let(:version) do
+        Mongo::ServerVersion.new("1.3.0")
+      end
+
+      before do
+        database.stubs(:kind_of?).returns(true)
+        database.stubs(:connection).returns(connection)
+        connection.stubs(:server_version).returns(version)
+      end
+
+      it "raises an error" do
+        lambda { config.slaves = [ database ] }.should
+          raise_error(Mongoid::Errors::UnsupportedVersion)
+      end
+    end
+  end
+
+  describe "#allow_dynamic_fields=" do
+
+    context "when setting to true" do
+
+      before do
+        config.allow_dynamic_fields = true
+      end
+
+      it "sets the value" do
+        config.allow_dynamic_fields.should == true
+      end
+
+    end
+
+    context "when setting to false" do
+
+      before do
+        config.allow_dynamic_fields = false
+      end
+
+      it "sets the value" do
+        config.allow_dynamic_fields.should == false
+      end
+
+    end
+
+  end
+
+  describe "#use_object_ids" do
+
+    it "defaults to false" do
+      config.use_object_ids.should == false
+    end
+  end
+
+end

data/spec/unit/mongoid/contexts/enumerable_spec.rb

@@ -0,0 +1,447 @@
+require "spec_helper"
+
+describe Mongoid::Contexts::Enumerable do
+
+  before do
+    @london = Address.new(:number => 1, :street => "Bond Street")
+    @shanghai = Address.new(:number => 10, :street => "Nan Jing Dong Lu")
+    @melbourne = Address.new(:number => 20, :street => "Bourke Street")
+    @new_york = Address.new(:number => 20, :street => "Broadway")
+    @docs = [ @london, @shanghai, @melbourne, @new_york ]
+    @criteria = Mongoid::Criteria.new(Address)
+    @criteria.documents = @docs
+    @criteria.only(:number)
+    @context = Mongoid::Contexts::Enumerable.new(@criteria)
+  end
+
+  describe "#aggregate" do
+
+    before do
+      @counts = @context.aggregate
+    end
+
+    it "groups by the fields provided in the options" do
+      @counts.size.should == 3
+    end
+
+    it "stores the counts in proper groups" do
+      @counts[1].should == 1
+      @counts[10].should == 1
+      @counts[20].should == 2
+    end
+  end
+
+  describe "#avg" do
+
+    it "returns the avg value for the supplied field" do
+      @context.avg(:number).should == 12.75
+    end
+  end
+
+  describe "#count" do
+
+    it "returns the size of the enumerable" do
+      @context.count.should == 4
+    end
+
+  end
+
+  describe "#distinct" do
+
+    context "when the criteria is limited" do
+
+      before do
+        @criteria.where(:street => "Bourke Street")
+      end
+
+      it "returns an array of distinct values for the field" do
+        @context.distinct(:street).should == [ "Bourke Street" ]
+      end
+    end
+
+    context "when the criteria is not limited" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Address)
+        @criteria.documents = @docs
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns an array of distinct values for the field" do
+        @context.distinct(:street).should ==
+          [ "Bond Street", "Nan Jing Dong Lu", "Bourke Street", "Broadway" ]
+      end
+    end
+  end
+
+  describe "#execute" do
+
+    before do
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = @docs
+    end
+
+    context "when the selector is present" do
+      before do
+        @criteria.where(:street => "Bourke Street")
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+      it "returns the matching documents from the array" do
+        @context.execute.should == [ @melbourne ]
+      end
+    end
+
+    context "when selector is empty" do
+
+      before do
+        @criteria.only(:number)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns all the documents" do
+        @context.execute.should == @docs
+      end
+    end
+
+    context "when skip and limit are in the options" do
+
+      before do
+        @criteria.skip(2).limit(2)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "properly narrows down the matching results" do
+        @context.execute.should == [ @melbourne, @new_york ]
+      end
+    end
+
+    context "when limit is set without skip in the options" do
+
+      before do
+        @criteria.limit(2)
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "properly narrows down the matching results" do
+        @context.execute.size.should == 2
+      end
+
+  end
+
+  end
+
+  describe "#first" do
+
+    context "when a selector is present" do
+      before do
+        @criteria.where(:street => "Bourke Street")
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns the first that matches the selector" do
+        @context.first.should == @melbourne
+      end
+    end
+
+  end
+
+  describe "#group" do
+
+    before do
+      @group = @context.group
+    end
+
+    it "groups by the fields provided in the options" do
+      @group.size.should == 3
+    end
+
+    it "stores the documents in proper groups" do
+      @group[1].should == [ @london ]
+      @group[10].should == [ @shanghai ]
+      @group[20].should == [ @melbourne, @new_york ]
+    end
+
+  end
+
+  describe ".initialize" do
+
+    let(:selector) { { :field => "value"  } }
+    let(:options) { { :skip => 20 } }
+    let(:documents) { [stub] }
+
+    before do
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = documents
+      @criteria.where(selector).skip(20)
+      @context = Mongoid::Contexts::Enumerable.new(@criteria)
+    end
+
+    it "sets the selector" do
+      @context.selector.should == selector
+    end
+
+    it "sets the options" do
+      @context.options.should == options
+    end
+
+    it "sets the documents" do
+      @context.documents.should == documents
+    end
+
+  end
+
+  describe "#iterate" do
+    before do
+      @criteria.where(:street => "Bourke Street")
+      @criteria.documents = @docs
+      @context = Mongoid::Contexts::Enumerable.new(@criteria)
+    end
+
+    it "executes the criteria" do
+      acc = []
+      @context.iterate do |doc|
+        acc << doc
+      end
+      acc.should == [@melbourne]
+    end
+  end
+
+  describe "#last" do
+
+    context "when the selector is present" do
+      before do
+        @criteria.where(:street => "Bourke Street")
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+      it "returns the last matching in the enumerable" do
+        @context.last.should == @melbourne
+      end
+    end
+
+  end
+
+  describe "#max" do
+
+    it "returns the max value for the supplied field" do
+      @context.max(:number).should == 20
+    end
+
+  end
+
+  describe "#min" do
+
+    it "returns the min value for the supplied field" do
+      @context.min(:number).should == 1
+    end
+
+  end
+
+  describe "#one" do
+
+    context "when the selector is present" do
+      before do
+        @criteria.where(:street => "Bourke Street")
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+      it "returns the first matching in the enumerable" do
+        @context.one.should == @melbourne
+      end
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns the page option" do
+        @context.page.should == 5
+      end
+
+    end
+
+    context "when the page option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person)
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns 1" do
+        @context.page.should == 1
+      end
+
+    end
+
+  end
+
+  describe "#paginate" do
+
+    before do
+      @criteria = Person.criteria.skip(2).limit(2)
+      @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      @results = @context.paginate
+    end
+
+    it "executes and paginates the results" do
+      @results.current_page.should == 2
+      @results.per_page.should == 2
+    end
+
+  end
+
+  describe "#per_page" do
+
+    context "when a limit option exists" do
+
+      it "returns 20" do
+        @context.per_page.should == 20
+      end
+
+    end
+
+    context "when a limit option does not exist" do
+
+      before do
+        @criteria = Person.criteria.limit(50)
+        @criteria.documents = []
+        @context = Mongoid::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns the limit" do
+        @context.per_page.should == 50
+      end
+
+    end
+
+  end
+
+  describe "#sum" do
+
+    it "returns the sum of all the field values" do
+      @context.sum(:number).should == 51
+    end
+
+  end
+
+  context "#id_criteria" do
+
+    let(:criteria) do
+      criteria = Mongoid::Criteria.new(Address)
+      criteria.documents = []
+      criteria
+    end
+    let(:context) { criteria.context }
+
+    context "with a single argument" do
+
+      let(:id) { BSON::ObjectID.new.to_s }
+
+      before do
+        criteria.expects(:id).with(id).returns(criteria)
+      end
+
+      context "when the document is found" do
+
+        let(:document) { stub }
+
+        it "returns a matching document" do
+          context.expects(:one).returns(document)
+          document.expects(:blank? => false)
+          context.id_criteria(id).should == document
+        end
+
+      end
+
+      context "when the document is not found" do
+
+        it "raises an error" do
+          context.expects(:one).returns(nil)
+          lambda { context.id_criteria(id) }.should raise_error
+        end
+
+      end
+
+    end
+
+    context "multiple arguments" do
+
+      context "when an array of ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << BSON::ObjectID.new.to_s }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+
+      context "when an array of object ids" do
+
+        let(:ids) do
+          (0..2).inject([]) { |ary, i| ary << BSON::ObjectID.new }
+        end
+
+        context "when documents are found" do
+
+          let(:docs) do
+            (0..2).inject([]) { |ary, i| ary << stub }
+          end
+
+          before do
+            criteria.expects(:id).with(ids).returns(criteria)
+          end
+
+          it "returns matching documents" do
+            context.expects(:execute).returns(docs)
+            context.id_criteria(ids).should == docs
+          end
+
+        end
+
+        context "when documents are not found" do
+
+          it "raises an error" do
+            context.expects(:execute).returns([])
+            lambda { context.id_criteria(ids) }.should raise_error
+          end
+
+        end
+
+      end
+    end
+
+  end
+
+end