Merge lp:~verterok/txstatsd/use-mock-instead-of-mocker into lp:txstatsd

[Guillermo Gonzalez]

Use mock instead of mocker in the tests

Use mock (python-mock) instead of mocker (python-mocker) as there is no py3k package for the later.

[Sidnei da Silva (sidnei)]

review: Approve

=== modified file 'requirements.txt'
--- requirements.txt	2012-05-08 16:23:00 +0000
+++ requirements.txt	2013-03-07 15:53:38 +0000
@@ -1,7 +1,7 @@
 Twisted==11.1.0
 carbon==0.9.9
 whisper==0.9.9
-mocker==1.1
+mock==1.0
 psutil==0.4.1
 wsgiref==0.1.2
 zope.interface==3.8.0
 
=== modified file 'txstatsd/tests/test_client.py'
--- txstatsd/tests/test_client.py	2012-12-27 20:49:06 +0000
+++ txstatsd/tests/test_client.py	2013-03-07 15:53:38 +0000
@@ -22,7 +22,7 @@
 
 import sys
 
-from mocker import Mocker, expect, ANY
+from mock import Mock, call
 from twisted.internet import reactor
 from twisted.internet.defer import inlineCallbacks, Deferred
 from twisted.python import log
@@ -67,7 +67,6 @@
         super(TestClient, self).setUp()
         self.client = None
         self.exception = None
-        self.mocker = Mocker()
 
     def tearDown(self):
         if self.client:
@@ -250,11 +249,11 @@
         self.client = TwistedStatsDClient('localhost', 8000)
         self.build_protocol()
 
-        self.client.connect_callback = self.mocker.mock()
-        expect(self.client.connect_callback())
+        self.client.connect_callback = Mock()
 
-        with self.mocker:
-            self.client.host_resolved('127.0.0.1')
+        self.client.host_resolved('127.0.0.1')
+        self.assertTrue(self.client.connect_callback.called)
+        self.client.connect_callback.assert_called_once_with()
 
     def test_sends_messages_to_gateway_after_host_resolves(self):
         """After the host is resolved, send messages to the
@@ -265,14 +264,12 @@
 
         message = 'some data'
         bytes_sent = len(message)
-        self.client.data_queue = self.mocker.mock(spec=DataQueue)  # not called
-        self.client.transport_gateway = self.mocker.mock(spec=TransportGateway)
-        callback = self.mocker.mock()
-        expect(self.client.transport_gateway.write(message, callback)).result(
-            bytes_sent)
-
-        with self.mocker:
-            self.assertEqual(self.client.write(message, callback), bytes_sent)
+        self.client.data_queue =  Mock(spec=DataQueue)
+        self.client.transport_gateway = Mock(spec=TransportGateway)
+        callback = Mock()
+        self.client.transport_gateway.write.return_value = bytes_sent
+        self.assertEqual(self.client.write(message, callback), bytes_sent)
+        self.client.transport_gateway.write.assert_called_once_with(message, callback)
 
     def test_sends_messages_to_queue_before_host_resolves(self):
         """Before the host is resolved, send messages to the DataQueue."""
@@ -280,13 +277,12 @@
         self.build_protocol()
 
         message = 'some data'
-        bytes_sent = len(message)
-        self.client.data_queue = self.mocker.mock(spec=DataQueue)
-        callback = self.mocker.mock()
-        expect(self.client.data_queue.write(message, callback)).result(None)
-
-        with self.mocker:
-            self.assertEqual(self.client.write(message, callback), None)
+        self.client.data_queue =  Mock(spec=DataQueue)
+        callback = Mock()
+        self.client.data_queue.write.return_value = None
+        result = self.client.write(message, callback)
+        self.client.data_queue.write.assert_called_once_with(message, callback)
+        self.assertEqual(result, None)
 
     def test_flushes_queued_messages_to_the_gateway_when_host_resolves(self):
         """As soon as the host is resolved, flush all messages to the
@@ -298,14 +294,14 @@
         self.client.data_queue.write('data 2', 'callback 2')
         self.client.data_queue.write('data 3', 'callback 3')
 
-        mock_gateway_write = self.mocker.mock()
+        mock_gateway_write = Mock()
         self.patch(TransportGateway, 'write', mock_gateway_write)
-        expect(mock_gateway_write('data 1', 'callback 1'))
-        expect(mock_gateway_write('data 2', 'callback 2'))
-        expect(mock_gateway_write('data 3', 'callback 3'))
-
-        with self.mocker:
-            self.client.host_resolved('127.0.0.1')
+        self.client.host_resolved('127.0.0.1')
+        self.assertTrue(mock_gateway_write.call_count, 3)
+        expected = [call('data 1', 'callback 1'),
+                    call('data 2', 'callback 2'),
+                    call('data 3', 'callback 3')]
+        self.assertEqual(mock_gateway_write.call_args_list, expected)
 
     def test_sets_client_transport_when_connected(self):
         """Set the transport as an attribute of the client."""
 
=== modified file 'txstatsd/tests/test_process.py'
--- txstatsd/tests/test_process.py	2012-06-28 17:29:26 +0000
+++ txstatsd/tests/test_process.py	2013-03-07 15:53:38 +0000
@@ -23,7 +23,7 @@
 import psutil
 import sys
 
-from mocker import MockerTestCase
+import mock
 from twisted.trial.unittest import TestCase
 
 from txstatsd.process import (
@@ -82,7 +82,7 @@
 tun0: 5138313   24837    0    0    0     0          0         0  5226635   26986    0    0    0     0       0          0"""
 
 
-class TestSystemPerformance(TestCase, MockerTestCase):
+class TestSystemPerformance(TestCase):
     """Test system performance monitoring."""
 
     def test_loadinfo(self):
@@ -102,11 +102,10 @@
     def test_cpu_counters(self):
         """System cpu counters are collected through psutil."""
         cpu_times = psutil.cpu_times()
-        mock = self.mocker.replace("psutil.cpu_times")
-        self.expect(mock(percpu=False)).result(cpu_times)
-        self.mocker.replay()
-
-        result = report_system_stats()
+        with mock.patch("psutil.cpu_times"):
+            psutil.cpu_times.return_value = cpu_times
+            result = report_system_stats()
+            psutil.cpu_times.assert_called_once_with(percpu=False)
         # cpu_times is platform-dependent
         if sys.platform.lower().startswith("linux"):
             self.assertEqual(cpu_times.user, result["sys.cpu.user"])
@@ -132,11 +131,10 @@
     def test_per_cpu_counters(self):
         """System percpu counters are collected through psutil."""
         cpu_times = psutil.cpu_times()
-        mock = self.mocker.replace("psutil.cpu_times")
-        self.expect(mock(percpu=True)).result([cpu_times, cpu_times])
-        self.mocker.replay()
-
-        result = report_system_stats(percpu=True)
+        with mock.patch("psutil.cpu_times"):
+            psutil.cpu_times.return_value = [cpu_times, cpu_times]
+            result = report_system_stats(percpu=True)
+            psutil.cpu_times.assert_called_once_with(percpu=True)
         # cpu_times is platform-dependent
         if sys.platform.lower().startswith("linux"):
             self.assertEqual(cpu_times.user, result["sys.cpu.000.user"])
@@ -187,14 +185,12 @@
         cpu_percent = process.get_cpu_percent()
         memory_percent = process.get_memory_percent()
 
-        mock = self.mocker.mock()
-        self.expect(mock.get_memory_info()).result((vsize, rss))
-        self.expect(mock.get_cpu_percent()).result(cpu_percent)
-        self.expect(mock.get_memory_percent()).result(memory_percent)
-        self.expect(mock.get_num_threads).result(None)
-        self.mocker.replay()
-
-        result = ProcessReport(process=mock).get_memory_and_cpu()
+        proc = mock.Mock()
+        proc.get_memory_info.return_value = (vsize, rss)
+        proc.get_cpu_percent.return_value = cpu_percent
+        proc.get_memory_percent.return_value = memory_percent
+        proc.get_num_threads = None
+        result = ProcessReport(process=proc).get_memory_and_cpu()
         self.assertEqual(cpu_percent, result["proc.cpu.percent"])
         self.assertEqual(vsize, result["proc.memory.vsize"])
         self.assertEqual(rss, result["proc.memory.rss"])
@@ -208,11 +204,10 @@
         process = psutil.Process(os.getpid())
         utime, stime = process.get_cpu_times()
 
-        mock = self.mocker.mock()
-        self.expect(mock.get_cpu_times()).result((utime, stime))
-        self.mocker.replay()
-
-        result = ProcessReport(process=mock).get_cpu_counters()
+        proc = mock.Mock()
+        proc.get_cpu_times.return_value = (utime, stime)
+        result = ProcessReport(process=proc).get_cpu_counters()
+        proc.get_cpu_times.assert_called_once_with()
         self.assertEqual(utime, result["proc.cpu.user"])
         self.assertEqual(stime, result["proc.cpu.system"])
 
@@ -229,14 +224,18 @@
         cpu_percent = process.get_cpu_percent()
         memory_percent = process.get_memory_percent()
 
-        mock = self.mocker.mock()
-        self.expect(mock.get_memory_info()).result((vsize, rss))
-        self.expect(mock.get_cpu_percent()).result(cpu_percent)
-        self.expect(mock.get_memory_percent()).result(memory_percent)
-        self.expect(mock.get_num_threads()).result(1)
-        self.mocker.replay()
-
-        result = ProcessReport(process=mock).get_memory_and_cpu()
+        proc = mock.Mock()
+        proc.get_memory_info.return_value = (vsize, rss)
+        proc.get_cpu_percent.return_value = cpu_percent
+        proc.get_memory_percent.return_value = memory_percent
+        proc.get_num_threads.return_value = 1
+        result = ProcessReport(process=proc).get_memory_and_cpu()
+        proc.get_memory_info.assert_called_once_with()
+        proc.get_cpu_percent.assert_called_once_with()
+        proc.get_memory_percent.assert_called_once_with()
+        proc.get_num_threads.assert_called_once_with()
+
+
         self.assertEqual(cpu_percent, result["proc.cpu.percent"])
         self.assertEqual(vsize, result["proc.memory.vsize"])
         self.assertEqual(rss, result["proc.memory.rss"])
@@ -245,13 +244,11 @@
 
     def test_ioinfo(self):
         """Process IO info is collected through psutil."""
-        mock = self.mocker.mock()
-        self.expect(mock.get_io_counters).result(None)
-        self.mocker.replay()
-
         # If the version of psutil doesn't have the C{get_io_counters},
         # then io stats are not included in the output.
-        result = ProcessReport(process=mock).get_io_counters()
+        proc = mock.Mock()
+        proc.get_io_counters = None
+        result = ProcessReport(process=proc).get_io_counters()
         self.failIf("proc.io.read.count" in result)
         self.failIf("proc.io.write.count" in result)
         self.failIf("proc.io.read.bytes" in result)
@@ -266,12 +263,10 @@
         """
         io_counters = (10, 42, 125, 16)
 
-        mock = self.mocker.mock()
-        self.expect(mock.get_io_counters).result(mock)
-        self.expect(mock.get_io_counters()).result(io_counters)
-        self.mocker.replay()
-
-        result = ProcessReport(process=mock).get_io_counters()
+        proc = mock.Mock()
+        proc.get_io_counters.return_value = io_counters
+        result = ProcessReport(process=proc).get_io_counters()
+        proc.get_io_counters.assert_called_once_with()
         self.assertEqual(10, result["proc.io.read.count"])
         self.assertEqual(42, result["proc.io.write.count"])
         self.assertEqual(125, result["proc.io.read.bytes"])
@@ -284,13 +279,11 @@
         If the version of psutil doesn't implement C{get_connections} for
         L{Process}, then no information is returned.
         """
-        mock = self.mocker.mock()
-        self.expect(mock.get_connections).result(None)
-        self.mocker.replay()
-
         # If the version of psutil doesn't have the C{get_io_counters},
         # then io stats are not included in the output.
-        result = ProcessReport(process=mock).get_net_stats()
+        proc = mock.Mock()
+        proc.get_connections = None
+        result = ProcessReport(process=proc).get_net_stats()
         self.failIf("proc.net.status.established" in result)
 
     def test_netinfo_with_get_connections(self):
@@ -311,37 +304,32 @@
              ("72.14.234.83", 443), "SYN_SENT")
             ]
 
-        mock = self.mocker.mock()
-        self.expect(mock.get_connections).result(mock)
-        self.expect(mock.get_connections()).result(connections)
-        self.mocker.replay()
-
-        result = ProcessReport(process=mock).get_net_stats()
+        proc = mock.Mock()
+        proc.get_connections.return_value = connections
+        result = ProcessReport(process=proc).get_net_stats()
+        proc.get_connections.assert_called_once_with()
         self.assertEqual(2, result["proc.net.status.established"])
         self.assertEqual(1, result["proc.net.status.closing"])
         self.assertEqual(1, result["proc.net.status.syn_sent"])
 
     def test_reactor_stats(self):
         """Given a twisted reactor, pull out some stats from it."""
-        mock = self.mocker.mock()
-        self.expect(mock.getReaders()).result([None, None, None])
-        self.expect(mock.getWriters()).result([None, None])
-        self.mocker.replay()
-
-        result = report_reactor_stats(mock)()
+        mock_reactor = mock.Mock()
+        mock_reactor.getReaders.return_value = [None, None, None]
+        mock_reactor.getWriters.return_value = [None, None]
+        result = report_reactor_stats(mock_reactor)()
         self.assertEqual(3, result["reactor.readers"])
         self.assertEqual(2, result["reactor.writers"])
 
     def test_threadpool_stats(self):
         """Given a twisted threadpool, pull out some stats from it."""
-        mock = self.mocker.mock()
-        self.expect(mock.q.qsize()).result(42)
-        self.expect(mock.threads).result(6 * [None])
-        self.expect(mock.waiters).result(2 * [None])
-        self.expect(mock.working).result(4 * [None])
-        self.mocker.replay()
+        mock_reactor = mock.Mock()
+        mock_reactor.q.qsize.return_value = 42
+        mock_reactor.threads = 6 * [None]
+        mock_reactor.waiters = 2 * [None]
+        mock_reactor.working = 4 * [None]
 
-        result = report_threadpool_stats(mock)()
+        result = report_threadpool_stats(mock_reactor)()
         self.assertEqual(42, result["threadpool.queue"])
         self.assertEqual(6, result["threadpool.threads"])
         self.assertEqual(2, result["threadpool.waiters"])
@@ -385,5 +373,5 @@
         self.assertEqual({"foo": 4}, wrapped())
         self.assertEqual({"foo": 5}, wrapped())
         self.assertEqual({"foo": 7}, wrapped())
-        
+