PYTHON-2116 Add __repr__ to monitoring events and description classes

Author: ShaneHarvey

pymongo/monitoring.py

@@ -561,6 +561,11 @@ def database_name(self):
         """The name of the database this command was run against."""
         return self.__db
 
+    def __repr__(self):
+        return "<%s %s db: %r, command: %r, operation_id: %s>" % (
+            self.__class__.__name__, self.connection_id, self.database_name,
+            self.command_name, self.operation_id)
+
 
 class CommandSucceededEvent(_CommandEvent):
     """Event published when a command succeeds.
@@ -596,6 +601,11 @@ def reply(self):
         """The server failure document for this operation."""
         return self.__reply
 
+    def __repr__(self):
+        return "<%s %s command: %r, operation_id: %s, duration_micros: %s>" % (
+            self.__class__.__name__, self.connection_id,
+            self.command_name, self.operation_id, self.duration_micros)
+
 
 class CommandFailedEvent(_CommandEvent):
     """Event published when a command fails.
@@ -626,6 +636,13 @@ def failure(self):
         """The server failure document for this operation."""
         return self.__failure
 
+    def __repr__(self):
+        return (
+            "<%s %s command: %r, operation_id: %s, duration_micros: %s, "
+            "failure: %r>" % (
+                self.__class__.__name__, self.connection_id, self.command_name,
+                self.operation_id, self.duration_micros, self.failure))
+
 
 class _PoolEvent(object):
     """Base class for pool events."""
@@ -928,6 +945,10 @@ def topology_id(self):
         """A unique identifier for the topology this server is a part of."""
         return self.__topology_id
 
+    def __repr__(self):
+        return "<%s %s topology_id: %s>" % (
+            self.__class__.__name__, self.server_address, self.topology_id)
+
 
 class ServerDescriptionChangedEvent(_ServerEvent):
     """Published when server description changes.
@@ -954,6 +975,11 @@ def new_description(self):
         :class:`~pymongo.server_description.ServerDescription`."""
         return self.__new_description
 
+    def __repr__(self):
+        return "<%s %s changed from: %s, to: %s>" % (
+            self.__class__.__name__, self.server_address,
+            self.previous_description, self.new_description)
+
 
 class ServerOpeningEvent(_ServerEvent):
     """Published when server is initialized.
@@ -986,6 +1012,10 @@ def topology_id(self):
         """A unique identifier for the topology this server is a part of."""
         return self.__topology_id
 
+    def __repr__(self):
+        return "<%s topology_id: %s>" % (
+            self.__class__.__name__, self.topology_id)
+
 
 class TopologyDescriptionChangedEvent(TopologyEvent):
     """Published when the topology description changes.
@@ -1012,6 +1042,11 @@ def new_description(self):
         :class:`~pymongo.topology_description.TopologyDescription`."""
         return self.__new_description
 
+    def __repr__(self):
+        return "<%s topology_id: %s changed from: %s, to: %s>" % (
+            self.__class__.__name__, self.topology_id,
+            self.previous_description, self.new_description)
+
 
 class TopologyOpenedEvent(TopologyEvent):
     """Published when the topology is initialized.
@@ -1045,6 +1080,9 @@ def connection_id(self):
         to."""
         return self.__connection_id
 
+    def __repr__(self):
+        return "<%s %s>" % (self.__class__.__name__, self.connection_id)
+
 
 class ServerHeartbeatStartedEvent(_ServerHeartbeatEvent):
     """Published when a heartbeat is started.
@@ -1078,6 +1116,11 @@ def reply(self):
         """An instance of :class:`~pymongo.ismaster.IsMaster`."""
         return self.__reply
 
+    def __repr__(self):
+        return "<%s %s duration: %s, reply: %s>" % (
+            self.__class__.__name__, self.connection_id,
+            self.duration, self.reply)
+
 
 class ServerHeartbeatFailedEvent(_ServerHeartbeatEvent):
     """Fired when the server heartbeat fails, either with an "ok: 0"
@@ -1103,6 +1146,11 @@ def reply(self):
         """A subclass of :exc:`Exception`."""
         return self.__reply
 
+    def __repr__(self):
+        return "<%s %s duration: %s, reply: %r>" % (
+            self.__class__.__name__, self.connection_id,
+            self.duration, self.reply)
+
 
 class _EventListeners(object):
     """Configure event listeners for a client instance.

pymongo/server.py

@@ -225,8 +225,5 @@ def _split_message(self, message):
             request_id, data = message
             return request_id, data, 0
 
-    def __str__(self):
-        d = self._description
-        return '<Server "%s:%s" %s>' % (
-            d.address[0], d.address[1],
-            SERVER_TYPE._fields[d.server_type])
+    def __repr__(self):
+        return '<%s %r>' % (self.__class__.__name__, self._description)

pymongo/server_description.py

@@ -228,5 +228,13 @@ def __eq__(self, other):
     def __ne__(self, other):
         return not self == other
 
+    def __repr__(self):
+        errmsg = ''
+        if self.error:
+            errmsg = ', error=%r' % (self.error,)
+        return "<%s %s server_type: %s, rtt: %s%s>" % (
+            self.__class__.__name__, self.address, self.server_type_name,
+            self.round_trip_time, errmsg)
+
     # For unittesting only. Use under no circumstances!
     _host_to_round_trip_time = {}

pymongo/topology.py

@@ -686,3 +686,9 @@ def _error_message(self, selector):
             else:
                 return ','.join(str(server.error) for server in servers
                                 if server.error)
+
+    def __repr__(self):
+        msg = ''
+        if not self._opened:
+            msg = 'CLOSED '
+        return '<%s %s%r>' % (self.__class__.__name__, msg, self._description)

pymongo/topology_description.py

@@ -288,6 +288,11 @@ def has_writable_server(self):
         """
         return self.has_readable_server(ReadPreference.PRIMARY)
 
+    def __repr__(self):
+        return "<%s id: %s, topology_type: %s, servers: %r>" % (
+            self.__class__.__name__, self._topology_settings._topology_id,
+            self.topology_type_name, list(self._server_descriptions.values()))
+
 
 # If topology type is Unknown and we receive an ismaster response, what should
 # the new topology type be?

test/test_monitoring.py

@@ -1347,5 +1347,91 @@ def test_simple(self):
         self.assertTrue(isinstance(started.request_id, int))
 
 
+class TestEventClasses(PyMongoTestCase):
+
+    def test_command_event_repr(self):
+        request_id, connection_id, operation_id = 1, ('localhost', 27017), 2
+        event = monitoring.CommandStartedEvent(
+            {'isMaster': 1}, 'admin', request_id, connection_id, operation_id)
+        self.assertEqual(
+            repr(event),
+            "<CommandStartedEvent ('localhost', 27017) db: 'admin', "
+            "command: 'isMaster', operation_id: 2>")
+        delta = datetime.timedelta(milliseconds=100)
+        event = monitoring.CommandSucceededEvent(
+            delta, {'ok': 1}, 'isMaster', request_id, connection_id,
+            operation_id)
+        self.assertEqual(
+            repr(event),
+            "<CommandSucceededEvent ('localhost', 27017) "
+            "command: 'isMaster', operation_id: 2, duration_micros: 100000>")
+        event = monitoring.CommandFailedEvent(
+            delta, {'ok': 0}, 'isMaster', request_id, connection_id,
+            operation_id)
+        self.assertEqual(
+            repr(event),
+            "<CommandFailedEvent ('localhost', 27017) "
+            "command: 'isMaster', operation_id: 2, duration_micros: 100000, "
+            "failure: {'ok': 0}>")
+
+    def test_server_heartbeat_event_repr(self):
+        connection_id = ('localhost', 27017)
+        event = monitoring.ServerHeartbeatStartedEvent(connection_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerHeartbeatStartedEvent ('localhost', 27017)>")
+        delta = 0.1
+        event = monitoring.ServerHeartbeatSucceededEvent(
+            delta, {'ok': 1}, connection_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerHeartbeatSucceededEvent ('localhost', 27017) "
+            "duration: 0.1, reply: {'ok': 1}>")
+        event = monitoring.ServerHeartbeatFailedEvent(
+            delta, 'ERROR', connection_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerHeartbeatFailedEvent ('localhost', 27017) "
+            "duration: 0.1, reply: 'ERROR'>")
+
+    def test_server_event_repr(self):
+        server_address = ('localhost', 27017)
+        topology_id = ObjectId('000000000000000000000001')
+        event = monitoring.ServerOpeningEvent(server_address, topology_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerOpeningEvent ('localhost', 27017) "
+            "topology_id: 000000000000000000000001>")
+        event = monitoring.ServerDescriptionChangedEvent(
+            'PREV', 'NEW', server_address, topology_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerDescriptionChangedEvent ('localhost', 27017) "
+            "changed from: PREV, to: NEW>")
+        event = monitoring.ServerClosedEvent(server_address, topology_id)
+        self.assertEqual(
+            repr(event),
+            "<ServerClosedEvent ('localhost', 27017) "
+            "topology_id: 000000000000000000000001>")
+
+    def test_topology_event_repr(self):
+        topology_id = ObjectId('000000000000000000000001')
+        event = monitoring.TopologyOpenedEvent(topology_id)
+        self.assertEqual(
+            repr(event),
+            "<TopologyOpenedEvent topology_id: 000000000000000000000001>")
+        event = monitoring.TopologyDescriptionChangedEvent(
+            'PREV', 'NEW', topology_id)
+        self.assertEqual(
+            repr(event),
+            "<TopologyDescriptionChangedEvent "
+            "topology_id: 000000000000000000000001 "
+            "changed from: PREV, to: NEW>")
+        event = monitoring.TopologyClosedEvent(topology_id)
+        self.assertEqual(
+            repr(event),
+            "<TopologyClosedEvent topology_id: 000000000000000000000001>")
+
+
 if __name__ == "__main__":
     unittest.main()

test/test_server_description.py

@@ -160,6 +160,12 @@ def test_all_hosts(self):
             [('a', 27017), ('b', 27018), ('c', 27017)],
             sorted(s.all_hosts))
 
+    def test_repr(self):
+        s = parse_ismaster_response({'ok': 1, 'msg': 'isdbgrid'})
+        self.assertEqual(repr(s),
+                         "<ServerDescription ('localhost', 27017)"
+                         " server_type: Mongos, rtt: None>")
+
 
 if __name__ == "__main__":
     unittest.main()

test/test_topology.py

@@ -114,12 +114,6 @@ def setUp(self):
         self.addCleanup(self.client_knobs.disable)
 
 
-# Use assertRaisesRegex if available, otherwise use Python 2.7's
-# deprecated assertRaisesRegexp, with a 'p'.
-if not hasattr(unittest.TestCase, 'assertRaisesRegex'):
-    TopologyTest.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 class TestTopologyConfiguration(TopologyTest):
     def test_timeout_configuration(self):
         pool_options = PoolOptions(connect_timeout=1, socket_timeout=2)
@@ -623,6 +617,22 @@ def write_batch_size():
 
         self.assertEqual(2, write_batch_size())
 
+    def test_topology_repr(self):
+        t = create_mock_topology(replica_set_name='rs')
+        self.addCleanup(t.close)
+        got_ismaster(t, ('a', 27017), {
+            'ok': 1,
+            'ismaster': True,
+            'setName': 'rs',
+            'hosts': ['a', 'b']})
+        self.assertEqual(
+            repr(t.description),
+            "<TopologyDescription id: %s, "
+            "topology_type: ReplicaSetWithPrimary, servers: ["
+            "<ServerDescription ('a', 27017) server_type: RSPrimary, rtt: 0>, "
+            "<ServerDescription ('b', 27017) server_type: Unknown,"
+            " rtt: None>]>" % (t._topology_id,))
+
 
 def wait_for_master(topology):
     """Wait for a Topology to discover a writable server.