mongoid 7.2.6 → 7.3.0

data/lib/mongoid/errors/empty_config_file.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Errors
-
-    # This error is raised when an empty configuration file is attempted to be
-    # loaded.
-    class EmptyConfigFile < MongoidError
-
-      # Create the new error.
-      #
-      # @param [ String ] path The path of the config file used.
-      #
-      # @api private
-      def initialize(path)
-        super(
-          compose_message(
-            "empty_config_file",
-            { path: path }
-          )
-        )
-      end
-    end
-  end
-end

data/lib/mongoid/errors/invalid_config_file.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Errors
-
-    # This error is raised when a bad configuration file is attempted to be
-    # loaded.
-    class InvalidConfigFile < MongoidError
-
-      # Create the new error.
-      #
-      # @param [ String ] path The path of the config file used.
-      #
-      # @api private
-      def initialize(path)
-        super(
-          compose_message(
-            "invalid_config_file",
-            { path: path }
-          )
-        )
-      end
-    end
-  end
-end

data/spec/integration/contextual/empty_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Contextual classes when dealing with empty result set' do
-  shared_examples 'behave as expected' do
-    context '#exists?' do
-      it 'is false' do
-        context.exists?.should be false
-      end
-    end
-
-    context '#count' do
-      it 'is 0' do
-        context.count.should == 0
-      end
-    end
-
-    context '#length' do
-      it 'is 0' do
-        context.length.should == 0
-      end
-    end
-
-    # #estimated_count only exists for Mongo
-
-    context '#distinct' do
-      it 'is empty array' do
-        context.distinct(:foo).should == []
-      end
-    end
-
-    context '#each' do
-      context 'with block' do
-        it 'does not invoke the block' do
-          called = false
-          context.each do
-            called = true
-          end
-          called.should be false
-        end
-      end
-
-      context 'without block' do
-        it 'returns Enumerable' do
-          context.each.should be_a(Enumerable)
-        end
-
-        it 'returns empty Enumerable' do
-          context.each.to_a.should == []
-        end
-      end
-    end
-
-    context '#map' do
-      context 'with block' do
-        it 'does not invoke the block' do
-          called = false
-          context.map do
-            called = true
-          end
-          called.should be false
-        end
-      end
-
-      context 'without block' do
-        it 'returns empty array' do
-          skip 'MONGOID-5148'
-
-          context.map(:field).should == []
-        end
-      end
-    end
-
-    context '#first' do
-      it 'is nil' do
-        context.first.should be nil
-      end
-    end
-
-    context '#find_first' do
-      it 'is nil' do
-        context.find_first.should be nil
-      end
-    end
-
-    context '#one' do
-      it 'is nil' do
-        context.one.should be nil
-      end
-    end
-
-    context '#last' do
-      it 'is nil' do
-        context.last.should be nil
-      end
-    end
-  end
-
-  let(:context) do
-    context_cls.new(criteria)
-  end
-
-  before do
-    # Create an object of the same class used in the Criteria instance
-    # to verify we are using the Contextual classes.
-    Mop.create!
-  end
-
-  context 'Mongo' do
-    let(:context_cls) { Mongoid::Contextual::Mongo }
-
-    let(:criteria) do
-      Mop.and(Mop.where(a: 1), Mop.where(a: 2))
-    end
-
-    include_examples 'behave as expected'
-  end
-
-  context 'Memory' do
-    let(:context_cls) { Mongoid::Contextual::Memory }
-
-    let(:criteria) do
-      Mop.all.tap do |criteria|
-        criteria.documents = []
-      end
-    end
-
-    include_examples 'behave as expected'
-  end
-
-  context 'None' do
-    let(:context_cls) { Mongoid::Contextual::None }
-
-    let(:criteria) do
-      Mop.none
-    end
-
-    include_examples 'behave as expected'
-  end
-end

data/spec/mongoid/errors/invalid_config_file_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Errors::InvalidConfigFile do
-
-  describe "#message" do
-
-    let(:error) do
-      described_class.new('/my/path')
-    end
-
-    it "contains the problem in the message" do
-      expect(error.message).to include(
-        "Invalid configuration file: /my/path."
-      )
-    end
-
-    it "contains the summary in the message" do
-      expect(error.message).to include(
-        "Your mongoid.yml configuration file does not contain the"
-      )
-    end
-
-    it "contains the resolution in the message" do
-      expect(error.message).to include(
-        "Ensure your configuration file contains the correct contents."
-      )
-    end
-  end
-end

data/spec/shared/bin/s3-copy

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'aws-sdk-s3'
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: s3-copy options"
-
-  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
-    options[:region] = v
-  end
-
-  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for new files") do |v|
-    options[:params] ||= {}
-    k, v = v.split('=', 2)
-    options[:params][k.to_sym] = v
-  end
-
-  opts.on("-f", "--from=BUCKET:PATH", "Bucket name and key (or path) to copy from") do |v|
-    options[:from] = v
-  end
-
-  opts.on("-t", "--to=BUCKET:PATH", "Bucket name and key (or path) to write to (may be specified more than once)") do |v|
-    options[:to] ||= []
-    options[:to] << v
-  end
-end.parse!
-
-ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
-
-bucket, key = options.fetch(:from).split(':', 2)
-
-s3 = Aws::S3::Client.new
-
-options.fetch(:to).each do |dest|
-  STDERR.puts "Copying to #{dest}"
-  dbucket, dkey = dest.split(':', 2)
-  s3.copy_object(
-    bucket: dbucket,
-    key: dkey,
-    copy_source: "/#{bucket}/#{key}",
-    **options[:params] || {},
-  )
-end

data/spec/shared/bin/s3-upload

@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'aws-sdk-s3'
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: s3-upload options"
-
-  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
-    options[:region] = v
-  end
-
-  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for S3 upload") do |v|
-    options[:params] ||= {}
-    k, v = v.split('=', 2)
-    options[:params][k.to_sym] = v
-  end
-
-  opts.on("-f", "--file=PATH", "Path to the file to upload, - to upload standard input") do |v|
-    options[:file] = v
-  end
-
-  opts.on("-w", "--write=BUCKET:PATH", "Bucket name and key (or path) to upload to") do |v|
-    options[:write] = v
-  end
-
-  opts.on("-c", "--copy=BUCKET:PATH", "Bucket name and key (or path) to copy to (may be specified more than once)") do |v|
-    options[:copy] ||= []
-    options[:copy] << v
-  end
-end.parse!
-
-ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
-
-def upload(f, options)
-  s3 = Aws::S3::Client.new
-  write = options.fetch(:write)
-  STDERR.puts "Writing #{write}"
-  bucket, key = write.split(':', 2)
-  s3.put_object(
-    body: f.read,
-    bucket: bucket,
-    key: key,
-    **options[:params] || {},
-  )
-  if copy = options[:copy]
-    copy.each do |dest|
-      STDERR.puts "Copying to #{dest}"
-      dbucket, dkey = dest.split(':', 2)
-      s3.copy_object(
-        bucket: dbucket,
-        key: dkey,
-        copy_source: "/#{bucket}/#{key}",
-        **options[:params] || {},
-      )
-    end
-  end
-end
-
-if options[:file] == '-'
-  upload(STDIN, options)
-elsif options[:file]
-  File.open(options[:file]) do |f|
-    upload(f, options)
-  end
-else
-  upload(STDIN, options)
-end

data/spec/shared/lib/mrss/event_subscriber.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module Mrss
-  # Test event subscriber.
-  class EventSubscriber
-
-    # The mappings of event names to types.
-    MAPPINGS = {
-      'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening,
-      'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
-      'topology_closed_event' => Mongo::Monitoring::Event::TopologyClosed,
-      'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
-      'server_description_changed_event' => Mongo::Monitoring::Event::ServerDescriptionChanged,
-      'server_closed_event' => Mongo::Monitoring::Event::ServerClosed
-    }.freeze
-
-    attr_reader :all_events
-
-    attr_reader :started_events
-
-    attr_reader :succeeded_events
-
-    attr_reader :failed_events
-
-    attr_reader :published_events
-
-    # @param [ String ] name Optional name for the event subscriber.
-    def initialize(name: nil)
-      @mutex = Mutex.new
-      clear_events!
-      @name = name
-    end
-
-    def to_s
-      %Q`#<EventSubscriber:#{@name ? "\"#{@name}\"" : '%x' % object_id} \
-  started=#{started_events.length} \
-  succeeded=#{succeeded_events.length} \
-  failed=#{failed_events.length} \
-  published=#{published_events.length}>`
-    end
-
-    alias :inspect :to_s
-
-    # Event retrieval
-
-    def select_started_events(cls)
-      started_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    def select_succeeded_events(cls)
-      succeeded_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    def select_completed_events(*classes)
-      (succeeded_events + failed_events).select do |event|
-        classes.any? { |c| c === event }
-      end
-    end
-
-    def select_published_events(cls)
-      published_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    # Filters command started events for the specified command name.
-    def command_started_events(command_name)
-      started_events.select do |event|
-        event.command[command_name]
-      end
-    end
-
-    def non_auth_command_started_events
-      started_events.reject do |event|
-        %w(authenticate getnonce saslSstart saslContinue).any? do |cmd|
-          event.command[cmd]
-        end
-      end
-    end
-
-    # Locates command stated events for the specified command name,
-    # asserts that there is exactly one such event, and returns it.
-    def single_command_started_event(command_name, include_auth: false)
-      events = if include_auth
-                 started_events
-               else
-                 non_auth_command_started_events
-               end
-      events.select! do |event|
-        event.command[command_name]
-      end
-      if events.length != 1
-        raise "Expected a single #{command_name} event but we have #{events.length}"
-      end
-      events.first
-    end
-
-
-    # Get the first succeeded event published for the name, and then delete it.
-    #
-    # @param [ String ] name The event name.
-    #
-    # @return [ Event ] The matching event.
-    def first_event(name)
-      cls = MAPPINGS[name]
-      if cls.nil?
-        raise ArgumentError, "Bogus event name #{name}"
-      end
-      matching = succeeded_events.find do |event|
-        cls === event
-      end
-      succeeded_events.delete(matching)
-      matching
-    end
-
-    # Event recording
-
-    # Cache the started event.
-    #
-    # @param [ Event ] event The event.
-    def started(event)
-      @mutex.synchronize do
-        started_events << event
-        all_events << event
-      end
-    end
-
-    # Cache the succeeded event.
-    #
-    # @param [ Event ] event The event.
-    def succeeded(event)
-      @mutex.synchronize do
-        succeeded_events << event
-        all_events << event
-      end
-    end
-
-    # Cache the failed event.
-    #
-    # @param [ Event ] event The event.
-    def failed(event)
-      @mutex.synchronize do
-        failed_events << event
-        all_events << event
-      end
-    end
-
-    def published(event)
-      @mutex.synchronize do
-        published_events << event
-        all_events << event
-      end
-    end
-
-    # Clear all cached events.
-    def clear_events!
-      @all_events = []
-      @started_events = []
-      @succeeded_events = []
-      @failed_events = []
-      @published_events = []
-      self
-    end
-  end
-  # Only handles succeeded events correctly.
-  class PhasedEventSubscriber < EventSubscriber
-    def initialize
-      super
-      @phase_events = {}
-    end
-
-    def phase_finished(phase_index)
-      @phase_events[phase_index] = succeeded_events
-      @succeeded_events = []
-    end
-
-    def phase_events(phase_index)
-      @phase_events[phase_index]
-    end
-
-    def event_count
-      @phase_events.inject(0) do |sum, event|
-        sum + event.length
-      end
-    end
-  end
-
-  class VerboseEventSubscriber < EventSubscriber
-    %w(started succeeded failed published).each do |meth|
-      define_method(meth) do |event|
-        puts event.summary
-        super(event)
-      end
-    end
-  end
-end

data/spec/shared/share/haproxy-1.conf

@@ -1,16 +0,0 @@
-# Modeled after
-# https://github.com/mongodb-labs/drivers-evergreen-tools/blob/master/.evergreen/run-load-balancer.sh
-
-defaults
-  mode tcp
-  timeout connect 7s
-  timeout client 55s
-  timeout server 55s
-
-frontend mongos_frontend
-  bind *:27017
-  use_backend mongos_backend
-
-backend mongos_backend
-  mode tcp
-  server mongos_one 127.0.0.1:27117 check

data/spec/shared/share/haproxy-2.conf

@@ -1,17 +0,0 @@
-# Modeled after
-# https://github.com/mongodb-labs/drivers-evergreen-tools/blob/master/.evergreen/run-load-balancer.sh
-
-defaults
-  mode tcp
-  timeout connect 7s
-  timeout client 55s
-  timeout server 55s
-
-frontend mongos_frontend
-  bind *:27017
-  use_backend mongos_backend
-
-backend mongos_backend
-  mode tcp
-  server mongos_one 127.0.0.1:27117 check
-  server mongos_two 127.0.0.1:27118 check