Merge "Refactor RFC2455 TRex traffic profile injection" into stable/fraser

8 files changed, 514 insertions, 672 deletions

diff --git a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
index 3d6fe183c..8f60a1054 100644
--- a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
+++ b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
@@ -493,5 +493,5 @@ class OvsDeployTestCase(unittest.TestCase):
                     'ovs_version': ovs_version,
                     'dpdk_version': dpdk_version,
                     'proxy': 'test_proxy'})
-            mock_execute.assert_called_with(cmd)
-            mock_env_get.assert_called_with('http_proxy', '')
+            mock_execute.assert_called_once_with(cmd)
+            mock_env_get.assert_has_calls([mock.call('http_proxy', '')])
diff --git a/yardstick/tests/unit/common/test_utils.py b/yardstick/tests/unit/common/test_utils.py
index 5fd91c87f..31b10e6da 100644
--- a/yardstick/tests/unit/common/test_utils.py
+++ b/yardstick/tests/unit/common/test_utils.py
@@ -1174,6 +1174,17 @@ class TimerTestCase(unittest.TestCase):
             with utils.Timer(timeout=1):
                 time.sleep(2)
 
+    def test__enter_with_timeout_no_exception(self):
+        with utils.Timer(timeout=1, raise_exception=False):
+            time.sleep(2)
+
+    def test__iter(self):
+        iterations = []
+        for i in utils.Timer(timeout=2):
+            iterations.append(i)
+            time.sleep(1.1)
+        self.assertEqual(2, len(iterations))
+
 
 class WaitUntilTrueTestCase(unittest.TestCase):
 
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_base.py b/yardstick/tests/unit/network_services/traffic_profile/test_base.py
index cf4888d82..55276af58 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_base.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_base.py
@@ -77,6 +77,12 @@ class TestDummyProfile(unittest.TestCase):
 class TrafficProfileConfigTestCase(unittest.TestCase):
 
     def test__init(self):
-        tp_config = {'traffic_profile': {'duration': 15}}
+        tp_config = {'traffic_profile': {'packet_sizes': {'64B': 100}}}
         tp_config_obj = base.TrafficProfileConfig(tp_config)
-        self.assertEqual(15, tp_config_obj.duration)
+        self.assertEqual({'64B': 100}, tp_config_obj.packet_sizes)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_SCHEMA,
+                         tp_config_obj.schema)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_FRAME_RATE,
+                         tp_config_obj.frame_rate)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_DURATION,
+                         tp_config_obj.duration)
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
index 2684e0ba1..0cf93f9ae 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
@@ -11,33 +11,26 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
-import unittest
 import mock
 
-from yardstick.tests import STL_MOCKS
-
+from trex_stl_lib import api as Pkt
+from trex_stl_lib import trex_stl_client
+from trex_stl_lib import trex_stl_packet_builder_scapy
+from trex_stl_lib import trex_stl_streams
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
+from yardstick.network_services.traffic_profile import rfc2544
+from yardstick.tests.unit import base
 
-if stl_patch:
-    from yardstick.network_services.traffic_profile.trex_traffic_profile \
-        import TrexProfile
-    from yardstick.network_services.traffic_profile.rfc2544 import \
-        RFC2544Profile
 
-
-class TestRFC2544Profile(unittest.TestCase):
+class TestRFC2544Profile(base.BaseUnitTestCase):
     TRAFFIC_PROFILE = {
         "schema": "isb:traffic_profile:0.1",
         "name": "fixed",
         "description": "Fixed traffic profile to run UDP traffic",
         "traffic_profile": {
             "traffic_type": "FixedTraffic",
-            "frame_rate": 100,  # pps
+            "frame_rate": 100,
             "flow_number": 10,
             "frame_size": 64}}
 
@@ -45,233 +38,251 @@ class TestRFC2544Profile(unittest.TestCase):
                'name': 'rfc2544',
                'traffic_profile': {'traffic_type': 'RFC2544Profile',
                                    'frame_rate': 100},
-               'downlink_0': {'ipv4':
-                              {'outer_l2': {'framesize':
-                                            {'64B': '100', '1518B': '0',
-                                             '128B': '0', '1400B': '0',
-                                             '256B': '0', '373b': '0',
-                                             '570B': '0'}},
-                               'outer_l3v4': {'dstip4': '1.1.1.1-1.15.255.255',
-                                              'proto': 'udp',
-                                              'srcip4': '90.90.1.1-90.105.255.255',
-                                              'dscp': 0, 'ttl': 32, 'count': 1},
-                               'outer_l4': {'srcport': '2001',
-                                            'dsrport': '1234', 'count': 1}}},
-               'uplink_0': {'ipv4':
-                            {'outer_l2': {'framesize':
-                                          {'64B': '100', '1518B': '0',
-                                           '128B': '0', '1400B': '0',
-                                           '256B': '0', '373b': '0',
-                                           '570B': '0'}},
-                             'outer_l3v4': {'dstip4': '9.9.1.1-90.105.255.255',
-                                            'proto': 'udp',
-                                            'srcip4': '1.1.1.1-1.15.255.255',
-                                            'dscp': 0, 'ttl': 32, 'count': 1},
-                             'outer_l4': {'dstport': '2001',
-                                          'srcport': '1234', 'count': 1}}},
+               'downlink_0':
+                   {'ipv4':
+                        {'outer_l2':
+                             {'framesize':
+                                  {'64B': '100', '1518B': '0',
+                                   '128B': '0', '1400B': '0',
+                                   '256B': '0', '373b': '0',
+                                   '570B': '0'}},
+                         'outer_l3v4':
+                             {'dstip4': '1.1.1.1-1.15.255.255',
+                              'proto': 'udp',
+                              'srcip4': '90.90.1.1-90.105.255.255',
+                              'dscp': 0, 'ttl': 32, 'count': 1},
+                         'outer_l4':
+                             {'srcport': '2001',
+                              'dsrport': '1234', 'count': 1}}},
+               'uplink_0':
+                   {'ipv4':
+                        {'outer_l2':
+                             {'framesize':
+                                  {'64B': '100', '1518B': '0',
+                                   '128B': '0', '1400B': '0',
+                                   '256B': '0', '373b': '0',
+                                   '570B': '0'}},
+                         'outer_l3v4':
+                             {'dstip4': '9.9.1.1-90.105.255.255',
+                              'proto': 'udp',
+                              'srcip4': '1.1.1.1-1.15.255.255',
+                              'dscp': 0, 'ttl': 32, 'count': 1},
+                         'outer_l4':
+                             {'dstport': '2001',
+                              'srcport': '1234', 'count': 1}}},
                'schema': 'isb:traffic_profile:0.1'}
 
     def test___init__(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        self.assertIsNotNone(r_f_c2544_profile.rate)
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        self.assertEqual(rfc2544_profile.max_rate, rfc2544_profile.rate)
+        self.assertEqual(0, rfc2544_profile.min_rate)
 
-    def test_execute(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client.return_value = True
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.first_run = True
-        self.assertIsNone(r_f_c2544_profile.execute_traffic(traffic_generator))
+    def test_stop_traffic(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        mock_generator = mock.Mock()
+        rfc2544_profile.stop_traffic(traffic_generator=mock_generator)
+        mock_generator.client.stop.assert_called_once()
+        mock_generator.client.reset.assert_called_once()
+        mock_generator.client.remove_all_streams.assert_called_once()
 
-    def test_get_drop_percentage(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client.return_value = True
+    def test_execute_traffic(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        mock_generator = mock.Mock()
+        mock_generator.networks = {
+            'downlink_0': ['xe0', 'xe1'],
+            'uplink_0': ['xe2', 'xe3'],
+            'downlink_1': []}
+        mock_generator.port_num.side_effect = [10, 20, 30, 40]
+        mock_generator.rfc2544_helper.correlated_traffic = False
+        rfc2544_profile.params = {
+            'downlink_0': 'profile1',
+            'uplink_0': 'profile2'}
 
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.register_generator(traffic_generator)
-        self.assertIsNone(r_f_c2544_profile.execute_traffic(traffic_generator))
+        with mock.patch.object(rfc2544_profile, '_create_profile') as \
+                mock_create_profile:
+            rfc2544_profile.execute_traffic(traffic_generator=mock_generator)
+        mock_create_profile.assert_has_calls([
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY)])
+        mock_generator.client.add_streams.assert_has_calls([
+            mock.call(mock.ANY, ports=[10]),
+            mock.call(mock.ANY, ports=[20]),
+            mock.call(mock.ANY, ports=[30]),
+            mock.call(mock.ANY, ports=[40])])
+        mock_generator.client.start(ports=[10, 20, 30, 40],
+                                    duration=rfc2544_profile.config.duration,
+                                    force=True)
 
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {
-                "rx_throughput_fps": 20,
-                "tx_throughput_fps": 20,
-                "rx_throughput_mbps": 10,
-                "tx_throughput_mbps": 10,
-                "in_packets": 1000,
-                "out_packets": 1000,
-            }
+    @mock.patch.object(trex_stl_streams, 'STLProfile')
+    def test__create_profile(self, mock_stl_profile):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        port_pg_id = mock.ANY
+        profile_data = {'packetid_1': {'outer_l2': {'framesize': 'imix_info'}}}
+        rate = 100
+        with mock.patch.object(rfc2544_profile, '_create_imix_data') as \
+                mock_create_imix, \
+                mock.patch.object(rfc2544_profile, '_create_vm') as \
+                mock_create_vm, \
+                mock.patch.object(rfc2544_profile, '_create_streams') as \
+                mock_create_streams:
+            mock_create_imix.return_value = 'imix_data'
+            mock_create_streams.return_value = ['stream1']
+            rfc2544_profile._create_profile(profile_data, rate, port_pg_id)
 
-        expected = {
-            'DropPercentage': 0.0,
-            'RxThroughput': 100 / 3.0,
-            'TxThroughput': 100 / 3.0,
-            'CurrentDropPercentage': 0.0,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20,
-                'in_packets': 1000,
-                'out_packets': 1000,
-                'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10,
-                'rx_throughput_fps': 20,
-            },
-        }
-        traffic_generator.generate_samples.return_value = samples
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        result = r_f_c2544_profile.get_drop_percentage(traffic_generator)
-        self.assertDictEqual(result, expected)
+        mock_create_imix.assert_called_once_with('imix_info')
+        mock_create_vm.assert_called_once_with(
+            {'outer_l2': {'framesize': 'imix_info'}})
+        mock_create_streams.assert_called_once_with('imix_data', 100,
+                                                    port_pg_id)
+        mock_stl_profile.assert_called_once_with(['stream1'])
 
-    def test_get_drop_percentage_update(self):
-        traffic_generator = mock.Mock(autospec=RFC2544Profile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client = mock.Mock(return_value=True)
+    def test__create_imix_data(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        data = {'64B': 50, '128B': 50}
+        self.assertEqual({'64': 50.0, '128': 50.0},
+                         rfc2544_profile._create_imix_data(data))
+        data = {'64B': 1, '128b': 3}
+        self.assertEqual({'64': 25.0, '128': 75.0},
+                         rfc2544_profile._create_imix_data(data))
+        data = {}
+        self.assertEqual({}, rfc2544_profile._create_imix_data(data))
 
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.register_generator(traffic_generator)
-        self.assertIsNone(r_f_c2544_profile.execute_traffic())
+    def test__create_vm(self):
+        packet = {'outer_l2': 'l2_definition'}
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        with mock.patch.object(rfc2544_profile, '_set_outer_l2_fields') as \
+                mock_l2_fileds:
+            rfc2544_profile._create_vm(packet)
+        mock_l2_fileds.assert_called_once_with('l2_definition')
 
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {
-                "rx_throughput_fps": 20,
-                "tx_throughput_fps": 20,
-                "rx_throughput_mbps": 10,
-                "tx_throughput_mbps": 10,
-                "in_packets": 1000,
-                "out_packets": 1002,
-            }
-        expected = {
-            'DropPercentage': 0.1996,
-            'RxThroughput': 33.333333333333336,
-            'TxThroughput': 33.4,
-            'CurrentDropPercentage': 0.1996,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20,
-                'in_packets': 1000,
-                'out_packets': 1002,
-                'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10,
-                'rx_throughput_fps': 20,
-            },
-        }
-        traffic_generator.generate_samples = mock.MagicMock(
-            return_value=samples)
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        result = r_f_c2544_profile.get_drop_percentage(traffic_generator)
-        self.assertDictEqual(expected, result)
+    @mock.patch.object(trex_stl_packet_builder_scapy, 'STLPktBuilder',
+                       return_value='packet')
+    def test__create_single_packet(self, mock_pktbuilder):
+        size = 128
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        rfc2544_profile.ether_packet = Pkt.Eth()
+        rfc2544_profile.ip_packet = Pkt.IP()
+        rfc2544_profile.udp_packet = Pkt.UDP()
+        rfc2544_profile.trex_vm = 'trex_vm'
+        base_pkt = (rfc2544_profile.ether_packet / rfc2544_profile.ip_packet /
+                    rfc2544_profile.udp_packet)
+        pad = (size - len(base_pkt)) * 'x'
+        output = rfc2544_profile._create_single_packet(size=size)
+        mock_pktbuilder.assert_called_once_with(pkt=base_pkt / pad,
+                                                vm='trex_vm')
+        self.assertEqual(output, 'packet')
 
-    def test_get_drop_percentage_div_zero(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client = \
-            mock.Mock(return_value=True)
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        self.assertIsNone(
-            r_f_c2544_profile.execute_traffic(traffic_generator))
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {"rx_throughput_fps": 20,
-                             "tx_throughput_fps": 20,
-                             "rx_throughput_mbps": 10,
-                             "tx_throughput_mbps": 10,
-                             "in_packets": 1000,
-                             "out_packets": 0}
-        r_f_c2544_profile.throughput_max = 0
-        expected = {
-            'DropPercentage': 100.0, 'RxThroughput': 100 / 3.0,
-            'TxThroughput': 0.0, 'CurrentDropPercentage': 100.0,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20, 'in_packets': 1000,
-                'out_packets': 0, 'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10, 'rx_throughput_fps': 20
-            }
-        }
-        traffic_generator.generate_samples = mock.Mock(return_value=samples)
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        self.assertDictEqual(expected,
-                             r_f_c2544_profile.get_drop_percentage(traffic_generator))
+    @mock.patch.object(trex_stl_packet_builder_scapy, 'STLPktBuilder',
+                       return_value='packet')
+    def test__create_single_packet_qinq(self, mock_pktbuilder):
+        size = 128
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        rfc2544_profile.ether_packet = Pkt.Eth()
+        rfc2544_profile.ip_packet = Pkt.IP()
+        rfc2544_profile.udp_packet = Pkt.UDP()
+        rfc2544_profile.trex_vm = 'trex_vm'
+        rfc2544_profile.qinq = True
+        rfc2544_profile.qinq_packet = Pkt.Dot1Q(vlan=1) / Pkt.Dot1Q(vlan=2)
+        base_pkt = (rfc2544_profile.ether_packet /
+                    rfc2544_profile.qinq_packet / rfc2544_profile.ip_packet /
+                    rfc2544_profile.udp_packet)
+        pad = (size - len(base_pkt)) * 'x'
+        output = rfc2544_profile._create_single_packet(size=size)
+        mock_pktbuilder.assert_called_once_with(pkt=base_pkt / pad,
+                                                vm='trex_vm')
+        self.assertEqual(output, 'packet')
+
+    @mock.patch.object(trex_stl_streams, 'STLFlowLatencyStats')
+    @mock.patch.object(trex_stl_streams, 'STLTXCont')
+    @mock.patch.object(trex_stl_client, 'STLStream')
+    def test__create_streams(self, mock_stream, mock_txcont, mock_latency):
+        imix_data = {'64': 25, '512': 75}
+        rate = 35
+        port_pg_id = rfc2544.PortPgIDMap()
+        port_pg_id.add_port(10)
+        mock_stream.side_effect = ['stream1', 'stream2']
+        mock_txcont.side_effect = ['txcont1', 'txcont2']
+        mock_latency.side_effect = ['latency1', 'latency2']
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        with mock.patch.object(rfc2544_profile, '_create_single_packet'):
+            output = rfc2544_profile._create_streams(imix_data, rate,
+                                                     port_pg_id)
+        self.assertEqual(['stream1', 'stream2'], output)
+        mock_latency.assert_has_calls([
+            mock.call(pg_id=1), mock.call(pg_id=2)])
+        mock_txcont.assert_has_calls([
+            mock.call(percentage=float(25 * 35) / 100),
+            mock.call(percentage=float(75 * 35) / 100)], any_order=True)
+
+    def test_get_drop_percentage(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        samples = [
+            {'xe1': {'tx_throughput_fps': 100,
+                     'rx_throughput_fps': 101,
+                     'out_packets': 2000,
+                     'in_packets': 2010},
+             'xe2': {'tx_throughput_fps': 200,
+                     'rx_throughput_fps': 201,
+                     'out_packets': 4000,
+                     'in_packets': 4010}},
+            {'xe1': {'tx_throughput_fps': 106,
+                     'rx_throughput_fps': 108,
+                     'out_packets': 2031,
+                     'in_packets': 2040,
+                     'latency': 'Latency1'},
+             'xe2': {'tx_throughput_fps': 203,
+                     'rx_throughput_fps': 215,
+                     'out_packets': 4025,
+                     'in_packets': 4040,
+                     'latency': 'Latency2'}}
+        ]
+        output = rfc2544_profile.get_drop_percentage(samples, 0, 0, False)
+        expected = {'DropPercentage': 0.3963,
+                    'Latency': {'xe1': 'Latency1', 'xe2': 'Latency2'},
+                    'RxThroughput': 312.5,
+                    'TxThroughput': 304.5,
+                    'CurrentDropPercentage': 0.3963,
+                    'Rate': 100,
+                    'Throughput': 312.5}
+        self.assertEqual(expected, output)
 
-    def test_get_multiplier(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.max_rate = 100
-        r_f_c2544_profile.min_rate = 100
-        self.assertEqual("1.0", r_f_c2544_profile.get_multiplier())
 
-    def test_calculate_pps(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.rate = 100
-        r_f_c2544_profile.pps = 100
-        samples = {'Throughput': 4549093.33}
-        self.assertEqual((2274546.67, 1.0),
-                         r_f_c2544_profile.calculate_pps(samples))
+class PortPgIDMapTestCase(base.BaseUnitTestCase):
 
-    def test_create_single_stream(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile._create_single_packet = mock.MagicMock()
-        r_f_c2544_profile.pg_id = 1
-        self.assertIsNotNone(
-            r_f_c2544_profile.create_single_stream(64, 2274546.67))
+    def test_add_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        self.assertEqual(10, port_pg_id_map._last_port)
+        self.assertEqual([], port_pg_id_map._port_pg_id_map[10])
 
-    def test_create_single_stream_no_pg_id(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile._create_single_packet = mock.MagicMock()
-        r_f_c2544_profile.pg_id = 0
-        self.assertIsNotNone(
-            r_f_c2544_profile.create_single_stream(64, 2274546.67))
+    def test_get_pg_ids(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        port_pg_id_map.increase_pg_id()
+        port_pg_id_map.increase_pg_id()
+        port_pg_id_map.add_port(20)
+        port_pg_id_map.increase_pg_id()
+        self.assertEqual([1, 2], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual([3], port_pg_id_map.get_pg_ids(20))
 
-    def test_execute_latency(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "private_0": ["xe0"],
-            "public_0": ["xe1"],
-        }
-        traffic_generator.client = \
-            mock.Mock(return_value=True)
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.first_run = True
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {"rx_throughput_fps": 20,
-                             "tx_throughput_fps": 20,
-                             "rx_throughput_mbps": 10,
-                             "tx_throughput_mbps": 10,
-                             "in_packets": 1000,
-                             "out_packets": 0}
+    def test_increase_pg_id_no_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        self.assertIsNone(port_pg_id_map.increase_pg_id())
 
-        samples['Throughput'] = 4549093.33
-        r_f_c2544_profile.calculate_pps = mock.Mock(return_value=[2274546.67,
-                                                                  1.0])
+    def test_increase_pg_id_last_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        self.assertEqual(1, port_pg_id_map.increase_pg_id())
+        self.assertEqual([1], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual(10, port_pg_id_map._last_port)
 
-        self.assertIsNone(r_f_c2544_profile.execute_latency(traffic_generator,
-                                                            samples))
+    def test_increase_pg_id(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        port_pg_id_map.increase_pg_id()
+        self.assertEqual(2, port_pg_id_map.increase_pg_id(port=20))
+        self.assertEqual([1], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual([2], port_pg_id_map.get_pg_ids(20))
+        self.assertEqual(20, port_pg_id_map._last_port)
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py b/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
index bc83224d5..628e85459 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
@@ -14,29 +14,12 @@
 
 import ipaddress
 
-import mock
 import six
 import unittest
 
-from yardstick.tests import STL_MOCKS
 from yardstick.common import exceptions as y_exc
-
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import TrexProfile
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import SRC
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import DST
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import ETHERNET
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import IP
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import IPv6
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import UDP
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import SRC_PORT
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import DST_PORT
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import TYPE_OF_SERVICE
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.traffic_profile import trex_traffic_profile
 
 
 class TestTrexProfile(unittest.TestCase):
@@ -59,7 +42,7 @@ class TestTrexProfile(unittest.TestCase):
         'name': 'rfc2544',
         'traffic_profile': {'traffic_type': 'RFC2544Profile',
                             'frame_rate': 100},
-        TrafficProfile.DOWNLINK: {
+        tp_base.TrafficProfile.DOWNLINK: {
             'ipv4': {'outer_l2': {'framesize': {'64B': '100',
                                                 '1518B': '0',
                                                 '128B': '0',
@@ -77,7 +60,7 @@ class TestTrexProfile(unittest.TestCase):
                      'outer_l4': {'srcport': '2001',
                                   'dsrport': '1234',
                                   'count': 1}}},
-        TrafficProfile.UPLINK: {
+        tp_base.TrafficProfile.UPLINK: {
             'ipv4':
                 {'outer_l2': {'framesize':
                                   {'64B': '100', '1518B': '0',
@@ -99,7 +82,7 @@ class TestTrexProfile(unittest.TestCase):
         'name': 'rfc2544',
         'traffic_profile': {'traffic_type': 'RFC2544Profile',
                             'frame_rate': 100},
-        TrafficProfile.DOWNLINK: {
+        tp_base.TrafficProfile.DOWNLINK: {
             'ipv6': {'outer_l2': {'framesize':
                                       {'64B': '100', '1518B': '0',
                                        '128B': '0', '1400B': '0',
@@ -118,7 +101,7 @@ class TestTrexProfile(unittest.TestCase):
                      'outer_l4': {'srcport': '2001',
                                   'dsrport': '1234',
                                   'count': 1}}},
-        TrafficProfile.UPLINK: {
+        tp_base.TrafficProfile.UPLINK: {
             'ipv6': {'outer_l2': {'framesize':
                                       {'64B': '100', '1518B': '0',
                                        '128B': '0', '1400B': '0',
@@ -139,66 +122,56 @@ class TestTrexProfile(unittest.TestCase):
                                   'count': 1}}},
         'schema': 'isb:traffic_profile:0.1'}
 
-    def setUp(self):
-        self.trex_profile = TrexProfile(self.PROFILE)
-
     def test___init__(self):
-        self.assertEqual(self.trex_profile.pps, 100)
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        self.assertEqual(trex_profile.pps, 100)
 
     def test_qinq(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         qinq = {"S-VLAN": {"id": 128, "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": 512, "priority": 0, "cfi": 0}}
 
-        self.assertIsNone(self.trex_profile.set_qinq(qinq))
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        self.assertIsNone(trex_profile.set_qinq(qinq))
 
         qinq = {"S-VLAN": {"id": "128-130", "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": "512-515", "priority": 0, "cfi": 0}}
-        self.assertIsNone(self.trex_profile.set_qinq(qinq))
+        self.assertIsNone(trex_profile.set_qinq(qinq))
 
     def test__set_outer_l2_fields(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         qinq = {"S-VLAN": {"id": 128, "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": 512, "priority": 0, "cfi": 0}}
-        outer_l2 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l2']
+        outer_l2 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l2']
         outer_l2['QinQ'] = qinq
-        self.assertIsNone(self.trex_profile._set_outer_l2_fields(outer_l2))
+        self.assertIsNone(trex_profile._set_outer_l2_fields(outer_l2))
 
     def test__set_outer_l3v4_fields(self):
-        outer_l3v4 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l3v4']
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l3v4 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l3v4']
         outer_l3v4['proto'] = 'tcp'
-        self.assertIsNone(self.trex_profile._set_outer_l3v4_fields(outer_l3v4))
+        self.assertIsNone(trex_profile._set_outer_l3v4_fields(outer_l3v4))
 
     def test__set_outer_l3v6_fields(self):
-        outer_l3v6 = self.PROFILE_v6[TrafficProfile.UPLINK]['ipv6']['outer_l3v4']
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l3v6 = self.PROFILE_v6[
+            tp_base.TrafficProfile.UPLINK]['ipv6']['outer_l3v4']
         outer_l3v6['proto'] = 'tcp'
         outer_l3v6['tc'] = 1
         outer_l3v6['hlim'] = 10
-        self.assertIsNone(self.trex_profile._set_outer_l3v6_fields(outer_l3v6))
+        self.assertIsNone(trex_profile._set_outer_l3v6_fields(outer_l3v6))
 
     def test__set_outer_l4_fields(self):
-        outer_l4 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l4']
-        self.assertIsNone(self.trex_profile._set_outer_l4_fields(outer_l4))
-
-    def test_get_streams(self):
-        profile_data = self.PROFILE[TrafficProfile.UPLINK]
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.pg_id = 1
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.params = self.PROFILE_v6
-        self.trex_profile.profile_data = self.PROFILE_v6[TrafficProfile.UPLINK]
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.pg_id = 1
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-
-    def test_generate_packets(self):
-        self.trex_profile.fsize = 10
-        self.trex_profile.base_pkt = [10]
-        self.assertIsNone(self.trex_profile.generate_packets())
-
-    def test_generate_imix_data_error(self):
-        self.assertEqual({}, self.trex_profile.generate_imix_data(False))
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l4 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l4']
+        self.assertIsNone(trex_profile._set_outer_l4_fields(outer_l4))
 
     def test__count_ip_ipv4(self):
-        start, end, count = TrexProfile._count_ip('1.1.1.1', '1.2.3.4')
+        start, end, count = trex_traffic_profile.TrexProfile._count_ip(
+            '1.1.1.1', '1.2.3.4')
         self.assertEqual('1.1.1.1', str(start))
         self.assertEqual('1.2.3.4', str(end))
         diff = (int(ipaddress.IPv4Address(six.u('1.2.3.4'))) -
@@ -208,7 +181,8 @@ class TestTrexProfile(unittest.TestCase):
     def test__count_ip_ipv6(self):
         start_ip = '0064:ff9b:0:0:0:0:9810:6414'
         end_ip = '0064:ff9b:0:0:0:0:9810:6420'
-        start, end, count = TrexProfile._count_ip(start_ip, end_ip)
+        start, end, count = trex_traffic_profile.TrexProfile._count_ip(
+            start_ip, end_ip)
         self.assertEqual(0x98106414, start)
         self.assertEqual(0x98106420, end)
         self.assertEqual(0x98106420 - 0x98106414, count)
@@ -217,10 +191,10 @@ class TestTrexProfile(unittest.TestCase):
         start_ip = '0064:ff9b:0:0:0:0:9810:6420'
         end_ip = '0064:ff9b:0:0:0:0:9810:6414'
         with self.assertRaises(y_exc.IPv6RangeError):
-            TrexProfile._count_ip(start_ip, end_ip)
+            trex_traffic_profile.TrexProfile._count_ip(start_ip, end_ip)
 
     def test__dscp_range_action_partial_actual_count_zero(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         dscp_partial = traffic_profile._dscp_range_action_partial()
 
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
@@ -228,7 +202,7 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__dscp_range_action_partial_count_greater_than_actual(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         dscp_partial = traffic_profile._dscp_range_action_partial()
 
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
@@ -236,7 +210,7 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__udp_range_action_partial_actual_count_zero(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         traffic_profile.udp['field1'] = 'value1'
         udp_partial = traffic_profile._udp_range_action_partial('field1')
 
@@ -245,46 +219,59 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__udp_range_action_partial_count_greater_than_actual(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         traffic_profile.udp['field1'] = 'value1'
-        udp_partial = traffic_profile._udp_range_action_partial('field1', 'not_used_count')
-
+        udp_partial = traffic_profile._udp_range_action_partial(
+            'field1', 'not_used_count')
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
         udp_partial('1', '10', '100')
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__general_single_action_partial(self):
-        self.trex_profile._general_single_action_partial(ETHERNET)(SRC)(
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        trex_profile._general_single_action_partial(
+            trex_traffic_profile.ETHERNET)(trex_traffic_profile.SRC)(
             self.EXAMPLE_ETHERNET_ADDR)
         self.assertEqual(self.EXAMPLE_ETHERNET_ADDR,
-                         self.trex_profile.ether_packet.src)
+                         trex_profile.ether_packet.src)
 
-        self.trex_profile._general_single_action_partial(IP)(DST)(
-            self.EXAMPLE_IP_ADDR)
-        self.assertEqual(self.EXAMPLE_IP_ADDR, self.trex_profile.ip_packet.dst)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IP)(
+            trex_traffic_profile.DST)(self.EXAMPLE_IP_ADDR)
+        self.assertEqual(self.EXAMPLE_IP_ADDR, trex_profile.ip_packet.dst)
 
-        self.trex_profile._general_single_action_partial(IPv6)(DST)(
-            self.EXAMPLE_IPv6_ADDR)
-        self.assertEqual(self.EXAMPLE_IPv6_ADDR,
-                         self.trex_profile.ip6_packet.dst)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IPv6)(
+            trex_traffic_profile.DST)(self.EXAMPLE_IPv6_ADDR)
+        self.assertEqual(self.EXAMPLE_IPv6_ADDR, trex_profile.ip6_packet.dst)
 
-        self.trex_profile._general_single_action_partial(UDP)(SRC_PORT)(5060)
-        self.assertEqual(5060, self.trex_profile.udp_packet.sport)
+        trex_profile._general_single_action_partial(trex_traffic_profile.UDP)(
+            trex_traffic_profile.SRC_PORT)(5060)
+        self.assertEqual(5060, trex_profile.udp_packet.sport)
 
-        self.trex_profile._general_single_action_partial(
-            IP)(TYPE_OF_SERVICE)(0)
-        self.assertEqual(0, self.trex_profile.ip_packet.tos)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IP)(
+            trex_traffic_profile.TYPE_OF_SERVICE)(0)
+        self.assertEqual(0, trex_profile.ip_packet.tos)
 
     def test__set_proto_addr(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+
         ether_range = "00:00:00:00:00:01-00:00:00:00:00:02"
         ip_range = "1.1.1.2-1.1.1.10"
         ipv6_range = '0064:ff9b:0:0:0:0:9810:6414-0064:ff9b:0:0:0:0:9810:6420'
 
-        self.trex_profile._set_proto_addr(ETHERNET, SRC, ether_range)
-        self.trex_profile._set_proto_addr(ETHERNET, DST, ether_range)
-        self.trex_profile._set_proto_addr(IP, SRC, ip_range)
-        self.trex_profile._set_proto_addr(IP, DST, ip_range)
-        self.trex_profile._set_proto_addr(IPv6, SRC, ipv6_range)
-        self.trex_profile._set_proto_addr(IPv6, DST, ipv6_range)
-        self.trex_profile._set_proto_addr(UDP, SRC_PORT, '5060-5090')
-        self.trex_profile._set_proto_addr(UDP, DST_PORT, '5060')
+        trex_profile._set_proto_addr(trex_traffic_profile.ETHERNET,
+                                     trex_traffic_profile.SRC, ether_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.ETHERNET,
+                                     trex_traffic_profile.DST, ether_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IP,
+                                     trex_traffic_profile.SRC, ip_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IP,
+                                     trex_traffic_profile.DST, ip_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IPv6,
+                                     trex_traffic_profile.SRC, ipv6_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IPv6,
+                                     trex_traffic_profile.DST, ipv6_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.UDP,
+                                     trex_traffic_profile.SRC_PORT,
+                                     '5060-5090')
+        trex_profile._set_proto_addr(trex_traffic_profile.UDP,
+                                     trex_traffic_profile.DST_PORT, '5060')
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
index 01d79303c..45e06689b 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
 from copy import deepcopy
 
@@ -19,37 +18,29 @@ import unittest
 import mock
 import six
 
-from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base import mock_ssh
-from yardstick.tests import STL_MOCKS
 from yardstick.benchmark.contexts.base import Context
 from yardstick.common import exceptions as y_exceptions
 from yardstick.common import utils
 from yardstick.network_services.nfvi.resource import ResourceProfile
 from yardstick.network_services.vnf_generic.vnf.base import VnfdHelper
-
-
-class MockError(BaseException):
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf.vnf_ssh_helper import VnfSshHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFDeployHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SetupEnvHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNF
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import DpdkVnfSetupEnvHelper
+from yardstick.tests.unit.network_services.vnf_generic.vnf import test_base
+
+
+class MockError(Exception):
     pass
 
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf import sample_vnf
-    from yardstick.network_services.vnf_generic.vnf.vnf_ssh_helper import VnfSshHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFDeployHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SetupEnvHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNF
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import DpdkVnfSetupEnvHelper
-
-
 class TestVnfSshHelper(unittest.TestCase):
 
     VNFD_0 = {
@@ -1003,176 +994,39 @@ class TestClientResourceHelper(unittest.TestCase):
     }
 
     @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.LOG')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.STLError',
-                new_callable=lambda: MockError)
-    def test_get_stats_not_connected(self, mock_state_error, *args):
+    @mock.patch.object(sample_vnf, 'STLError', new_callable=lambda: MockError)
+    def test_get_stats_not_connected(self, mock_stl_error, *args):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.side_effect = mock_state_error
+        client_resource_helper.client = mock.Mock()
+        client_resource_helper.client.get_stats.side_effect = mock_stl_error
 
         self.assertEqual(client_resource_helper.get_stats(), {})
         self.assertEqual(client_resource_helper.client.get_stats.call_count, 1)
 
-    def test_generate_samples(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports)
-        self.assertDictEqual(result, expected)
-
-    def test_generate_samples_with_key(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            'key_name': 'key_value',
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                'key_name': 'key_value',
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                'key_name': 'key_value',
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports, 'key_name')
-        self.assertDictEqual(result, expected)
-
-    def test_generate_samples_with_key_and_default(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                'key_name': 'default',
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                'key_name': 'default',
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports, 'key_name', 'default')
-        self.assertDictEqual(result, expected)
-
     def test_clear_stats(self):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
         self.assertIsNone(client_resource_helper.clear_stats())
-        self.assertEqual(client_resource_helper.client.clear_stats.call_count, 1)
+        self.assertEqual(
+            client_resource_helper.client.clear_stats.call_count, 1)
 
     def test_clear_stats_of_ports(self):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
@@ -1183,7 +1037,8 @@ class TestClientResourceHelper(unittest.TestCase):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
@@ -1194,7 +1049,8 @@ class TestClientResourceHelper(unittest.TestCase):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
@@ -1221,17 +1077,15 @@ class TestClientResourceHelper(unittest.TestCase):
         self.assertDictEqual(result, expected)
 
     @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.time')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.LOG')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.STLError',
-                new_callable=lambda: MockError)
-    def test__connect_with_failures(self, mock_error, *args):
+    @mock.patch.object(sample_vnf, 'STLError')
+    def test__connect_with_failures(self, mock_stl_error, *args):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
         dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client = mock.MagicMock()
-        client.connect.side_effect = mock_error
+        client.connect.side_effect = mock_stl_error(msg='msg')
 
         self.assertIs(client_resource_helper._connect(client), client)
 
@@ -1680,7 +1534,7 @@ class TestSampleVnf(unittest.TestCase):
 
     @mock.patch("yardstick.ssh.SSH")
     def test_instantiate(self, ssh):
-        mock_ssh(ssh)
+        test_base.mock_ssh(ssh)
 
         nodes = {
             'vnf1': 'name1',
@@ -1780,7 +1634,7 @@ class TestSampleVnf(unittest.TestCase):
     @mock.patch("yardstick.network_services.vnf_generic.vnf.sample_vnf.time")
     @mock.patch("yardstick.ssh.SSH")
     def test_wait_for_instantiate_empty_queue(self, ssh, *args):
-        mock_ssh(ssh, exec_result=(1, "", ""))
+        test_base.mock_ssh(ssh, exec_result=(1, "", ""))
 
         queue_size_list = [
             0,
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
index 8b1b8a39c..a463fa0de 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
@@ -11,44 +11,39 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
-
-import unittest
-import mock
-
-from yardstick.tests import STL_MOCKS
-SSH_HELPER = 'yardstick.network_services.vnf_generic.vnf.sample_vnf.VnfSshHelper'
 
+from __future__ import absolute_import
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex import TrexTrafficGenRFC, \
-        TrexRfcResourceHelper
-    from yardstick.network_services.vnf_generic.vnf import tg_rfc2544_trex
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-    from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base \
-        import FileAbsPath, mock_ssh
+import mock
+import unittest
 
-MODULE_PATH = FileAbsPath(__file__)
-get_file_abspath = MODULE_PATH.get_path
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf import tg_rfc2544_trex
 
 
 class TestTrexRfcResouceHelper(unittest.TestCase):
 
-    @mock.patch('yardstick.network_services.helpers.samplevnf_helper.MultiPortConfig')
-    @mock.patch("yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex.time")
-    @mock.patch(SSH_HELPER)
-    def test__run_traffic_once(self, ssh, *_):
-        mock_ssh(ssh)
+    def test__run_traffic_once(self):
+        mock_setup_helper = mock.Mock()
+        mock_traffic_profile = mock.Mock()
+        mock_traffic_profile.config.duration = 3
+        mock_traffic_profile.execute_traffic.return_value = ('fake_ports',
+                                                             'port_pg_id_map')
+        mock_traffic_profile.get_drop_percentage.return_value = 'percentage'
+        rfc_rh = tg_rfc2544_trex.TrexRfcResourceHelper(mock_setup_helper)
+        rfc_rh.TRANSIENT_PERIOD = 0
+        rfc_rh.rfc2544_helper = mock.Mock()
+
+        with mock.patch.object(rfc_rh, '_get_samples') as mock_get_samples:
+            rfc_rh._run_traffic_once(mock_traffic_profile)
 
-        mock_traffic_profile = mock.MagicMock(autospec=TrafficProfile,
-                                              **{'get_drop_percentage.return_value': {}})
-        sut = TrexRfcResourceHelper(mock.MagicMock(), mock.MagicMock())
-        sut.client = mock.MagicMock()
-        sut._run_traffic_once(mock_traffic_profile)
+        mock_traffic_profile.execute_traffic.assert_called_once_with(rfc_rh)
+        mock_traffic_profile.stop_traffic.assert_called_once_with(rfc_rh)
+        mock_traffic_profile.stop_traffic.assert_called_once()
+        mock_get_samples.assert_has_calls([
+            mock.call('fake_ports', port_pg_id='port_pg_id_map'),
+            mock.call('fake_ports', port_pg_id='port_pg_id_map')])
 
 
 class TestTrexTrafficGenRFC(unittest.TestCase):
@@ -219,33 +214,24 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
         'schema': 'yardstick:task:0.1',
     }
 
-    @mock.patch(SSH_HELPER)
-    def test___init__(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertIsNotNone(trex_traffic_gen.resource_helper._terminated.value)
-
-    @mock.patch(SSH_HELPER)
-    def test_collect_kpi(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertEqual(trex_traffic_gen.collect_kpi(), {})
+    def setUp(self):
+        self._mock_ssh_helper = mock.patch.object(sample_vnf, 'VnfSshHelper')
+        self.mock_ssh_helper = self._mock_ssh_helper.start()
+        self.addCleanup(self._stop_mocks)
 
-    @mock.patch(SSH_HELPER)
-    def test_listen_traffic(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertIsNone(trex_traffic_gen.listen_traffic({}))
+    def _stop_mocks(self):
+        self._mock_ssh_helper.stop()
 
-    @mock.patch(SSH_HELPER)
-    def test_instantiate(self, ssh):
-        mock_ssh(ssh)
+    def test___init__(self):
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        self.assertIsNotNone(trex_traffic_gen.resource_helper._terminated.value)
 
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_instantiate(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen.resource_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
@@ -274,15 +260,12 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
         scenario_cfg.update({"nodes": ["tg_1", "vnf_1"]})
         self.assertIsNone(trex_traffic_gen.instantiate(scenario_cfg, {}))
 
-    @mock.patch(SSH_HELPER)
-    def test_instantiate_error(self, ssh):
-        mock_ssh(ssh, exec_result=(1, "", ""))
-
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_instantiate_error(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
         trex_traffic_gen.resource_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
         scenario_cfg = {
@@ -310,29 +293,3 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
             },
         }
         trex_traffic_gen.instantiate(scenario_cfg, {})
-
-    @mock.patch(SSH_HELPER)
-    def test__start_server(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        trex_traffic_gen.resource_helper = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen._start_server())
-
-    @mock.patch("yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex.time")
-    @mock.patch(SSH_HELPER)
-    def test__generate_trex_cfg(self, ssh, _):
-        mock_ssh(ssh)
-
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        trex_traffic_gen.ssh_helper = mock.MagicMock()
-        trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen.resource_helper.generate_cfg())
-
-    def test_terminate(self):
-        with mock.patch(SSH_HELPER) as ssh:
-            ssh_mock = mock.Mock(autospec=ssh.SSH)
-            ssh_mock.execute = mock.Mock(return_value=(0, "", ""))
-            ssh.from_node.return_value = ssh_mock
-            trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-            trex_traffic_gen.resource_helper = mock.MagicMock()
-            self.assertIsNone(trex_traffic_gen.terminate())
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
index aae3d468f..4f8742477 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
@@ -11,31 +11,23 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
 import copy
 
 import mock
 import unittest
 
-from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base import mock_ssh
-from yardstick.tests import STL_MOCKS
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.traffic_profile import rfc2544
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf import tg_trex
 
 
-SSH_HELPER = 'yardstick.network_services.vnf_generic.vnf.sample_vnf.VnfSshHelper'
 NAME = 'vnf_1'
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf.tg_trex import \
-        TrexTrafficGen, TrexResourceHelper
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-
 
 class TestTrexTrafficGen(unittest.TestCase):
+
     VNFD = {'vnfd:vnfd-catalog':
             {'vnfd':
              [{'short-name': 'VpeVnf',
@@ -168,7 +160,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens786f0",
-                        "vld_id": TrafficProfile.UPLINK,
+                        "vld_id": tp_base.TrafficProfile.UPLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.0",
                         "local_ip": "152.16.100.19",
@@ -180,7 +172,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                     },
                     "xe1": {
                         "local_iface_name": "ens786f1",
-                        "vld_id": TrafficProfile.DOWNLINK,
+                        "vld_id": tp_base.TrafficProfile.DOWNLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.1",
                         "local_ip": "152.16.40.19",
@@ -236,7 +228,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens513f0",
-                        "vld_id": TrafficProfile.DOWNLINK,
+                        "vld_id": tp_base.TrafficProfile.DOWNLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:02:00.0",
                         "local_ip": "152.16.40.20",
@@ -270,7 +262,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens785f0",
-                        "vld_id": TrafficProfile.UPLINK,
+                        "vld_id": tp_base.TrafficProfile.UPLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.0",
                         "local_ip": "152.16.100.20",
@@ -297,36 +289,35 @@ class TestTrexTrafficGen(unittest.TestCase):
         }
     }
 
-    @mock.patch(SSH_HELPER)
-    def test___init__(self, ssh):
-        mock_ssh(ssh)
+    def setUp(self):
+        self._mock_ssh_helper = mock.patch.object(sample_vnf, 'VnfSshHelper')
+        self.mock_ssh_helper = self._mock_ssh_helper.start()
+        self.addCleanup(self._stop_mocks)
+
+    def _stop_mocks(self):
+        self._mock_ssh_helper.stop()
+
+    def test___init__(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
-        self.assertIsInstance(
-            trex_traffic_gen.resource_helper, TrexResourceHelper)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
+        self.assertIsInstance(trex_traffic_gen.resource_helper,
+                              tg_trex.TrexResourceHelper)
 
-    @mock.patch(SSH_HELPER)
-    def test_collect_kpi(self, ssh):
-        mock_ssh(ssh)
+    def test_collect_kpi(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper._queue.put({})
         result = trex_traffic_gen.collect_kpi()
         self.assertEqual({}, result)
 
-    @mock.patch(SSH_HELPER)
-    def test_listen_traffic(self, ssh):
-        mock_ssh(ssh)
+    def test_listen_traffic(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.assertIsNone(trex_traffic_gen.listen_traffic({}))
 
-    @mock.patch(SSH_HELPER)
-    def test_instantiate(self, ssh):
-        mock_ssh(ssh)
-
+    def test_instantiate(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen._tg_process = mock.MagicMock()
         trex_traffic_gen._tg_process.start = mock.Mock()
@@ -335,16 +326,12 @@ class TestTrexTrafficGen(unittest.TestCase):
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
+        self.assertIsNone(trex_traffic_gen.instantiate(self.SCENARIO_CFG,
+                                                       self.CONTEXT_CFG))
 
-        self.assertIsNone(trex_traffic_gen.instantiate(
-            self.SCENARIO_CFG, self.CONTEXT_CFG))
-
-    @mock.patch(SSH_HELPER)
-    def test_instantiate_error(self, ssh):
-        mock_ssh(ssh, exec_result=(1, "", ""))
-
+    def test_instantiate_error(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen._tg_process = mock.MagicMock()
         trex_traffic_gen._tg_process.start = mock.Mock()
@@ -352,62 +339,53 @@ class TestTrexTrafficGen(unittest.TestCase):
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen.instantiate(
-            self.SCENARIO_CFG, self.CONTEXT_CFG))
+        self.assertIsNone(trex_traffic_gen.instantiate(self.SCENARIO_CFG,
+                                                       self.CONTEXT_CFG))
 
-    @mock.patch(SSH_HELPER)
-    def test__start_server(self, ssh):
-        mock_ssh(ssh)
+    def test__start_server(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.scenario_helper.scenario_cfg = {}
         self.assertIsNone(trex_traffic_gen._start_server())
 
-    @mock.patch(SSH_HELPER)
-    def test__start_server_multiple_queues(self, ssh):
-        mock_ssh(ssh)
+    def test__start_server_multiple_queues(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.scenario_helper.scenario_cfg = {
             "options": {NAME: {"queues_per_port": 2}}}
         self.assertIsNone(trex_traffic_gen._start_server())
 
-    @mock.patch(SSH_HELPER)
-    def test__traffic_runner(self, ssh):
-        mock_ssh(ssh)
-
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test__traffic_runner(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.execute_traffic.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        self.sut = TrexTrafficGen(NAME, vnfd)
+        self.sut = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.sut.ssh_helper = mock.Mock()
         self.sut.ssh_helper.run = mock.Mock()
-        self.sut._connect_client = mock.Mock(autospec=STLClient)
+        self.sut._connect_client = mock.Mock()
         self.sut._connect_client.get_stats = mock.Mock(return_value="0")
         self.sut.resource_helper.RUN_DURATION = 0
         self.sut.resource_helper.QUEUE_WAIT_TIME = 0
-        # must generate cfg before we can run traffic so Trex port mapping is created
+        # must generate cfg before we can run traffic so Trex port mapping is
+        # created
         self.sut.resource_helper.generate_cfg()
-        self.sut._traffic_runner(mock_traffic_profile)
+        with mock.patch.object(self.sut.resource_helper, 'run_traffic'):
+            self.sut._traffic_runner(mock_traffic_profile)
 
-    @mock.patch(SSH_HELPER)
-    def test__generate_trex_cfg(self, ssh):
-        mock_ssh(ssh)
+    def test__generate_trex_cfg(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         self.assertIsNone(trex_traffic_gen.resource_helper.generate_cfg())
 
-    @mock.patch(SSH_HELPER)
-    def test_build_ports_reversed_pci_ordering(self, ssh):
-        mock_ssh(ssh)
+    def test_build_ports_reversed_pci_ordering(self):
         vnfd = copy.deepcopy(self.VNFD['vnfd:vnfd-catalog']['vnfd'][0])
         vnfd['vdu'][0]['external-interface'] = [
             {'virtual-interface':
@@ -442,26 +420,24 @@ class TestTrexTrafficGen(unittest.TestCase):
               'local_mac': '00:00:00:00:00:01'},
              'vnfd-connection-point-ref': 'xe1',
              'name': 'xe1'}]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.generate_cfg()
         trex_traffic_gen.resource_helper._build_ports()
-        self.assertEqual(
-            sorted(trex_traffic_gen.resource_helper.all_ports), [0, 1])
+        self.assertEqual(sorted(trex_traffic_gen.resource_helper.all_ports),
+                         [0, 1])
         # there is a gap in ordering
-        self.assertEqual(dict(trex_traffic_gen.resource_helper.dpdk_to_trex_port_map),
-                         {0: 0, 2: 1})
-
-    @mock.patch(SSH_HELPER)
-    def test_run_traffic(self, ssh):
-        mock_ssh(ssh)
+        self.assertEqual(
+            {0: 0, 2: 1},
+            dict(trex_traffic_gen.resource_helper.dpdk_to_trex_port_map))
 
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_run_traffic(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        self.sut = TrexTrafficGen(NAME, vnfd)
+        self.sut = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.sut.ssh_helper = mock.Mock()
         self.sut.ssh_helper.run = mock.Mock()
         self.sut._traffic_runner = mock.Mock(return_value=0)
@@ -470,20 +446,60 @@ class TestTrexTrafficGen(unittest.TestCase):
         self.sut._traffic_process.terminate()
         self.assertIsNotNone(result)
 
-    @mock.patch(SSH_HELPER)
-    def test_terminate(self, ssh):
-        mock_ssh(ssh)
+    def test_terminate(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         self.assertIsNone(trex_traffic_gen.terminate())
 
-    @mock.patch(SSH_HELPER)
-    def test__connect_client(self, ssh):
-        mock_ssh(ssh)
+    def test__connect_client(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
-        client = mock.Mock(autospec=STLClient)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
+        client = mock.Mock()
         client.connect = mock.Mock(return_value=0)
         self.assertIsNotNone(trex_traffic_gen.resource_helper._connect(client))
+
+
+class TrexResourceHelperTestCase(unittest.TestCase):
+
+    def test__get_samples(self):
+        mock_setup_helper = mock.Mock()
+        trex_rh = tg_trex.TrexResourceHelper(mock_setup_helper)
+        trex_rh.vnfd_helper.interfaces = [
+            {'name': 'interface1'},
+            {'name': 'interface2'}]
+        stats = {
+            10: {'rx_pps': 5, 'ipackets': 200},
+            20: {'rx_pps': 10, 'ipackets': 300},
+            'latency': {1: {'latency': 'latency_port_10_pg_id_1'},
+                        2: {'latency': 'latency_port_10_pg_id_2'},
+                        3: {'latency': 'latency_port_20_pg_id_3'},
+                        4: {'latency': 'latency_port_20_pg_id_4'}}
+        }
+        port_pg_id = rfc2544.PortPgIDMap()
+        port_pg_id.add_port(10)
+        port_pg_id.increase_pg_id()
+        port_pg_id.increase_pg_id()
+        port_pg_id.add_port(20)
+        port_pg_id.increase_pg_id()
+        port_pg_id.increase_pg_id()
+
+        with mock.patch.object(trex_rh, 'get_stats') as mock_get_stats, \
+                mock.patch.object(trex_rh.vnfd_helper, 'port_num') as \
+                mock_port_num:
+            mock_get_stats.return_value = stats
+            mock_port_num.side_effect = [10, 20]
+            output = trex_rh._get_samples([10, 20], port_pg_id=port_pg_id)
+
+        interface = output['interface1']
+        self.assertEqual(5.0, interface['rx_throughput_fps'])
+        self.assertEqual(200, interface['in_packets'])
+        self.assertEqual('latency_port_10_pg_id_1', interface['latency'][1])
+        self.assertEqual('latency_port_10_pg_id_2', interface['latency'][2])
+
+        interface = output['interface2']
+        self.assertEqual(10.0, interface['rx_throughput_fps'])
+        self.assertEqual(300, interface['in_packets'])
+        self.assertEqual('latency_port_20_pg_id_3', interface['latency'][3])
+        self.assertEqual('latency_port_20_pg_id_4', interface['latency'][4])