mongoid-ultra 9.0.0.0.alpha1

data/spec/mongoid/extensions/object_spec.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Extensions::Object do
+
+  let(:object) do
+    Object.new
+  end
+
+  describe "#__evolve_object_id__" do
+
+    it "returns self" do
+      expect(object.__evolve_object_id__).to eq(object)
+    end
+  end
+
+  describe "#__find_args__" do
+
+    it "returns self" do
+      expect(object.__find_args__).to eq(object)
+    end
+  end
+
+  describe "#__mongoize_object_id__" do
+
+    it "returns self" do
+      expect(object.__mongoize_object_id__).to eq(object)
+    end
+  end
+
+  describe ".__mongoize_fk__" do
+
+    context "when the related model uses object ids" do
+
+      let(:association) do
+        Game.relations["person"]
+      end
+
+      context "when provided an object id" do
+
+        let(:object_id) do
+          BSON::ObjectId.new
+        end
+
+        let(:fk) do
+          Object.__mongoize_fk__(association, object_id)
+        end
+
+        it "returns the object id" do
+          expect(fk).to eq(object_id)
+        end
+      end
+
+      context "when provided a string" do
+
+        context "when the string is a legal object id" do
+
+          let(:object_id) do
+            BSON::ObjectId.new
+          end
+
+          let(:fk) do
+            Object.__mongoize_fk__(association, object_id.to_s)
+          end
+
+          it "returns the object id" do
+            expect(fk).to eq(object_id)
+          end
+        end
+
+        context "when the string is not a legal object id" do
+
+          let(:string) do
+            "blah"
+          end
+
+          let(:fk) do
+            Object.__mongoize_fk__(association, string)
+          end
+
+          it "returns the string" do
+            expect(fk).to eq(string)
+          end
+        end
+
+        context "when the string is blank" do
+
+          let(:fk) do
+            Object.__mongoize_fk__(association, "")
+          end
+
+          it "returns nil" do
+            expect(fk).to be_nil
+          end
+        end
+      end
+
+      context "when provided nil" do
+
+        let(:fk) do
+          Object.__mongoize_fk__(association, nil)
+        end
+
+        it "returns nil" do
+          expect(fk).to be_nil
+        end
+      end
+
+      context "when provided an empty array" do
+
+        let(:fk) do
+          Object.__mongoize_fk__(association, [])
+        end
+
+        it "returns an empty array" do
+          expect(fk).to eq([])
+        end
+      end
+    end
+  end
+
+  describe "#__mongoize_time__" do
+
+    it "returns self" do
+      expect(object.__mongoize_time__).to eq(object)
+    end
+  end
+
+  describe "#__sortable__" do
+
+    it "returns self" do
+      expect(object.__sortable__).to eq(object)
+    end
+  end
+
+  describe ".demongoize" do
+
+    let(:object) do
+      "testing"
+    end
+
+    it "returns the provided object" do
+      expect(Object.demongoize(object)).to eq(object)
+    end
+  end
+
+  describe "#do_or_do_not" do
+
+    context "when the object is nil" do
+
+      let(:result) do
+        nil.do_or_do_not(:not_a_method, "The force is strong with you")
+      end
+
+      it "returns nil" do
+        expect(result).to be_nil
+      end
+    end
+
+    context "when the object is not nil" do
+
+      context "when the object responds to the method" do
+
+        let(:result) do
+          [ "Yoda", "Luke" ].do_or_do_not(:join, ",")
+        end
+
+        it "returns the result of the method" do
+          expect(result).to eq("Yoda,Luke")
+        end
+      end
+
+      context "when the object does not respond to the method" do
+
+        let(:result) do
+          "Yoda".do_or_do_not(:use, "The Force", 1000)
+        end
+
+        it "returns the result of the method" do
+          expect(result).to be_nil
+        end
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    let(:object) do
+      "testing"
+    end
+
+    it "returns the provided object" do
+      expect(Object.mongoize(object)).to eq(object)
+    end
+  end
+
+  describe "#mongoize" do
+
+    let(:object) do
+      "testing"
+    end
+
+    it "returns the object" do
+      expect(object.mongoize).to eq(object)
+    end
+  end
+
+  describe "#resizable?" do
+
+    it "returns false" do
+      expect(Object.new).to_not be_resizable
+    end
+  end
+
+  describe "#you_must" do
+
+    context "when the object is frozen" do
+
+      let(:person) do
+        Person.new.tap { |peep| peep.freeze }
+      end
+
+      let(:result) do
+        person.you_must(:aliases=, [])
+      end
+
+      it "returns nil" do
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe "#remove_ivar" do
+
+    context "when the instance variable is defined" do
+
+      let(:document) do
+        Person.new
+      end
+
+      before do
+        document.instance_variable_set(:@_testing, "testing")
+      end
+
+      let!(:removal) do
+        document.remove_ivar("testing")
+      end
+
+      it "removes the instance variable" do
+        expect(document.instance_variable_defined?(:@_testing)).to be false
+      end
+
+      it "returns the value" do
+        expect(removal).to eq("testing")
+      end
+    end
+
+    context "when the instance variable is not defined" do
+
+      let(:document) do
+        Person.new
+      end
+
+      let!(:removal) do
+        document.remove_ivar("testing")
+      end
+
+      it "returns false" do
+        expect(removal).to be false
+      end
+    end
+  end
+
+  describe "#numeric?" do
+
+    it "returns false" do
+      expect(object.numeric?).to eq(false)
+    end
+  end
+
+  describe "#blank_criteria?" do
+
+    it "is false" do
+      expect(object.blank_criteria?).to be false
+    end
+  end
+end

data/spec/mongoid/extensions/range_spec.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Extensions::Range do
+
+  describe "#__find_args__" do
+
+    let(:range) do
+      1..3
+    end
+
+    it "returns the range as an array" do
+      expect(range.__find_args__).to eq([ 1, 2, 3 ])
+    end
+  end
+
+  describe ".demongoize" do
+    subject { Range.demongoize(hash) }
+
+    context "when the range is ascending" do
+      let(:hash) { { "min" => 1, "max" => 3 } }
+
+      it "returns an ascending range" do
+        is_expected.to eq(1..3)
+      end
+    end
+
+    context "when the range is ascending with exclude end" do
+      let(:hash) { { "min" => 1, "max" => 3, "exclude_end" => true } }
+
+      it "returns an ascending range" do
+        is_expected.to eq(1...3)
+      end
+    end
+
+    context "when the range is descending" do
+      let(:hash) { { "min" => 5, "max" => 1 } }
+
+      it "returns an descending range" do
+        is_expected.to eq(5..1)
+      end
+    end
+
+    context "when the range is descending with exclude end" do
+      let(:hash) { { "min" => 5, "max" => 1, "exclude_end" => true } }
+
+      it "returns an descending range" do
+        is_expected.to eq(5...1)
+      end
+    end
+
+    context "when the range is letters" do
+      let(:hash) { { "min" => "a", "max" => "z" } }
+
+      it "returns an alphabetic range" do
+        is_expected.to eq("a".."z")
+      end
+    end
+
+    context "when the range is letters with exclude end" do
+      let(:hash) { { "min" => "a", "max" => "z", "exclude_end" => true } }
+
+      it "returns an alphabetic range" do
+        is_expected.to eq("a"..."z")
+      end
+    end
+
+    context "when the range is endless" do
+      let(:hash) { { "min" => 1, "max" => nil } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.6'
+
+        it "returns an alphabetic range" do
+          is_expected.to eq(eval('1..'))
+        end
+      end
+
+      context 'kernel cannot support endless range' do
+        ruby_version_lt '2.6'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is endless with exclude end" do
+      let(:hash) { { "min" => 1, "max" => nil, "exclude_end" => true } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.6'
+
+        it "returns an alphabetic range" do
+          is_expected.to eq(eval('1...'))
+        end
+      end
+
+      context 'kernel cannot support endless range' do
+        ruby_version_lt '2.6'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is beginning-less" do
+      let(:hash) { { "min" => nil, "max" => 3 } }
+
+      context 'kernel can support beginning-less range' do
+        ruby_version_gte '2.7'
+
+        it "returns an alphabetic range" do
+          is_expected.to eq(nil..3)
+        end
+      end
+
+      context 'kernel cannot support beginning-less range' do
+        ruby_version_lt '2.7'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is beginning-less with exclude end" do
+      let(:hash) { { "min" => nil, "max" => 3, "exclude_end" => true } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.7'
+
+        it "returns an alphabetic beginning-less" do
+          is_expected.to eq(eval('...3'))
+        end
+      end
+
+      context 'kernel cannot support beginning-less range' do
+        ruby_version_lt '2.7'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range doesn't have any correct keys" do
+      let(:hash) { { "min^" => "a", "max^" => "z", "exclude_end^" => true } }
+
+      it "returns nil" do
+        is_expected.to be nil
+      end
+    end
+
+    context "when the range has symbol keys" do
+      let(:hash) { { min: 1, max: 3 } }
+
+      it "returns an ascending range" do
+        is_expected.to eq(1..3)
+      end
+    end
+  end
+
+  shared_examples_for 'mongoize range' do
+
+    context 'given a normal range' do
+      let(:range) { 1..3 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 1, "max" => 3)
+      end
+    end
+
+    context 'given a normal range not inclusive' do
+      let(:range) { 1...3 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 1, "max" => 3, "exclude_end" => true)
+      end
+    end
+
+    context 'given a descending range' do
+      let(:range) { 5..1 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "max" => 1)
+      end
+    end
+
+    context 'given a descending range not inclusive' do
+      let(:range) { 5...1 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "max" => 1, "exclude_end" => true)
+      end
+    end
+
+    context 'given an endless range' do
+      ruby_version_gte '2.6'
+
+      let(:range) { eval('5..') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5)
+      end
+    end
+
+    context 'given an endless range not inclusive' do
+      ruby_version_gte '2.6'
+
+      let(:range) { eval('5...') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "exclude_end" => true)
+      end
+    end
+
+    context 'given a beginning-less range' do
+      ruby_version_gte '2.7'
+
+      let(:range) { eval('..5') }
+
+      it "returns the object hash" do
+        is_expected.to eq("max" => 5)
+      end
+    end
+
+    context 'given an endless range not inclusive' do
+      ruby_version_gte '2.7'
+
+      let(:range) { eval('...5') }
+
+      it "returns the object hash" do
+        is_expected.to eq("max" => 5, "exclude_end" => true)
+      end
+    end
+
+    context 'given a letter range' do
+      let(:range) { 'a'..'z' }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => "a", "max" => "z")
+      end
+    end
+
+    context 'given a letter range not inclusive' do
+      let(:range) { 'a'...'z' }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => "a", "max" => "z", "exclude_end" => true)
+      end
+    end
+
+    context 'given a Time range' do
+      let(:range) { Time.at(0)..Time.at(1) }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.at(0), "max" => Time.at(1))
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
+      end
+    end
+
+    context 'given an ActiveSupport::TimeWithZone range' do
+      let(:range) { Time.at(0)..Time.at(1) }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.at(0).in_time_zone, "max" => Time.at(1).in_time_zone)
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
+      end
+    end
+
+    context 'given a Date range' do
+      let(:range) { Date.new(2020, 1, 1)..Date.new(2020, 1, 2) }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.utc(2020, 1, 1), "max" => Time.utc(2020, 1, 2))
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
+      end
+    end
+
+    context "given nil" do
+      let(:range) { nil }
+
+      it "returns nil" do
+        is_expected.to be_nil
+      end
+    end
+
+    context "given a hash" do
+      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end' => true } }
+
+      it "returns the hash" do
+        is_expected.to eq(range)
+      end
+    end
+
+    context "given a hash missing fields" do
+      let(:range) { { 'min' => 1 } }
+
+      it "returns the hash" do
+        is_expected.to eq(range)
+      end
+    end
+  end
+
+  describe "#mongoize" do
+    subject { range.mongoize }
+
+    context 'given a String' do
+      let(:range) { '3' }
+
+      it 'returns a string' do
+        is_expected.to eq('3')
+      end
+    end
+
+    it_behaves_like 'mongoize range'
+  end
+
+  describe ".mongoize" do
+    subject { Range.mongoize(range) }
+
+    context 'given a String' do
+      let(:range) { '3' }
+
+      it "returns nil" do
+        is_expected.to be_nil
+      end
+    end
+
+    context "given a hash with wrong fields" do
+      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end^' => true} }
+
+      it "removes the bogus fields" do
+        is_expected.to eq({ 'min' => 1, 'max' => 5 })
+      end
+    end
+
+    context "given a hash with no correct fields" do
+      let(:range) { { 'min^' => 1, 'max^' => 5, 'exclude_end^' => true} }
+
+      it "returns nil" do
+        is_expected.to be_nil
+      end
+    end
+
+    it_behaves_like 'mongoize range'
+  end
+
+  describe "#resizable?" do
+    let(:range) do
+      1...3
+    end
+
+    it "returns true" do
+      expect(range).to be_resizable
+    end
+  end
+end

data/spec/mongoid/extensions/raw_value_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::RawValue do
+
+  describe "::()" do
+    subject { Mongoid::RawValue(raw_value).raw_value }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the value' do
+        is_expected.to eq 'Hello World!'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the value' do
+        is_expected.to eq 42
+      end
+    end
+  end
+
+  describe "#raw_value" do
+    subject { described_class.new(raw_value).raw_value }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the value' do
+        is_expected.to eq 'Hello World!'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the value' do
+        is_expected.to eq 42
+      end
+    end
+  end
+
+  describe "#inspect" do
+    subject { described_class.new(raw_value).inspect }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the inspection' do
+        is_expected.to eq 'RawValue: "Hello World!"'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the inspection' do
+        is_expected.to eq 'RawValue: 42'
+      end
+    end
+  end
+end