mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/{extensions/origin/regexp_raw_spec.rb → criteria/queryable/extensions/regexp_spec.rb}

@@ -1,45 +1,46 @@
 require "spec_helper"
 
-describe Origin::Extensions::Regexp::Raw do
+
+describe Mongoid::Criteria::Queryable::Extensions::Regexp do
 
   describe ".evolve" do
 
-    context "when provided a bson raw regexp" do
+    context "when provided a regexp" do
 
       let(:regexp) do
-        BSON::Regexp::Raw.new("^[123]")
+        /^[123]/
       end
 
       let(:evolved) do
-        BSON::Regexp::Raw.evolve(regexp)
+        Regexp.evolve(regexp)
       end
 
       it "returns the regexp" do
-        expect(evolved).to be(regexp)
+        expect(evolved).to eq(regexp)
       end
     end
 
-    context "when providing a string" do
+    context "when provided a string" do
 
-      let(:regexp_string) do
-        '^[123]'
+      let(:regexp) do
+        "^[123]"
       end
 
       let(:evolved) do
-        BSON::Regexp::Raw.evolve(regexp_string)
+        Regexp.evolve(regexp)
       end
 
-      it "returns the converted raw regexp" do
-        expect(evolved).to eq(BSON::Regexp::Raw.new(regexp_string))
+      it "returns the converted regexp" do
+        expect(evolved).to eq(/^[123]/)
       end
     end
 
     context "when provided an array" do
 
-      context "when the elements are bson raw regexps" do
+      context "when the elements are regexps" do
 
         let(:regexp) do
-          BSON::Regexp::Raw.new("^[123]")
+          /^[123]/
         end
 
         let(:array) do
@@ -47,10 +48,10 @@ describe Origin::Extensions::Regexp::Raw do
         end
 
         let(:evolved) do
-          BSON::Regexp::Raw.evolve(array)
+          Regexp.evolve(array)
         end
 
-        it "returns the array containing raw regexps" do
+        it "returns the regexps" do
           expect(evolved).to eq([ regexp ])
         end
 
@@ -61,16 +62,16 @@ describe Origin::Extensions::Regexp::Raw do
 
       context "when the elements are strings" do
 
-        let(:regexp_string) do
+        let(:regexp) do
           "^[123]"
         end
 
         let(:evolved) do
-          BSON::Regexp::Raw.evolve([ regexp_string ])
+          Regexp.evolve([ regexp ])
         end
 
         it "returns the regexps" do
-          expect(evolved).to eq([ BSON::Regexp::Raw.new(regexp_string) ])
+          expect(evolved).to eq([ /^[123]/ ])
         end
       end
     end
@@ -79,11 +80,11 @@ describe Origin::Extensions::Regexp::Raw do
   describe "#regexp?" do
 
     let(:regexp) do
-      BSON::Regexp::Raw.new('^[123]')
+      /^[123]/
     end
 
     it "returns true" do
       expect(regexp).to be_regexp
     end
   end
-end
+end

data/spec/mongoid/criteria/queryable/extensions/set_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Set do
+
+  describe ".evolve" do
+
+    context "when provided a set" do
+
+      let(:set) do
+        ::Set.new([ 1, 2, 3 ])
+      end
+
+      it "returns an array" do
+        expect(described_class.evolve(set)).to eq([ 1, 2, 3 ])
+      end
+    end
+
+    context "when provided an array" do
+
+      it "returns an array" do
+        expect(described_class.evolve([ 1, 2, 3 ])).to eq([ 1, 2, 3 ])
+      end
+    end
+
+    context "when provided another object" do
+
+      it "returns the object" do
+        expect(described_class.evolve("testing")).to eq("testing")
+      end
+    end
+
+    context "when provided nil" do
+
+      it "returns nil" do
+        expect(described_class.evolve(nil)).to be_nil
+      end
+    end
+  end
+end

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -0,0 +1,302 @@
+require "spec_helper"
+
+describe String do
+
+  describe "#__evolve_date__" do
+
+    context "when the string is verbose" do
+
+      let(:date) do
+        "1st Jan 2010"
+      end
+
+      let(:evolved) do
+        date.__evolve_date__
+      end
+
+      it "returns the strings as a times" do
+        expect(evolved).to eq(Time.new(2010, 1, 1, 0, 0, 0, 0).utc)
+      end
+    end
+
+    context "when the string is in international format" do
+
+      let(:date) do
+        "2010-1-1"
+      end
+
+      let(:evolved) do
+        date.__evolve_date__
+      end
+
+      it "returns the strings as a times" do
+        expect(evolved).to eq(Time.new(2010, 1, 1, 0, 0, 0, 0).utc)
+      end
+    end
+  end
+
+  describe "#__evolve_time__" do
+
+    context "when the string is verbose" do
+
+      let(:date) do
+        "1st Jan 2010 12:00:00+01:00"
+      end
+
+      let(:evolved) do
+        date.__evolve_time__
+      end
+
+      it "returns the string as a utc time" do
+        expect(evolved).to eq(Time.new(2010, 1, 1, 11, 0, 0, 0).utc)
+      end
+    end
+
+    context "when the string is in international format" do
+
+      let(:date) do
+        "2010-01-01 12:00:00+01:00"
+      end
+
+      let(:evolved) do
+        date.__evolve_time__
+      end
+
+      it "returns the string as a utc time" do
+        expect(evolved).to eq(Time.new(2010, 1, 1, 11, 0, 0, 0).utc)
+      end
+    end
+  end
+
+  describe "#__sort_option__" do
+
+    context "when the string contains ascending" do
+
+      let(:option) do
+        "field_one ascending, field_two ascending".__sort_option__
+      end
+
+      it "returns the ascending sort option hash" do
+        expect(option).to eq({ field_one: 1, field_two: 1 })
+      end
+    end
+
+    context "when the string contains asc" do
+
+      let(:option) do
+        "field_one asc, field_two asc".__sort_option__
+      end
+
+      it "returns the ascending sort option hash" do
+        expect(option).to eq({ field_one: 1, field_two: 1 })
+      end
+    end
+
+    context "when the string contains ASCENDING" do
+
+      let(:option) do
+        "field_one ASCENDING, field_two ASCENDING".__sort_option__
+      end
+
+      it "returns the ascending sort option hash" do
+        expect(option).to eq({ field_one: 1, field_two: 1 })
+      end
+    end
+
+    context "when the string contains ASC" do
+
+      let(:option) do
+        "field_one ASC, field_two ASC".__sort_option__
+      end
+
+      it "returns the ascending sort option hash" do
+        expect(option).to eq({ field_one: 1, field_two: 1 })
+      end
+    end
+
+    context "when the string contains descending" do
+
+      let(:option) do
+        "field_one descending, field_two descending".__sort_option__
+      end
+
+      it "returns the descending sort option hash" do
+        expect(option).to eq({ field_one: -1, field_two: -1 })
+      end
+    end
+
+    context "when the string contains desc" do
+
+      let(:option) do
+        "field_one desc, field_two desc".__sort_option__
+      end
+
+      it "returns the descending sort option hash" do
+        expect(option).to eq({ field_one: -1, field_two: -1 })
+      end
+    end
+
+    context "when the string contains DESCENDING" do
+
+      let(:option) do
+        "field_one DESCENDING, field_two DESCENDING".__sort_option__
+      end
+
+      it "returns the descending sort option hash" do
+        expect(option).to eq({ field_one: -1, field_two: -1 })
+      end
+    end
+
+    context "when the string contains DESC" do
+
+      let(:option) do
+        "field_one DESC, field_two DESC".__sort_option__
+      end
+
+      it "returns the descending sort option hash" do
+        expect(option).to eq({ field_one: -1, field_two: -1 })
+      end
+    end
+  end
+
+  describe "#__expr_part__" do
+
+    let(:specified) do
+      "field".__expr_part__(10)
+    end
+
+    it "returns the string with the value" do
+      expect(specified).to eq({ "field" => 10 })
+    end
+
+    context "with a regexp" do
+
+      let(:specified) do
+        "field".__expr_part__(/test/)
+      end
+
+      it "returns the symbol with the value" do
+        expect(specified).to eq({ "field" => /test/ })
+      end
+
+    end
+
+    context "when negated" do
+
+      context "with a regexp" do
+
+        let(:specified) do
+          "field".__expr_part__(/test/, true)
+        end
+
+        it "returns the string with the value negated" do
+          expect(specified).to eq({ "field" => { "$not" => /test/ } })
+        end
+
+      end
+
+      context "with anything else" do
+
+        let(:specified) do
+          "field".__expr_part__('test', true)
+        end
+
+        it "returns the string with the value negated" do
+          expect(specified).to eq({ "field" => { "$ne" => "test" }})
+        end
+      end
+    end
+  end
+
+  describe "#to_direction" do
+
+    context "when ascending" do
+
+      it "returns 1" do
+        expect("ascending".to_direction).to eq(1)
+      end
+    end
+
+    context "when asc" do
+
+      it "returns 1" do
+        expect("asc".to_direction).to eq(1)
+      end
+    end
+
+    context "when ASCENDING" do
+
+      it "returns 1" do
+        expect("ASCENDING".to_direction).to eq(1)
+      end
+    end
+
+    context "when ASC" do
+
+      it "returns 1" do
+        expect("ASC".to_direction).to eq(1)
+      end
+    end
+
+    context "when descending" do
+
+      it "returns -1" do
+        expect("descending".to_direction).to eq(-1)
+      end
+    end
+
+    context "when desc" do
+
+      it "returns -1" do
+        expect("desc".to_direction).to eq(-1)
+      end
+    end
+
+    context "when DESCENDING" do
+
+      it "returns -1" do
+        expect("DESCENDING".to_direction).to eq(-1)
+      end
+    end
+
+    context "when DESC" do
+
+      it "returns -1" do
+        expect("DESC".to_direction).to eq(-1)
+      end
+    end
+  end
+
+  describe ".evolve" do
+
+    context "when provided a regex" do
+
+      let(:regex) do
+        /^[123]/
+      end
+
+      let(:evolved) do
+        described_class.evolve(regex)
+      end
+
+      it "returns the regex" do
+        expect(evolved).to eq(regex)
+      end
+    end
+
+    context "when provided an object" do
+
+      let(:object) do
+        1234
+      end
+
+      let(:evolved) do
+        described_class.evolve(object)
+      end
+
+      it "returns the object as a string" do
+        expect(evolved).to eq("1234")
+      end
+    end
+  end
+end

data/spec/mongoid/criteria/queryable/extensions/symbol_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+
+describe Symbol do
+
+  describe ".add_key" do
+
+    before do
+      described_class.add_key(:fubar, :union, "$fu", "$bar") do |value|
+        value.to_s
+      end
+    end
+
+    let(:fubar) do
+      :testing.fubar
+    end
+
+    it "adds the method to symbol" do
+      expect(fubar).to be_a(Mongoid::Criteria::Queryable::Key)
+    end
+
+    it "sets the key name" do
+      expect(fubar.name).to eq(:testing)
+    end
+
+    it "sets the key strategy" do
+      expect(fubar.strategy).to eq(:__union__)
+    end
+
+    it "sets the key operator" do
+      expect(fubar.operator).to eq("$fu")
+    end
+
+    it "sets the additional key operator" do
+      expect(fubar.expanded).to eq("$bar")
+    end
+
+    it "sets the transform block" do
+      expect(fubar.block).to be
+    end
+  end
+
+  describe ".evolve" do
+
+    context "when provided nil" do
+
+      it "returns nil" do
+        expect(described_class.evolve(nil)).to be_nil
+      end
+    end
+
+    context "when provided a string" do
+
+      it "returns the string as a symbol" do
+        expect(described_class.evolve("test")).to eq(:test)
+      end
+    end
+  end
+
+  describe "#__expr_part__" do
+
+    let(:specified) do
+      :field.__expr_part__(10)
+    end
+
+    it "returns the string with the value" do
+      expect(specified).to eq({ field: 10 })
+    end
+
+    context "with a regexp" do
+
+      let(:specified) do
+        :field.__expr_part__(/test/)
+      end
+
+      it "returns the symbol with the value" do
+        expect(specified).to eq({ field: /test/ })
+      end
+
+    end
+
+    context "when negated" do
+
+      context "with a regexp" do
+
+        let(:specified) do
+          :field.__expr_part__(/test/, true)
+        end
+
+        it "returns the symbol with the value negated" do
+          expect(specified).to eq({ field: { "$not" => /test/ } })
+        end
+
+      end
+
+      context "with anything else" do
+
+        let(:specified) do
+          :field.__expr_part__('test', true)
+        end
+
+        it "returns the symbol with the value negated" do
+          expect(specified).to eq({ field: { "$ne" => "test" }})
+        end
+
+      end
+    end
+  end
+
+  describe "#to_direction" do
+
+    context "when ascending" do
+
+      it "returns 1" do
+        expect(:ascending.to_direction).to eq(1)
+      end
+    end
+
+    context "when asc" do
+
+      it "returns 1" do
+        expect(:asc.to_direction).to eq(1)
+      end
+    end
+
+    context "when ASCENDING" do
+
+      it "returns 1" do
+        expect(:ASCENDING.to_direction).to eq(1)
+      end
+    end
+
+    context "when ASC" do
+
+      it "returns 1" do
+        expect(:ASC.to_direction).to eq(1)
+      end
+    end
+
+    context "when descending" do
+
+      it "returns -1" do
+        expect(:descending.to_direction).to eq(-1)
+      end
+    end
+
+    context "when desc" do
+
+      it "returns -1" do
+        expect(:desc.to_direction).to eq(-1)
+      end
+    end
+
+    context "when DESCENDING" do
+
+      it "returns -1" do
+        expect(:DESCENDING.to_direction).to eq(-1)
+      end
+    end
+
+    context "when DESC" do
+
+      it "returns -1" do
+        expect(:DESC.to_direction).to eq(-1)
+      end
+    end
+  end
+end