mongo 2.0.5 → 2.0.6

data/spec/mongo/cluster/topology/single_spec.rb

@@ -13,19 +13,19 @@ describe Mongo::Cluster::Topology::Single do
   describe '.servers' do
 
     let(:mongos) do
-      Mongo::Server.new(address, Mongo::Event::Listeners.new, TEST_OPTIONS)
+      Mongo::Server.new(address, double('cluster'), Mongo::Event::Listeners.new, TEST_OPTIONS)
     end
 
     let(:standalone) do
-      Mongo::Server.new(address, Mongo::Event::Listeners.new, TEST_OPTIONS)
+      Mongo::Server.new(address, double('cluster'), Mongo::Event::Listeners.new, TEST_OPTIONS)
     end
 
     let(:standalone_two) do
-      Mongo::Server.new(address, Mongo::Event::Listeners.new, TEST_OPTIONS)
+      Mongo::Server.new(address, double('cluster'), Mongo::Event::Listeners.new, TEST_OPTIONS)
     end
 
     let(:replica_set) do
-      Mongo::Server.new(address, Mongo::Event::Listeners.new, TEST_OPTIONS)
+      Mongo::Server.new(address, double('cluster'), Mongo::Event::Listeners.new, TEST_OPTIONS)
     end
 
     let(:mongos_description) do
@@ -76,4 +76,25 @@ describe Mongo::Cluster::Topology::Single do
       expect(topology).to be_single
     end
   end
+
+  describe '#add_hosts?' do
+
+    it 'returns false' do
+      expect(topology.add_hosts?(double('description'), [])).to eq(false)
+    end
+  end
+
+  describe '#remove_hosts?' do
+
+    it 'returns false' do
+      expect(topology.remove_hosts?(double('description'))).to eq(false)
+    end
+  end
+
+  describe '#remove_server?' do
+
+    it 'returns false' do
+      expect(topology.remove_server?(double('description'), double('server'))).to eq(false)
+    end
+  end
 end

data/spec/mongo/cluster/topology/unknown_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Mongo::Cluster::Topology::Unknown do
+
+  let(:topology) do
+    described_class.new({})
+  end
+
+  describe '.servers' do
+
+    let(:servers) do
+      topology.servers([ double('mongos'), double('standalone') ])
+    end
+
+    it 'returns an empty array' do
+      expect(servers).to eq([ ])
+    end
+  end
+
+  describe '.replica_set?' do
+
+    it 'returns false' do
+      expect(topology).to_not be_replica_set
+    end
+  end
+
+  describe '.sharded?' do
+
+    it 'returns false' do
+      expect(topology).not_to be_sharded
+    end
+  end
+
+  describe '.single?' do
+
+    it 'returns false' do
+      expect(topology).not_to be_single
+    end
+  end
+
+  describe '.unknown?' do
+
+    it 'returns true' do
+      expect(topology.unknown?).to be(true)
+    end
+  end
+
+  describe '#add_hosts?' do
+
+    context 'when the description is from an unknown server' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:unknown?).and_return(true)
+        end
+      end
+
+      it 'returns false' do
+        expect(topology.add_hosts?(description, [])).to be(false)
+      end
+    end
+
+    context 'when the description is from a ghost server' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:unknown?).and_return(false)
+          allow(d).to receive(:ghost?).and_return(true)
+        end
+      end
+
+      it 'returns false' do
+        expect(topology.add_hosts?(description, [])).to be(false)
+      end
+    end
+
+    context 'when the description is not from an unknown or ghost' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:unknown?).and_return(false)
+          allow(d).to receive(:ghost?).and_return(false)
+        end
+      end
+
+      it 'returns true' do
+        expect(topology.add_hosts?(description, [])).to be(true)
+      end
+    end
+  end
+
+  describe '#remove_hosts?' do
+
+    context 'when the description is from a standalone' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:standalone?).and_return(true)
+        end
+      end
+
+      it 'returns true' do
+        expect(topology.remove_hosts?(description)).to be(true)
+      end
+    end
+
+    context 'when the description is not from a standalone' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:standalone?).and_return(false)
+        end
+      end
+
+      it 'returns true' do
+        expect(topology.remove_hosts?(description)).to be(false)
+      end
+    end
+  end
+
+  describe '#remove_server?' do
+
+     context 'when the description is from a standalone' do
+
+       let(:description) do
+         double('description').tap do |d|
+           allow(d).to receive(:standalone?).and_return(true)
+           allow(d).to receive(:is_server?).and_return(true)
+         end
+       end
+
+       context 'when the description is from the server in question' do
+
+         it 'returns true' do
+           expect(topology.remove_server?(description, double('server'))).to be(true)
+         end
+       end
+
+       context 'when the description is not from the server in question' do
+
+         let(:description) do
+           double('description').tap do |d|
+             allow(d).to receive(:standalone?).and_return(true)
+             allow(d).to receive(:is_server?).and_return(false)
+           end
+         end
+
+         it 'returns false' do
+           expect(topology.remove_server?(description, double('server'))).to be(false)
+         end
+       end
+     end
+
+    context 'when the description is not from a standalone' do
+
+      let(:description) do
+        double('description').tap do |d|
+          allow(d).to receive(:standalone?).and_return(false)
+        end
+      end
+
+      it 'returns false' do
+        expect(topology.remove_server?(description, double('server'))).to be(false)
+      end
+    end
+  end
+end

data/spec/mongo/cluster/topology_spec.rb

@@ -60,26 +60,26 @@ describe Mongo::Cluster::Topology do
           described_class.initial([], {})
         end
 
-        it 'returns a single topology' do
-          expect(topology).to be_a(Mongo::Cluster::Topology::Single)
+        it 'returns an unknown topology' do
+          expect(topology).to be_a(Mongo::Cluster::Topology::Unknown)
         end
       end
 
       context 'when provided a single mongos', if: single_mongos? do
 
         let(:topology) do
-          described_class.initial(ADDRESSES, {})
+          described_class.initial(ADDRESSES, TEST_OPTIONS)
         end
 
-        it 'returns a single topology' do
-          expect(topology).to be_a(Mongo::Cluster::Topology::Single)
+        it 'returns a sharded topology' do
+          expect(topology).to be_a(Mongo::Cluster::Topology::Sharded)
         end
       end
 
       context 'when provided a single replica set member', if: single_rs_member? do
 
         let(:topology) do
-          described_class.initial(ADDRESSES, {})
+          described_class.initial(ADDRESSES, TEST_OPTIONS)
         end
 
         it 'returns a single topology' do

data/spec/mongo/cluster_spec.rb

@@ -88,7 +88,7 @@ describe Mongo::Cluster do
     context 'when the option is not provided' do
 
       let(:cluster) do
-        described_class.new([ '127.0.0.1:27017' ], TEST_OPTIONS)
+        described_class.new([ '127.0.0.1:27017' ], TEST_OPTIONS.dup.delete_if { |k| k == :replica_set })
       end
 
       it 'returns nil' do
@@ -209,4 +209,182 @@ describe Mongo::Cluster do
       end
     end
   end
+
+  describe '#remove' do
+
+    let(:address_a) do
+      Mongo::Address.new('127.0.0.1:27017')
+    end
+
+    let(:address_b) do
+      Mongo::Address.new('127.0.0.1:27018')
+    end
+
+    let(:server_a) do
+      Mongo::Server.new(address_a, cluster, Mongo::Event::Listeners.new)
+    end
+
+    let(:server_b) do
+      Mongo::Server.new(address_b, cluster, Mongo::Event::Listeners.new)
+    end
+
+    let(:servers) do
+      [ server_a, server_b ]
+    end
+
+    let(:addresses) do
+      [ address_a, address_b ]
+    end
+
+    before do
+      cluster.instance_variable_set(:@servers, servers)
+      cluster.instance_variable_set(:@addresses, addresses)
+      cluster.remove('127.0.0.1:27017')
+    end
+
+    it 'removes the host from the list of servers' do
+      expect(cluster.instance_variable_get(:@servers)).to eq([server_b])
+    end
+
+    it 'removes the host from the list of addresses' do
+      expect(cluster.instance_variable_get(:@addresses)).to eq([address_b])
+    end
+  end
+
+  describe '#add_hosts' do
+
+    let(:servers) do
+      [nil]
+    end
+
+    let(:hosts) do
+      ["127.0.0.1:27018"]
+    end
+
+    let(:description) do
+      Mongo::Server::Description.new(double('address'), { 'hosts' => hosts })
+    end
+
+    before do
+      cluster.instance_variable_set(:@servers, servers)
+      cluster.instance_variable_set(:@topology, topology)
+    end
+
+    context 'when the topology allows servers to be added' do
+
+      let(:topology) do
+        double('topology').tap do |t|
+          allow(t).to receive(:add_hosts?).and_return(true)
+        end
+      end
+
+      it 'adds the servers' do
+        expect(cluster).to receive(:add).once
+        cluster.add_hosts(description)
+      end
+    end
+
+    context 'when the topology does not allow servers to be added' do
+
+      let(:topology) do
+        double('topology').tap do |t|
+          allow(t).to receive(:add_hosts?).and_return(false)
+        end
+      end
+
+      it 'does not add the servers' do
+        expect(cluster).not_to receive(:add)
+        cluster.add_hosts(description)
+      end
+    end
+  end
+
+  describe '#remove_hosts' do
+
+    let(:listeners) do
+      Mongo::Event::Listeners.new
+    end
+
+    let(:address) do
+      Mongo::Address.new('127.0.0.1:27017')
+    end
+
+    let(:server) do
+      Mongo::Server.new(address, cluster, listeners)
+    end
+
+    let(:servers) do
+      [ server ]
+    end
+
+    let(:hosts) do
+      ["127.0.0.1:27018"]
+    end
+
+    let(:description) do
+      Mongo::Server::Description.new(double('address'), { 'hosts' => hosts })
+    end
+
+    context 'when the topology allows servers to be removed' do
+
+      context 'when the topology allows a specific server to be removed' do
+
+        let(:topology) do
+          double('topology').tap do |t|
+            allow(t).to receive(:remove_hosts?).and_return(true)
+            allow(t).to receive(:remove_server?).and_return(true)
+          end
+        end
+
+        before do
+          cluster.instance_variable_set(:@servers, servers)
+          cluster.instance_variable_set(:@topology, topology)
+        end
+
+        it 'removes the servers' do
+          expect(cluster).to receive(:remove).once
+          cluster.remove_hosts(description)
+        end
+      end
+
+      context 'when the topology does not allow a specific server to be removed' do
+
+        let(:topology) do
+          double('topology').tap do |t|
+            allow(t).to receive(:remove_hosts?).and_return(true)
+            allow(t).to receive(:remove_server?).and_return(false)
+          end
+        end
+
+        before do
+          cluster.instance_variable_set(:@servers, servers)
+          cluster.instance_variable_set(:@topology, topology)
+        end
+
+        it 'removes the servers' do
+          expect(cluster).not_to receive(:remove)
+          cluster.remove_hosts(description)
+        end
+      end
+    end
+
+    context 'when the topology does not allow servers to be removed' do
+
+      let(:topology) do
+        double('topology').tap do |t|
+          allow(t).to receive(:remove_hosts?).and_return(false)
+        end
+      end
+
+      before do
+        cluster.instance_variable_set(:@servers, servers)
+        cluster.instance_variable_set(:@topology, topology)
+      end
+
+      it 'does not remove the servers' do
+        expect(cluster).not_to receive(:remove)
+        cluster.remove_hosts(description)
+      end
+    end
+  end
 end

data/spec/mongo/operation/read_preferrable_spec.rb

@@ -10,14 +10,22 @@ describe Mongo::Operation::ReadPreferrable do
     {}
   end
 
-  let(:mongos) do
-    false
+  let(:cluster_double) do
+    double('cluster')
+  end
+
+  let(:single?) do
+    true
   end
 
-  let(:slave_ok) do
+  let(:mongos?) do
     false
   end
 
+  let(:read_pref) do
+    Mongo::ServerSelector.get
+  end
+
   let(:read_preferrable) do
     Class.new do
       include Mongo::Operation::ReadPreferrable
@@ -30,8 +38,9 @@ describe Mongo::Operation::ReadPreferrable do
 
   let(:context) do
     double('context').tap do |c|
-      allow(c).to receive(:slave_ok?).and_return(slave_ok)
-      allow(c).to receive(:mongos?).and_return(mongos)
+      allow(c).to receive(:cluster).and_return(cluster_double)
+      allow(cluster_double).to receive(:single?).and_return(single?)
+      allow(c).to receive(:mongos?).and_return(mongos?)
     end
   end
 
@@ -60,7 +69,7 @@ describe Mongo::Operation::ReadPreferrable do
         selector.merge(:$readPreference => read_pref.to_mongos)
       end
 
-      it 'returns a special selector' do
+      it 'returns an unaltered special selector' do
         expect(read_preferrable.send(:update_selector, context)).to eq(expected)
       end
     end
@@ -72,14 +81,14 @@ describe Mongo::Operation::ReadPreferrable do
       Mongo::ServerSelector.get(:mode => mode)
     end
 
-    it 'returns a special selector' do
+    it 'returns a selector' do
       expect(read_preferrable.send(:update_selector, context)).to eq(selector)
     end
   end
 
   context 'when the server is a mongos' do
 
-    let(:mongos) do
+    let(:mongos?) do
       true
     end
 
@@ -131,6 +140,10 @@ describe Mongo::Operation::ReadPreferrable do
 
   context 'when the server is not a mongos' do
 
+    let(:mongos?) do
+      false
+    end
+
     let(:mode) do
       :secondary_preferred
     end
@@ -138,31 +151,31 @@ describe Mongo::Operation::ReadPreferrable do
     it_behaves_like 'not a selector updater'
   end
 
-  context 'when the server context requires the slaveOk bit to be set' do
+  context 'when the topology is Single' do
 
-    let(:read_pref) do
-      Mongo::ServerSelector.get(:mode => :secondary)
+    let(:single?) do
+      true
     end
 
-    let(:expected) do
-      { :flags => [ :slave_ok ] }
-    end
+    context 'when the server is a mongos' do
 
-    let(:slave_ok) do
-      true
-    end
+      let(:mongos?) do
+        true
+      end
 
-    it 'sets the slave_ok flag' do
-      expect(read_preferrable.send(:update_options, context)).to eq(expected)
-    end
-  end
+      let(:expected) do
+        { }
+      end
 
-  context 'when the server is not a mongos' do
+      it 'does not set the slave_ok flag' do
+        expect(read_preferrable.send(:update_options, context)).to eq(expected)
+      end
+    end
 
-    context 'when the read preference requires the slaveOk bit to be set' do
+    context 'when the server is not a mongos' do
 
-      let(:read_pref) do
-        Mongo::ServerSelector.get(:mode => :secondary)
+      let(:mongos?) do
+        false
       end
 
       let(:expected) do
@@ -173,20 +186,60 @@ describe Mongo::Operation::ReadPreferrable do
         expect(read_preferrable.send(:update_options, context)).to eq(expected)
       end
     end
+  end
 
-    context 'when the read preference does not require the slaveOk bit to be set' do
+  context 'when the topology is not Single' do
+
+    let(:single?) do
+      false
+    end
+
+    context 'when there is no read preference set' do
 
       let(:read_pref) do
-        Mongo::ServerSelector.get(:mode => :primary)
+        Mongo::ServerSelector.get
       end
 
       let(:expected) do
         { }
       end
 
-      it 'sets the slave_ok flag' do
+      it 'does not set the slave_ok flag' do
         expect(read_preferrable.send(:update_options, context)).to eq(expected)
       end
     end
+
+    context 'when there is a read preference' do
+
+      context 'when the read preference requires the slave_ok flag' do
+
+        let(:read_pref) do
+          Mongo::ServerSelector.get(:mode => :secondary)
+        end
+
+        let(:expected) do
+          { :flags => [ :slave_ok ] }
+        end
+
+        it 'sets the slave_ok flag' do
+          expect(read_preferrable.send(:update_options, context)).to eq(expected)
+        end
+      end
+
+      context 'when the read preference does not require the slave_ok flag' do
+
+        let(:read_pref) do
+          Mongo::ServerSelector.get(:mode => :primary)
+        end
+
+        let(:expected) do
+          { }
+        end
+
+        it 'does not set the slave_ok flag' do
+          expect(read_preferrable.send(:update_options, context)).to eq(expected)
+        end
+      end
+    end
   end
 end