mongoid 4.0.2 → 5.0.0

data/spec/mongoid/contextual/find_and_modify_spec.rb

@@ -1,220 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Contextual::FindAndModify do
-
-  describe "#result" do
-
-    let!(:depeche) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let!(:tool) do
-      Band.create(name: "Tool")
-    end
-
-    let!(:collection) do
-      Band.collection
-    end
-
-    context "when the selector matches" do
-
-      context "when not providing options" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to eq(1)
-        end
-      end
-
-      context "when providing values that needs to be cast" do
-
-        let(:date_time) do
-          DateTime.new(1978, 1, 1)
-        end
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$set" => { created: date_time }})
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.created).to eq(date_time)
-        end
-      end
-
-      context "when sorting" do
-
-        let(:criteria) do
-          Band.desc(:name)
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["name"]).to eq("Tool")
-        end
-
-        it "updates the document in the database" do
-          expect(tool.reload.likes).to eq(1)
-        end
-      end
-
-      context "when limiting fields" do
-
-        let(:criteria) do
-          Band.only(:_id)
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["_id"]).to eq(depeche.id)
-        end
-
-        it "limits the returned fields" do
-          expect(result["name"]).to be_nil
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to eq(1)
-        end
-      end
-
-      context "when returning new" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$inc" => { likes: 1 }}, new: true)
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "returns the updated document" do
-          expect(result["likes"]).to eq(1)
-        end
-      end
-
-      context "when removing" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, {}, remove: true)
-        end
-
-        let!(:result) do
-          context.result
-        end
-
-        it "returns the first matching document" do
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "deletes the document from the database" do
-          expect {
-            depeche.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound)
-        end
-      end
-
-      context "when upserting" do
-
-        let(:criteria) do
-          Band.where(name: "The Mars Volta")
-        end
-
-        let(:context) do
-          described_class.new(collection, criteria, { "$inc" => { likes: 1 }}, upsert: true)
-        end
-
-        let(:result) do
-          context.result
-        end
-
-        it "creates the document if it does not exist" do
-          expect {
-            result
-          }.to change{Band.where(name: "The Mars Volta").count}.from(0).to(1)
-        end
-
-        it "updates the document in the database if it does exist" do
-          the_mars_volta = Band.create(name: "The Mars Volta")
-
-          expect {
-            result
-          }.to_not change{Band.where(name: "The Mars Volta").count}
-
-          expect(the_mars_volta.reload.likes).to eq(1)
-        end
-      end
-    end
-
-    context "when the selector does not match" do
-
-      let(:criteria) do
-        Band.where(name: "Placebo")
-      end
-
-      let(:context) do
-        described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
-      end
-
-      let(:result) do
-        context.result
-      end
-
-      it "returns nil" do
-        expect(result).to be_nil
-      end
-    end
-  end
-end

data/spec/mongoid/contextual/text_search_spec.rb

@@ -1,209 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Contextual::TextSearch do
-
-  before do
-    Word.with(database: "admin").mongo_session.command(setParameter: 1, textSearchEnabled: true)
-    Word.create_indexes
-  end
-
-  after(:all) do
-    Word.remove_indexes
-  end
-
-  describe "#each" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.all
-    end
-
-    before do
-      Word.create!(name: "phase", origin: "latin")
-      Word.create!(name: "phazed", origin: "latin")
-    end
-
-    context "when the search is projecting" do
-
-      let(:search) do
-        described_class.new(collection, criteria, "phase").project(name: 1)
-      end
-
-      let(:documents) do
-        search.entries
-      end
-
-      it "limits the fields to the projection" do
-        expect {
-          documents.first.origin
-        }.to raise_error(ActiveModel::MissingAttributeError)
-      end
-    end
-
-    context "when the search is not projecting" do
-
-      let(:search) do
-        described_class.new(collection, criteria, "phase")
-      end
-
-      let(:documents) do
-        search.entries
-      end
-
-      it "returns all fields" do
-        expect(documents.first.origin).to eq("latin")
-      end
-    end
-  end
-
-  describe "#execute" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.all
-    end
-
-    let(:search) do
-      described_class.new(collection, criteria, "phase")
-    end
-
-    before do
-      Word.create!(name: "phase", origin: "latin")
-      Word.create!(name: "phazed", origin: "latin")
-    end
-
-    let(:results) do
-      search.execute
-    end
-
-    it "returns the raw results" do
-      expect(results).to_not be_empty
-    end
-  end
-
-  describe "#initialize" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.limit(100)
-    end
-
-    let(:search) do
-      described_class.new(collection, criteria, "phase")
-    end
-
-    it "sets the collection" do
-      expect(search.collection).to eq(collection)
-    end
-
-    it "sets the criteria" do
-      expect(search.criteria).to eq(criteria)
-    end
-
-    it "sets the text command" do
-      expect(search.command[:text]).to eq(collection.name)
-    end
-
-    it "sets the text search parameter" do
-      expect(search.command[:search]).to eq("phase")
-    end
-
-    it "sets the criteria" do
-      expect(search.command[:filter]).to be_empty
-    end
-
-    it "sets the limit" do
-      expect(search.command[:limit]).to eq(100)
-    end
-  end
-
-  describe "#language" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.limit(100)
-    end
-
-    let(:search) do
-      described_class.new(collection, criteria, "phase")
-    end
-
-    let!(:text_search) do
-      search.language("deutsch")
-    end
-
-    it "sets the search language" do
-      expect(search.command[:language]).to eq("deutsch")
-    end
-
-    it "returns the text search" do
-      expect(text_search).to equal(search)
-    end
-  end
-
-  describe "#project" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.limit(100)
-    end
-
-    let(:search) do
-      described_class.new(collection, criteria, "phase")
-    end
-
-    let!(:text_search) do
-      search.project(name: 1, title: 1)
-    end
-
-    it "sets the search field limitations" do
-      expect(search.command[:project]).to eq(name: 1, title: 1)
-    end
-
-    it "returns the text search" do
-      expect(text_search).to equal(search)
-    end
-  end
-
-  describe "#stats" do
-
-    let(:collection) do
-      Word.collection
-    end
-
-    let(:criteria) do
-      Word.all
-    end
-
-    let(:search) do
-      described_class.new(collection, criteria, "phase")
-    end
-
-    before do
-      Word.create!(name: "phase", origin: "latin")
-    end
-
-    let(:stats) do
-      search.stats
-    end
-
-    it "returns the raw stats" do
-      expect(stats["nscanned"]).to eq(1)
-    end
-  end
-end

data/spec/mongoid/log_subscriber_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::LogSubscriber do
-
-  describe ".query" do
-
-    let!(:subscribe) do
-      Mongoid::LogSubscriber.log_subscribers.first
-    end
-
-    before do
-      @old_level, Moped.logger.level = Moped.logger.level, 0
-    end
-
-    after do
-      Moped.logger.level = @old_level
-    end
-
-    context "when quering the database" do
-
-      it "logs the operation" do
-        expect(subscribe).to receive(:debug).once
-        Band.all.to_a
-      end
-    end
-
-    context "when creating a new subscriber" do
-
-      class TestLogSubscriber < ActiveSupport::LogSubscriber
-        attr_reader :debugs
-
-        def initialize
-          super
-          @debugs = []
-        end
-
-        def query(event)
-          @debugs << event
-        end
-
-        def logger
-          Moped.logger
-        end
-      end
-
-      let(:test_subscriber) do
-        TestLogSubscriber.new
-      end
-
-      before do
-        ActiveSupport::LogSubscriber.attach_to :moped, test_subscriber
-      end
-
-      after do
-        TestLogSubscriber.log_subscribers.pop
-      end
-
-      it "pushes the new log subscriber" do
-        expect(Mongoid::LogSubscriber.subscribers.last).to be_a TestLogSubscriber
-      end
-
-      context "when quering the database" do
-
-        before do
-          expect(subscribe).to receive(:debug).once
-          PetOwner.all.to_a
-        end
-
-        it "sends operations logs to TestLogSubscriber" do
-          expect(test_subscriber.debugs.size).to eq(1)
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/positional_spec.rb

@@ -1,222 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Positional do
-
-  describe "#positionally" do
-
-    let(:positionable) do
-      Class.new do
-        include Mongoid::Positional
-      end.new
-    end
-
-    let(:updates) do
-      {
-        "$set" => {
-          "field" => "value",
-          "children.0.field" => "value",
-          "children.0.children.1.children.3.field" => "value"
-        },
-        "$pushAll" => {
-          "children.0.children.1.children.3.fields" => [ "value", "value" ]
-        }
-      }
-    end
-
-    context "when a child has an embeds many under an embeds one" do
-
-      context "when selector does not include the embeds one" do
-
-        let(:selector) do
-          { "_id" => 1, "child._id" => 2 }
-        end
-
-        let(:ops) do
-          {
-            "$set" => {
-              "field" => "value",
-              "child.children.1.children.3.field" => "value",
-            }
-          }
-        end
-
-        let(:processed) do
-          positionable.positionally(selector, ops)
-        end
-
-        it "does not do any replacement" do
-          expect(processed).to eq(ops)
-        end
-      end
-
-      context "when selector includes the embeds one" do
-
-        let(:selector) do
-          { "_id" => 1, "child._id" => 2, "child.children._id" => 3 }
-        end
-
-        let(:ops) do
-          {
-            "$set" => {
-              "field" => "value",
-              "child.children.1.children.3.field" => "value",
-            }
-          }
-        end
-
-        let(:expected) do
-          {
-            "$set" => {
-              "field" => "value",
-              "child.children.$.children.3.field" => "value",
-            }
-          }
-        end
-
-
-        let(:processed) do
-          positionable.positionally(selector, ops)
-        end
-
-        it "does not do any replacement" do
-          expect(processed).to eq(expected)
-        end
-      end
-    end
-
-    context "when the selector has only 1 pair" do
-
-      let(:selector) do
-        { "_id" => 1 }
-      end
-
-      let(:processed) do
-        positionable.positionally(selector, updates)
-      end
-
-      it "does not do any replacement" do
-        expect(processed).to eq(updates)
-      end
-    end
-
-    context "when the selector has 2 pairs" do
-
-      context "when the second pair has an id" do
-
-        let(:selector) do
-          { "_id" => 1, "children._id" => 2 }
-        end
-
-        let(:expected) do
-          {
-            "$set" => {
-              "field" => "value",
-              "children.$.field" => "value",
-              "children.$.children.1.children.3.field" => "value"
-            },
-            "$pushAll" => {
-              "children.$.children.1.children.3.fields" => [ "value", "value" ]
-            }
-          }
-        end
-
-        let(:processed) do
-          positionable.positionally(selector, updates)
-        end
-
-        it "replaces the first index with the positional operator" do
-          expect(processed).to eq(expected)
-        end
-      end
-
-      context "when the second pair has no id" do
-
-        let(:selector) do
-          { "_id" => 1, "children._id" => nil }
-        end
-
-        let(:expected) do
-          {
-            "$set" => {
-              "field" => "value",
-              "children.0.field" => "value",
-              "children.0.children.1.children.3.field" => "value"
-            },
-            "$pushAll" => {
-              "children.0.children.1.children.3.fields" => [ "value", "value" ]
-            }
-          }
-        end
-
-        let(:processed) do
-          positionable.positionally(selector, updates)
-        end
-
-        it "replaces the first index with the positional operator" do
-          expect(processed).to eq(expected)
-        end
-      end
-    end
-
-    context "when the selector has 3 pairs" do
-
-      let(:selector) do
-        { "_id" => 1, "children._id" => 2, "children.0.children._id" => 3 }
-      end
-
-      let(:expected) do
-        {
-          "$set" => {
-            "field" => "value",
-            "children.$.field" => "value",
-            "children.0.children.$.children.3.field" => "value"
-          },
-          "$pushAll" => {
-            "children.0.children.$.children.3.fields" => [ "value", "value" ]
-          }
-        }
-      end
-
-      let(:processed) do
-        positionable.positionally(selector, updates)
-      end
-
-      it "replaces the first index with the positional operator" do
-        expect(processed).to eq(expected)
-      end
-    end
-
-    context "when the selector has 4 pairs" do
-
-      let(:selector) do
-        {
-          "_id" => 1,
-          "children._id" => 2,
-          "children.0.children._id" => 3,
-          "children.0.children.1.children._id" => 4
-        }
-      end
-
-      let(:expected) do
-        {
-          "$set" => {
-            "field" => "value",
-            "children.$.field" => "value",
-            "children.0.children.1.children.$.field" => "value"
-          },
-          "$pushAll" => {
-            "children.0.children.1.children.$.fields" => [ "value", "value" ]
-          }
-        }
-      end
-
-      let(:processed) do
-        positionable.positionally(selector, updates)
-      end
-
-      it "replaces the first index with the positional operator" do
-        expect(processed).to eq(expected)
-      end
-    end
-  end
-end