mongo 2.0.6 → 2.1.0.beta

data/spec/support/sdam/rs/null_election_id.yml

@@ -0,0 +1,144 @@
+description: "Primaries with and without electionIds"
+
+uri: "mongodb://a/?replicaSet=rs"
+
+phases: [
+
+    # Primary A has no electionId.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017", "c:27017"],
+                setName: "rs"
+            }]
+        ],
+
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId:
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "c:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    },
+
+    # B is elected, it has an electionId.
+    {
+        responses: [
+            ["b:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017", "c:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000002"}
+            }]
+        ],
+
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000002"}
+                },
+                "c:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    },
+
+    # A still claims to be primary, no electionId, we have to trust it.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017", "c:27017"],
+                setName: "rs"
+            }]
+        ],
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId:
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "c:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    },
+
+    # But we remember A's electionId, so when we finally hear from C
+    # claiming it is primary, we ignore it due to its outdated electionId
+    {
+        responses: [
+            ["c:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017", "c:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }]
+        ],
+        outcome: {
+            servers: {
+                # Still primary.
+                "a:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId:
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "c:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    }
+]

data/spec/support/sdam/rs/primary_disconnect_electionid.yml

@@ -0,0 +1,124 @@
+description: "Disconnected from primary, reject stale primary"
+
+uri: "mongodb://a/?replicaSet=rs"
+
+phases: [
+
+    # A is elected, then B.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }],
+            ["b:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000002"}
+            }]
+        ],
+
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000002"}
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    },
+
+    # Disconnected from B.
+    {
+        responses: [
+            ["b:27017", {}]
+        ],
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetNoPrimary",
+            setName: "rs",
+        }
+    },
+
+    # A still claims to be primary but it's ignored.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }]
+        ],
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetNoPrimary",
+            setName: "rs",
+        }
+    },
+
+    # Now A is re-elected.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000003"}
+            }]
+        ],
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000003"}
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+        }
+    }
+]

data/spec/support/sdam/sharded/mongos_disconnect.yml

@@ -0,0 +1,104 @@
+description: "Mongos disconnect"
+
+uri: "mongodb://a,b"
+
+phases: [
+
+    {
+        responses: [
+
+                ["a:27017", {
+
+                    ok: 1,
+                    ismaster: true,
+                    msg: "isdbgrid"
+                }],
+
+                ["b:27017", {
+
+                    ok: 1,
+                    ismaster: true,
+                    msg: "isdbgrid"
+                }]
+        ],
+
+        outcome: {
+
+            servers: {
+
+                "a:27017": {
+
+                    type: "Mongos",
+                    setName:
+                },
+
+                "b:27017": {
+
+                    type: "Mongos",
+                    setName:
+                }
+            },
+
+            topologyType: "Sharded",
+            setName:
+        }
+    },
+    {
+        responses: [
+                ["a:27017", {}],  # Hangup.
+        ],
+
+        outcome: {
+
+            servers: {
+
+                "a:27017": {
+
+                    type: "Unknown",
+                    setName:
+                },
+
+                "b:27017": {
+
+                    type: "Mongos",
+                    setName:
+                }
+            },
+
+            topologyType: "Sharded",
+            setName:
+        }
+    },
+    {
+        responses: [
+                # Back in action.
+                ["a:27017", {
+
+                    ok: 1,
+                    ismaster: true,
+                    msg: "isdbgrid"
+                }],
+        ],
+
+        outcome: {
+
+            servers: {
+
+                "a:27017": {
+
+                    type: "Mongos",
+                    setName:
+                },
+
+                "b:27017": {
+
+                    type: "Mongos",
+                    setName:
+                }
+            },
+
+            topologyType: "Sharded",
+            setName:
+        }
+    }
+]

data/spec/support/server_discovery_and_monitoring.rb

@@ -45,6 +45,15 @@ module Mongo
       client.cluster.instance_variable_get(:@servers).detect{ |s| s.address.to_s == uri }
     end
 
+    # Helper to convert an extended JSON ObjectId electionId to BSON::ObjectId.
+    #
+    # @since 2.1.0
+    def self.convert_election_ids(docs)
+      docs.each do |doc |
+        doc['electionId'] = BSON::ObjectId.from_string(doc['electionId']['$oid']) if doc['electionId']
+      end
+    end
+
     # Represents a specification.
     #
     # @since 2.0.0
@@ -102,7 +111,7 @@ module Mongo
       # @since 2.0.0
       def initialize(phase, uri)
         @phase = phase
-        @responses = @phase['responses'].map{ |response| Response.new(response, uri) }
+        @responses = @phase['responses'].map{ |response| Response.new(SDAM::convert_election_ids(response), uri) }
         @outcome = Outcome.new(@phase['outcome'])
       end
     end
@@ -158,10 +167,18 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(outcome)
-        @servers = outcome['servers']
+        @servers = process_servers(outcome['servers'])
         @set_name = outcome['setName']
         @topology_type = outcome['topologyType']
       end
+
+      private
+
+      def process_servers(servers)
+        servers.each do |s|
+          SDAM::convert_election_ids([ s[1] ])
+        end
+      end
     end
   end
 end

data/spec/support/shared/bulk_write.rb

@@ -35,7 +35,7 @@ shared_examples 'a bulk write object' do
       end
 
       it 'returns n_inserted of 1' do
-        expect(bulk.execute[:n_inserted]).to eq(1)
+        expect(bulk.execute.inserted_count).to eq(1)
       end
 
       it 'only inserts that document' do
@@ -94,7 +94,7 @@ shared_examples 'a bulk write object' do
     context 'when multiple documents match delete selector' do
 
       it 'reports n_removed correctly' do
-        expect(bulk.execute[:n_removed]).to eq(1)
+        expect(bulk.execute.deleted_count).to eq(1)
       end
 
       it 'deletes only matching documents' do
@@ -136,7 +136,7 @@ shared_examples 'a bulk write object' do
       context 'when multiple documents match delete selector' do
 
         it 'reports n_removed correctly' do
-          expect(bulk.execute[:n_removed]).to eq(2)
+          expect(bulk.execute.deleted_count).to eq(2)
         end
 
         it 'deletes all matching documents' do
@@ -156,7 +156,7 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_removed correctly' do
-          expect(bulk.execute[:n_removed]).to eq(1)
+          expect(bulk.execute.deleted_count).to eq(1)
         end
 
         it 'deletes all matching documents' do
@@ -233,7 +233,7 @@ shared_examples 'a bulk write object' do
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(1)
+        expect(bulk.execute.matched_count).to eq(1)
       end
 
       it 'only applies the replacement to one matching document' do
@@ -260,7 +260,7 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'does not replace any documents' do
@@ -331,19 +331,19 @@ shared_examples 'a bulk write object' do
     context 'when a valid update document is specified' do
 
       it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(1)
+        expect(bulk.execute.modified_count).to eq(1)
       end
 
       it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(nil)
+        expect(bulk.execute.modified_count).to eq(nil)
       end
 
       it 'reports n_upserted correctly' do
-        expect(bulk.execute[:n_upserted]).to eq(0)
+        expect(bulk.execute.upserted_count).to eq(0)
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(1)
+        expect(bulk.execute.matched_count).to eq(1)
       end
 
       it 'applies the correct writes' do
@@ -365,19 +365,23 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(0)
+          expect(bulk.execute.modified_count).to eq(0)
         end
 
         it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(nil)
+          expect(bulk.execute.modified_count).to eq(nil)
         end
 
         it 'reports n_upserted correctly' do
-          expect(bulk.execute[:n_upserted]).to eq(1)
+          expect(bulk.execute.upserted_count).to eq(1)
+        end
+
+        it 'returns the upserted ids', if: write_command_enabled? do
+          expect(bulk.execute.upserted_ids.size).to eq(1)
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'applies the correct writes' do
@@ -444,19 +448,19 @@ shared_examples 'a bulk write object' do
     context 'when a valid update document is specified' do
 
       it 'reports n_modified correctly', if: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(2)
+        expect(bulk.execute.modified_count).to eq(2)
       end
 
       it 'reports n_modified correctly', unless: write_command_enabled?  do
-        expect(bulk.execute[:n_modified]).to eq(nil)
+        expect(bulk.execute.modified_count).to eq(nil)
       end
 
       it 'reports n_upserted correctly' do
-        expect(bulk.execute[:n_upserted]).to eq(0)
+        expect(bulk.execute.upserted_count).to eq(0)
       end
 
       it 'reports n_matched correctly' do
-        expect(bulk.execute[:n_matched]).to eq(2)
+        expect(bulk.execute.matched_count).to eq(2)
       end
 
       it 'applies the correct writes' do
@@ -478,19 +482,19 @@ shared_examples 'a bulk write object' do
         end
 
         it 'reports n_modified correctly', if: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(0)
+          expect(bulk.execute.modified_count).to eq(0)
         end
 
         it 'reports n_modified correctly', unless: write_command_enabled?  do
-          expect(bulk.execute[:n_modified]).to eq(nil)
+          expect(bulk.execute.modified_count).to eq(nil)
         end
 
         it 'reports n_upserted correctly' do
-          expect(bulk.execute[:n_upserted]).to eq(1)
+          expect(bulk.execute.upserted_count).to eq(1)
         end
 
         it 'reports n_matched correctly' do
-          expect(bulk.execute[:n_matched]).to eq(0)
+          expect(bulk.execute.matched_count).to eq(0)
         end
 
         it 'applies the correct writes' do