mongo 1.12.5 → 2.0.0

data/spec/mongo/server_selector/secondary_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe Mongo::ServerSelector::Secondary do
+
+  include_context 'server selector'
+
+  it_behaves_like 'a read preference mode' do
+    let(:name) { :secondary }
+    let(:slave_ok) { true }
+  end
+
+  it_behaves_like 'a read preference mode accepting tag sets'
+
+  describe '#to_mongos' do
+
+    it 'returns read preference formatted for mongos' do
+      expect(read_pref.to_mongos).to eq(
+        { :mode => 'secondary' }
+      )
+    end
+
+    context 'tag sets provided' do
+      let(:tag_sets) { [tag_set] }
+
+      it 'returns read preference formatted for mongos with tag sets' do
+        expect(read_pref.to_mongos).to eq(
+          { :mode => 'secondary', :tags => tag_sets}
+        )
+      end
+    end
+  end
+
+  describe '#select' do
+
+    context 'no candidates' do
+      let(:candidates) { [] }
+
+      it 'returns an empty array' do
+        expect(read_pref.send(:select, candidates)).to be_empty
+      end
+    end
+
+    context 'single primary candidate' do
+      let(:candidates) { [primary] }
+
+      it 'returns an empty array' do
+        expect(read_pref.send(:select, candidates)).to be_empty
+      end
+    end
+
+    context 'single secondary candidate' do
+      let(:candidates) { [secondary] }
+
+      it 'returns array with secondary' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary])
+      end
+    end
+
+    context 'primary and secondary candidates' do
+      let(:candidates) { [primary, secondary] }
+
+      it 'returns array with secondary' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary])
+      end
+    end
+
+    context 'multiple secondary candidates' do
+      let(:candidates) { [secondary, secondary, primary] }
+
+      it 'returns array with all secondaries' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary, secondary])
+      end
+    end
+
+    context 'tag sets provided' do
+      let(:tag_sets) { [tag_set] }
+      let(:matching_secondary) { server(:secondary, :tags => server_tags) }
+
+      context 'single candidate' do
+
+        context 'primary' do
+          let(:candidates) { [primary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'secondary' do
+          let(:candidates) { [secondary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'matching secondary' do
+          let(:candidates) { [matching_secondary] }
+
+          it 'returns an array with matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+      end
+
+      context 'multiple candidates' do
+
+        context 'no matching candidates' do
+          let(:candidates) { [primary, secondary, secondary] }
+
+          it 'returns an emtpy array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'one matching secondary' do
+          let(:candidates) { [secondary, matching_secondary]}
+
+          it 'returns array with matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+
+        context 'two matching secondaries' do
+          let(:candidates) { [matching_secondary, matching_secondary] }
+
+          it 'returns an array with both matching secondaries' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary, matching_secondary])
+          end
+        end
+      end
+    end
+
+    context 'high latency servers' do
+      let(:far_primary) { server(:primary, :average_round_trip_time => 100) }
+      let(:far_secondary) { server(:secondary, :average_round_trip_time => 113) }
+
+      context 'single candidate' do
+
+        context 'far primary' do
+          let(:candidates) { [far_primary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'far secondary' do
+          let(:candidates) { [far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+      end
+
+      context 'multiple candidates' do
+
+        context 'local primary, far secondary' do
+          let(:candidates) { [primary, far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+
+        context 'far primary, far secondary' do
+          let(:candidates) { [far_primary, far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+
+        context 'two near servers, one far server' do
+
+          context 'near primary, near and far secondaries' do
+            let(:candidates) { [primary, secondary, far_secondary] }
+
+            it 'returns an array with near secondary' do
+              expect(read_pref.send(:select, candidates)).to eq([secondary])
+            end
+          end
+
+          context 'far primary and two near secondaries' do
+            let(:candidates) { [far_primary, secondary, secondary] }
+
+            it 'returns an array with two secondaries' do
+              expect(read_pref.send(:select, candidates)).to eq([secondary, secondary])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/server_selector_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Mongo::ServerSelector do
+
+  include_context 'server selector'
+
+  describe '.get' do
+
+    let(:read_pref) do
+      described_class.get({ :mode => name })
+    end
+
+    let(:name) { :secondary }
+    let(:tag_sets) { [{ 'test' => 'tag' }] }
+
+    context 'when the mode is primary' do
+      let(:name) { :primary }
+
+      it 'returns a read preference of class Primary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+      end
+    end
+
+    context 'when the mode is primary_preferred' do
+      let(:name) { :primary_preferred }
+
+      it 'returns a read preference of class PrimaryPreferred' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+      end
+    end
+
+    context 'when the mode is secondary' do
+      let(:name) { :secondary }
+
+      it 'returns a read preference of class Secondary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Secondary)
+      end
+    end
+
+    context 'when the mode is secondary_preferred' do
+      let(:name) { :secondary_preferred }
+
+      it 'returns a read preference of class SecondaryPreferred' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+      end
+    end
+
+    context 'when the mode is nearest' do
+      let(:name) { :nearest }
+
+      it 'returns a read preference of class Nearest' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Nearest)
+      end
+    end
+
+    context 'when a mode is not provided' do
+      let(:read_pref) { described_class.get }
+
+      it 'returns a read preference of class Primary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+      end
+    end
+
+    context 'when tag sets provided' do
+      let(:read_pref) { described_class.get(:mode => name, :tag_sets => tag_sets) }
+
+      it 'sets tag sets on the read preference object' do
+        expect(read_pref.tag_sets).to eq(tag_sets)
+      end
+    end
+  end
+
+  describe "#select_server" do
+
+    context 'when #select returns a list of nils' do
+
+      let(:servers) { [ server(:primary) ] }
+
+      let(:cluster) do
+        double('cluster').tap do |c|
+          allow(c).to receive(:servers).and_return(servers)
+          allow(c).to receive(:standalone?).and_return(false)
+          allow(c).to receive(:sharded?).and_return(false)
+          allow(c).to receive(:scan!).and_return(true)
+        end
+      end
+
+      let(:read_pref) do
+        described_class.get({ mode: :primary }, server_selection_timeout: 1).tap do |pref|
+          allow(pref).to receive(:select).and_return([ nil, nil ])
+        end
+      end
+
+      it 'raises a NoServerAvailable error' do
+        expect do
+          read_pref.select_server(cluster)
+        end.to raise_exception(Mongo::ServerSelector::NoServerAvailable)
+      end
+    end
+  end
+end

data/spec/mongo/server_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Mongo::Server do
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
+
+  describe '#==' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    context 'when the other is not a server' do
+
+      let(:other) do
+        false
+      end
+
+      it 'returns false' do
+        expect(server).to_not eq(other)
+      end
+    end
+
+    context 'when the other is a server' do
+
+      context 'when the addresses match' do
+
+        let(:other) do
+          described_class.new(address, listeners)
+        end
+
+        it 'returns true' do
+          expect(server).to eq(other)
+        end
+      end
+
+      context 'when the addresses dont match' do
+
+        let(:other_address) do
+          Mongo::Address.new('127.0.0.1:27018')
+        end
+
+        let(:other) do
+          described_class.new(other_address, listeners)
+        end
+
+        it 'returns false' do
+          expect(server).to_not eq(other)
+        end
+      end
+    end
+  end
+
+  describe '#context' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    let(:context) do
+      server.context
+    end
+
+    it 'returns a new server context' do
+      expect(context.server).to eq(server)
+    end
+  end
+
+  describe '#disconnect!' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    it 'stops the monitor instance' do
+      expect(server.instance_variable_get(:@monitor)).to receive(:stop!).and_return(true)
+      server.disconnect!
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:server) do
+      described_class.new(address, listeners, :heartbeat_frequency => 5)
+    end
+
+    it 'sets the address host' do
+      expect(server.address.host).to eq('127.0.0.1')
+    end
+
+    it 'sets the address port' do
+      expect(server.address.port).to eq(27017)
+    end
+
+    it 'sets the options' do
+      expect(server.options).to eq(:heartbeat_frequency => 5)
+    end
+  end
+
+  describe '#pool' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    let(:pool) do
+      server.pool
+    end
+
+    it 'returns the connection pool for the server' do
+      expect(pool).to be_a(Mongo::Server::ConnectionPool)
+    end
+  end
+
+  describe '#scan!' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    it 'forces a scan on the monitor' do
+      expect(server.scan!).to eq(server.description)
+    end
+  end
+end