mongoid 7.0.2 → 8.1.1

data/spec/mongoid/mongoizable_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This file is for testing the functionality of uncastable values for all
+# mongoizable classes.
+describe "mongoize/demongoize/evolve methods" do
+
+  shared_examples "handles unmongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to mongoize" do
+        it "returns nil" do
+          expect(klass.mongoize(invalid_value)).to be_nil
+        end
+      end
+
+      context "when assigning an invalid value to a field" do
+        let(:catalog) { Catalog.create!(field_name => invalid_value) }
+
+        it "returns nil" do
+          catalog.attributes[field_name].should be_nil
+        end
+
+        it "persists nil" do
+          Catalog.find(catalog._id).attributes[field_name].should be_nil
+        end
+      end
+    end
+  end
+
+  shared_examples "handles undemongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to demongoize" do
+        it "returns nil" do
+          expect(klass.demongoize(invalid_value)).to be_nil
+        end
+      end
+
+      context "when retrieving an invalid value from the db" do
+
+        before do
+          Catalog.collection.insert_one(field_name => invalid_value)
+        end
+
+        let(:catalog) { Catalog.first }
+
+        it "returns nil" do
+          catalog.send(field_name).should be_nil
+        end
+      end
+    end
+  end
+
+  shared_examples "pushes through unmongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to mongoize" do
+        it "returns that value" do
+          expect(klass.mongoize(invalid_value)).to eq(mongoized_value)
+        end
+      end
+    end
+
+    context "when assigning an invalid value to a field" do
+      let!(:catalog) { Catalog.create!(field_name => invalid_value) }
+      let(:from_db) { Catalog.find(catalog._id) }
+
+      it "returns the inputted value" do
+        catalog.attributes[field_name].should be_nil
+      end
+
+      it "persists the inputted value" do
+        from_db.attributes[field_name].should be_nil
+      end
+    end
+  end
+
+  shared_examples "pushes through undemongoizable values" do
+
+    context "when reading an invalid value from the db" do
+      before do
+        Catalog.collection.insert_one(field_name => invalid_value)
+      end
+
+      let(:from_db) { Catalog.first }
+
+      it "reads the inputted value" do
+        from_db.send(field_name).should eq(demongoized_value)
+      end
+    end
+  end
+
+  shared_examples "pushes through unevolvable values" do
+
+    context "when passing an uncastable value to evolve" do
+
+      it "pushes the value through" do
+        expect(klass.evolve(invalid_value)).to eq(mongoized_value)
+      end
+    end
+  end
+
+  shared_examples "pushes through uncastable values" do
+    include_examples "pushes through unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+  end
+
+  shared_examples "handles uncastable values" do
+    include_examples "handles unmongoizable values"
+    include_examples "handles undemongoizable values"
+  end
+
+  let(:mongoized_value) { invalid_value }
+  let(:demongoized_value) { invalid_value }
+
+  describe Array do
+    let(:invalid_value) { 1 }
+    let(:klass) { Array }
+    let(:field_name) { :array_field }
+
+    include_examples "handles unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BigDecimal do
+    let(:invalid_value) { "bogus" }
+    let(:klass) { described_class }
+    let(:field_name) { :big_decimal_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Mongoid::Boolean do
+    let(:invalid_value) { "invalid_value" }
+    let(:klass) { described_class }
+    let(:field_name) { :boolean_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Date do
+    let(:invalid_value) { :hello }
+    let(:klass) { described_class }
+    let(:field_name) { :date_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe DateTime do
+    let(:invalid_value) { :hello }
+    let(:klass) { described_class }
+    let(:field_name) { :date_time_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Float do
+    let(:invalid_value) { [] }
+    let(:klass) { described_class }
+    let(:field_name) { :float_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Hash do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :hash_field }
+
+    include_examples "handles unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Integer do
+    let(:invalid_value) { [] }
+    let(:klass) { described_class }
+    let(:field_name) { :integer_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BSON::ObjectId do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :object_id_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BSON::Binary do
+    let(:invalid_value) { true }
+    let(:klass) { described_class }
+    let(:field_name) { :binary_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Range do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :range_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Regexp do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :regexp_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Set do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :set_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe String do
+    let(:invalid_value) { 1 }
+    let(:mongoized_value) { "1" }
+    let(:demongoized_value) { "1" }
+    let(:klass) { described_class }
+    let(:field_name) { :string_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Mongoid::StringifiedSymbol do
+    let(:invalid_value) { [] }
+    let(:mongoized_value) { "[]" }
+    let(:demongoized_value) { :[] }
+    let(:klass) { described_class }
+    let(:field_name) { :stringified_symbol_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Symbol do
+    let(:invalid_value) { Time.new }
+    let(:klass) { described_class }
+    let(:field_name) { :symbol_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Time do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :time_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe ActiveSupport::TimeWithZone do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :time_with_zone_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Persistable::Creatable do
@@ -140,29 +142,84 @@ describe Mongoid::Persistable::Creatable do
     end
 
     context "when the document is a subclass of a root class" do
+      context "when using the default discriminator key" do
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
 
-      let!(:browser) do
-        Browser.create(version: 3, name: "Test")
-      end
+        let(:collection) do
+          Canvas.collection
+        end
 
-      let(:collection) do
-        Canvas.collection
-      end
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
 
-      let(:attributes) do
-        collection.find({ name: "Test"}).first
-      end
+        it "persists the versions" do
+          expect(attributes["version"]).to eq(3)
+        end
 
-      it "persists the versions" do
-        expect(attributes["version"]).to eq(3)
+        it "persists the type" do
+          expect(attributes["_type"]).to eq("Browser")
+        end
+
+        it "persists the attributes" do
+          expect(attributes["name"]).to eq("Test")
+        end
       end
 
-      it "persists the type" do
-        expect(attributes["_type"]).to eq("Browser")
+      context "when using a custom discriminator key" do
+        before do
+          Canvas.discriminator_key = "dkey"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("Browser")
+        end
       end
 
-      it "persists the attributes" do
-        expect(attributes["name"]).to eq("Test")
+      context "when using a custom discriminator key and discriminator value" do
+        before do
+          Canvas.discriminator_key = "dkey"
+          Browser.discriminator_value = "dvalue"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+          Browser.discriminator_value = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("dvalue")
+        end
       end
     end
 
@@ -177,11 +234,11 @@ describe Mongoid::Persistable::Creatable do
       end
 
       let(:attributes) do
-        collection.find({ name: "Testy"}).first
+        collection.find({ name: "Testy" }).first
       end
 
       before do
-        Browser.create(name: 'Safari', version: '4.0.0')
+        Browser.create(name: 'Safari', version: 4.0)
       end
 
       it "persists the versions" do
@@ -204,7 +261,7 @@ describe Mongoid::Persistable::Creatable do
         expect(Canvas.where(name: "Testy").first).to eq(firefox)
       end
 
-      it "returnss on of this subclasses if you find by _type" do
+      it "returns on of this subclasses if you find by _type" do
         expect(Canvas.where(:_type.in => ['Firefox']).count).to eq(1)
       end
     end
@@ -263,8 +320,8 @@ describe Mongoid::Persistable::Creatable do
       end
 
       it "does not bleed relations from one subclass to another" do
-        expect(Truck.relations.keys).to eq(%w/ shipping_container driver bed /)
-        expect(Car.relations.keys).to eq(%w/ shipping_container driver /)
+        expect(Truck.relations.keys).to eq(%w/ shipping_container driver crates seats bed /)
+        expect(Car.relations.keys).to eq(%w/ shipping_container driver crates seats /)
       end
 
       context "when appending new documents" do
@@ -294,8 +351,8 @@ describe Mongoid::Persistable::Creatable do
       context "when building related documents" do
 
         before do
-          container.vehicles.build({}, Car).save
-          container.vehicles.build({}, Truck).save
+          container.vehicles.build({}, Car).save!
+          container.vehicles.build({}, Truck).save!
         end
 
         it "allows STI from the build call" do
@@ -340,17 +397,45 @@ describe Mongoid::Persistable::Creatable do
       end
 
       context "#find_or_initialize_by" do
+        context "when using the default discriminator key" do
+          before do
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
 
-        before do
-          container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
-        end
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
 
-        it "initializes the given type document" do
-          expect(container.vehicles.map(&:class)).to eq([ Car ])
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a type field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["_type"]
+            ).to eq("Car")
+          end
         end
 
-        it "initializes with the given attributes" do
-          expect(container.vehicles.map(&:driver)).to eq([ driver ])
+        context "when using a custom discriminator key" do
+          before do
+            Vehicle.discriminator_key = "dkey"
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
+
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
+
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a dkey field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["dkey"]
+            ).to eq("Car")
+          end
         end
       end