mongo 2.15.1 → 2.16.0.alpha1

data/spec/mongo/cursor/builder/op_kill_cursors_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mongo::Cursor::Builder::OpKillCursors do
-
-  let(:reply) do
-    Mongo::Protocol::Reply.allocate.tap do |reply|
-      allow(reply).to receive(:cursor_id).and_return(8000)
-    end
-  end
-
-  let(:description) do
-    Mongo::Server::Description.new(
-      double('description address'),
-      { 'minWireVersion' => 0, 'maxWireVersion' => 2 }
-    )
-  end
-
-  let(:result) do
-    Mongo::Operation::Result.new(reply, description)
-  end
-
-  let(:view) do
-    Mongo::Collection::View.new(
-      authorized_collection,
-      {},
-      tailable: true,
-      max_time_ms: 100
-    )
-  end
-
-  let(:cursor) do
-    Mongo::Cursor.new(view, result, authorized_primary)
-  end
-
-  let(:builder) do
-    described_class.new(cursor)
-  end
-
-  describe '#specification' do
-
-    let(:specification) do
-      builder.specification
-    end
-
-    it 'includes the cursor ids' do
-      expect(specification[:cursor_ids]).to eq([BSON::Int64.new(8000)])
-    end
-
-    it 'includes the database name' do
-      expect(specification[:db_name]).to eq(SpecConfig.instance.test_db)
-    end
-
-    it 'includes the collection name' do
-      expect(specification[:coll_name]).to eq(TEST_COLL)
-    end
-  end
-
-  describe '.get_cursors_list' do
-    it 'returns integer cursor ids' do
-      expect(described_class.get_cursors_list(builder.specification)).to eq([8000])
-    end
-  end
-end

data/spec/runners/unified/using_hash.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Unified
-
-  class UsingHash < Hash
-    def use(key)
-      wrap(self[key]).tap do
-        delete(key)
-      end
-    end
-
-    def use!(key)
-      wrap(fetch(key)).tap do
-        delete(key)
-      end
-    end
-
-    private
-
-    def wrap(v)
-      case v
-      when Hash
-        self.class[v]
-      when Array
-        v.map do |subv|
-          wrap(subv)
-        end
-      else
-        v
-      end
-    end
-  end
-end

data/spec/spec_tests/dns_seedlist_discovery_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'lite_spec_helper'
-
-require 'runners/connection_string'
-
-describe 'DNS Seedlist Discovery' do
-  require_external_connectivity
-
-  include Mongo::ConnectionString
-
-  DNS_SEEDLIST_DISCOVERY_TESTS.each do |test_path|
-
-    spec = YAML.load(File.read(test_path))
-
-    test = Mongo::ConnectionString::Test.new(spec)
-
-    context(File.basename(test_path)) do
-
-      context 'when the uri is invalid', if: test.raise_error? do
-
-        let(:valid_errors) do
-          [
-            Mongo::Error::InvalidTXTRecord,
-            Mongo::Error::NoSRVRecords,
-            Mongo::Error::InvalidURI,
-            Mongo::Error::MismatchedDomain,
-          ]
-        end
-
-        let(:error) do
-          e = nil
-          begin; test.uri; rescue => ex; e = ex; end
-          e
-        end
-
-        it 'raises an error' do
-          expect(valid_errors).to include(error.class)
-        end
-      end
-
-      context 'when the uri is valid', unless: test.raise_error? do
-
-        it 'does not raise an exception' do
-          expect(test.uri).to be_a(Mongo::URI::SRVProtocol)
-        end
-
-        if test.seeds
-          # DNS seed list tests specify both seeds and hosts.
-          # To get the hosts, the client must do SDAM (as required in the
-          # spec tests' description), but this isn't testing DNS seed list -
-          # it is testing SDAM. Plus, all of the hosts are always the same.
-          # If seed list is given in the expectations, just test the seed
-          # list and not the expanded hosts.
-          it 'creates a client with the correct seeds' do
-            expect(test.client).to have_hosts(test, test.seeds)
-          end
-        else
-          it 'creates a client with the correct hosts' do
-            expect(test.client).to have_hosts(test, test.hosts)
-          end
-        end
-
-        it 'creates a client with the correct options' do
-          mapped = Mongo::URI::OptionsMapper.new.ruby_to_smc(test.client.options)
-          # Connection string spec tests do not use canonical URI option names
-          actual = Utils.downcase_keys(mapped)
-          expected = Utils.downcase_keys(test.options)
-          # SRV tests use ssl URI option instead of tls one
-          if expected.key?('ssl') && !expected.key?('tls')
-            expected['tls'] = expected.delete('ssl')
-          end
-          actual.should == expected
-        end
-      end
-    end
-  end
-end

data/spec/support/event_subscriber.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# Test event subscriber.
-#
-# @since 2.5.0
-class EventSubscriber
-
-  # The mappings of event names to types.
-  #
-  # @since 2.4.0
-  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
-
-  # All events.
-  attr_reader :all_events
-
-  # The started events.
-  #
-  # @since 2.5.0
-  attr_reader :started_events
-
-  # The succeeded events.
-  #
-  # @since 2.5.0
-  attr_reader :succeeded_events
-
-  # The failed events.
-  #
-  # @since 2.5.0
-  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.
-  #
-  # @since 2.5.0
-  def started(event)
-    @mutex.synchronize do
-      started_events << event
-      all_events << event
-    end
-  end
-
-  # Cache the succeeded event.
-  #
-  # @param [ Event ] event The event.
-  #
-  # @since 2.5.0
-  def succeeded(event)
-    @mutex.synchronize do
-      succeeded_events << event
-      all_events << event
-    end
-  end
-
-  # Cache the failed event.
-  #
-  # @param [ Event ] event The event.
-  #
-  # @since 2.5.0
-  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.
-  #
-  # @since 2.5.1
-  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