mongoid 3.1.4 → 3.1.5

data/spec/mongoid/relations/constraint_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Constraint do
+
+  describe "#convert" do
+
+    context "when the id's class stores object ids" do
+
+      before(:all) do
+        Person.field(
+          :_id,
+          type: Moped::BSON::ObjectId,
+          pre_processed: true,
+          default: ->{ Moped::BSON::ObjectId.new }
+        )
+      end
+
+      let(:metadata) do
+        Mongoid::Relations::Metadata.new(
+          class_name: "Person",
+          name: :person,
+          inverse_class_name: "Post",
+          relation: Mongoid::Relations::Referenced::In
+        )
+      end
+
+      let(:constraint) do
+        described_class.new(metadata)
+      end
+
+      context "when provided an object id" do
+
+        let(:object) do
+          Moped::BSON::ObjectId.new
+        end
+
+        it "returns the object id" do
+          constraint.convert(object).should eq(object)
+        end
+      end
+
+      context "when provided a string" do
+
+        let(:object) do
+          Moped::BSON::ObjectId.new
+        end
+
+        it "returns an object id from the string" do
+          constraint.convert(object.to_s).should eq(object)
+        end
+      end
+    end
+
+    context "when the id's class does not store object ids" do
+
+      let(:metadata) do
+        Mongoid::Relations::Metadata.new(
+          class_name: "Account",
+          name: :account,
+          inverse_class_name: "Alert",
+          relation: Mongoid::Relations::Referenced::In
+        )
+      end
+
+      let(:constraint) do
+        described_class.new(metadata)
+      end
+
+      it "returns the object" do
+        constraint.convert("testing").should eq("testing")
+      end
+    end
+  end
+end

data/spec/mongoid/relations/conversions_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Conversions do
+
+  describe ".flag" do
+
+    context "when the inverse uses object ids" do
+
+      let(:metadata) do
+        Person.relations["game"]
+      end
+
+      let(:object) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:flagged) do
+        described_class.flag(object, metadata)
+      end
+
+      it "returns the object" do
+        flagged.should eq(object)
+      end
+    end
+
+    context "when the inverse uses string ids" do
+
+      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(:metadata) do
+        Person.relations["game"]
+      end
+
+      context "when provided an object id" do
+
+        let(:object) do
+          Moped::BSON::ObjectId.new
+        end
+
+        let(:flagged) do
+          described_class.flag(object, metadata)
+        end
+
+        it "returns the object id" do
+          flagged.should eq(object)
+        end
+      end
+
+      context "when provided a string" do
+
+        let(:object) do
+          Moped::BSON::ObjectId.new.to_s
+        end
+
+        let(:flagged) do
+          described_class.flag(object, metadata)
+        end
+
+        it "returns the string" do
+          flagged.should eq(object)
+        end
+
+        it "marks the string as unconvertable" do
+          flagged.should be_unconvertable_to_bson
+        end
+      end
+    end
+
+    context "when the inverse uses integer ids" do
+
+      let(:metadata) do
+        Jar.relations["cookies"]
+      end
+
+      context "when provided an object id" do
+
+        let(:object) do
+          Moped::BSON::ObjectId.new
+        end
+
+        let(:flagged) do
+          described_class.flag(object, metadata)
+        end
+
+        it "returns the object id" do
+          flagged.should eq(object)
+        end
+      end
+
+      context "when provided an integer" do
+
+        let(:object) do
+          15
+        end
+
+        let(:flagged) do
+          described_class.flag(object, metadata)
+        end
+
+        it "returns the integer" do
+          flagged.should eq(15)
+        end
+
+        it "marks the integer as unconvertable" do
+          flagged.should be_unconvertable_to_bson
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/relations/counter_cache_spec.rb

@@ -0,0 +1,205 @@
+require "spec_helper"
+
+describe Mongoid::Relations::CounterCache do
+
+  describe "#reset_counters" do
+
+    context "when counter is reset" do
+
+      let(:person) do
+        Person.create do |person|
+          person[:drugs_count] = 3
+        end
+      end
+
+      before do
+        Person.reset_counters person.id, :drugs
+      end
+
+      it "returns zero" do
+        expect(person.reload.drugs_count).to eq(0)
+      end
+    end
+
+    context "when counter is reset with wrong id" do
+
+      it "expect to raise an error" do
+        expect {
+          Person.reset_counters "1", :drugs
+        }.to raise_error
+      end
+    end
+
+    context "when reset with invalid name" do
+
+      let(:person) do
+        Person.create
+      end
+
+      it "expect to raise an error" do
+        expect {
+          Person.reset_counters person.id, :not_exist
+        }.to raise_error
+      end
+    end
+
+    context "when counter gets messy" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:post) do
+        person.posts.create(title: "my first post")
+      end
+
+      before do
+        Person.update_counters(person.id, :posts_count => 10)
+        Person.reset_counters(person.id, :posts)
+      end
+
+      it "resets to the right value" do
+        expect(person.reload.posts_count).to eq(1)
+      end
+    end
+
+    context "when the counter is on a subclass" do
+
+      let(:subscription) do
+        Subscription.create
+      end
+
+      let!(:pack) do
+        subscription.packs.create
+      end
+
+      before do
+        Subscription.reset_counters(subscription.id, :packs)
+      end
+
+      it "resets the appropriate counter" do
+        expect(subscription.reload[:packs_count]).to eq(1)
+      end
+    end
+  end
+
+  describe "#update_counters" do
+
+    context "when was 3 " do
+
+      let(:person) do
+        Person.create do |person|
+          person[:drugs_count] = 3
+        end
+      end
+
+      context "and update counter with 5" do
+
+        before do
+          Person.update_counters person.id, :drugs_count => 5
+        end
+
+        it "return 8" do
+          expect(person.reload.drugs_count).to eq(8)
+        end
+      end
+
+      context "and update counter with -5" do
+
+        before do
+          Person.update_counters person.id, :drugs_count => -5
+        end
+
+        it "return -2" do
+          expect(person.reload.drugs_count).to eq(-2)
+        end
+      end
+    end
+    context "when update with 2 and use a string argument" do
+
+      let(:person) { Person.create }
+
+      before do
+        Person.update_counters person.id, "drugs_count" => 2
+      end
+
+      it "returns 2" do
+        expect(person.reload.drugs_count).to eq(2)
+      end
+    end
+
+    context "when update more multiple counters" do
+
+      let(:person) { Person.create }
+
+      before do
+        Person.update_counters(person.id, :drugs_count => 2, :second_counter => 5)
+      end
+
+      it "updates drugs_counter" do
+        expect(person.reload.drugs_count).to eq(2)
+      end
+
+      it "updates second_counter" do
+        expect(person.reload.second_counter).to eq(5)
+      end
+    end
+  end
+
+  describe "#increment_counter" do
+
+    let(:person) { Person.create }
+
+    context "when increment 3 times" do
+
+      before do
+        3.times { Person.increment_counter(:drugs_count, person.id) }
+      end
+
+      it "returns 3" do
+        expect(person.reload.drugs_count).to eq(3)
+      end
+    end
+
+    context "when increment 3 times using string as argument" do
+
+      before do
+        3.times { Person.increment_counter("drugs_count", person.id) }
+      end
+
+      it "returns 3" do
+        expect(person.reload.drugs_count).to eq(3)
+      end
+    end
+  end
+
+  describe "#decrement_counter" do
+
+    let(:person) do
+      Person.create do |p|
+        p[:drugs_count] = 3
+      end
+    end
+
+    context "when decrement 3 times" do
+
+      before do
+        3.times { Person.decrement_counter(:drugs_count, person.id) }
+      end
+
+      it "returns 0" do
+        expect(person.reload.drugs_count).to eq(0)
+      end
+    end
+    context "when increment 3 times using string as argument" do
+
+      before do
+        3.times { Person.decrement_counter("drugs_count", person.id) }
+      end
+
+      it "returns 0" do
+        expect(person.reload.drugs_count).to eq(0)
+      end
+    end
+  end
+end

data/spec/mongoid/relations/cyclic_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Cyclic do
+
+  describe ".recursively_embeds_many" do
+
+    context "when the name is inflected easily" do
+
+      let(:document) do
+        Role.new
+      end
+
+      it "creates the parent relation" do
+        document.should respond_to(:parent_role)
+      end
+
+      it "creates the child relation" do
+        document.should respond_to(:child_roles)
+      end
+
+      it "sets cyclic to true" do
+        document.cyclic.should be_true
+      end
+    end
+
+    context "when the name is not inflected easily" do
+
+      let(:document) do
+        Entry.new
+      end
+
+      it "creates the parent relation" do
+        document.should respond_to(:parent_entry)
+      end
+
+      it "creates the child relation" do
+        document.should respond_to(:child_entries)
+      end
+
+      it "sets cyclic to true" do
+        document.cyclic.should be_true
+      end
+    end
+
+    context "when the document is namespaced" do
+
+      module Trees
+        class Node
+          include Mongoid::Document
+          recursively_embeds_many
+
+          field :name, type: String
+
+          def is_root?
+            parent_node.nil?
+          end
+        end
+      end
+
+      let(:document) do
+        Trees::Node.new
+      end
+
+      it "creates the parent relation" do
+        document.should respond_to(:parent_node)
+      end
+
+      it "creates the child relation" do
+        document.should respond_to(:child_nodes)
+      end
+
+      it "sets cyclic to true" do
+        document.cyclic.should be_true
+      end
+    end
+
+    context "when the classes are namespaced" do
+
+      let(:document) do
+        Fruits::Apple.new
+      end
+
+      it "creates the parent relation" do
+        document.should respond_to(:parent_apple)
+      end
+
+      it "creates the child relation" do
+        document.should respond_to(:child_apples)
+      end
+
+      it "sets cyclic to true" do
+        document.cyclic.should be_true
+      end
+    end
+
+    context "when cascading callbacks are enabled" do
+
+      let(:document) do
+        Fruits::Pineapple.new
+      end
+
+      it "creates relation with cascading callbacks enabled" do
+        document.class.relations['child_pineapples'].should be_cascading_callbacks
+      end
+    end
+  end
+
+  describe ".recursively_embeds_one" do
+
+    let(:document) do
+      Shelf.new
+    end
+
+    it "creates the parent relation" do
+      document.should respond_to(:parent_shelf)
+    end
+
+    it "creates the child relation" do
+      document.should respond_to(:child_shelf)
+    end
+
+    it "sets cyclic to true" do
+      document.cyclic.should be_true
+    end
+
+    context "when cascading callbacks are enabled" do
+
+      let(:document) do
+        Fruits::Mango.new
+      end
+
+      it "creates relation with cascading callbacks enabled" do
+        document.class.relations['child_mango'].should be_cascading_callbacks
+      end
+    end
+  end
+
+  context "when building a namespaced hierarchy" do
+
+    let(:root) do
+      Trees::Node.new(name: "root")
+    end
+
+    let!(:child_one) do
+      root.child_nodes.build(name: "first_child")
+    end
+
+    let!(:child_two) do
+      root.child_nodes.build(name: "second_child")
+    end
+
+    it "sets the parent node" do
+      child_one.parent_node.should eq(root)
+    end
+  end
+end