mongoid 3.1.6 → 4.0.0

data/spec/mongoid/persistence/atomic/add_to_set_spec.rb

@@ -1,262 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Atomic::AddToSet do
-
-  describe "#persist" do
-
-    context "when the document is new" do
-
-      let(:person) do
-        Person.new
-      end
-
-      context "when adding a single value" do
-
-        let!(:added) do
-          person.add_to_set(:aliases, "Bond")
-        end
-
-        it "adds the value onto the array" do
-          person.aliases.should eq([ "Bond" ])
-        end
-
-        it "does not reset the dirty flagging" do
-          person.changes["aliases"].should eq([nil, ["Bond"]])
-        end
-
-        it "returns the new array value" do
-          added.should eq([ "Bond" ])
-        end
-      end
-
-      context "when adding multiple values" do
-
-        let!(:added) do
-          person.add_to_set(:aliases, [ "Bond", "James" ])
-        end
-
-        it "adds the value onto the array" do
-          person.aliases.should eq([ "Bond", "James" ])
-        end
-
-        it "does not reset the dirty flagging" do
-          person.changes["aliases"].should eq([nil, ["Bond", "James"]])
-        end
-
-        it "returns the new array value" do
-          added.should eq([ "Bond", "James" ])
-        end
-      end
-    end
-
-    context "when the field exists" do
-
-      context "when the value is unique" do
-
-        let(:person) do
-          Person.create(aliases: [ "007" ])
-        end
-
-        context "when adding a single value" do
-
-          let!(:added) do
-            person.add_to_set(:aliases, "Bond")
-          end
-
-          let(:reloaded) do
-            person.reload
-          end
-
-          it "adds the value onto the array" do
-            person.aliases.should eq([ "007", "Bond" ])
-          end
-
-          it "persists the data" do
-            reloaded.aliases.should eq([ "007", "Bond" ])
-          end
-
-          it "removes the field from the dirty attributes" do
-            person.changes["aliases"].should be_nil
-          end
-
-          it "resets the document dirty flag" do
-            person.should_not be_changed
-          end
-
-          it "returns the new array value" do
-            added.should eq([ "007", "Bond" ])
-          end
-        end
-
-        context "when adding a multiple values" do
-
-          let!(:added) do
-            person.add_to_set(:aliases, [ "Bond", "James" ])
-          end
-
-          let(:reloaded) do
-            person.reload
-          end
-
-          it "adds the value onto the array" do
-            person.aliases.should eq([ "007", "Bond", "James" ])
-          end
-
-          it "persists the data" do
-            reloaded.aliases.should eq([ "007", "Bond", "James" ])
-          end
-
-          it "removes the field from the dirty attributes" do
-            person.changes["aliases"].should be_nil
-          end
-
-          it "resets the document dirty flag" do
-            person.should_not be_changed
-          end
-
-          it "returns the new array value" do
-            added.should eq([ "007", "Bond", "James" ])
-          end
-        end
-      end
-
-      context "when the value is not unique" do
-
-        let(:person) do
-          Person.create(aliases: [ "Bond" ])
-        end
-
-        context "when adding a single value" do
-
-          let!(:added) do
-            person.add_to_set(:aliases, "Bond")
-          end
-
-          let(:reloaded) do
-            person.reload
-          end
-
-          it "does not add the value" do
-            person.aliases.should eq([ "Bond" ])
-          end
-
-          it "persists the data" do
-            reloaded.aliases.should eq([ "Bond" ])
-          end
-
-          it "removes the field from the dirty attributes" do
-            person.changes["aliases"].should be_nil
-          end
-
-          it "resets the document dirty flag" do
-            person.should_not be_changed
-          end
-
-          it "returns the array value" do
-            added.should eq([ "Bond" ])
-          end
-        end
-
-        context "when adding multiple values" do
-
-          let!(:added) do
-            person.add_to_set(:aliases, [ "Bond", "James" ])
-          end
-
-          let(:reloaded) do
-            person.reload
-          end
-
-          it "does not add the duplicate value" do
-            person.aliases.should eq([ "Bond", "James" ])
-          end
-
-          it "persists the data" do
-            reloaded.aliases.should eq([ "Bond", "James" ])
-          end
-
-          it "removes the field from the dirty attributes" do
-            person.changes["aliases"].should be_nil
-          end
-
-          it "resets the document dirty flag" do
-            person.should_not be_changed
-          end
-
-          it "returns the array value" do
-            added.should eq([ "Bond", "James" ])
-          end
-        end
-      end
-    end
-
-    context "when the field does not exist" do
-
-      let(:person) do
-        Person.create
-      end
-
-      context "when adding a single value" do
-
-        let!(:added) do
-          person.add_to_set(:aliases, "Bond")
-        end
-
-        let(:reloaded) do
-          person.reload
-        end
-
-        it "adds the value onto the array" do
-          person.aliases.should eq([ "Bond" ])
-        end
-
-        it "persists the data" do
-          reloaded.aliases.should eq([ "Bond" ])
-        end
-
-        it "removes the field from the dirty attributes" do
-          person.changes["aliases"].should be_nil
-        end
-
-        it "resets the document dirty flag" do
-          person.should_not be_changed
-        end
-
-        it "returns the new array value" do
-          added.should eq([ "Bond" ])
-        end
-      end
-
-      context "when adding multiple values" do
-
-        let!(:added) do
-          person.add_to_set(:aliases, [ "Bond", "James" ])
-        end
-
-        let(:reloaded) do
-          person.reload
-        end
-
-        it "adds the value onto the array" do
-          person.aliases.should eq([ "Bond", "James" ])
-        end
-
-        it "persists the data" do
-          reloaded.aliases.should eq([ "Bond", "James" ])
-        end
-
-        it "removes the field from the dirty attributes" do
-          person.changes["aliases"].should be_nil
-        end
-
-        it "resets the document dirty flag" do
-          person.should_not be_changed
-        end
-
-        it "returns the new array value" do
-          added.should eq([ "Bond", "James" ])
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/atomic/bit_spec.rb

@@ -1,88 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Atomic::Bit do
-
-  describe "#bit" do
-
-    let(:person) do
-      Person.create(age: 60)
-    end
-
-    let(:reloaded) do
-      person.reload
-    end
-
-    context "when performing a bitwise and" do
-
-      let!(:bit) do
-        person.bit(:age, { and: 13 })
-      end
-
-      it "performs the bitwise operation" do
-        person.age.should eq(12)
-      end
-
-      it "returns the new value" do
-        bit.should eq(12)
-      end
-
-      it "persists the changes" do
-        reloaded.age.should eq(12)
-      end
-
-      it "resets the dirty attributes" do
-        person.changes["age"].should be_nil
-      end
-    end
-
-    context "when performing a bitwise or" do
-
-      let!(:bit) do
-        person.bit(:age, { or: 13 })
-      end
-
-      it "performs the bitwise operation" do
-        person.age.should eq(61)
-      end
-
-      it "returns the new value" do
-        bit.should eq(61)
-      end
-
-      it "persists the changes" do
-        reloaded.age.should eq(61)
-      end
-
-      it "resets the dirty attributes" do
-        person.changes["age"].should be_nil
-      end
-    end
-
-    context "when chaining bitwise operations" do
-
-      let(:hash) do
-        { and: 13, or: 10 }
-      end
-
-      let!(:bit) do
-        person.bit(:age, hash)
-      end
-
-      it "performs the bitwise operation" do
-        person.age.should eq(14)
-      end
-
-      it "returns the new value" do
-        bit.should eq(14)
-      end
-
-      it "persists the changes" do
-        reloaded.age.should eq(14)
-      end
-
-      it "resets the dirty attributes" do
-        person.changes["age"].should be_nil
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/atomic/inc_spec.rb

@@ -1,133 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Atomic::Inc do
-
-  describe "#inc" do
-
-    let(:person) do
-      Person.create(age: 100)
-    end
-
-    let(:reloaded) do
-      person.reload
-    end
-
-    context "when incrementing a field on an embedded document" do
-
-      let(:address) do
-        person.addresses.create(street: "Tauentzienstr", number: 5)
-      end
-
-      let!(:inced) do
-        address.inc(:number, 5)
-      end
-
-      it "increments the provided value" do
-        inced.should eq(10)
-      end
-
-      it "persists the change" do
-        reloaded.addresses.first.number.should eq(10)
-      end
-    end
-
-    context "when incrementing a field with a value" do
-
-      context "when provided an integer" do
-
-        let!(:inced) do
-          person.inc(:age, 2)
-        end
-
-        it "increments by the provided value" do
-          person.age.should eq(102)
-        end
-
-        it "returns the new value" do
-          inced.should eq(102)
-        end
-
-        it "persists the changes" do
-          reloaded.age.should eq(102)
-        end
-
-        it "keeps the field as an integer" do
-          inced.should be_a(Integer)
-        end
-
-        it "resets the dirty attributes" do
-          person.changes["age"].should be_nil
-        end
-      end
-
-      context "when provided a big decimal" do
-
-        let!(:inced) do
-          person.inc(:blood_alcohol_content, BigDecimal.new("2.2"))
-        end
-
-        it "increments by the provided value" do
-          person.blood_alcohol_content.should eq(2.2)
-        end
-
-        it "returns the new value" do
-          inced.should eq(2.2)
-        end
-
-        it "persists the changes" do
-          reloaded.blood_alcohol_content.should eq(2.2)
-        end
-
-        it "resets the dirty attributes" do
-          person.changes["blood_alcohol_content"].should be_nil
-        end
-      end
-    end
-
-    context "when incrementing a nil field" do
-
-      let!(:inced) do
-        person.inc(:score, 2)
-      end
-
-      it "sets the value to the provided number" do
-        person.score.should eq(2)
-      end
-
-      it "returns the new value" do
-        inced.should eq(2)
-      end
-
-      it "persists the changes" do
-        reloaded.score.should eq(2)
-      end
-
-      it "resets the dirty attributes" do
-        person.changes["score"].should be_nil
-      end
-    end
-
-    context "when incrementing a non existant field" do
-
-      let!(:inced) do
-        person.inc(:high_score, 5)
-      end
-
-      it "sets the value to the provided number" do
-        person.high_score.should eq(5)
-      end
-
-      it "returns the new value" do
-        inced.should eq(5)
-      end
-
-      it "persists the changes" do
-        reloaded.high_score.should eq(5)
-      end
-
-      it "resets the dirty attributes" do
-        person.changes["high_score"].should be_nil
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/atomic/pop_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Atomic::Pop do
-
-  describe "#persist" do
-
-    context "when the field exists" do
-
-      let(:person) do
-        Person.create(aliases: [ "007", "008", "009" ])
-      end
-
-      context "when popping the last element" do
-
-        let!(:popped) do
-          person.pop(:aliases, 1)
-        end
-
-        let(:reloaded) do
-          person.reload
-        end
-
-        it "pops the value from the array" do
-          person.aliases.should eq([ "007", "008" ])
-        end
-
-        it "persists the data" do
-          reloaded.aliases.should eq([ "007", "008" ])
-        end
-
-        it "removes the field from the dirty attributes" do
-          person.changes["aliases"].should be_nil
-        end
-
-        it "resets the document dirty flag" do
-          person.should_not be_changed
-        end
-
-        it "returns the new array value" do
-          popped.should eq([ "007", "008" ])
-        end
-      end
-
-      context "when popping the first element" do
-
-        let!(:popped) do
-          person.pop(:aliases, -1)
-        end
-
-        let(:reloaded) do
-          person.reload
-        end
-
-        it "pops the value from the array" do
-          person.aliases.should eq([ "008", "009" ])
-        end
-
-        it "persists the data" do
-          reloaded.aliases.should eq([ "008", "009" ])
-        end
-
-        it "removes the field from the dirty attributes" do
-          person.changes["aliases"].should be_nil
-        end
-
-        it "resets the document dirty flag" do
-          person.should_not be_changed
-        end
-
-        it "returns the new array value" do
-          popped.should eq([ "008", "009" ])
-        end
-      end
-    end
-
-    context "when the field does not exist" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:popped) do
-        person.pop(:aliases, 1)
-      end
-
-      let(:reloaded) do
-        person.reload
-      end
-
-      it "does not modify the field" do
-        person.aliases.should be_nil
-      end
-
-      it "persists no data" do
-        reloaded.aliases.should be_nil
-      end
-
-      it "removes the field from the dirty attributes" do
-        person.changes["aliases"].should be_nil
-      end
-
-      it "resets the document dirty flag" do
-        person.should_not be_changed
-      end
-
-      it "returns nil" do
-        popped.should be_nil
-      end
-    end
-  end
-end

data/spec/mongoid/persistence/atomic/pull_all_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Persistence::Atomic::PullAll do
-
-  describe "#persist" do
-
-    context "when the field exists" do
-
-      let(:person) do
-        Person.create(aliases: [ "007" ])
-      end
-
-      let!(:pulled) do
-        person.pull_all(:aliases, [ "007" ])
-      end
-
-      let(:reloaded) do
-        person.reload
-      end
-
-      it "pulls the value from the array" do
-        person.aliases.should be_empty
-      end
-
-      it "persists the data" do
-        reloaded.aliases.should be_empty
-      end
-
-      it "removes the field from the dirty attributes" do
-        person.changes["aliases"].should be_nil
-      end
-
-      it "resets the document dirty flag" do
-        person.should_not be_changed
-      end
-
-      it "returns the new array value" do
-        pulled.should be_empty
-      end
-    end
-
-    context "when the field does not exist" do
-
-      let(:person) do
-        Person.create
-      end
-
-      let!(:pulled) do
-        person.pull_all(:aliases, [ "Bond" ])
-      end
-
-      let(:reloaded) do
-        person.reload
-      end
-
-      it "does not modify the field" do
-        person.aliases.should be_nil
-      end
-
-      it "persists no data" do
-        reloaded.aliases.should be_nil
-      end
-
-      it "removes the field from the dirty attributes" do
-        person.changes["aliases"].should be_nil
-      end
-
-      it "resets the document dirty flag" do
-        person.should_not be_changed
-      end
-
-      it "returns nil" do
-        pulled.should be_nil
-      end
-    end
-  end
-end