Cleanup unittests for test_lmbench

unused-arg check was re-enabled after being disabled at a file level.
Changes were made so that the file conforms to our testing conventions.

Change-Id: Ie34a0088258c1aaff6cb0fdf0b86b37920d35bd6
JIRA: YARDSTICK-1384
Signed-off-by: Emma Foley <emma.l.foley@intel.com>

diff --git a/yardstick/tests/unit/benchmark/scenarios/compute/test_lmbench.py b/yardstick/tests/unit/benchmark/scenarios/compute/test_lmbench.py
index c4ac347..ba63e5f 100644 (file)
--- a/yardstick/tests/unit/benchmark/scenarios/compute/test_lmbench.py
+++ b/yardstick/tests/unit/benchmark/scenarios/compute/test_lmbench.py
@@ -6,11 +6,6 @@
 # which accompanies this distribution, and is available at
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
-
-# Unittest for yardstick.benchmark.scenarios.compute.lmbench.Lmbench
-
-from __future__ import absolute_import
-
 import unittest
 
 import mock
@@ -18,13 +13,9 @@ from oslo_serialization import jsonutils
 
 from yardstick.benchmark.scenarios.compute import lmbench
 from yardstick.common import exceptions as y_exc
+from yardstick import ssh
 
 
-# pylint: disable=unused-argument
-# disable this for now because I keep forgetting mock patch arg ordering
-
-
-@mock.patch('yardstick.benchmark.scenarios.compute.lmbench.ssh')
 class LmbenchTestCase(unittest.TestCase):
 
     def setUp(self):
@@ -38,16 +29,23 @@ class LmbenchTestCase(unittest.TestCase):
 
         self.result = {}
 
-    def test_successful_setup(self, mock_ssh):
+        self._mock_ssh = mock.patch.object(ssh, 'SSH')
+        self.mock_ssh = self._mock_ssh.start()
+        self.addCleanup(self._stop_mocks)
+
+    def _stop_mocks(self):
+        self._mock_ssh.stop()
+
+    def test_successful_setup(self):
 
         l = lmbench.Lmbench({}, self.ctx)
-        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        self.mock_ssh.from_node().execute.return_value = (0, '', '')
 
         l.setup()
         self.assertIsNotNone(l.client)
         self.assertTrue(l.setup_done)
 
-    def test_unsuccessful_unknown_type_run(self, mock_ssh):
+    def test_unsuccessful_unknown_type_run(self):
 
         options = {
             "test_type": "foo"
@@ -58,7 +56,7 @@ class LmbenchTestCase(unittest.TestCase):
 
         self.assertRaises(RuntimeError, l.run, self.result)
 
-    def test_successful_latency_run_no_sla(self, mock_ssh):
+    def test_successful_latency_run_no_sla(self):
 
         options = {
             "test_type": "latency",
@@ -69,12 +67,12 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 4.944, "size": 0.00049}]'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = {"latencies0.latency": 4.944, "latencies0.size": 0.00049}
         self.assertEqual(self.result, expected_result)
 
-    def test_successful_bandwidth_run_no_sla(self, mock_ssh):
+    def test_successful_bandwidth_run_no_sla(self):
 
         options = {
             "test_type": "bandwidth",
@@ -86,12 +84,12 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
 
-    def test_successful_latency_run_sla(self, mock_ssh):
+    def test_successful_latency_run_sla(self):
 
         options = {
             "test_type": "latency",
@@ -105,12 +103,12 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 4.944, "size": 0.00049}]'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = {"latencies0.latency": 4.944, "latencies0.size": 0.00049}
         self.assertEqual(self.result, expected_result)
 
-    def test_successful_bandwidth_run_sla(self, mock_ssh):
+    def test_successful_bandwidth_run_sla(self):
 
         options = {
             "test_type": "bandwidth",
@@ -125,12 +123,12 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
 
-    def test_unsuccessful_latency_run_sla(self, mock_ssh):
+    def test_unsuccessful_latency_run_sla(self):
 
         options = {
             "test_type": "latency",
@@ -144,10 +142,10 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 37.5, "size": 0.00049}]'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(y_exc.SLAValidationError, l.run, self.result)
 
-    def test_unsuccessful_bandwidth_run_sla(self, mock_ssh):
+    def test_unsuccessful_bandwidth_run_sla(self):
 
         options = {
             "test_type": "bandwidth",
@@ -162,10 +160,10 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 9925.5}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(y_exc.SLAValidationError, l.run, self.result)
 
-    def test_successful_latency_for_cache_run_sla(self, mock_ssh):
+    def test_successful_latency_for_cache_run_sla(self):
 
         options = {
             "test_type": "latency_for_cache",
@@ -179,16 +177,16 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = "{\"L1cache\": 1.6}"
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_ssh.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
 
-    def test_unsuccessful_script_error(self, mock_ssh):
+    def test_unsuccessful_script_error(self):
 
         options = {"test_type": "bandwidth"}
         args = {"options": options}
         l = lmbench.Lmbench(args, self.ctx)
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
+        self.mock_ssh.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, l.run, self.result)