mongoid-locomotive 2.0.0.beta9

data/spec/unit/mongoid/hierarchy_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Mongoid::Hierarchy do
+
+  describe "#_children" do
+
+    let(:person) do
+      Person.new(:title => "King")
+    end
+
+    context "with one level of embedding" do
+
+      let(:name) do
+        Name.new(:first_name => "Titus")
+      end
+
+      let(:address) do
+        Address.new(:street => "Queen St")
+      end
+
+      before do
+        person.name = name
+        person.addresses << address
+      end
+
+      it "includes embeds_one documents" do
+        person._children.should include(name)
+      end
+
+      it "includes embeds_many documents" do
+        person._children.should include(address)
+      end
+    end
+
+    context "with multiple levels of embedding" do
+
+      let(:name) do
+        Name.new(:first_name => "Titus")
+      end
+
+      let(:address) do
+        Address.new(:street => "Queen St")
+      end
+
+      let(:location) do
+        Location.new(:name => "Work")
+      end
+
+      before do
+        person.name = name
+        address.locations << location
+        person.addresses << address
+      end
+
+      it "includes embeds_one documents" do
+        person._children.should include(name)
+      end
+
+      it "includes embeds_many documents" do
+        person._children.should include(address)
+      end
+
+      it "includes embedded documents multiple levels deep" do
+        person._children.should include(location)
+      end
+    end
+  end
+end

data/spec/unit/mongoid/identity_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe Mongoid::Identity do
+
+  describe ".create" do
+
+    let(:name) { Name.new }
+
+    context "when class is inherited" do
+
+      let(:canvas) { Canvas.new }
+
+      it "sets the document _type to the class name" do
+        Mongoid::Identity.new(canvas).create
+        canvas._type.should == "Canvas"
+      end
+
+    end
+
+    context "when class is a subclass" do
+
+      let(:browser) { Browser.new }
+
+      it "sets the document _type to the class name" do
+        Mongoid::Identity.new(browser).create
+        browser._type.should == "Browser"
+      end
+
+    end
+
+    context "when not using inheritance" do
+
+      it "does not set the type" do
+        name._type.should be_nil
+      end
+
+    end
+
+    context "when the document has a primary key" do
+
+      before do
+        @address = Address.allocate
+        @address.instance_variable_set(:@attributes, { "street" => "Market St"})
+      end
+
+      it "sets the id to the composite key" do
+        Mongoid::Identity.new(@address).create
+        @address.id.should == "market-st"
+      end
+
+    end
+
+    context "when the document has no primary key" do
+
+      context "when the document has no id" do
+
+        before do
+          @person = Person.allocate
+          @person.instance_variable_set(:@attributes, {})
+          @object_id = stub(:to_s => "1")
+          BSON::ObjectID.expects(:new).returns(@object_id)
+        end
+
+        context "when using object ids" do
+
+          before do
+            Mongoid.use_object_ids = true
+          end
+
+          after do
+            Mongoid.use_object_ids = false
+          end
+
+          it "sets the id to a mongo object id" do
+            Mongoid::Identity.new(@person).create
+            @person.id.should == @object_id
+          end
+        end
+
+        context "when not using object ids" do
+
+          it "sets the id to a mongo object id string" do
+            Mongoid::Identity.new(@person).create
+            @person.id.should == "1"
+          end
+
+        end
+
+      end
+
+      context "when the document has an id" do
+
+        before do
+          @person = Person.allocate
+          @person.instance_variable_set(:@attributes, { "_id" => "5" })
+        end
+
+        it "returns the existing id" do
+          Mongoid::Identity.new(@person)
+          @person.id.should == "5"
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/indexes_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+describe Mongoid::Indexes do
+
+  describe ".included" do
+
+    before do
+      @class = Class.new do
+        include Mongoid::Indexes
+      end
+    end
+
+    it "adds an indexed accessor" do
+      @class.should respond_to(:indexed)
+    end
+
+    it "defaults indexed to false" do
+      @class.indexed.should be_false
+    end
+
+  end
+
+  describe ".add_indexes" do
+
+    before do
+      @collection = mock
+    end
+
+    context "when indexes have not been added" do
+
+      before do
+        @class = Class.new do
+          include Mongoid::Indexes
+          def self.hereditary
+            true
+          end
+        end
+      end
+
+      it "adds the _type index" do
+        @class.expects(:_collection).returns(@collection)
+        @collection.expects(:create_index).with(:_type, :unique => false, :background => true)
+        @class.add_indexes
+        @class.indexed.should be_true
+      end
+
+    end
+
+    context "when indexes have been added" do
+
+      before do
+        @class = Class.new do
+          include Mongoid::Indexes
+          def self.hereditary
+            true
+          end
+        end
+        @class.indexed = true
+      end
+
+      it "ignores the request" do
+        @class.add_indexes
+      end
+
+    end
+
+  end
+
+  describe ".index" do
+
+    before do
+      @collection = mock
+      @class = Class.new do
+        include Mongoid::Indexes
+      end
+      @class.expects(:collection).returns(@collection)
+    end
+
+    context "when unique" do
+
+      it "creates a unique index on the collection" do
+        @collection.expects(:create_index).with(:name, :unique => true)
+        @class.index(:name, :unique => true)
+      end
+
+    end
+
+    context "when not unique" do
+
+      it "creates an index on the collection" do
+        @collection.expects(:create_index).with(:name, :unique => false)
+        @class.index(:name)
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/javascript_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Mongoid::Javascript do
+
+  let(:js) do
+    Mongoid::Javascript
+  end
+
+  describe ".aggregate" do
+
+    it "returns the aggregate function" do
+      js.aggregate.should == "function(obj, prev) { prev.count++; }"
+    end
+  end
+
+  describe ".group" do
+
+    it "returns the group function" do
+      js.group.should == "function(obj, prev) { prev.group.push(obj); }"
+    end
+  end
+
+  describe ".max" do
+
+    it "returns the max function" do
+      js.max.should == "function(obj, prev) { if (prev.max == 'start') { " +
+        "prev.max = obj.[field]; } if (prev.max < obj.[field]) { prev.max = obj.[field];" +
+        " } }"
+    end
+  end
+
+  describe ".min" do
+
+    it "returns the min function" do
+      js.min.should == "function(obj, prev) { if (prev.min == 'start') { " +
+        "prev.min = obj.[field]; } if (prev.min > obj.[field]) { prev.min = obj.[field];" +
+        " } }"
+    end
+  end
+
+  describe ".sum" do
+
+    it "returns the sum function" do
+      js.sum.should == "function(obj, prev) { if (prev.sum == 'start') { prev.sum = 0; " +
+        "} prev.sum += obj.[field]; }"
+    end
+  end
+end

data/spec/unit/mongoid/logger_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Mongoid::Logger do
+  describe ".logger" do
+    it "returns Mongoid's configured logger" do
+      Mongoid.expects(:logger)
+      subject.logger
+    end
+  end
+
+  context "log_levels" do
+    log_levels = %w(info debug warn error fatal)
+
+    context "with a logger set" do
+      let(:logger) { stub.quacks_like(Logger.allocate) }
+      log_levels.each do |log_level|
+        before do
+          subject.stubs(:logger => logger)
+        end
+        it "#{log_level} delegates to the configured logger" do
+          logger.expects(log_level).with("message")
+          subject.send(log_level.to_sym, "message")
+        end
+      end
+    end
+
+    context "with a nil logger" do
+      log_levels.each do |log_level|
+        before do
+          subject.stubs(:logger => nil)
+        end
+        it "#{log_level} does nothing" do
+          expect { subject.send(log_level.to_sym, "message") }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/unit/mongoid/matchers/all_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::All do
+
+  let(:matcher) { Mongoid::Matchers::All.new(["first", "second"]) }
+
+  describe "#matches?" do
+
+    context "when the values are equal" do
+
+      it "returns true" do
+        matcher.matches?("$all" => ["first", "second"]).should be_true
+      end
+
+    end
+
+    context "when the values are not equal" do
+
+      it "returns false" do
+        matcher.matches?("$all" => ["first"]).should be_false
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/matchers/default_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::Default do
+
+  let(:matcher) { Mongoid::Matchers::Default.new("Testing") }
+
+  describe "#matches?" do
+
+    context "when the values are equal" do
+
+      it "returns true" do
+        matcher.matches?("Testing").should be_true
+      end
+
+    end
+
+    context "when the values are not equal" do
+
+      it "returns false" do
+        matcher.matches?("Other").should be_false
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/matchers/exists_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::Exists do
+
+  describe "#matches?" do
+
+    context "when checking for existence" do
+
+      context "when the value exists" do
+
+        let(:matcher) { Mongoid::Matchers::Exists.new("Test") }
+
+        it "returns true" do
+          matcher.matches?("$exists" => true).should be_true
+        end
+
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) { Mongoid::Matchers::Exists.new(nil) }
+
+        it "returns false" do
+          matcher.matches?("$exists" => true).should be_false
+        end
+
+      end
+
+    end
+
+    context "when checking for nonexistence" do
+
+      context "when the value exists" do
+
+        let(:matcher) { Mongoid::Matchers::Exists.new("Test") }
+
+        it "returns false" do
+          matcher.matches?("$exists" => false).should be_false
+        end
+
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) { Mongoid::Matchers::Exists.new(nil) }
+
+        it "returns true" do
+          matcher.matches?("$exists" => false).should be_true
+        end
+
+      end
+    end
+
+  end
+
+end