mongoid 5.4.0 → 6.4.8

data/spec/mongoid/criteria/queryable/options_spec.rb

@@ -0,0 +1,360 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Queryable::Options do
+
+  describe "#__deep_copy__" do
+
+    let(:sort) do
+      [[ :name, :asc ]]
+    end
+
+    let(:options) do
+      described_class.new
+    end
+
+    before do
+      options[:sort] = sort
+    end
+
+    let(:cloned) do
+      options.__deep_copy__
+    end
+
+    it "returns an equal copy" do
+      expect(cloned).to eq(options)
+    end
+
+    it "performs a deep copy" do
+      expect(cloned[:sort]).to_not equal(sort)
+    end
+  end
+
+  describe "#fields" do
+
+    let(:options) do
+      described_class.new
+    end
+
+    context "when field options exist" do
+
+      before do
+        options[:fields] = { name: 1 }
+      end
+
+      it "returns the field options" do
+        expect(options.fields).to eq({ "name" => 1 })
+      end
+    end
+
+    context "when field options do not exist" do
+
+      it "returns nil" do
+        expect(options.fields).to be_nil
+      end
+    end
+  end
+
+  describe "#limit" do
+
+    let(:options) do
+      described_class.new
+    end
+
+    context "when limit options exist" do
+
+      before do
+        options[:limit] = 20
+      end
+
+      it "returns the limit options" do
+        expect(options.limit).to eq(20)
+      end
+    end
+
+    context "when limit options do not exist" do
+
+      it "returns nil" do
+        expect(options.limit).to be_nil
+      end
+    end
+  end
+
+  describe "#skip" do
+
+    let(:options) do
+      described_class.new
+    end
+
+    context "when skip options exist" do
+
+      before do
+        options[:skip] = 100
+      end
+
+      it "returns the skip options" do
+        expect(options.skip).to eq(100)
+      end
+    end
+
+    context "when skip options do not exist" do
+
+      it "returns nil" do
+        expect(options.skip).to be_nil
+      end
+    end
+  end
+
+  describe "#sort" do
+
+    let(:options) do
+      described_class.new
+    end
+
+    context "when sort options exist" do
+
+      before do
+        options[:sort] = { name: 1 }
+      end
+
+      it "returns the sort options" do
+        expect(options.sort).to eq({ "name" => 1 })
+      end
+    end
+
+    context "when sort options do not exist" do
+
+      it "returns nil" do
+        expect(options.sort).to be_nil
+      end
+    end
+  end
+
+  [ :store, :[]= ].each do |method|
+
+    describe "##{method}" do
+
+      context "when aliases are provided" do
+
+        context "when the alias has no serializer" do
+
+          let(:options) do
+            described_class.new({ "id" => "_id" })
+          end
+
+          before do
+            options.send(method, :sort, { :id => 1 })
+          end
+
+          it "stores the field in the options by database name" do
+            expect(options[:sort]).to eq({ "_id" => 1 })
+          end
+        end
+      end
+
+      context "when no serializers are provided" do
+
+        let(:options) do
+          described_class.new
+        end
+
+        context "when provided a standard object" do
+
+          context "when the keys are strings" do
+
+            it "does not serialize values" do
+              expect(options.send(method, "limit", "5")).to eq("5")
+            end
+          end
+
+          context "when the keys are symbols" do
+
+            it "does not serialize values" do
+              expect(options.send(method, :limit, "5")).to eq("5")
+            end
+          end
+        end
+      end
+
+      context "when serializers are provided" do
+
+        context "when the serializer is not localized" do
+
+          before(:all) do
+            class Field
+              def localized?
+                false
+              end
+            end
+          end
+
+          after(:all) do
+            Object.send(:remove_const, :Field)
+          end
+
+          let(:options) do
+            described_class.new({}, { "key" => Field.new })
+          end
+
+          context "when the criterion is simple" do
+
+            before do
+              options.send(method, :limit, 1)
+            end
+
+            it "does not localize the keys" do
+              expect(options[:limit]).to eq(1)
+            end
+          end
+
+          context "when the criterion is complex" do
+
+            before do
+              options.send(method, :sort, { :key => 1 })
+            end
+
+            it "does not localize the keys" do
+              expect(options[:sort]).to eq({ "key" => 1 })
+            end
+          end
+        end
+
+        context "when the serializer is localized" do
+
+          before(:all) do
+            class Field
+              def localized?
+                true
+              end
+            end
+          end
+
+          after(:all) do
+            Object.send(:remove_const, :Field)
+            ::I18n.locale = :en
+          end
+
+          let(:options) do
+            described_class.new({}, { "key" => Field.new })
+          end
+
+          before do
+            ::I18n.locale = :de
+          end
+
+          context "when the criterion is simple" do
+
+            before do
+              options.send(method, :limit, 1)
+            end
+
+            it "does not localize the keys" do
+              expect(options[:limit]).to eq(1)
+            end
+          end
+
+          context "when the criterion is complex" do
+
+            before do
+              options.send(method, :sort, { :key => 1 })
+            end
+
+            it "does not localize the keys" do
+              expect(options[:sort]).to eq({ "key.de" => 1 })
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#to_pipeline" do
+
+    let(:options) do
+      described_class.new
+    end
+
+    context "when no options exist" do
+
+      let(:pipeline) do
+        options.to_pipeline
+      end
+
+      it "returns an empty array" do
+        expect(pipeline).to be_empty
+      end
+    end
+
+    context "when multiple options exist" do
+
+      before do
+        options[:fields] = { "name" => 1 }
+        options[:skip] = 10
+        options[:limit] = 10
+        options[:sort] = { "name" => 1 }
+      end
+
+      let(:pipeline) do
+        options.to_pipeline
+      end
+
+      it "converts the option to a $sort" do
+        expect(pipeline).to eq([
+          { "$skip" => 10 },
+          { "$limit" => 10 },
+          { "$sort" => { "name" => 1 }}
+        ])
+      end
+    end
+
+    context "when a sort exists" do
+
+      before do
+        options[:sort] = { "name" => 1 }
+      end
+
+      let(:pipeline) do
+        options.to_pipeline
+      end
+
+      it "converts the option to a $sort" do
+        expect(pipeline).to eq([
+          { "$sort" => { "name" => 1 }}
+        ])
+      end
+    end
+
+    context "when a limit exists" do
+
+      before do
+        options[:limit] = 10
+      end
+
+      let(:pipeline) do
+        options.to_pipeline
+      end
+
+      it "converts the option to a $sort" do
+        expect(pipeline).to eq([
+          { "$limit" => 10 }
+        ])
+      end
+    end
+
+    context "when a skip exists" do
+
+      before do
+        options[:skip] = 10
+      end
+
+      let(:pipeline) do
+        options.to_pipeline
+      end
+
+      it "converts the option to a $sort" do
+        expect(pipeline).to eq([
+          { "$skip" => 10 }
+        ])
+      end
+    end
+  end
+end

data/spec/mongoid/criteria/queryable/pipeline_spec.rb

@@ -0,0 +1,200 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Queryable::Pipeline do
+
+  describe "#__deep_copy" do
+
+    let(:project) do
+      { "$project" => { "name" => 1 }}
+    end
+
+    let(:pipeline) do
+      described_class.new
+    end
+
+    before do
+      pipeline.push(project)
+    end
+
+    let(:copied) do
+      pipeline.__deep_copy__
+    end
+
+    it "clones all the objects in the pipeline" do
+      expect(copied.first).to_not equal(project)
+    end
+
+    it "clones the pipeline" do
+      expect(copied).to_not equal(pipeline)
+    end
+  end
+
+  describe "#group" do
+
+    context "when the expression fields are not aliased" do
+
+      let(:pipeline) do
+        described_class.new
+      end
+
+      context "when using full notation" do
+
+        before do
+          pipeline.group(count: { "$sum" => 1 }, max: { "$max" => "likes" })
+        end
+
+        it "adds the group operation to the pipeline" do
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
+          ])
+        end
+      end
+
+      context "when using symbol shortcuts" do
+
+        before do
+          pipeline.group(:count.sum => 1, :max.max => "likes")
+        end
+
+        it "adds the group operation to the pipeline" do
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
+          ])
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when provided aliases" do
+
+      let(:aliases) do
+        { "id" => "_id" }
+      end
+
+      let(:pipeline) do
+        described_class.new(aliases)
+      end
+
+      it "sets the aliases" do
+        expect(pipeline.aliases).to eq(aliases)
+      end
+    end
+
+    context "when not provided aliases" do
+
+      let(:pipeline) do
+        described_class.new
+      end
+
+      it "sets the aliases to an empty hash" do
+        expect(pipeline.aliases).to be_empty
+      end
+    end
+  end
+
+  describe "#project" do
+
+    let(:pipeline) do
+      described_class.new("id" => "_id")
+    end
+
+    context "when the field is not aliased" do
+
+      before do
+        pipeline.project(name: 1)
+      end
+
+      it "sets the aliased projection" do
+        expect(pipeline).to eq([
+          { "$project" => { "name" => 1 }}
+        ])
+      end
+    end
+
+    context "when the field is aliased" do
+
+      before do
+        pipeline.project(id: 1)
+      end
+
+      it "sets the aliased projection" do
+        expect(pipeline).to eq([
+          { "$project" => { "_id" => 1 }}
+        ])
+      end
+    end
+  end
+
+  describe "#unwind" do
+
+    let(:pipeline) do
+      described_class.new("alias" => "a")
+    end
+
+    context "when provided a symbol" do
+
+      context "when the symbol begins with $" do
+
+        before do
+          pipeline.unwind(:$author)
+        end
+
+        it "converts the symbol to a string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+      end
+
+      context "when the symbol does not begin with $" do
+
+        before do
+          pipeline.unwind(:author)
+        end
+
+        it "converts the symbol to a string and prepends $" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+      end
+    end
+
+    context "when provided a string" do
+
+      context "when the string begins with $" do
+
+        before do
+          pipeline.unwind("$author")
+        end
+
+        it "sets the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+      end
+
+      context "when the string does not begin with $" do
+
+        before do
+          pipeline.unwind(:author)
+        end
+
+        it "prepends $ to the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+      end
+    end
+
+    context "when provided a string alias" do
+
+      context "when the string does not begin with $" do
+
+        before do
+          pipeline.unwind(:alias)
+        end
+
+        it "prepends $ to the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$a" }])
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/criteria/queryable/queryable_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+
+describe Mongoid::Query do
+
+  describe "#==" do
+
+    let(:query) do
+      described_class.new
+    end
+
+    context "when the objects have the same selector" do
+
+      let(:other) do
+        described_class.new
+      end
+
+      context "when the options are the same" do
+
+        it "returns true" do
+          expect(query).to eq(other)
+        end
+      end
+
+      context "when the options are different" do
+
+        before do
+          other.options[:skip] = 20
+        end
+
+        it "returns false" do
+          expect(query).to_not eq(other)
+        end
+      end
+    end
+
+    context "when the objects have different selectors" do
+
+      let(:other) do
+        described_class.new do |query|
+          query.selector["field"] = "value"
+        end
+      end
+
+      it "returns false" do
+        expect(query).to_not eq(other)
+      end
+    end
+
+    context "when the objects are different types" do
+
+      let(:other) do
+        "Query"
+      end
+
+      it "returns false" do
+        expect(query).to_not eq(other)
+      end
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when passed no arguments" do
+
+      let(:query) do
+        described_class.new
+      end
+
+      it "intializes the selector" do
+        expect(query.selector).to eq({})
+      end
+
+      it "initializes the options" do
+        expect(query.options).to eq({})
+      end
+    end
+
+    context "when passed a block" do
+
+      let(:query) do
+        described_class.new do |query|
+          query.selector["field"] = "value"
+        end
+      end
+
+      it "yields to the block" do
+        expect(query.selector).to eq({ "field" => "value" })
+      end
+    end
+  end
+
+  describe "#initialize_copy" do
+
+    let(:sort) do
+      { "name" => 1 }
+    end
+
+    let(:query) do
+      described_class.new do |query|
+        query.selector["field"] = "value"
+        query.options["sort"] = { "field" => sort }
+      end
+    end
+
+    let!(:cloned) do
+      query.clone
+    end
+
+    it "returns a query" do
+      expect(cloned).to be_a(Mongoid::Query)
+    end
+
+    it "returns a new instance" do
+      expect(cloned).to_not equal(query)
+    end
+
+    it "retains the selector values" do
+      expect(cloned.selector).to eq({ "field" => "value" })
+    end
+
+    it "retains the option values" do
+      expect(cloned.options).to eq({ "sort" => { "field" => sort }})
+    end
+
+    it "deep copies the selector" do
+      expect(cloned.selector).to_not equal(query.selector)
+    end
+
+    it "deep copies the options" do
+      expect(cloned.options).to_not equal(query.options)
+    end
+
+    it "deep copies n levels deep" do
+      expect(cloned.options["sort"]["field"]).to_not equal(sort)
+    end
+  end
+end