mongoid_rails4 4.0.0

data/spec/mongoid/selectable_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+describe Mongoid::Selectable do
+
+  describe "#atomic_selector" do
+
+    context "when the document is a root document" do
+
+      context "when the document has a shard key" do
+
+        let(:profile) do
+          Profile.create(name: "google")
+        end
+
+        let!(:selector) do
+          profile.atomic_selector
+        end
+
+        it "returns the id and shard key in the hash" do
+          expect(selector).to eq({ "_id" => profile.id, "name" => profile.name })
+        end
+      end
+
+      context "when the document does not have a shard key" do
+
+        context "when using object ids" do
+
+          let(:band) do
+            Band.create
+          end
+
+          let(:selector) do
+            band.atomic_selector
+          end
+
+          it "returns the hash with the id" do
+            expect(selector).to eq({ "_id" => band.id })
+          end
+        end
+
+        context "when using a custom id" do
+
+          let(:account) do
+            Account.create(name: "savings")
+          end
+
+          let(:selector) do
+            account.atomic_selector
+          end
+
+          context "when the id has not changed" do
+
+            it "returns the hash with the key" do
+              expect(selector).to eq({ "_id" => "savings" })
+            end
+          end
+
+          context "when the composite key has changed" do
+
+            before do
+              account.new_record = false
+              account.name = "current"
+            end
+
+            it "returns the hash with the old key" do
+              expect(selector).to eq({ "_id" => "savings" })
+            end
+          end
+        end
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when the document is an embeds one" do
+
+        let(:name) do
+          person.create_name(first_name: "test", last_name: "user")
+        end
+
+        it "returns the hash with the selector" do
+          expect(name.atomic_selector).to eq(
+            { "_id" => person.id, "name._id" => name.id }
+          )
+        end
+      end
+
+      context "when the document is an embeds many" do
+
+        let(:address) do
+          person.addresses.create(street: "kreuzbergstr")
+        end
+
+        it "returns the hash with the selector" do
+          expect(address.atomic_selector).to eq(
+            { "_id" => person.id, "addresses._id" => address.id }
+          )
+        end
+
+        context "when the document's id changes" do
+
+          before do
+            address._id = "hobrecht"
+          end
+
+          it "returns only the parent selector" do
+            expect(address.atomic_selector).to eq(person.atomic_selector)
+          end
+        end
+
+        context "when the document is embedded multiple levels" do
+
+          let(:location) do
+            address.locations.create
+          end
+
+          it "returns a hash with the selector" do
+            expect(location.atomic_selector).to eq(
+              {
+                "_id" => person.id,
+                "addresses._id" => address.id,
+                "addresses.0.locations._id" => location.id
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/serializable_spec.rb

@@ -0,0 +1,862 @@
+require "spec_helper"
+
+describe Mongoid::Serializable do
+
+  describe "#field_names" do
+
+    let(:band) do
+      Band.new
+    end
+
+    it "does not duplicate fields" do
+      expect(band.send(:field_names, {})).to eq(band.fields.except("_type").keys.sort)
+    end
+  end
+
+  describe ".include_root_in_json" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when config set to true" do
+
+      before do
+        Mongoid.include_root_in_json = true
+      end
+
+      it "returns true" do
+        expect(person.include_root_in_json).to be_true
+      end
+    end
+
+    context "when config set to false" do
+
+      before do
+        Mongoid.include_root_in_json = false
+      end
+
+      it "returns false" do
+        expect(person.include_root_in_json).to be_false
+      end
+    end
+  end
+
+  describe "#serializable_hash" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when a dynamic attribute has the same name as a ruby method" do
+
+      before do
+        person[:loop] = "testing"
+      end
+
+      let(:attributes) do
+        person.serializable_hash
+      end
+
+      it "grabs the attribute direct from the hash" do
+        expect(attributes["loop"]).to eq("testing")
+      end
+    end
+
+    context "when the method for a declared field is overridden" do
+
+      before do
+        person.override_me = 1
+      end
+
+      let(:attributes) do
+        person.serializable_hash
+      end
+
+      it "uses the overridden method" do
+        expect(attributes["override_me"]).to eq("1")
+      end
+    end
+
+    context "when the model has embedded documents" do
+
+      let!(:address) do
+        person.addresses.build(street: "test")
+      end
+
+      context "when providing no custom options" do
+
+        let(:attributes) do
+          person.serializable_hash
+        end
+
+        it "includes the embedded documents" do
+          expect(attributes["addresses"].first).to eq(address.serializable_hash)
+        end
+      end
+
+      context "when providing options" do
+
+        let(:attributes) do
+          person.serializable_hash(methods: :id, except: :_id)
+        end
+
+        let(:address_attributes) do
+          attributes["addresses"].first
+        end
+
+        it "uses the options" do
+          expect(attributes["id"]).to eq(person.id)
+        end
+
+        it "uses the options on embedded documents" do
+          expect(address_attributes["id"]).to eq(address.id)
+        end
+      end
+
+      context "when nested multiple levels" do
+
+        let!(:location) do
+          address.locations.build(name: "home")
+        end
+
+        let(:attributes) do
+          person.serializable_hash
+        end
+
+        it "includes the deeply nested document" do
+          expect(attributes["addresses"][0]["locations"]).to_not be_empty
+        end
+      end
+    end
+
+    context "when the model has attributes that need conversion" do
+
+      let(:date) do
+        Date.new(1970, 1, 1)
+      end
+
+      before do
+        person.dob = date
+      end
+
+      let(:attributes) do
+        person.serializable_hash
+      end
+
+      it "converts the objects to the defined type" do
+        expect(attributes["dob"]).to eq(date)
+      end
+    end
+
+    context "when a model has defined fields" do
+
+      let(:attributes) do
+        { "title" => "President", "security_code" => "1234" }
+      end
+
+      before do
+        person.write_attributes(attributes)
+      end
+
+      let(:field_names) do
+        person.fields.keys.map(&:to_s) - ["_type"]
+      end
+
+      it "serializes assigned attributes" do
+        expect(person.serializable_hash).to include attributes
+      end
+
+      it "includes all defined fields except _type" do
+        expect(person.serializable_hash.keys).to include(*field_names)
+      end
+
+      it "does not include _type" do
+        expect(person.serializable_hash.keys).to_not include "_type"
+      end
+
+      context "when providing options" do
+
+        let(:options) do
+          { only: :name }
+        end
+
+        before do
+          person.serializable_hash(options)
+        end
+
+        it "does not modify the options in the argument" do
+          expect(options[:except]).to be_nil
+        end
+      end
+
+      context "when include_type_for_serialization is true" do
+
+        before do
+          Mongoid.include_type_for_serialization = true
+        end
+
+        after do
+          Mongoid.include_type_for_serialization = false
+        end
+
+        it "includes _type field" do
+          expect(person.serializable_hash.keys).to include '_type'
+        end
+      end
+
+      context "when specifying which fields to only include" do
+
+        it "only includes the specified fields" do
+          expect(person.serializable_hash(only: [:title])).to eq(
+            { "title" => attributes["title"] }
+          )
+        end
+      end
+
+      context "when specifying extra inclusions" do
+
+        it "includes the extra fields" do
+          expect(person.serializable_hash(
+            methods: [ :_type ]
+          ).has_key?("_type")).to be_true
+        end
+      end
+
+      context "when specifying which fields to exclude" do
+
+        it "excludes the specified fields" do
+          expect(person.serializable_hash(except: [:title])).to_not include(
+            "title" => attributes["title"]
+          )
+        end
+      end
+    end
+
+    context "when a model has dynamic fields" do
+
+      let(:dynamic_field_name) do
+        "dynamic_field_name"
+      end
+
+      let(:dynamic_value) do
+        "dynamic_value"
+      end
+
+      before do
+        person.write_attribute(dynamic_field_name, dynamic_value)
+      end
+
+      it "includes dynamic fields" do
+        expect(person.serializable_hash[dynamic_field_name]).to eq(dynamic_value)
+      end
+
+      context "when specifying which dynamic fields to only include" do
+
+        it "only includes the specified dynamic fields" do
+          expect(person.serializable_hash(only: [dynamic_field_name])).to eq(
+            { dynamic_field_name => dynamic_value }
+          )
+        end
+      end
+
+      context "when specified which dynamic fields to exclude" do
+
+        it "excludes the specified fields" do
+          expect(person.serializable_hash(except: [dynamic_field_name])).to_not include(
+            dynamic_field_name => dynamic_value
+          )
+        end
+      end
+    end
+
+    context "when a model has relations" do
+
+      let(:attributes) do
+        { "title" => "President", "security_code" => "1234" }
+      end
+
+      before do
+        person.write_attributes(attributes)
+      end
+
+      context "when the model is saved before the relation is added" do
+
+        before do
+          person.save
+        end
+
+        context "when a model has an embeds many" do
+
+          let!(:address_one) do
+            person.addresses.build(street: "Kudamm")
+          end
+
+          before do
+            person.save
+          end
+
+          it "includes the relation" do
+            expect(person.serializable_hash.keys).to include('addresses')
+          end
+        end
+
+        context "when a model has an embeds one" do
+          let!(:name) do
+            person.build_name(first_name: "Leo", last_name: "Marvin")
+          end
+
+          before do
+            person.save
+          end
+
+          it "includes the relation" do
+            expect(person.serializable_hash.keys).to include('name')
+          end
+        end
+      end
+
+      context "when the model is saved after the relation is added" do
+
+        context "when a model has an embeds many" do
+
+          let!(:address_one) do
+            person.addresses.build(street: "Kudamm")
+          end
+
+          before do
+            person.save
+          end
+
+          it "includes the relation" do
+            expect(person.serializable_hash.keys).to include('addresses')
+          end
+        end
+
+        context "when a model has an embeds one" do
+          let!(:name) do
+            person.build_name(first_name: "Leo", last_name: "Marvin")
+          end
+
+          before do
+            person.save
+          end
+
+          it "includes the relation" do
+            expect(person.serializable_hash.keys).to include('name')
+          end
+        end
+      end
+    end
+
+    context "when including methods" do
+
+      it "includes the method result" do
+        expect(person.serializable_hash(methods: [:foo])).to include(
+          "foo" => person.foo
+        )
+      end
+    end
+
+    context "when including relations" do
+
+      context "when including a single relation" do
+
+        context "when including an embeds many" do
+
+          let!(:address_one) do
+            person.addresses.build(street: "Kudamm")
+          end
+
+          let!(:address_two) do
+            person.addresses.build(street: "Tauentzienstr")
+          end
+
+          let(:relation_hash) do
+            hash["addresses"]
+          end
+
+          pending "when the ids were not loaded" do
+
+            before do
+              person.save
+            end
+
+            let(:from_db) do
+              Person.only("addresses.street").first
+            end
+
+            let(:hash) do
+              from_db.serializable_hash
+            end
+
+            it "does not generate new ids" do
+              expect(hash["addresses"].first["_id"]).to be_nil
+            end
+          end
+
+          context "when providing the include as a symbol" do
+
+            let(:hash) do
+              person.serializable_hash(include: :addresses)
+            end
+
+            it "includes the first relation" do
+              expect(relation_hash[0]).to include
+                { "_id" => "kudamm", "street" => "Kudamm" }
+            end
+
+            it "includes the second relation" do
+              expect(relation_hash[1]).to include
+                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
+            end
+          end
+
+          context "when providing the include as an array" do
+
+            let(:hash) do
+              person.serializable_hash(include: [ :addresses ])
+            end
+
+            it "includes the first relation" do
+              expect(relation_hash[0]).to include
+                { "_id" => "kudamm", "street" => "Kudamm" }
+            end
+
+            it "includes the second relation" do
+              expect(relation_hash[1]).to include
+                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
+            end
+          end
+
+          context "when providing the include as a hash" do
+
+            context "when including one level deep" do
+
+              let(:hash) do
+                person.serializable_hash(include: { addresses: { except: :_id } })
+              end
+
+              it "includes the first relation sans exceptions" do
+                expect(relation_hash[0]).to include({ "street" => "Kudamm" })
+              end
+
+              it "includes the second relation sans exceptions" do
+                expect(relation_hash[1]).to include({ "street" => "Tauentzienstr" })
+              end
+            end
+
+            context "when including multiple levels deep" do
+
+              let!(:location) do
+                address_one.locations.build(name: "Home")
+              end
+
+              let(:hash) do
+                person.serializable_hash(
+                  include: { addresses: {
+                    except: :_id, include: { locations: { except: :_id } }
+                  }
+                })
+              end
+
+              it "includes the first relation" do
+                expect(relation_hash[0]["locations"].any? do |location|
+                  location["name"] == "Home"
+                end).to be_true
+              end
+
+              context "after retrieved from database" do
+
+                let(:db_person) do
+                  Person.all.last
+                end
+
+                let!(:second_location) do
+                  address_two.locations.build(name: "Hotel")
+                end
+
+                let(:hash) do
+                  db_person.serializable_hash(
+                    include: { addresses: {
+                      except: :_id, include: { locations: { except: :_id } }
+                    }
+                  })
+                end
+
+                before do
+                  person.save
+                end
+
+                it "includes the specific ralations" do
+                  expect(relation_hash[0]["locations"].map do |location|
+                    location["name"]
+                  end).to include "Home"
+                  expect(relation_hash[1]["locations"].map do |location|
+                    location["name"]
+                  end).to include "Hotel"
+                end
+              end
+            end
+
+            context "when defining a default exclusion" do
+
+              let!(:name) do
+                person.build_name(first_name: "Sebastien")
+              end
+
+              let(:hash) do
+                person.serializable_hash(
+                  except: :_id,
+                  include: [ :addresses, :name ]
+                )
+              end
+
+              it "does not contain the root exclusion" do
+                expect(hash["_id"]).to be_nil
+              end
+
+              it "does not include the embedded many exclusion" do
+                expect(relation_hash[0]["_id"]).to be_nil
+              end
+
+              it "does not include the embedded one exclusion" do
+                expect(hash["name"]["_id"]).to be_nil
+              end
+            end
+          end
+        end
+
+        context "when including an embeds one" do
+
+          let!(:name) do
+            person.build_name(first_name: "Leo", last_name: "Marvin")
+          end
+
+          let(:relation_hash) do
+            hash["name"]
+          end
+
+          context "when providing the include as a symbol" do
+
+            let(:hash) do
+              person.serializable_hash(include: :name)
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to include
+                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
+            end
+          end
+
+          context "when providing the include as an array" do
+
+            let(:hash) do
+              person.serializable_hash(include: [ :name ])
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to include
+                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
+            end
+          end
+
+          context "when providing the include as a hash" do
+
+            let(:hash) do
+              person.serializable_hash(include: { name: { except: :_id }})
+            end
+
+            it "includes the specified relation sans exceptions" do
+              expect(relation_hash).to include
+                { "first_name" => "Leo", "last_name" => "Marvin" }
+            end
+          end
+        end
+
+        context "when including a references many" do
+
+          let!(:post_one) do
+            person.posts.build(title: "First")
+          end
+
+          let!(:post_two) do
+            person.posts.build(title: "Second")
+          end
+
+          let(:relation_hash) do
+            hash["posts"]
+          end
+
+          context "when providing the include as a symbol" do
+
+            let(:hash) do
+              person.serializable_hash(include: :posts)
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["title"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["title"]).to eq("Second")
+            end
+          end
+
+          context "when providing the include as an array" do
+
+            let(:hash) do
+              person.serializable_hash(include: [ :posts ])
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["title"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["title"]).to eq("Second")
+            end
+          end
+
+          context "when providing the include as a hash" do
+
+            let(:hash) do
+              person.serializable_hash(include: { posts: { except: :_id } })
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["title"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["title"]).to eq("Second")
+            end
+
+            it "does not include the first document exceptions" do
+              expect(relation_hash[0]["_id"]).to be_nil
+            end
+
+            it "does not include the second document exceptions" do
+              expect(relation_hash[1]["_id"]).to be_nil
+            end
+          end
+        end
+
+        context "when including a references many to many" do
+
+          let!(:preference_one) do
+            person.preferences.build(name: "First")
+          end
+
+          let!(:preference_two) do
+            person.preferences.build(name: "Second")
+          end
+
+          let(:relation_hash) do
+            hash["preferences"]
+          end
+
+          context "when providing the include as a symbol" do
+
+            let(:hash) do
+              person.serializable_hash(include: :preferences)
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["name"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["name"]).to eq("Second")
+            end
+          end
+
+          context "when providing the include as an array" do
+
+            let(:hash) do
+              person.serializable_hash(include: [ :preferences ])
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["name"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["name"]).to eq("Second")
+            end
+          end
+
+          context "when providing the include as a hash" do
+
+            let(:hash) do
+              person.serializable_hash(
+                include: {
+                  preferences: {
+                    except: :_id
+                  }
+                },
+                except: :preference_ids
+              )
+            end
+
+            it "includes the specified relation" do
+              expect(relation_hash).to_not be_nil
+            end
+
+            it "includes the first document related fields" do
+              expect(relation_hash[0]["name"]).to eq("First")
+            end
+
+            it "includes the second document related fields" do
+              expect(relation_hash[1]["name"]).to eq("Second")
+            end
+
+            it "does not include the first document exceptions" do
+              expect(relation_hash[0]["_id"]).to be_nil
+            end
+
+            it "does not include the second document exceptions" do
+              expect(relation_hash[1]["_id"]).to be_nil
+            end
+
+            it "does not include the root exceptions" do
+              expect(hash["preference_ids"]).to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#to_json" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when including root in json" do
+
+      before do
+        Mongoid.include_root_in_json = true
+      end
+
+      it "uses the mongoid configuration" do
+        expect(person.to_json).to include("person")
+      end
+    end
+
+    context "when not including root in json" do
+
+      before do
+        Mongoid.include_root_in_json = false
+      end
+
+      it "uses the mongoid configuration" do
+        expect(person.to_json).to_not include("person")
+      end
+    end
+
+    context "when serializing a relation directly" do
+
+      context "when serializing an embeds many" do
+
+        let!(:address) do
+          person.addresses.build(street: "Kudamm")
+        end
+
+        let(:json) do
+          person.addresses.to_json
+        end
+
+        it "serializes only the relation" do
+          expect(json).to include(address.street)
+        end
+      end
+
+      context "when serializing a references many" do
+
+        let!(:post) do
+          person.posts.build(title: "testing")
+        end
+
+        let(:json) do
+          person.posts.to_json
+        end
+
+        it "serializes only the relation" do
+          expect(json).to include(post.title)
+        end
+      end
+    end
+  end
+
+  describe "#to_xml" do
+
+    context "Moped::BSON::ObjectId" do
+
+      let(:person) do
+        Person.new
+      end
+
+      it "serializes as string" do
+        expect(person.to_xml).to include("<_id>#{person.id}</_id>")
+      end
+    end
+
+    context "when an Array field is defined" do
+
+      let(:person) do
+        Person.new(
+          aliases: [ "Kelly", "Machine Gun" ]
+        )
+      end
+
+      it "properly types the array" do
+        expect(person.to_xml).to include("<aliases type=\"array\">")
+      end
+
+      it "serializes the array" do
+        expect(person.to_xml).to include("<alias>Kelly</alias>")
+        expect(person.to_xml).to include("<alias>Machine Gun</alias>")
+      end
+    end
+
+    context "when a Hash field is defined" do
+
+      let(:person) do
+        Person.new(
+          map: { lat: 24.5, long: 22.1 }
+        )
+      end
+
+      it "properly types the hash" do
+        expect(person.to_xml).to include("<map>")
+      end
+
+      it "serializes the hash" do
+        expect(person.to_xml).to include("<lat type=\"float\">24.5</lat>")
+        expect(person.to_xml).to include("<long type=\"float\">22.1</long>")
+      end
+    end
+  end
+end