mongoid 6.4.8 → 7.0.0

data/spec/mongoid/matchable/nor_spec.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Nor do
-
-  let(:target) do
-    Person.new
-  end
-
-  let(:matcher) do
-    described_class.new("value", target)
-  end
-
-  describe "#_matches?" do
-
-    context "when provided a simple expression" do
-
-      context "when one of the hashes does not match model" do
-
-        let(:matches) do
-          matcher._matches?(
-            [ { title: "Sir" }, { title: "King" } ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Queen')
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when all of the hashes match different fields in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { age: 10 }, { title: "King" } ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'King', age: 10)
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when one of the hashes matches an array field in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { af: "Sir" }, { af: "King" } ]
-          )
-        end
-
-        let(:target) do
-          ArrayField.new(af: ['King'])
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when none of the hashes matches an array field in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { af: "Sir" }, { af: "King" } ]
-          )
-        end
-
-        let(:target) do
-          ArrayField.new(af: ['Boo'])
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when there are no criteria" do
-
-        it "returns false" do
-          expect(matcher._matches?([])).to be false
-        end
-      end
-
-      # $nor with $not is a double negation.
-      # Whatever the argument of $not is is what the overall condition
-      # is looking for.
-      context "when the expression is a $not" do
-
-        let(:matches) do
-          matcher._matches?([ { title: {:$not => /Foobar/ } }])
-        end
-
-        context "when the value does not match $not argument" do
-
-          let(:target) do
-            Person.new(title: 'test')
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-
-        context "when the value matches $not argument" do
-
-          let(:target) do
-            Person.new(title: 'Foobar baz')
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-      end
-    end
-
-    context "when provided a complex expression" do
-
-      context "when none of the model values match criteria values" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Sir", "Madam" ] } },
-              { title: "King" }
-            ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Queen')
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when there is a matching value" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Prince", "Madam" ] } },
-              { title: "King" }
-            ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Prince')
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when expression contain multiple fields" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: "Sir", age: 23 },
-              { title: "King", age: 100 }
-            ]
-          )
-        end
-
-        context 'and model has different values in all of the fields' do
-          let(:target) do
-            Person.new(title: 'Queen', age: 10)
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context 'and model has identical value in one of the fields' do
-          let(:target) do
-            Person.new(title: 'Queen', age: 23)
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context 'and model has identical values in all of the fields' do
-          let(:target) do
-            Person.new(title: 'Sir', age: 23)
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/relations/builders/referenced/many_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Builders::Referenced::Many do
-
-  let(:base) do
-    double
-  end
-
-  describe "#build" do
-
-    let(:criteria) do
-      double(klass: Post, selector: { "person_id" => "" }, selector_with_type_selection: { "person_id" => "" })
-    end
-
-    let(:metadata) do
-      double(
-        klass: Post,
-        name: :posts,
-        foreign_key: "person_id",
-        inverse_klass: Person,
-        criteria: criteria,
-      )
-    end
-
-    let(:builder) do
-      described_class.new(base, metadata, object)
-    end
-
-    context "when provided an id" do
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:object) do
-        object_id
-      end
-
-      let(:post) do
-        double
-      end
-
-      let(:documents) do
-        builder.build
-      end
-
-      it "sets the documents" do
-        expect(documents).to eq(criteria)
-      end
-    end
-
-    context "when order specified" do
-
-      let(:metadata) do
-        double(
-          klass: Post,
-          name: :posts,
-          foreign_key: "person_id",
-          inverse_klass: Person,
-          order: :rating.asc,
-          criteria: criteria
-        )
-      end
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:object) do
-        object_id
-      end
-
-      let(:post) do
-        double
-      end
-
-      let(:documents) do
-        builder.build
-      end
-
-      it "ordered by specified filed" do
-        expect(documents).to eq(criteria)
-      end
-    end
-
-    context "when provided a object" do
-
-      let(:metadata) do
-        double(
-          klass: Post,
-          name: :posts,
-          foreign_key: "person_id",
-          inverse_klass: Person
-        )
-      end
-
-      let(:object) do
-        [ Person.new ]
-      end
-
-      let(:documents) do
-        builder.build
-      end
-
-      it "returns the object" do
-        expect(documents).to eq(object)
-      end
-    end
-  end
-
-  describe "#build" do
-
-    let(:person) do
-      Person.new
-    end
-
-    context "when no documents found in the database" do
-
-      context "when the ids are empty" do
-
-        it "returns an empty array" do
-          expect(person.posts).to be_empty
-        end
-
-        context "during initialization" do
-
-          it "returns an empty array" do
-            Person.new do |p|
-              expect(p.posts).to be_empty
-              expect(p.posts.__metadata).to_not be_nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/relations/builders/referenced/many_to_many_spec.rb

@@ -1,178 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Builders::Referenced::ManyToMany do
-
-  let(:person) do
-    Person.new
-  end
-
-  let(:base) do
-    double
-  end
-
-  describe "#build" do
-
-    let(:criteria) do
-      double(klass: Preference, selector: { "_id" => { "$in" => [] }})
-    end
-
-    let(:metadata) do
-      double(
-        klass: Preference,
-        name: :preferences,
-        foreign_key: "preference_ids",
-        criteria: criteria
-      )
-    end
-
-    let(:builder) do
-      described_class.new(base, metadata, object)
-    end
-
-    context "when provided ids" do
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:object) do
-        [ object_id ]
-      end
-
-      let(:preference) do
-        double
-      end
-
-      let(:documents) do
-        builder.build
-      end
-
-      it "sets the documents" do
-        expect(documents).to eq(criteria)
-      end
-    end
-
-    context "when order specified" do
-
-      let(:metadata) do
-        double(
-          klass: Post,
-          name: :preferences,
-          foreign_key: "person_id",
-          inverse_klass: Person,
-          order: :rating.asc,
-          criteria: criteria
-        )
-      end
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:object) do
-        [ object_id ]
-      end
-
-      let(:preference) do
-        double
-      end
-
-      let(:documents) do
-        builder.build
-      end
-
-      it "ordered by specified filed" do
-        expect(documents).to eq(criteria)
-      end
-    end
-
-    context "when provided a object" do
-
-      context "when the object is not nil" do
-
-        let(:object) do
-          [ Post.new ]
-        end
-
-        let(:preference) do
-          double
-        end
-
-        let!(:documents) do
-          builder.build
-        end
-
-        it "returns the objects" do
-          expect(documents).to eq(object)
-        end
-      end
-
-      context "when the object is nil" do
-
-        let(:metadata) do
-          double(
-            klass: Post,
-            name: :preferences,
-            foreign_key: "preference_ids",
-            criteria: criteria
-          )
-        end
-
-        let(:object) do
-          nil
-        end
-
-        let!(:documents) do
-          builder.build
-        end
-
-        it "returns the object" do
-          expect(documents).to eq(criteria)
-        end
-      end
-    end
-  end
-
-  describe "#build" do
-
-    let(:person) do
-      Person.new
-    end
-
-    context "when no documents found in the database" do
-
-      context "when the ids are empty" do
-
-        it "returns an empty array" do
-          expect(person.preferences).to be_empty
-        end
-      end
-
-      context "when the ids are incorrect" do
-
-        before do
-          person.preference_ids = [ BSON::ObjectId.new ]
-        end
-
-        it "returns an empty array" do
-          expect(person.preferences).to be_empty
-        end
-      end
-    end
-  end
-
-  context "when the foreign key is nil" do
-
-    let(:builder) do
-      described_class.new(person, Person.relations["preferences"], nil)
-    end
-
-    let(:criteria) do
-      builder.build
-    end
-
-    it "returns the criteria" do
-      expect(criteria).to be_empty
-    end
-  end
-end

data/spec/mongoid/relations/builders/referenced/one_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Builders::Referenced::One do
-
-  let(:base) do
-    double(new_record?: false)
-  end
-
-  describe "#build" do
-
-    let(:criteria) do
-      Post.where("person_id" => object)
-    end
-
-    let(:metadata) do
-      double(
-        klass: Post,
-        name: :post,
-        foreign_key: "person_id",
-        criteria: criteria,
-        inverse_klass: Person
-      )
-    end
-
-    let(:builder) do
-      described_class.new(base, metadata, object)
-    end
-
-    context "when provided an id" do
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:object) do
-        object_id
-      end
-
-      let(:post) do
-        double
-      end
-
-      before do
-        expect(criteria).to receive(:first).and_return(post)
-      end
-
-      let!(:documents) do
-        builder.build
-      end
-
-      it "sets the document" do
-        expect(documents).to eq(post)
-      end
-    end
-
-    context "when provided a object" do
-
-      let(:object) do
-        Post.new
-      end
-
-      let(:document) do
-        builder.build
-      end
-
-      it "returns the object" do
-        expect(document).to eq(object)
-      end
-    end
-  end
-
-  describe "#build" do
-
-    let(:person) do
-      Person.new
-    end
-
-    context "when the document is not found" do
-
-      it "returns nil" do
-        expect(person.game).to be_nil
-      end
-    end
-
-    context "when the document is persisted" do
-
-      let!(:game) do
-        Game.create(person: person)
-      end
-
-      it "returns the document" do
-        expect(person.game).to eq(game)
-      end
-    end
-
-    context "when the document have a non standard pk" do
-
-      before do
-        person.save
-      end
-
-      let!(:cat) do
-        Cat.create(person: person)
-      end
-
-      it "returns the document" do
-        expect(person.cat).to eq(cat)
-      end
-    end
-  end
-end