humanoid 1.2.7

data/spec/unit/mongoid/config_spec.rb

@@ -0,0 +1,165 @@
+require "spec_helper"
+
+describe Humanoid::Config do
+
+  after :all do
+    config.raise_not_found_error = true
+  end
+
+  let(:config) { Humanoid::Config.instance }
+
+  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
+      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
+      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
+
+      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_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
+
+  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,374 @@
+require "spec_helper"
+
+describe Humanoid::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 = Humanoid::Criteria.new(Address)
+    @criteria.documents = @docs
+    @criteria.where(:street => "Bourke Street").only(:number)
+    @context = Humanoid::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 "#count" do
+
+    it "returns the size of the enumerable" do
+      @context.count.should == 4
+    end
+
+  end
+
+  describe "#execute" do
+
+    before do
+      @criteria = Humanoid::Criteria.new(Address)
+      @criteria.documents = @docs
+    end
+
+    it "returns the matching documents from the array" do
+      @context.execute.should == [ @melbourne ]
+    end
+
+    context "when selector is empty" do
+
+      before do
+        @criteria.only(:number)
+        @context = Humanoid::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 = Humanoid::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 = Humanoid::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
+
+      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 = Humanoid::Criteria.new(Address)
+      @criteria.documents = documents
+      @criteria.where(selector).skip(20)
+      @context = Humanoid::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 "#last" do
+
+    it "returns the last matching in the enumerable" do
+      @context.last.should == @melbourne
+    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
+
+    it "returns the first matching in the enumerable" do
+      @context.one.should == @melbourne
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Humanoid::Criteria.new(Person).extras({ :page => 5 })
+        @criteria.documents = []
+        @context = Humanoid::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 = Humanoid::Criteria.new(Person)
+        @criteria.documents = []
+        @context = Humanoid::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 = Humanoid::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 = Humanoid::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 = Humanoid::Criteria.new(Address)
+      criteria.documents = []
+      criteria
+    end
+    let(:context) { criteria.context }
+
+    context "with a single argument" do
+
+      let(:id) { Mongo::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 << Mongo::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 << Mongo::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