standardize ssh auth

we need to be following defautl paramiko rules,
first use pkey, then key_filenames (autodetecting ~/.ssh/ keys),
then password

We have too much boilerplate redudant code everywhere, we need
to standardize on a factory function that takes a node dict.

Using Python3 ChainMap we can layer overrides and defaults.

VNF descriptors have to default key_filename, password to Python None.
The only way to do this is to omit key values if the variable is not
defined, this way the dict will not have the value and it will
default to Python None

Add python2 chainmap backport

Updated unittest mocking to use ssh.SSH.from_node

Change-Id: I80b0cb606e593b33e317c9e5e8ed0b74da591514
Signed-off-by: Ross Brattain <ross.b.brattain@intel.com>

33 files changed, 289 insertions, 289 deletions

diff --git a/tests/unit/benchmark/core/test_plugin.py b/tests/unit/benchmark/core/test_plugin.py
index edc103415..f9c076159 100644
--- a/tests/unit/benchmark/core/test_plugin.py
+++ b/tests/unit/benchmark/core/test_plugin.py
@@ -41,7 +41,7 @@ class pluginTestCase(unittest.TestCase):
 
     def test_install(self, mock_ssh):
         p = plugin.Plugin()
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         input_file = Arg()
         p.install(input_file)
         expected_result = {}
@@ -49,7 +49,7 @@ class pluginTestCase(unittest.TestCase):
 
     def test_remove(self, mock_ssh):
         p = plugin.Plugin()
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         input_file = Arg()
         p.remove(input_file)
         expected_result = {}
@@ -57,7 +57,7 @@ class pluginTestCase(unittest.TestCase):
 
     def test_install_setup_run(self, mock_ssh):
         p = plugin.Plugin()
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         plugins = {
             "name": "sample"
         }
@@ -76,7 +76,7 @@ class pluginTestCase(unittest.TestCase):
 
     def test_remove_setup_run(self, mock_ssh):
         p = plugin.Plugin()
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         plugins = {
             "name": "sample"
         }
diff --git a/tests/unit/benchmark/scenarios/availability/test_attacker_baremetal.py b/tests/unit/benchmark/scenarios/availability/test_attacker_baremetal.py
index 9e2e8b172..28b27c78a 100644
--- a/tests/unit/benchmark/scenarios/availability/test_attacker_baremetal.py
+++ b/tests/unit/benchmark/scenarios/availability/test_attacker_baremetal.py
@@ -63,7 +63,7 @@ class AttackerBaremetalTestCase(unittest.TestCase):
         ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
                                                    self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.setup()
         ins.inject_fault()
         ins.recover()
@@ -71,7 +71,7 @@ class AttackerBaremetalTestCase(unittest.TestCase):
     def test__attacker_baremetal_check_failuer(self, mock_ssh):
         ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
                                                    self.context)
-        mock_ssh.SSH().execute.return_value = (0, "error check", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
         ins.setup()
 
     def test__attacker_baremetal_recover_successful(self, mock_ssh):
@@ -81,6 +81,6 @@ class AttackerBaremetalTestCase(unittest.TestCase):
         ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
                                                    self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.setup()
         ins.recover()
diff --git a/tests/unit/benchmark/scenarios/availability/test_attacker_general.py b/tests/unit/benchmark/scenarios/availability/test_attacker_general.py
index 322b58391..612b5a662 100644
--- a/tests/unit/benchmark/scenarios/availability/test_attacker_general.py
+++ b/tests/unit/benchmark/scenarios/availability/test_attacker_general.py
@@ -44,7 +44,7 @@ class GeneralAttackerServiceTestCase(unittest.TestCase):
         cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
         ins = cls(self.attacker_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.setup()
         ins.inject_fault()
         ins.recover()
@@ -54,5 +54,5 @@ class GeneralAttackerServiceTestCase(unittest.TestCase):
         cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
         ins = cls(self.attacker_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "error check", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
         ins.setup()
diff --git a/tests/unit/benchmark/scenarios/availability/test_attacker_process.py b/tests/unit/benchmark/scenarios/availability/test_attacker_process.py
index d7771bd33..eec512a58 100644
--- a/tests/unit/benchmark/scenarios/availability/test_attacker_process.py
+++ b/tests/unit/benchmark/scenarios/availability/test_attacker_process.py
@@ -41,7 +41,7 @@ class AttackerServiceTestCase(unittest.TestCase):
         cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
         ins = cls(self.attacker_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.setup()
         ins.inject_fault()
         ins.recover()
@@ -51,5 +51,5 @@ class AttackerServiceTestCase(unittest.TestCase):
         cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
         ins = cls(self.attacker_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "error check", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
         ins.setup()
diff --git a/tests/unit/benchmark/scenarios/availability/test_monitor_command.py b/tests/unit/benchmark/scenarios/availability/test_monitor_command.py
index a84bfd2c5..c179bbfaf 100644
--- a/tests/unit/benchmark/scenarios/availability/test_monitor_command.py
+++ b/tests/unit/benchmark/scenarios/availability/test_monitor_command.py
@@ -87,5 +87,5 @@ class MonitorOpenstackCmdTestCase(unittest.TestCase):
         instance = monitor_command.MonitorOpenstackCmd(
             self.config, self.context)
         instance.setup()
-        mock_ssh.SSH().execute.return_value = (0, "0", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
         ret = instance.monitor_func()
diff --git a/tests/unit/benchmark/scenarios/availability/test_monitor_general.py b/tests/unit/benchmark/scenarios/availability/test_monitor_general.py
index 369f6f4f7..169b630bf 100644
--- a/tests/unit/benchmark/scenarios/availability/test_monitor_general.py
+++ b/tests/unit/benchmark/scenarios/availability/test_monitor_general.py
@@ -53,7 +53,7 @@ class GeneralMonitorServiceTestCase(unittest.TestCase):
         ins = monitor_general.GeneralMonitor(self.monitor_cfg, self.context)
 
         ins.setup()
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.monitor_func()
         ins._result = {'outage_time': 0}
         ins.verify_SLA()
@@ -64,7 +64,7 @@ class GeneralMonitorServiceTestCase(unittest.TestCase):
             self.monitor_cfg_noparam, self.context)
 
         ins.setup()
-        mock_ssh.SSH().execute.return_value = (0, "running", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
         ins.monitor_func()
         ins._result = {'outage_time': 0}
         ins.verify_SLA()
@@ -74,7 +74,7 @@ class GeneralMonitorServiceTestCase(unittest.TestCase):
             self.monitor_cfg_noparam, self.context)
 
         ins.setup()
-        mock_ssh.SSH().execute.return_value = (1, "error", 'error')
+        mock_ssh.SSH.from_node().execute.return_value = (1, "error", 'error')
         ins.monitor_func()
         ins._result = {'outage_time': 2}
         ins.verify_SLA()
diff --git a/tests/unit/benchmark/scenarios/availability/test_monitor_process.py b/tests/unit/benchmark/scenarios/availability/test_monitor_process.py
index 8270405cd..8c267e413 100644
--- a/tests/unit/benchmark/scenarios/availability/test_monitor_process.py
+++ b/tests/unit/benchmark/scenarios/availability/test_monitor_process.py
@@ -42,7 +42,7 @@ class MonitorProcessTestCase(unittest.TestCase):
 
         ins = monitor_process.MonitorProcess(self.monitor_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "1", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
         ins.setup()
         ins.monitor_func()
         ins._result = {"outage_time": 0}
@@ -52,7 +52,7 @@ class MonitorProcessTestCase(unittest.TestCase):
 
         ins = monitor_process.MonitorProcess(self.monitor_cfg, self.context)
 
-        mock_ssh.SSH().execute.return_value = (0, "0", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
         ins.setup()
         ins.monitor_func()
         ins._result = {"outage_time": 10}
diff --git a/tests/unit/benchmark/scenarios/availability/test_operation_general.py b/tests/unit/benchmark/scenarios/availability/test_operation_general.py
index 2c6dc1617..fb8ccb122 100644
--- a/tests/unit/benchmark/scenarios/availability/test_operation_general.py
+++ b/tests/unit/benchmark/scenarios/availability/test_operation_general.py
@@ -50,7 +50,7 @@ class GeneralOperaionTestCase(unittest.TestCase):
     def test__operation_successful(self, mock_open, mock_ssh):
         ins = operation_general.GeneralOperaion(self.operation_cfg,
                                                 self.context)
-        mock_ssh.SSH().execute.return_value = (0, "success", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "success", '')
         ins.setup()
         ins.run()
         ins.rollback()
@@ -58,7 +58,7 @@ class GeneralOperaionTestCase(unittest.TestCase):
     def test__operation_successful_noparam(self, mock_open, mock_ssh):
         ins = operation_general.GeneralOperaion(self.operation_cfg_noparam,
                                                 self.context)
-        mock_ssh.SSH().execute.return_value = (0, "success", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "success", '')
         ins.setup()
         ins.run()
         ins.rollback()
@@ -66,7 +66,7 @@ class GeneralOperaionTestCase(unittest.TestCase):
     def test__operation_fail(self, mock_open, mock_ssh):
         ins = operation_general.GeneralOperaion(self.operation_cfg,
                                                 self.context)
-        mock_ssh.SSH().execute.return_value = (1, "failed", '')
+        mock_ssh.SSH.from_node().execute.return_value = (1, "failed", '')
         ins.setup()
         ins.run()
         ins.rollback()
diff --git a/tests/unit/benchmark/scenarios/availability/test_result_checker_general.py b/tests/unit/benchmark/scenarios/availability/test_result_checker_general.py
index c5451fabd..d036bb0da 100644
--- a/tests/unit/benchmark/scenarios/availability/test_result_checker_general.py
+++ b/tests/unit/benchmark/scenarios/availability/test_result_checker_general.py
@@ -47,7 +47,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
     def test__result_checker_eq(self, mock_open, mock_ssh):
         ins = result_checker_general.GeneralResultChecker(self.checker_cfg,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "1", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -56,7 +56,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['condition'] = 'gt'
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "2", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "2", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -65,7 +65,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['condition'] = 'gt_eq'
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "1", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -74,7 +74,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['condition'] = 'lt'
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "0", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -83,7 +83,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['condition'] = 'lt_eq'
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "1", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -93,7 +93,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['expectedValue'] = "value"
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "value return", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "value return", '')
         ins.setup()
         self.assertTrue(ins.verify())
 
@@ -102,7 +102,7 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config['condition'] = 'wrong'
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (0, "1", '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
         ins.setup()
         self.assertFalse(ins.verify())
 
@@ -111,6 +111,6 @@ class GeneralResultCheckerTestCase(unittest.TestCase):
         config.pop('parameter')
         ins = result_checker_general.GeneralResultChecker(config,
                                                           self.context)
-        mock_ssh.SSH().execute.return_value = (1, "fail", '')
+        mock_ssh.SSH.from_node().execute.return_value = (1, "fail", '')
         ins.setup()
         ins.verify()
diff --git a/tests/unit/benchmark/scenarios/compute/test_cachestat.py b/tests/unit/benchmark/scenarios/compute/test_cachestat.py
index 8a06c754b..b0ddfc6b4 100644
--- a/tests/unit/benchmark/scenarios/compute/test_cachestat.py
+++ b/tests/unit/benchmark/scenarios/compute/test_cachestat.py
@@ -35,7 +35,7 @@ class CACHEstatTestCase(unittest.TestCase):
 
     def test_cachestat_successful_setup(self, mock_ssh):
         c = cachestat.CACHEstat({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         c.setup()
         self.assertIsNotNone(c.client)
@@ -43,20 +43,20 @@ class CACHEstatTestCase(unittest.TestCase):
 
     def test_execute_command_success(self, mock_ssh):
         c = cachestat.CACHEstat({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
         expected_result = 'abcdefg'
-        mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
         result = c._execute_command("foo")
         self.assertEqual(result, expected_result)
 
     def test_execute_command_failed(self, mock_ssh):
         c = cachestat.CACHEstat({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        mock_ssh.SSH().execute.return_value = (127, '', 'Failed executing \
+        mock_ssh.SSH.from_node().execute.return_value = (127, '', 'Failed executing \
             command')
         self.assertRaises(RuntimeError, c._execute_command,
                           "cat /proc/meminfo")
@@ -67,11 +67,11 @@ class CACHEstatTestCase(unittest.TestCase):
         }
         args = {"options": options}
         c = cachestat.CACHEstat(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
         output = self._read_file("cachestat_sample_output.txt")
-        mock_ssh.SSH().execute.return_value = (0, output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
         result = c._get_cache_usage()
         expected_result = {"cachestat": {"cache0": {"HITS": "6462",
                                                     "DIRTIES": "29",
diff --git a/tests/unit/benchmark/scenarios/compute/test_computecapacity.py b/tests/unit/benchmark/scenarios/compute/test_computecapacity.py
index 4efa66932..7b9a5ad4a 100644
--- a/tests/unit/benchmark/scenarios/compute/test_computecapacity.py
+++ b/tests/unit/benchmark/scenarios/compute/test_computecapacity.py
@@ -45,7 +45,7 @@ class ComputeCapacityTestCase(unittest.TestCase):
 
     def test_capacity_successful_setup(self, mock_ssh):
         c = computecapacity.ComputeCapacity({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         c.setup()
         self.assertIsNotNone(c.client)
@@ -54,7 +54,7 @@ class ComputeCapacityTestCase(unittest.TestCase):
     def test_capacity_successful(self, mock_ssh):
         c = computecapacity.ComputeCapacity({}, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, SAMPLE_OUTPUT, '')
         c.run(self.result)
         expected_result = jsonutils.loads(SAMPLE_OUTPUT)
         self.assertEqual(self.result, expected_result)
@@ -62,5 +62,5 @@ class ComputeCapacityTestCase(unittest.TestCase):
     def test_capacity_unsuccessful_script_error(self, mock_ssh):
         c = computecapacity.ComputeCapacity({}, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, c.run, self.result)
diff --git a/tests/unit/benchmark/scenarios/compute/test_cpuload.py b/tests/unit/benchmark/scenarios/compute/test_cpuload.py
index ffa781215..840ac7885 100644
--- a/tests/unit/benchmark/scenarios/compute/test_cpuload.py
+++ b/tests/unit/benchmark/scenarios/compute/test_cpuload.py
@@ -42,7 +42,7 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         l.setup()
         self.assertIsNotNone(l.client)
@@ -58,7 +58,7 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (127, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (127, '', '')
 
         l.setup()
         self.assertIsNotNone(l.client)
@@ -74,11 +74,11 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         l.setup()
 
         expected_result = 'abcdefg'
-        mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
         result = l._execute_command("foo")
         self.assertEqual(result, expected_result)
 
@@ -91,10 +91,10 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         l.setup()
 
-        mock_ssh.SSH().execute.return_value = (127, '', 'abcdefg')
+        mock_ssh.SSH.from_node().execute.return_value = (127, '', 'abcdefg')
         self.assertRaises(RuntimeError, l._execute_command,
                           "cat /proc/loadavg")
 
@@ -107,10 +107,10 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         l.setup()
 
-        mock_ssh.SSH().execute.return_value = \
+        mock_ssh.SSH.from_node().execute.return_value = \
             (0, '1.50 1.45 1.51 3/813 14322', '')
         result = l._get_loadavg()
         expected_result = \
@@ -126,13 +126,13 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         l.setup()
 
         l.interval = 1
         l.count = 1
         mpstat_output = self._read_file("cpuload_sample_output1.txt")
-        mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
         result = l._get_cpu_usage_mpstat()
 
         expected_result = \
@@ -175,12 +175,12 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         l.setup()
 
         l.interval = 0
         output = self._read_file("cpuload_sample_output2.txt")
-        mock_ssh.SSH().execute.return_value = (0, output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
         result = l._get_cpu_usage()
 
         expected_result = \
@@ -219,12 +219,12 @@ class CPULoadTestCase(unittest.TestCase):
         args = {'options': options}
 
         l = cpuload.CPULoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
         l.setup()
 
         l.interval = 0
         stat_output = self._read_file("cpuload_sample_output2.txt")
-        mock_ssh.SSH().execute.side_effect = \
+        mock_ssh.SSH.from_node().execute.side_effect = \
             [(0, '1.50 1.45 1.51 3/813 14322', ''), (0, stat_output, '')]
 
         l.run(self.result)
diff --git a/tests/unit/benchmark/scenarios/compute/test_cyclictest.py b/tests/unit/benchmark/scenarios/compute/test_cyclictest.py
index 04ca2abf9..dc52a80c7 100644
--- a/tests/unit/benchmark/scenarios/compute/test_cyclictest.py
+++ b/tests/unit/benchmark/scenarios/compute/test_cyclictest.py
@@ -69,7 +69,7 @@ class CyclictestTestCase(unittest.TestCase):
     def test_cyclictest_successful_setup(self, mock_ssh):
 
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         c.setup()
         self.assertIsNotNone(c.guest)
@@ -80,12 +80,12 @@ class CyclictestTestCase(unittest.TestCase):
         result = {}
         self.scenario_cfg.pop("sla", None)
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
         sample_output = '{"min": 100, "avg": 500, "max": 1000}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         c.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -101,12 +101,12 @@ class CyclictestTestCase(unittest.TestCase):
         }
         })
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
         sample_output = '{"min": 100, "avg": 500, "max": 1000}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         c.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -117,13 +117,13 @@ class CyclictestTestCase(unittest.TestCase):
         result = {}
         self.scenario_cfg.update({"sla": {"max_min_latency": 10}})
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
         sample_output = '{"min": 100, "avg": 500, "max": 1000}'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, c.run, result)
 
     def test_cyclictest_unsuccessful_sla_avg_latency(self, mock_ssh):
@@ -131,13 +131,13 @@ class CyclictestTestCase(unittest.TestCase):
         result = {}
         self.scenario_cfg.update({"sla": {"max_avg_latency": 10}})
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
         sample_output = '{"min": 100, "avg": 500, "max": 1000}'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, c.run, result)
 
     def test_cyclictest_unsuccessful_sla_max_latency(self, mock_ssh):
@@ -145,13 +145,13 @@ class CyclictestTestCase(unittest.TestCase):
         result = {}
         self.scenario_cfg.update({"sla": {"max_max_latency": 10}})
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
         sample_output = '{"min": 100, "avg": 500, "max": 1000}'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, c.run, result)
 
     def test_cyclictest_unsuccessful_script_error(self, mock_ssh):
@@ -159,12 +159,12 @@ class CyclictestTestCase(unittest.TestCase):
         result = {}
         self.scenario_cfg.update({"sla": {"max_max_latency": 10}})
         c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
 
-        c.guest = mock_ssh.SSH()
+        c.guest = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, c.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/compute/test_lmbench.py b/tests/unit/benchmark/scenarios/compute/test_lmbench.py
index 5b72ef75d..08f5da332 100644
--- a/tests/unit/benchmark/scenarios/compute/test_lmbench.py
+++ b/tests/unit/benchmark/scenarios/compute/test_lmbench.py
@@ -38,7 +38,7 @@ class LmbenchTestCase(unittest.TestCase):
     def test_successful_setup(self, mock_ssh):
 
         l = lmbench.Lmbench({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         l.setup()
         self.assertIsNotNone(l.client)
@@ -66,7 +66,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 4.944, "size": 0.00049}]'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = jsonutils.loads(
             '{"latencies": ' + sample_output + "}")
@@ -84,7 +84,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.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)
@@ -103,7 +103,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 4.944, "size": 0.00049}]'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         l.run(self.result)
         expected_result = jsonutils.loads(
             '{"latencies": ' + sample_output + "}")
@@ -124,7 +124,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.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)
@@ -143,7 +143,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '[{"latency": 37.5, "size": 0.00049}]'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, l.run, self.result)
 
     def test_unsuccessful_bandwidth_run_sla(self, mock_ssh):
@@ -161,7 +161,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 9925.5}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, l.run, self.result)
 
     def test_successful_latency_for_cache_run_sla(self, mock_ssh):
@@ -178,7 +178,7 @@ class LmbenchTestCase(unittest.TestCase):
         l = lmbench.Lmbench(args, self.ctx)
 
         sample_output = "{\"L1cache\": 1.6}"
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.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)
@@ -189,5 +189,5 @@ class LmbenchTestCase(unittest.TestCase):
         args = {"options": options}
         l = lmbench.Lmbench(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, l.run, self.result)
diff --git a/tests/unit/benchmark/scenarios/compute/test_memload.py b/tests/unit/benchmark/scenarios/compute/test_memload.py
index ede3309c2..ebae9993d 100644
--- a/tests/unit/benchmark/scenarios/compute/test_memload.py
+++ b/tests/unit/benchmark/scenarios/compute/test_memload.py
@@ -35,7 +35,7 @@ class MEMLoadTestCase(unittest.TestCase):
 
     def test_memload_successful_setup(self, mock_ssh):
         m = memload.MEMLoad({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         m.setup()
         self.assertIsNotNone(m.client)
@@ -43,20 +43,20 @@ class MEMLoadTestCase(unittest.TestCase):
 
     def test_execute_command_success(self, mock_ssh):
         m = memload.MEMLoad({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         m.setup()
 
         expected_result = 'abcdefg'
-        mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
         result = m._execute_command("foo")
         self.assertEqual(result, expected_result)
 
     def test_execute_command_failed(self, mock_ssh):
         m = memload.MEMLoad({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         m.setup()
 
-        mock_ssh.SSH().execute.return_value = (127, '', 'Failed executing \
+        mock_ssh.SSH.from_node().execute.return_value = (127, '', 'Failed executing \
                                                command')
         self.assertRaises(RuntimeError, m._execute_command,
                           "cat /proc/meminfo")
@@ -68,11 +68,11 @@ class MEMLoadTestCase(unittest.TestCase):
         }
         args = {"options": options}
         m = memload.MEMLoad(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         m.setup()
 
         output = self._read_file("memload_sample_output.txt")
-        mock_ssh.SSH().execute.return_value = (0, output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
         result = m._get_mem_usage()
         expected_result = {
             "max": {
diff --git a/tests/unit/benchmark/scenarios/compute/test_plugintest.py b/tests/unit/benchmark/scenarios/compute/test_plugintest.py
index a5331caf7..680f6ad65 100644
--- a/tests/unit/benchmark/scenarios/compute/test_plugintest.py
+++ b/tests/unit/benchmark/scenarios/compute/test_plugintest.py
@@ -40,7 +40,7 @@ class PluginTestTestCase(unittest.TestCase):
 
     def test_sample_successful_setup(self, mock_ssh):
         s = plugintest.PluginTest({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         s.setup()
         self.assertIsNotNone(s.client)
@@ -50,7 +50,7 @@ class PluginTestTestCase(unittest.TestCase):
         s = plugintest.PluginTest({}, self.ctx)
 
         sample_output = '{"Test Output": "Hello world!"}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         s.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
@@ -58,5 +58,5 @@ class PluginTestTestCase(unittest.TestCase):
     def test_sample_unsuccessful_script_error(self, mock_ssh):
         s = plugintest.PluginTest({}, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, s.run, self.result)
diff --git a/tests/unit/benchmark/scenarios/compute/test_ramspeed.py b/tests/unit/benchmark/scenarios/compute/test_ramspeed.py
index 82cc93870..85d49641e 100644
--- a/tests/unit/benchmark/scenarios/compute/test_ramspeed.py
+++ b/tests/unit/benchmark/scenarios/compute/test_ramspeed.py
@@ -38,7 +38,7 @@ class RamspeedTestCase(unittest.TestCase):
     def test_ramspeed_successful_setup(self, mock_ssh):
 
         r = ramspeed.Ramspeed({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         r.setup()
         self.assertIsNotNone(r.client)
@@ -75,7 +75,7 @@ class RamspeedTestCase(unittest.TestCase):
  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
  "Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
  "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         r.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
@@ -111,7 +111,7 @@ class RamspeedTestCase(unittest.TestCase):
  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
  "Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
  "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         r.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
@@ -146,7 +146,7 @@ class RamspeedTestCase(unittest.TestCase):
  "Bandwidth(MBps)": 14159.86}, {"Test_type": "INTEGER & WRITING",\
  "Block_size(kb)": 16384, "Bandwidth(MBps)": 14128.94}, {"Test_type":\
  "INTEGER & WRITING", "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, r.run, self.result)
 
     def test_ramspeed_unsuccessful_script_error(self, mock_ssh):
@@ -158,7 +158,7 @@ class RamspeedTestCase(unittest.TestCase):
         args = {"options": options}
         r = ramspeed.Ramspeed(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, r.run, self.result)
 
     def test_ramspeed_mem_successful_run_no_sla(self, mock_ssh):
@@ -177,7 +177,7 @@ class RamspeedTestCase(unittest.TestCase):
  "Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
  "Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
  "Bandwidth(MBps)": 9401.58}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         r.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
@@ -198,7 +198,7 @@ class RamspeedTestCase(unittest.TestCase):
  "Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
  "Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
  "Bandwidth(MBps)": 9401.58}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         r.run(self.result)
         expected_result = jsonutils.loads(sample_output)
         self.assertEqual(self.result, expected_result)
@@ -219,7 +219,7 @@ class RamspeedTestCase(unittest.TestCase):
  "Bandwidth(MBps)": 4300.48}, {"Test_type": "INTEGER Triad:",\
  "Bandwidth(MBps)": 1300.27}, {"Test_type": "INTEGER AVERAGE:",\
  "Bandwidth(MBps)": 2401.58}]}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, r.run, self.result)
 
     def test_ramspeed_unsuccessful_unknown_type_run(self, mock_ssh):
@@ -231,7 +231,7 @@ class RamspeedTestCase(unittest.TestCase):
         args = {'options': options}
         r = ramspeed.Ramspeed(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'No such type_id: 30 for \
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'No such type_id: 30 for \
                                                Ramspeed scenario')
         self.assertRaises(RuntimeError, r.run, self.result)
 
diff --git a/tests/unit/benchmark/scenarios/compute/test_unixbench.py b/tests/unit/benchmark/scenarios/compute/test_unixbench.py
index 747bda1ed..7d071e91c 100644
--- a/tests/unit/benchmark/scenarios/compute/test_unixbench.py
+++ b/tests/unit/benchmark/scenarios/compute/test_unixbench.py
@@ -38,7 +38,7 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench({}, self.ctx)
         u.setup()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         self.assertIsNotNone(u.client)
         self.assertEqual(u.setup_done, True)
 
@@ -54,10 +54,10 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
 
         sample_output = '{"Score":"4425.4"}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         u.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -76,10 +76,10 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
 
         sample_output = '{"Score":"4425.4"}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         u.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -102,10 +102,10 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
 
         sample_output = '{"signle_score":"2251.7","parallel_score":"4395.9"}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         u.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -120,10 +120,10 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
         sample_output = '{"single_score":"200.7","parallel_score":"4395.9"}'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, u.run, result)
 
     def test_unixbench_unsuccessful_sla_parallel_score(self, mock_ssh):
@@ -135,10 +135,10 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
         sample_output = '{"signle_score":"2251.7","parallel_score":"3395.9"}'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, u.run, result)
 
     def test_unixbench_unsuccessful_script_error(self, mock_ssh):
@@ -158,9 +158,9 @@ class UnixbenchTestCase(unittest.TestCase):
         u = unixbench.Unixbench(args, self.ctx)
         result = {}
 
-        u.server = mock_ssh.SSH()
+        u.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, u.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_iperf3.py b/tests/unit/benchmark/scenarios/networking/test_iperf3.py
index ea53cb9ab..45ff1b779 100644
--- a/tests/unit/benchmark/scenarios/networking/test_iperf3.py
+++ b/tests/unit/benchmark/scenarios/networking/test_iperf3.py
@@ -45,29 +45,29 @@ class IperfTestCase(unittest.TestCase):
     def test_iperf_successful_setup(self, mock_ssh):
 
         p = iperf3.Iperf({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p.setup()
         self.assertIsNotNone(p.target)
         self.assertIsNotNone(p.host)
-        mock_ssh.SSH().execute.assert_called_with("iperf3 -s -D")
+        mock_ssh.SSH.from_node().execute.assert_called_with("iperf3 -s -D")
 
     def test_iperf_unsuccessful_setup(self, mock_ssh):
 
         p = iperf3.Iperf({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.setup)
 
     def test_iperf_successful_teardown(self, mock_ssh):
 
         p = iperf3.Iperf({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
-        p.target = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
+        p.target = mock_ssh.SSH.from_node()
 
         p.teardown()
-        self.assertTrue(mock_ssh.SSH().close.called)
-        mock_ssh.SSH().execute.assert_called_with("pkill iperf3")
+        self.assertTrue(mock_ssh.SSH.from_node().close.called)
+        mock_ssh.SSH.from_node().execute.assert_called_with("pkill iperf3")
 
     def test_iperf_successful_no_sla(self, mock_ssh):
 
@@ -76,11 +76,11 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.output_name_tcp)
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -95,11 +95,11 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.output_name_tcp)
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -114,11 +114,11 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.output_name_tcp)
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_iperf_successful_sla_jitter(self, mock_ssh):
@@ -130,11 +130,11 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.output_name_udp)
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -148,11 +148,11 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.output_name_udp)
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_iperf_unsuccessful_script_error(self, mock_ssh):
@@ -162,10 +162,10 @@ class IperfTestCase(unittest.TestCase):
         result = {}
 
         p = iperf3.Iperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
     def _read_sample_output(self, filename):
diff --git a/tests/unit/benchmark/scenarios/networking/test_netperf.py b/tests/unit/benchmark/scenarios/networking/test_netperf.py
index 1b5dd6472..d0f862fb5 100755
--- a/tests/unit/benchmark/scenarios/networking/test_netperf.py
+++ b/tests/unit/benchmark/scenarios/networking/test_netperf.py
@@ -43,7 +43,7 @@ class NetperfTestCase(unittest.TestCase):
     def test_netperf_successful_setup(self, mock_ssh):
 
         p = netperf.Netperf({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p.setup()
         self.assertIsNotNone(p.server)
@@ -57,11 +57,11 @@ class NetperfTestCase(unittest.TestCase):
         result = {}
 
         p = netperf.Netperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -76,11 +76,11 @@ class NetperfTestCase(unittest.TestCase):
         result = {}
 
         p = netperf.Netperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -95,11 +95,11 @@ class NetperfTestCase(unittest.TestCase):
         result = {}
 
         p = netperf.Netperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_netperf_unsuccessful_script_error(self, mock_ssh):
@@ -109,10 +109,10 @@ class NetperfTestCase(unittest.TestCase):
         result = {}
 
         p = netperf.Netperf(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
     def _read_sample_output(self):
diff --git a/tests/unit/benchmark/scenarios/networking/test_netperf_node.py b/tests/unit/benchmark/scenarios/networking/test_netperf_node.py
index 29a7edf67..62874cc44 100755
--- a/tests/unit/benchmark/scenarios/networking/test_netperf_node.py
+++ b/tests/unit/benchmark/scenarios/networking/test_netperf_node.py
@@ -43,7 +43,7 @@ class NetperfNodeTestCase(unittest.TestCase):
     def test_netperf_node_successful_setup(self, mock_ssh):
 
         p = netperf_node.NetperfNode({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p.setup()
         self.assertIsNotNone(p.server)
@@ -57,11 +57,11 @@ class NetperfNodeTestCase(unittest.TestCase):
         result = {}
 
         p = netperf_node.NetperfNode(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -76,11 +76,11 @@ class NetperfNodeTestCase(unittest.TestCase):
         result = {}
 
         p = netperf_node.NetperfNode(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         expected_result = jsonutils.loads(sample_output)
         p.run(result)
         self.assertEqual(result, expected_result)
@@ -95,11 +95,11 @@ class NetperfNodeTestCase(unittest.TestCase):
         result = {}
 
         p = netperf_node.NetperfNode(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output()
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_netperf_node_unsuccessful_script_error(self, mock_ssh):
@@ -109,10 +109,10 @@ class NetperfNodeTestCase(unittest.TestCase):
         result = {}
 
         p = netperf_node.NetperfNode(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        p.host = mock_ssh.SSH()
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        p.host = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
     def _read_sample_output(self):
diff --git a/tests/unit/benchmark/scenarios/networking/test_netutilization.py b/tests/unit/benchmark/scenarios/networking/test_netutilization.py
index 7c04f5e9a..1227e056e 100644
--- a/tests/unit/benchmark/scenarios/networking/test_netutilization.py
+++ b/tests/unit/benchmark/scenarios/networking/test_netutilization.py
@@ -42,7 +42,7 @@ class NetUtilizationTestCase(unittest.TestCase):
         args = {'options': options}
 
         n = netutilization.NetUtilization(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         n.setup()
         self.assertIsNotNone(n.client)
@@ -56,11 +56,11 @@ class NetUtilizationTestCase(unittest.TestCase):
         args = {'options': options}
 
         n = netutilization.NetUtilization(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         n.setup()
 
         expected_result = 'abcdefg'
-        mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
         result = n._execute_command("foo")
         self.assertEqual(result, expected_result)
 
@@ -72,10 +72,10 @@ class NetUtilizationTestCase(unittest.TestCase):
         args = {'options': options}
 
         n = netutilization.NetUtilization(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         n.setup()
 
-        mock_ssh.SSH().execute.return_value = (127, '', 'abcdefg')
+        mock_ssh.SSH.from_node().execute.return_value = (127, '', 'abcdefg')
         self.assertRaises(RuntimeError, n._execute_command,
                           "failed")
 
@@ -87,11 +87,11 @@ class NetUtilizationTestCase(unittest.TestCase):
         args = {'options': options}
 
         n = netutilization.NetUtilization(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         n.setup()
 
         mpstat_output = self._read_file("netutilization_sample_output1.txt")
-        mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
         result = n._get_network_utilization()
 
         expected_result = \
@@ -157,11 +157,11 @@ class NetUtilizationTestCase(unittest.TestCase):
         args = {'options': options}
 
         n = netutilization.NetUtilization(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         n.setup()
 
         mpstat_output = self._read_file("netutilization_sample_output2.txt")
-        mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
         result = n._get_network_utilization()
 
         expected_result = \
diff --git a/tests/unit/benchmark/scenarios/networking/test_networkcapacity.py b/tests/unit/benchmark/scenarios/networking/test_networkcapacity.py
index 3f8d84e54..3e7a3c5ee 100644
--- a/tests/unit/benchmark/scenarios/networking/test_networkcapacity.py
+++ b/tests/unit/benchmark/scenarios/networking/test_networkcapacity.py
@@ -41,7 +41,7 @@ class NetworkCapacityTestCase(unittest.TestCase):
 
     def test_capacity_successful_setup(self, mock_ssh):
         c = networkcapacity.NetworkCapacity({}, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
         self.assertIsNotNone(c.client)
         self.assertTrue(c.setup_done)
@@ -49,7 +49,7 @@ class NetworkCapacityTestCase(unittest.TestCase):
     def test_capacity_successful(self, mock_ssh):
         c = networkcapacity.NetworkCapacity({}, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, SAMPLE_OUTPUT, '')
         c.run(self.result)
         expected_result = jsonutils.loads(SAMPLE_OUTPUT)
         self.assertEqual(self.result, expected_result)
@@ -57,5 +57,5 @@ class NetworkCapacityTestCase(unittest.TestCase):
     def test_capacity_unsuccessful_script_error(self, mock_ssh):
         c = networkcapacity.NetworkCapacity({}, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, c.run, self.result)
diff --git a/tests/unit/benchmark/scenarios/networking/test_nstat.py b/tests/unit/benchmark/scenarios/networking/test_nstat.py
index 87a766302..131716727 100644
--- a/tests/unit/benchmark/scenarios/networking/test_nstat.py
+++ b/tests/unit/benchmark/scenarios/networking/test_nstat.py
@@ -36,7 +36,7 @@ class NstatTestCase(unittest.TestCase):
         n = nstat.Nstat({}, self.ctx)
         n.setup()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         self.assertIsNotNone(n.client)
         self.assertEqual(n.setup_done, True)
 
@@ -53,7 +53,7 @@ class NstatTestCase(unittest.TestCase):
 
         sample_output = '#kernel\nIpInReceives                    1837               0.0\nIpInHdrErrors                   0                  0.0\nIpInAddrErrors                  2                  0.0\nIcmpInMsgs                      319                  0.0\nIcmpInErrors                    0                0.0\nTcpInSegs                       36               0.0\nTcpInErrs                       0                  0.0\nUdpInDatagrams                  1318                  0.0\nUdpInErrors                     0                  0.0\n'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         n.run(result)
         expected_result = {"TcpInErrs": 0, "UdpInDatagrams": 1318,
@@ -81,7 +81,7 @@ class NstatTestCase(unittest.TestCase):
 
         sample_output = '#kernel\nIpInReceives                    1837               0.0\nIpInHdrErrors                   0                  0.0\nIpInAddrErrors                  2                  0.0\nIcmpInMsgs                      319                  0.0\nIcmpInErrors                    0                0.0\nTcpInSegs                       36               0.0\nTcpInErrs                       0                  0.0\nUdpInDatagrams                  1318                  0.0\nUdpInErrors                     0                  0.0\n'
 
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         n.run(result)
         expected_result = {"TcpInErrs": 0, "UdpInDatagrams": 1318,
@@ -107,7 +107,7 @@ class NstatTestCase(unittest.TestCase):
         n = nstat.Nstat(args, self.ctx)
         result = {}
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, n.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_ping.py b/tests/unit/benchmark/scenarios/networking/test_ping.py
index 5535a79a9..5269309c2 100644
--- a/tests/unit/benchmark/scenarios/networking/test_ping.py
+++ b/tests/unit/benchmark/scenarios/networking/test_ping.py
@@ -43,7 +43,7 @@ class PingTestCase(unittest.TestCase):
 
         p = ping.Ping(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, '100', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
         p.run(result)
         self.assertEqual(result, {'rtt': {'ares': 100.0}})
 
@@ -59,7 +59,7 @@ class PingTestCase(unittest.TestCase):
 
         p = ping.Ping(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, '100', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
         p.run(result)
         self.assertEqual(result, {'rtt': {'ares': 100.0}})
 
@@ -75,7 +75,7 @@ class PingTestCase(unittest.TestCase):
 
         p = ping.Ping(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, '100', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
         self.assertRaises(AssertionError, p.run, result)
 
     @mock.patch('yardstick.benchmark.scenarios.networking.ping.ssh')
@@ -90,7 +90,7 @@ class PingTestCase(unittest.TestCase):
 
         p = ping.Ping(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_ping6.py b/tests/unit/benchmark/scenarios/networking/test_ping6.py
index e22cacb36..ecce7cee5 100644
--- a/tests/unit/benchmark/scenarios/networking/test_ping6.py
+++ b/tests/unit/benchmark/scenarios/networking/test_ping6.py
@@ -56,7 +56,7 @@ class PingTestCase(unittest.TestCase):
             'sla': {'max_rtt': 50}
         }
         p = ping6.Ping6(args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '0', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '0', '')
         p.setup()
 
         self.assertEqual(p.setup_done, True)
@@ -70,8 +70,8 @@ class PingTestCase(unittest.TestCase):
         result = {}
 
         p = ping6.Ping6(args, self.ctx)
-        p.client = mock_ssh.SSH()
-        mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+        p.client = mock_ssh.SSH.from_node()
+        mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
         p.run(result)
         self.assertEqual(result, {'rtt': 100.0})
 
@@ -84,8 +84,8 @@ class PingTestCase(unittest.TestCase):
         result = {}
 
         p = ping6.Ping6(args, self.ctx)
-        p.client = mock_ssh.SSH()
-        mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+        p.client = mock_ssh.SSH.from_node()
+        mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
         p.run(result)
         self.assertEqual(result, {'rtt': 100.0})
 
@@ -98,8 +98,8 @@ class PingTestCase(unittest.TestCase):
         result = {}
 
         p = ping6.Ping6(args, self.ctx)
-        p.client = mock_ssh.SSH()
-        mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+        p.client = mock_ssh.SSH.from_node()
+        mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
         self.assertRaises(AssertionError, p.run, result)
 
     @mock.patch('yardstick.benchmark.scenarios.networking.ping6.ssh')
@@ -112,8 +112,8 @@ class PingTestCase(unittest.TestCase):
         result = {}
 
         p = ping6.Ping6(args, self.ctx)
-        p.client = mock_ssh.SSH()
-        mock_ssh.SSH().execute.side_effect = [
+        p.client = mock_ssh.SSH.from_node()
+        mock_ssh.SSH.from_node().execute.side_effect = [
             (0, 'host1', ''), (1, '', 'FOOBAR')]
         self.assertRaises(RuntimeError, p.run, result)
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_pktgen.py b/tests/unit/benchmark/scenarios/networking/test_pktgen.py
index 989c5b712..d4eb1246f 100644
--- a/tests/unit/benchmark/scenarios/networking/test_pktgen.py
+++ b/tests/unit/benchmark/scenarios/networking/test_pktgen.py
@@ -47,7 +47,7 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.setup()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         self.assertIsNotNone(p.server)
         self.assertIsNotNone(p.client)
         self.assertEqual(p.setup_done, True)
@@ -58,14 +58,14 @@ class PktgenTestCase(unittest.TestCase):
             'options': {'packetsize': 60, 'number_of_ports': 10},
         }
         p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p._iptables_setup()
 
-        mock_ssh.SSH().execute.assert_called_with(
+        mock_ssh.SSH.from_node().execute.assert_called_with(
             "sudo iptables -F; "
             "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
             % 1010)
@@ -77,10 +77,10 @@ class PktgenTestCase(unittest.TestCase):
         }
 
         p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p._iptables_setup)
 
     def test_pktgen_successful_iptables_get_result(self, mock_ssh):
@@ -90,13 +90,13 @@ class PktgenTestCase(unittest.TestCase):
         }
 
         p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH().execute.return_value = (0, '150000', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
         p._iptables_get_result()
 
-        mock_ssh.SSH().execute.assert_called_with(
+        mock_ssh.SSH.from_node().execute.assert_called_with(
             "sudo iptables -L INPUT -vnx |"
             "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
             % 1010)
@@ -109,10 +109,10 @@ class PktgenTestCase(unittest.TestCase):
 
         p = pktgen.Pktgen(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p._iptables_get_result)
 
     def test_pktgen_successful_no_sla(self, mock_ssh):
@@ -124,8 +124,8 @@ class PktgenTestCase(unittest.TestCase):
 
         p = pktgen.Pktgen(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
-        p.client = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
+        p.client = mock_ssh.SSH.from_node()
 
         mock_iptables_result = mock.Mock()
         mock_iptables_result.return_value = 149300
@@ -133,7 +133,7 @@ class PktgenTestCase(unittest.TestCase):
 
         sample_output = '{"packets_per_second": 9753, "errors": 0, \
             "packets_sent": 149776, "packetsize": 60, "flows": 110}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -150,8 +150,8 @@ class PktgenTestCase(unittest.TestCase):
 
         p = pktgen.Pktgen(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
-        p.client = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
+        p.client = mock_ssh.SSH.from_node()
 
         mock_iptables_result = mock.Mock()
         mock_iptables_result.return_value = 149300
@@ -159,7 +159,7 @@ class PktgenTestCase(unittest.TestCase):
 
         sample_output = '{"packets_per_second": 9753, "errors": 0, \
             "packets_sent": 149776, "packetsize": 60, "flows": 110}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
         expected_result = jsonutils.loads(sample_output)
@@ -176,8 +176,8 @@ class PktgenTestCase(unittest.TestCase):
 
         p = pktgen.Pktgen(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
-        p.client = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
+        p.client = mock_ssh.SSH.from_node()
 
         mock_iptables_result = mock.Mock()
         mock_iptables_result.return_value = 149300
@@ -185,7 +185,7 @@ class PktgenTestCase(unittest.TestCase):
 
         sample_output = '{"packets_per_second": 9753, "errors": 0, \
             "packets_sent": 149776, "packetsize": 60, "flows": 110}'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_pktgen_unsuccessful_script_error(self, mock_ssh):
@@ -198,10 +198,10 @@ class PktgenTestCase(unittest.TestCase):
 
         p = pktgen.Pktgen(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
-        p.client = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
+        p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py b/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
index 7ba4db9d9..496ee770c 100644
--- a/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
+++ b/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
@@ -45,7 +45,7 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
         p.setup()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         self.assertIsNotNone(p.server)
         self.assertIsNotNone(p.client)
         self.assertEqual(p.setup_done, True)
@@ -56,13 +56,13 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
             'options': {'packetsize': 60},
         }
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p.get_port_ip(p.server, "eth1")
 
-        mock_ssh.SSH().execute.assert_called_with(
+        mock_ssh.SSH.from_node().execute.assert_called_with(
             "ifconfig eth1 |grep 'inet addr' |awk '{print $2}' \
             |cut -d ':' -f2 ")
 
@@ -73,9 +73,9 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
         }
 
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.get_port_ip, p.server, "eth1")
 
     def test_pktgen_dpdk_successful_get_port_mac(self, mock_ssh):
@@ -84,13 +84,13 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
             'options': {'packetsize': 60},
         }
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
         p.get_port_mac(p.server, "eth1")
 
-        mock_ssh.SSH().execute.assert_called_with(
+        mock_ssh.SSH.from_node().execute.assert_called_with(
             "ifconfig |grep HWaddr |grep eth1 |awk '{print $5}' ")
 
     def test_pktgen_dpdk_unsuccessful_get_port_mac(self, mock_ssh):
@@ -100,9 +100,9 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
         }
 
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.get_port_mac, p.server, "eth1")
 
     def test_pktgen_dpdk_successful_no_sla(self, mock_ssh):
@@ -115,7 +115,7 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
 
         sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
         # with python 3 we get float, might be due python division changes
@@ -135,7 +135,7 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
 
         sample_output = '100\n100\n100\n100\n100\n100\n100\n100\n100\n100\n'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -151,11 +151,11 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
 
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
 
-        p.server = mock_ssh.SSH()
-        p.client = mock_ssh.SSH()
+        p.server = mock_ssh.SSH.from_node()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_pktgen_dpdk_unsuccessful_script_error(self, mock_ssh):
@@ -168,7 +168,7 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
 
         p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
 
diff --git a/tests/unit/benchmark/scenarios/networking/test_sfc.py b/tests/unit/benchmark/scenarios/networking/test_sfc.py
index 224a43bd8..78c0352dd 100644
--- a/tests/unit/benchmark/scenarios/networking/test_sfc.py
+++ b/tests/unit/benchmark/scenarios/networking/test_sfc.py
@@ -21,22 +21,22 @@ from yardstick.benchmark.scenarios.networking import sfc
 class SfcTestCase(unittest.TestCase):
 
     def setUp(self):
-        scenario_cfg = dict()
-        context_cfg = dict()
-
-        # Used in Sfc.setup()
-        context_cfg['target'] = dict()
-        context_cfg['target']['user'] = 'root'
-        context_cfg['target']['password'] = 'opnfv'
-        context_cfg['target']['ip'] = '127.0.0.1'
-
-        # Used in Sfc.run()
-        context_cfg['host'] = dict()
-        context_cfg['host']['user'] = 'root'
-        context_cfg['host']['password'] = 'opnfv'
-        context_cfg['host']['ip'] = None
-        context_cfg['target'] = dict()
-        context_cfg['target']['ip'] = '127.0.0.1'
+        scenario_cfg = {}
+        context_cfg = {
+            # Used in Sfc.setup()
+            'target': {
+                'user': 'root',
+                'password': 'opnfv',
+                'ip': '127.0.0.1',
+            },
+
+            # Used in Sfc.run()
+            'host': {
+                'user': 'root',
+                'password': 'opnfv',
+                'ip': None,
+            }
+        }
 
         self.sfc = sfc.Sfc(scenario_cfg=scenario_cfg, context_cfg=context_cfg)
 
@@ -45,7 +45,7 @@ class SfcTestCase(unittest.TestCase):
     @mock.patch('yardstick.benchmark.scenarios.networking.sfc.subprocess')
     def test_run_for_success(self, mock_subprocess, mock_openstack, mock_ssh):
         # Mock a successfull SSH in Sfc.setup() and Sfc.run()
-        mock_ssh.SSH().execute.return_value = (0, '100', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
         mock_openstack.get_an_IP.return_value = "127.0.0.1"
         mock_subprocess.call.return_value = 'mocked!'
 
@@ -59,7 +59,7 @@ class SfcTestCase(unittest.TestCase):
     @mock.patch('yardstick.benchmark.scenarios.networking.sfc.subprocess')
     def test2_run_for_success(self, mock_subprocess, mock_openstack, mock_ssh):
         # Mock a successfull SSH in Sfc.setup() and Sfc.run()
-        mock_ssh.SSH().execute.return_value = (
+        mock_ssh.SSH.from_node().execute.return_value = (
             0, 'vxlan_tool.py', 'succeeded timed out')
         mock_openstack.get_an_IP.return_value = "127.0.0.1"
         mock_subprocess.call.return_value = 'mocked!'
diff --git a/tests/unit/benchmark/scenarios/networking/test_vnf_generic.py b/tests/unit/benchmark/scenarios/networking/test_vnf_generic.py
index 1b02b6eff..4167d6f3b 100644
--- a/tests/unit/benchmark/scenarios/networking/test_vnf_generic.py
+++ b/tests/unit/benchmark/scenarios/networking/test_vnf_generic.py
@@ -316,7 +316,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
             for node, node_dict in self.context_cfg["nodes"].items():
                 with SshManager(node_dict) as conn:
                     self.assertIsNotNone(conn)
@@ -357,7 +357,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
             self.s.map_topology_to_infrastructure(self.context_cfg,
                                                   self.topology)
         self.assertEqual("tg_trex_tpl.yaml",
@@ -371,7 +371,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(1, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
 
             self.assertRaises(IncorrectSetup,
                               self.s.map_topology_to_infrastructure,
@@ -384,7 +384,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
 
             self.assertRaises(IncorrectConfig,
                               self.s.map_topology_to_infrastructure,
@@ -395,7 +395,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
 
             del self.context_cfg['nodes']
             self.assertRaises(IncorrectConfig, self.s._resolve_topology,
@@ -428,7 +428,7 @@ class TestNetworkServiceTestCase(unittest.TestCase):
             ssh_mock = mock.Mock(autospec=ssh.SSH)
             ssh_mock.execute = \
                 mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
-            ssh.return_value = ssh_mock
+            ssh.from_node.return_value = ssh_mock
 
             tgen = mock.Mock(autospec=GenericTrafficGen)
             tgen.traffic_finished = True
diff --git a/tests/unit/benchmark/scenarios/networking/test_vsperf.py b/tests/unit/benchmark/scenarios/networking/test_vsperf.py
index 76d2afdc0..348aa4a63 100644
--- a/tests/unit/benchmark/scenarios/networking/test_vsperf.py
+++ b/tests/unit/benchmark/scenarios/networking/test_vsperf.py
@@ -63,7 +63,7 @@ class VsperfTestCase(unittest.TestCase):
 
     def test_vsperf_setup(self, mock_ssh, mock_subprocess):
         p = vsperf.Vsperf(self.args, self.ctx)
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         mock_subprocess.call().execute.return_value = None
 
         p.setup()
@@ -74,7 +74,7 @@ class VsperfTestCase(unittest.TestCase):
         p = vsperf.Vsperf(self.args, self.ctx)
 
         # setup() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         mock_subprocess.call().execute.return_value = None
 
         p.setup()
@@ -88,12 +88,12 @@ class VsperfTestCase(unittest.TestCase):
         p = vsperf.Vsperf(self.args, self.ctx)
 
         # setup() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         mock_subprocess.call().execute.return_value = None
 
         # run() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        mock_ssh.SSH().execute.return_value = (
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (
             0, 'throughput_rx_fps\r\n14797660.000\r\n', '')
 
         result = {}
@@ -106,11 +106,11 @@ class VsperfTestCase(unittest.TestCase):
         p = vsperf.Vsperf(self.args, self.ctx)
 
         # setup() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         mock_subprocess.call().execute.return_value = None
 
         # run() specific mocks
-        mock_ssh.SSH().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 
         result = {}
         self.assertRaises(RuntimeError, p.run, result)
@@ -119,12 +119,12 @@ class VsperfTestCase(unittest.TestCase):
         p = vsperf.Vsperf(self.args, self.ctx)
 
         # setup() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         mock_subprocess.call().execute.return_value = None
 
         # run() specific mocks
-        mock_ssh.SSH().execute.return_value = (0, '', '')
-        mock_ssh.SSH().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 
         result = {}
         self.assertRaises(RuntimeError, p.run, result)
diff --git a/tests/unit/benchmark/scenarios/storage/test_fio.py b/tests/unit/benchmark/scenarios/storage/test_fio.py
index 603ff389e..55e443885 100644
--- a/tests/unit/benchmark/scenarios/storage/test_fio.py
+++ b/tests/unit/benchmark/scenarios/storage/test_fio.py
@@ -51,7 +51,7 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         p.setup()
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         self.assertIsNotNone(p.client)
         self.assertEqual(p.setup_done, True)
 
@@ -67,10 +67,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['rw'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -92,10 +92,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['read'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -116,10 +116,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['write'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -143,10 +143,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['rw'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -171,10 +171,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['rw'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_fio_successful_bw_iops_sla(self, mock_ssh):
@@ -192,10 +192,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['rw'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 
         p.run(result)
 
@@ -220,10 +220,10 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
         sample_output = self._read_sample_output(self.sample_output['rw'])
-        mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
         self.assertRaises(AssertionError, p.run, result)
 
     def test_fio_unsuccessful_script_error(self, mock_ssh):
@@ -238,9 +238,9 @@ class FioTestCase(unittest.TestCase):
         p = fio.Fio(args, self.ctx)
         result = {}
 
-        p.client = mock_ssh.SSH()
+        p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, p.run, result)
 
     def _read_sample_output(self, file_name):
diff --git a/tests/unit/benchmark/scenarios/storage/test_storagecapacity.py b/tests/unit/benchmark/scenarios/storage/test_storagecapacity.py
index 6fb5f5686..095674f72 100644
--- a/tests/unit/benchmark/scenarios/storage/test_storagecapacity.py
+++ b/tests/unit/benchmark/scenarios/storage/test_storagecapacity.py
@@ -50,7 +50,7 @@ class StorageCapacityTestCase(unittest.TestCase):
     def test_capacity_successful_setup(self, mock_ssh):
         c = storagecapacity.StorageCapacity(self.scn, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
         c.setup()
         self.assertIsNotNone(c.client)
         self.assertTrue(c.setup_done)
@@ -58,7 +58,7 @@ class StorageCapacityTestCase(unittest.TestCase):
     def test_capacity_disk_size_successful(self, mock_ssh):
         c = storagecapacity.StorageCapacity(self.scn, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, DISK_SIZE_SAMPLE_OUTPUT, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, DISK_SIZE_SAMPLE_OUTPUT, '')
         c.run(self.result)
         expected_result = jsonutils.loads(
             DISK_SIZE_SAMPLE_OUTPUT)
@@ -72,7 +72,7 @@ class StorageCapacityTestCase(unittest.TestCase):
         }
         c = storagecapacity.StorageCapacity(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, BLOCK_SIZE_SAMPLE_OUTPUT, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, BLOCK_SIZE_SAMPLE_OUTPUT, '')
         c.run(self.result)
         expected_result = jsonutils.loads(
             BLOCK_SIZE_SAMPLE_OUTPUT)
@@ -88,7 +88,7 @@ class StorageCapacityTestCase(unittest.TestCase):
         }
         c = storagecapacity.StorageCapacity(args, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (0, DISK_UTIL_RAW_OUTPUT, '')
+        mock_ssh.SSH.from_node().execute.return_value = (0, DISK_UTIL_RAW_OUTPUT, '')
         c.run(self.result)
         expected_result = jsonutils.loads(
             DISK_UTIL_SAMPLE_OUTPUT)
@@ -97,7 +97,7 @@ class StorageCapacityTestCase(unittest.TestCase):
     def test_capacity_unsuccessful_script_error(self, mock_ssh):
         c = storagecapacity.StorageCapacity(self.scn, self.ctx)
 
-        mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
         self.assertRaises(RuntimeError, c.run, self.result)