mongoid_rails4 4.0.0

data/spec/mongoid/fields/internal/foreign_keys/array_spec.rb

@@ -0,0 +1,184 @@
+require "spec_helper"
+
+# describe Mongoid::Fields::Internal::ForeignKeys::Array do
+
+  # describe "#add_atomic_changes" do
+
+    # let(:field) do
+      # described_class.instantiate(
+        # :vals,
+        # metadata: Person.relations["preferences"],
+        # type: Array,
+        # default: [],
+        # identity: true
+      # )
+    # end
+
+    # let(:person) do
+      # Person.new
+    # end
+
+    # let(:preference_one) do
+      # Preference.new
+    # end
+
+    # let(:preference_two) do
+      # Preference.new
+    # end
+
+    # let(:preference_three) do
+      # Preference.new
+    # end
+
+    # let(:mods) do
+      # {}
+    # end
+
+    # before do
+      # person.preferences.concat(preference_one, preference_three)
+    # end
+
+    # context "when adding and removing" do
+
+      # before do
+        # field.add_atomic_changes(
+          # person, "preference_ids", "preference_ids", mods, [ preference_three.id ], [ preference_two.id ]
+        # )
+      # end
+
+      # it "adds the current to the modifications" do
+        # expect(mods["preference_ids"]).to eq(
+          # [ preference_one.id, preference_three.id ]
+        # )
+      # end
+    # end
+  # end
+
+  # describe "#eval_default" do
+
+    # let(:default) do
+      # [ Moped::BSON::ObjectId.new ]
+    # end
+
+    # let(:field) do
+      # described_class.instantiate(
+        # :vals,
+        # metadata: Person.relations["posts"],
+        # type: Array,
+        # default: default,
+        # identity: true
+      # )
+    # end
+
+    # it "dups the default value" do
+      # expect(field.eval_default(nil)).to_not equal(default)
+    # end
+
+    # it "returns the correct value" do
+      # expect(field.eval_default(nil)).to eq(default)
+    # end
+  # end
+
+  # describe "#foreign_key?" do
+
+    # let(:field) do
+      # described_class.instantiate(
+        # :vals,
+        # metadata: Person.relations["posts"],
+        # type: Array,
+        # default: [],
+        # identity: true
+      # )
+    # end
+
+    # it "returns true" do
+      # expect(field).to be_foreign_key
+    # end
+  # end
+
+  # describe "#serialize" do
+
+    # context "when the array is object ids" do
+
+      # let(:metadata) do
+        # Mongoid::Relations::Metadata.new(
+          # inverse_class_name: "Game",
+          # name: :person,
+          # relation: Mongoid::Relations::Referenced::In
+        # )
+      # end
+
+      # let(:field) do
+        # described_class.instantiate(
+          # :vals,
+          # type: Array,
+          # default: [],
+          # identity: true,
+          # metadata: metadata
+        # )
+      # end
+
+      # context "when provided nil" do
+
+        # it "returns an empty array" do
+          # expect(field.serialize(nil)).to be_empty
+        # end
+      # end
+
+      # context "when provided an empty array" do
+
+        # let(:array) do
+          # []
+        # end
+
+        # it "returns an empty array" do
+          # expect(field.serialize(array)).to eq(array)
+        # end
+
+        # it "returns the same instance" do
+          # expect(field.serialize(array)).to equal(array)
+        # end
+      # end
+
+      # context "when using object ids" do
+
+        # let(:object_id) do
+          # Moped::BSON::ObjectId.new
+        # end
+
+        # it "performs conversion on the ids if strings" do
+          # expect(field.serialize([object_id.to_s])).to eq([object_id])
+        # end
+      # end
+
+      # context "when not using object ids" do
+
+        # let(:object_id) do
+          # Moped::BSON::ObjectId.new
+        # end
+
+        # before do
+          # Person.field(
+            # :_id,
+            # type: String,
+            # pre_processed: true,
+            # default: ->{ Moped::BSON::ObjectId.new.to_s }
+          # )
+        # end
+
+        # after do
+          # Person.field(
+            # :_id,
+            # type: Moped::BSON::ObjectId,
+            # pre_processed: true,
+            # default: ->{ Moped::BSON::ObjectId.new }
+          # )
+        # end
+
+        # it "does not convert" do
+          # expect(field.serialize([object_id.to_s])).to eq([object_id.to_s])
+        # end
+      # end
+    # end
+  # end
+# end

data/spec/mongoid/fields/internal/foreign_keys/object_spec.rb

@@ -0,0 +1,201 @@
+require "spec_helper"
+
+# describe Mongoid::Fields::Internal::ForeignKeys::Object do
+
+  # describe "#foreign_key?" do
+
+    # let(:field) do
+      # described_class.instantiate(
+        # :vals,
+        # metadata: Person.relations["posts"],
+        # type: Object,
+        # default: [],
+        # identity: true
+      # )
+    # end
+
+    # it "returns true" do
+      # expect(field).to be_foreign_key
+    # end
+  # end
+
+  # describe "#serialize" do
+
+    # context "when the array is object ids" do
+
+      # let(:metadata) do
+        # Mongoid::Relations::Metadata.new(
+          # inverse_class_name: "Game",
+          # name: :person,
+          # relation: Mongoid::Relations::Referenced::In
+        # )
+      # end
+
+      # let(:field) do
+        # described_class.instantiate(
+          # :vals,
+          # type: Object,
+          # default: nil,
+          # identity: true,
+          # metadata: metadata
+        # )
+      # end
+
+      # context "when using object ids" do
+
+        # let(:object_id) do
+          # Moped::BSON::ObjectId.new
+        # end
+
+        # it "performs conversion on the ids if strings" do
+          # expect(field.serialize(object_id.to_s)).to eq(object_id)
+        # end
+      # end
+
+      # context "when not using object ids" do
+
+        # context "when using strings" do
+
+          # context "when provided a string" do
+
+            # let(:object_id) do
+              # Moped::BSON::ObjectId.new
+            # end
+
+            # before do
+              # Person.field(
+                # :_id,
+                # type: String,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new.to_s }
+              # )
+            # end
+
+            # after do
+              # Person.field(
+                # :_id,
+                # type: Moped::BSON::ObjectId,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new }
+              # )
+            # end
+
+            # it "does not convert" do
+              # expect(field.serialize(object_id.to_s)).to eq(object_id.to_s)
+            # end
+          # end
+
+          # context "when provided a hash" do
+
+            # let(:object_id) do
+              # Moped::BSON::ObjectId.new
+            # end
+
+            # before do
+              # Person.field(
+                # :_id,
+                # type: String,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new.to_s }
+              # )
+            # end
+
+            # after do
+              # Person.field(
+                # :_id,
+                # type: Moped::BSON::ObjectId,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new }
+              # )
+            # end
+
+            # let(:criterion) do
+              # { "$in" => [ object_id.to_s ] }
+            # end
+
+            # it "does not convert" do
+              # expect(field.serialize(criterion)).to eq(
+                # criterion
+              # )
+            # end
+          # end
+        # end
+
+        # context "when using integers" do
+
+          # context "when provided a string" do
+
+            # before do
+              # Person.field(:_id, type: Integer)
+            # end
+
+            # after do
+              # Person.field(
+                # :_id,
+                # type: Moped::BSON::ObjectId,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new }
+              # )
+            # end
+
+            # it "does not convert" do
+              # expect(field.serialize("1")).to eq(1)
+            # end
+          # end
+
+          # context "when provided a hash with a string value" do
+
+            # before do
+              # Person.field(:_id, type: Integer)
+            # end
+
+            # after do
+              # Person.field(
+                # :_id,
+                # type: Moped::BSON::ObjectId,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new }
+              # )
+            # end
+
+            # let(:criterion) do
+              # { "$eq" => "1" }
+            # end
+
+            # it "does not convert" do
+              # expect(field.serialize(criterion)).to eq(
+                # { "$eq" => 1 }
+              # )
+            # end
+          # end
+
+          # context "when provided a hash with an array of string values" do
+
+            # before do
+              # Person.field(:_id, type: Integer)
+            # end
+
+            # after do
+              # Person.field(
+                # :_id,
+                # type: Moped::BSON::ObjectId,
+                # pre_processed: true,
+                # default: ->{ Moped::BSON::ObjectId.new }
+              # )
+            # end
+
+            # let(:criterion) do
+              # { "$in" => [ "1" ] }
+            # end
+
+            # it "does not convert" do
+              # expect(field.serialize(criterion)).to eq(
+                # { "$in" => [ 1 ] }
+              # )
+            # end
+          # end
+        # end
+      # end
+    # end
+  # end
+# end

data/spec/mongoid/fields/localized_spec.rb

@@ -0,0 +1,386 @@
+require "spec_helper"
+
+describe Mongoid::Fields::Localized do
+
+  context "when no default is provided" do
+
+    let(:field) do
+      described_class.new(:description, localize: true, type: String)
+    end
+
+    it "defaults to nil" do
+      expect(field.default_val).to be_nil
+    end
+  end
+
+  context "when a default is provided" do
+
+    context "when the type is a string" do
+
+      let(:field) do
+        described_class.new(
+          :description,
+          localize: true,
+          default: "No translation",
+          type: String
+        )
+      end
+
+      it "defaults to the value" do
+        expect(field.default_val).to eq("No translation")
+      end
+    end
+
+    context "when the type is not a string" do
+
+      let(:field) do
+        described_class.new(
+          :description,
+          localize: true,
+          default: 1,
+          type: Integer
+        )
+      end
+
+      it "keeps the default in the proper type" do
+        expect(field.default_val).to eq(1)
+      end
+    end
+  end
+
+  describe "#demongoize" do
+
+    context "when the type is a string" do
+
+      let(:field) do
+        described_class.new(:description, localize: true, type: String)
+      end
+
+      context "when the field is nil" do
+
+        let(:value) do
+          field.demongoize(nil)
+        end
+
+        it "returns nil" do
+          expect(value).to be_nil
+        end
+      end
+
+      context "when no locale is defined" do
+
+        let(:value) do
+          field.demongoize({ "en" => "This is a test" })
+        end
+
+        it "returns the string from the default locale" do
+          expect(value).to eq("This is a test")
+        end
+      end
+
+      context "when a locale is provided" do
+
+        before do
+          ::I18n.locale = :de
+        end
+
+        after do
+          ::I18n.locale = :en
+        end
+
+        context "when the value exists" do
+
+          let(:value) do
+            field.demongoize({ "de" => "This is a test" })
+          end
+
+          it "returns the string from the set locale" do
+            expect(value).to eq("This is a test")
+          end
+        end
+
+        context "when the value does not exist" do
+
+          context "when not using fallbacks" do
+
+            let(:value) do
+              field.demongoize({ "en" => "testing" })
+            end
+
+            it "returns nil" do
+              expect(value).to be_nil
+            end
+          end
+
+          context "when using fallbacks" do
+
+            before(:all) do
+              require "i18n/backend/fallbacks"
+              I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+            end
+
+            context "when fallbacks are defined" do
+
+              before do
+                ::I18n.fallbacks[:de] = [ :de, :en, :es ]
+              end
+
+              context "when the first fallback translation exists" do
+
+                let(:value) do
+                  field.demongoize({ "en" => "testing" })
+                end
+
+                it "returns the fallback translation" do
+                  expect(value).to eq("testing")
+                end
+              end
+
+              context "when another fallback translation exists" do
+
+                let(:value) do
+                  field.demongoize({ "es" => "pruebas" })
+                end
+
+                it "returns the fallback translation" do
+                  expect(value).to eq("pruebas")
+                end
+              end
+
+              context "when the fallback translation does not exist" do
+
+                let(:value) do
+                  field.demongoize({ "fr" => "oui" })
+                end
+
+                it "returns nil" do
+                  expect(value).to be_nil
+                end
+              end
+            end
+
+            context "when no fallbacks are defined" do
+
+              before do
+                ::I18n.fallbacks[:de] = [ :de ]
+              end
+
+              let(:value) do
+                field.demongoize({ "es" => "pruebas" })
+              end
+
+              it "returns nil" do
+                expect(value).to be_nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context "when the type is not a string" do
+
+      let(:field) do
+        described_class.new(:description, localize: true, type: Integer)
+      end
+
+      context "when the field is nil" do
+
+        let(:value) do
+          field.demongoize(nil)
+        end
+
+        it "returns nil" do
+          expect(value).to be_nil
+        end
+      end
+
+      context "when no locale is defined" do
+
+        let(:value) do
+          field.demongoize({ "en" => 100 })
+        end
+
+        it "returns the value from the default locale" do
+          expect(value).to eq(100)
+        end
+      end
+
+      context "when a locale is provided" do
+
+        before do
+          ::I18n.locale = :de
+        end
+
+        after do
+          ::I18n.locale = :en
+        end
+
+        context "when the value exists" do
+
+          let(:value) do
+            field.demongoize({ "de" => 100 })
+          end
+
+          it "returns the value from the set locale" do
+            expect(value).to eq(100)
+          end
+        end
+
+        context "when the value does not exist" do
+
+          context "when not using fallbacks" do
+
+            let(:value) do
+              field.demongoize({ "en" => 100 })
+            end
+
+            it "returns nil" do
+              expect(value).to be_nil
+            end
+          end
+
+          context "when using fallbacks" do
+
+            before(:all) do
+              require "i18n/backend/fallbacks"
+              I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+            end
+
+            context "when fallbacks are defined" do
+
+              before do
+                ::I18n.fallbacks[:de] = [ :de, :en, :es ]
+              end
+
+              context "when the first fallback translation exists" do
+
+                let(:value) do
+                  field.demongoize({ "en" => 1 })
+                end
+
+                it "returns the fallback translation" do
+                  expect(value).to eq(1)
+                end
+              end
+
+              context "when another fallback translation exists" do
+
+                let(:value) do
+                  field.demongoize({ "es" => 100 })
+                end
+
+                it "returns the fallback translation" do
+                  expect(value).to eq(100)
+                end
+              end
+
+              context "when the fallback translation does not exist" do
+
+                let(:value) do
+                  field.demongoize({ "fr" => 50 })
+                end
+
+                it "returns nil" do
+                  expect(value).to be_nil
+                end
+              end
+            end
+
+            context "when no fallbacks are defined" do
+
+              before do
+                ::I18n.fallbacks[:de] = [ :de ]
+              end
+
+              let(:value) do
+                field.demongoize({ "es" => 100 })
+              end
+
+              it "returns nil" do
+                expect(value).to be_nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    context "when the type is a string" do
+
+      let(:field) do
+        described_class.new(:description, localize: true, type: String)
+      end
+
+      context "when no locale is defined" do
+
+        let(:value) do
+          field.mongoize("This is a test")
+        end
+
+        it "returns the string in the default locale" do
+          expect(value).to eq({ "en" => "This is a test" })
+        end
+      end
+
+      context "when a locale is provided" do
+
+        before do
+          ::I18n.locale = :de
+        end
+
+        after do
+          ::I18n.locale = :en
+        end
+
+        let(:value) do
+          field.mongoize("This is a test")
+        end
+
+        it "returns the string in the set locale" do
+          expect(value).to eq({ "de" => "This is a test" })
+        end
+      end
+    end
+
+    context "when the type is not a string" do
+
+      let(:field) do
+        described_class.new(:description, localize: true, type: Integer)
+      end
+
+      context "when no locale is defined" do
+
+        let(:value) do
+          field.mongoize("100")
+        end
+
+        it "returns the value in the default locale" do
+          expect(value).to eq({ "en" => 100 })
+        end
+      end
+
+      context "when a locale is provided" do
+
+        before do
+          ::I18n.locale = :de
+        end
+
+        after do
+          ::I18n.locale = :en
+        end
+
+        let(:value) do
+          field.mongoize("100")
+        end
+
+        it "returns the string in the set locale" do
+          expect(value).to eq({ "de" => 100 })
+        end
+      end
+    end
+  end
+end