Leverage on Xtesting

It removes all the files which have moved to Xtesting.
Vnf inheritances and env management will be improved in other
changes.

It keeps the same tree thanks to a symlink to allow publishing
artifacts.

Change-Id: I551bbd3f344cdab0158a50b7b09e541576695631
Signed-off-by: Cédric Ollivier <cedric.ollivier@orange.com>

6 files changed, 2 insertions, 694 deletions

diff --git a/functest/tests/unit/core/__init__.py b/functest/tests/unit/core/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/functest/tests/unit/core/__init__.py
+++ /dev/null
diff --git a/functest/tests/unit/core/test_feature.py b/functest/tests/unit/core/test_feature.py
deleted file mode 100644
index 3219c7265..000000000
--- a/functest/tests/unit/core/test_feature.py
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2017 Orange and others.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# pylint: disable=missing-docstring
-
-import logging
-import unittest
-
-import mock
-
-from functest.core import feature
-from functest.core import testcase
-
-
-class FeatureTestingBase(unittest.TestCase):
-
-    _case_name = "foo"
-    _project_name = "bar"
-    _repo = "dir_repo_bar"
-    _cmd = "run_bar_tests.py"
-    _output_file = '/home/opnfv/functest/results/foo.log'
-    feature = None
-
-    @mock.patch('time.time', side_effect=[1, 2])
-    def _test_run(self, status, mock_method=None):
-        self.assertEqual(self.feature.run(cmd=self._cmd), status)
-        if status == testcase.TestCase.EX_OK:
-            self.assertEqual(self.feature.result, 100)
-        else:
-            self.assertEqual(self.feature.result, 0)
-        mock_method.assert_has_calls([mock.call(), mock.call()])
-        self.assertEqual(self.feature.start_time, 1)
-        self.assertEqual(self.feature.stop_time, 2)
-
-    def test_logger_module_ko(self):
-        with mock.patch('six.moves.builtins.open'):
-            self.feature = feature.Feature(
-                project_name=self._project_name, case_name=self._case_name)
-            self.assertEqual(self.feature.logger.name, self._case_name)
-
-    def test_logger_module(self):
-        with mock.patch('six.moves.builtins.open'):
-            self.feature = feature.Feature(
-                project_name=self._project_name, case_name=self._case_name,
-                run={'module': 'bar'})
-            self.assertEqual(self.feature.logger.name, 'bar')
-
-
-class FeatureTesting(FeatureTestingBase):
-
-    def setUp(self):
-        # logging must be disabled else it calls time.time()
-        # what will break these unit tests.
-        logging.disable(logging.CRITICAL)
-        with mock.patch('six.moves.builtins.open'):
-            self.feature = feature.Feature(
-                project_name=self._project_name, case_name=self._case_name)
-
-    def test_run_exc(self):
-        # pylint: disable=bad-continuation
-        with mock.patch.object(
-                self.feature, 'execute',
-                side_effect=Exception) as mock_method:
-            self._test_run(testcase.TestCase.EX_RUN_ERROR)
-            mock_method.assert_called_once_with(cmd=self._cmd)
-
-    def test_run(self):
-        self._test_run(testcase.TestCase.EX_RUN_ERROR)
-
-
-class BashFeatureTesting(FeatureTestingBase):
-
-    def setUp(self):
-        # logging must be disabled else it calls time.time()
-        # what will break these unit tests.
-        logging.disable(logging.CRITICAL)
-        with mock.patch('six.moves.builtins.open'):
-            self.feature = feature.BashFeature(
-                project_name=self._project_name, case_name=self._case_name)
-
-    @mock.patch('subprocess.Popen')
-    def test_run_no_cmd(self, mock_subproc):
-        self.assertEqual(
-            self.feature.run(), testcase.TestCase.EX_RUN_ERROR)
-        mock_subproc.assert_not_called()
-
-    @mock.patch('subprocess.Popen')
-    def test_run_ko(self, mock_subproc):
-        with mock.patch('six.moves.builtins.open', mock.mock_open()) as mopen:
-            mock_obj = mock.Mock()
-            attrs = {'wait.return_value': 1}
-            mock_obj.configure_mock(**attrs)
-
-            mock_subproc.return_value = mock_obj
-            self._test_run(testcase.TestCase.EX_RUN_ERROR)
-            mopen.assert_called_once_with(self._output_file, "w+")
-
-    @mock.patch('subprocess.Popen')
-    def test_run(self, mock_subproc):
-        with mock.patch('six.moves.builtins.open', mock.mock_open()) as mopen:
-            mock_obj = mock.Mock()
-            attrs = {'wait.return_value': 0}
-            mock_obj.configure_mock(**attrs)
-
-            mock_subproc.return_value = mock_obj
-            self._test_run(testcase.TestCase.EX_OK)
-            mopen.assert_called_once_with(self._output_file, "w+")
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
diff --git a/functest/tests/unit/core/test_robotframework.py b/functest/tests/unit/core/test_robotframework.py
deleted file mode 100644
index 28fd15f69..000000000
--- a/functest/tests/unit/core/test_robotframework.py
+++ /dev/null
@@ -1,199 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2017 Orange and others.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-"""Define the classes required to fully cover robot."""
-
-import errno
-import logging
-import os
-import unittest
-
-import mock
-from robot.errors import DataError, RobotError
-from robot.result import model
-from robot.utils.robottime import timestamp_to_secs
-
-from functest.core import robotframework
-
-__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
-
-
-class ResultVisitorTesting(unittest.TestCase):
-
-    """The class testing ResultVisitor."""
-    # pylint: disable=missing-docstring
-
-    def setUp(self):
-        self.visitor = robotframework.ResultVisitor()
-
-    def test_empty(self):
-        self.assertFalse(self.visitor.get_data())
-
-    def test_ok(self):
-        data = {'name': 'foo',
-                'parent': 'bar',
-                'status': 'PASS',
-                'starttime': "20161216 16:00:00.000",
-                'endtime': "20161216 16:00:01.000",
-                'elapsedtime': 1000,
-                'text': 'Hello, World!',
-                'critical': True}
-        test = model.TestCase(
-            name=data['name'], status=data['status'], message=data['text'],
-            starttime=data['starttime'], endtime=data['endtime'])
-        test.parent = mock.Mock()
-        config = {'name': data['parent'],
-                  'criticality.test_is_critical.return_value': data[
-                      'critical']}
-        test.parent.configure_mock(**config)
-        self.visitor.visit_test(test)
-        self.assertEqual(self.visitor.get_data(), [data])
-
-
-class ParseResultTesting(unittest.TestCase):
-
-    """The class testing RobotFramework.parse_results()."""
-    # pylint: disable=missing-docstring
-
-    _config = {'name': 'dummy', 'starttime': '20161216 16:00:00.000',
-               'endtime': '20161216 16:00:01.000'}
-
-    def setUp(self):
-        self.test = robotframework.RobotFramework(
-            case_name='robot', project_name='functest')
-
-    @mock.patch('robot.api.ExecutionResult', side_effect=DataError)
-    def test_raises_exc(self, mock_method):
-        with self.assertRaises(DataError):
-            self.test.parse_results()
-        mock_method.assert_called_once_with(
-            os.path.join(self.test.res_dir, 'output.xml'))
-
-    def _test_result(self, config, result):
-        suite = mock.Mock()
-        suite.configure_mock(**config)
-        with mock.patch('robot.api.ExecutionResult',
-                        return_value=mock.Mock(suite=suite)):
-            self.test.parse_results()
-            self.assertEqual(self.test.result, result)
-            self.assertEqual(self.test.start_time,
-                             timestamp_to_secs(config['starttime']))
-            self.assertEqual(self.test.stop_time,
-                             timestamp_to_secs(config['endtime']))
-            self.assertEqual(self.test.details,
-                             {'description': config['name'], 'tests': []})
-
-    def test_null_passed(self):
-        self._config.update({'statistics.critical.passed': 0,
-                             'statistics.critical.total': 20})
-        self._test_result(self._config, 0)
-
-    def test_no_test(self):
-        self._config.update({'statistics.critical.passed': 20,
-                             'statistics.critical.total': 0})
-        self._test_result(self._config, 0)
-
-    def test_half_success(self):
-        self._config.update({'statistics.critical.passed': 10,
-                             'statistics.critical.total': 20})
-        self._test_result(self._config, 50)
-
-    def test_success(self):
-        self._config.update({'statistics.critical.passed': 20,
-                             'statistics.critical.total': 20})
-        self._test_result(self._config, 100)
-
-
-class RunTesting(unittest.TestCase):
-
-    """The class testing RobotFramework.run()."""
-    # pylint: disable=missing-docstring
-
-    suites = ["foo"]
-    variable = []
-    variablefile = []
-
-    def setUp(self):
-        self.test = robotframework.RobotFramework(
-            case_name='robot', project_name='functest')
-
-    def test_exc_key_error(self):
-        self.assertEqual(self.test.run(), self.test.EX_RUN_ERROR)
-
-    @mock.patch('robot.run')
-    def _test_makedirs_exc(self, *args):
-        with mock.patch.object(self.test, 'parse_results') as mock_method:
-            self.assertEqual(
-                self.test.run(
-                    suites=self.suites, variable=self.variable,
-                    variablefile=self.variablefile),
-                self.test.EX_RUN_ERROR)
-            args[0].assert_not_called()
-            mock_method.asser_not_called()
-
-    @mock.patch('os.makedirs', side_effect=Exception)
-    def test_makedirs_exc(self, *args):
-        self._test_makedirs_exc()
-        args[0].assert_called_once_with(self.test.res_dir)
-
-    @mock.patch('os.makedirs', side_effect=OSError)
-    def test_makedirs_oserror(self, *args):
-        self._test_makedirs_exc()
-        args[0].assert_called_once_with(self.test.res_dir)
-
-    @mock.patch('robot.run')
-    def _test_makedirs(self, *args):
-        with mock.patch.object(self.test, 'parse_results') as mock_method:
-            self.assertEqual(
-                self.test.run(suites=self.suites, variable=self.variable),
-                self.test.EX_OK)
-            args[0].assert_called_once_with(
-                *self.suites, log='NONE', output=self.test.xml_file,
-                report='NONE', stdout=mock.ANY, variable=self.variable,
-                variablefile=self.variablefile)
-            mock_method.assert_called_once_with()
-
-    @mock.patch('os.makedirs', side_effect=OSError(errno.EEXIST, ''))
-    def test_makedirs_oserror17(self, *args):
-        self._test_makedirs()
-        args[0].assert_called_once_with(self.test.res_dir)
-
-    @mock.patch('os.makedirs')
-    def test_makedirs(self, *args):
-        self._test_makedirs()
-        args[0].assert_called_once_with(self.test.res_dir)
-
-    @mock.patch('robot.run')
-    def _test_parse_results(self, status, *args):
-        self.assertEqual(
-            self.test.run(
-                suites=self.suites, variable=self.variable,
-                variablefile=self.variablefile),
-            status)
-        args[0].assert_called_once_with(
-            *self.suites, log='NONE', output=self.test.xml_file,
-            report='NONE', stdout=mock.ANY, variable=self.variable,
-            variablefile=self.variablefile)
-
-    def test_parse_results_exc(self):
-        with mock.patch.object(self.test, 'parse_results',
-                               side_effect=Exception) as mock_method:
-            self._test_parse_results(self.test.EX_RUN_ERROR)
-            mock_method.assert_called_once_with()
-
-    def test_parse_results_robot_error(self):
-        with mock.patch.object(self.test, 'parse_results',
-                               side_effect=RobotError('foo')) as mock_method:
-            self._test_parse_results(self.test.EX_RUN_ERROR)
-            mock_method.assert_called_once_with()
-
-
-if __name__ == "__main__":
-    logging.disable(logging.CRITICAL)
-    unittest.main(verbosity=2)
diff --git a/functest/tests/unit/core/test_testcase.py b/functest/tests/unit/core/test_testcase.py
deleted file mode 100644
index e11e5ff7b..000000000
--- a/functest/tests/unit/core/test_testcase.py
+++ /dev/null
@@ -1,277 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2016 Orange and others.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-"""Define the class required to fully cover testcase."""
-
-from datetime import datetime
-import json
-import logging
-import os
-import unittest
-
-from functest.core import testcase
-
-import mock
-import requests
-
-
-__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
-
-
-class TestCaseTesting(unittest.TestCase):
-    """The class testing TestCase."""
-
-    # pylint: disable=missing-docstring,too-many-public-methods
-
-    _case_name = "base"
-    _project_name = "functest"
-    _published_result = "PASS"
-    _test_db_url = "http://testresults.opnfv.org/test/api/v1/results"
-    _headers = {'Content-Type': 'application/json'}
-
-    def setUp(self):
-        self.test = testcase.TestCase(case_name=self._case_name,
-                                      project_name=self._project_name)
-        self.test.start_time = 1
-        self.test.stop_time = 2
-        self.test.result = 100
-        self.test.details = {"Hello": "World"}
-        os.environ['TEST_DB_URL'] = TestCaseTesting._test_db_url
-        os.environ['INSTALLER_TYPE'] = "installer_type"
-        os.environ['DEPLOY_SCENARIO'] = "scenario"
-        os.environ['NODE_NAME'] = "node_name"
-        os.environ['BUILD_TAG'] = "foo-daily-master-bar"
-
-    def test_run_unimplemented(self):
-        self.assertEqual(self.test.run(),
-                         testcase.TestCase.EX_RUN_ERROR)
-
-    def _test_pushdb_missing_attribute(self):
-        self.assertEqual(self.test.push_to_db(),
-                         testcase.TestCase.EX_PUSH_TO_DB_ERROR)
-
-    def test_pushdb_no_project_name(self):
-        self.test.project_name = None
-        self._test_pushdb_missing_attribute()
-
-    def test_pushdb_no_case_name(self):
-        self.test.case_name = None
-        self._test_pushdb_missing_attribute()
-
-    def test_pushdb_no_start_time(self):
-        self.test.start_time = None
-        self._test_pushdb_missing_attribute()
-
-    def test_pushdb_no_stop_time(self):
-        self.test.stop_time = None
-        self._test_pushdb_missing_attribute()
-
-    def _test_pushdb_missing_env(self, var):
-        del os.environ[var]
-        self.assertEqual(self.test.push_to_db(),
-                         testcase.TestCase.EX_PUSH_TO_DB_ERROR)
-
-    def test_pushdb_no_db_url(self):
-        self._test_pushdb_missing_env('TEST_DB_URL')
-
-    def test_pushdb_no_installer_type(self):
-        self._test_pushdb_missing_env('INSTALLER_TYPE')
-
-    def test_pushdb_no_deploy_scenario(self):
-        self._test_pushdb_missing_env('DEPLOY_SCENARIO')
-
-    def test_pushdb_no_node_name(self):
-        self._test_pushdb_missing_env('NODE_NAME')
-
-    def test_pushdb_no_build_tag(self):
-        self._test_pushdb_missing_env('BUILD_TAG')
-
-    @mock.patch('requests.post')
-    def test_pushdb_bad_start_time(self, mock_function=None):
-        self.test.start_time = "1"
-        self.assertEqual(
-            self.test.push_to_db(),
-            testcase.TestCase.EX_PUSH_TO_DB_ERROR)
-        mock_function.assert_not_called()
-
-    @mock.patch('requests.post')
-    def test_pushdb_bad_end_time(self, mock_function=None):
-        self.test.stop_time = "2"
-        self.assertEqual(
-            self.test.push_to_db(),
-            testcase.TestCase.EX_PUSH_TO_DB_ERROR)
-        mock_function.assert_not_called()
-
-    def _get_data(self):
-        return {
-            "build_tag": os.environ['BUILD_TAG'],
-            "case_name": self._case_name,
-            "criteria": 'PASS' if self.test.is_successful(
-                ) == self.test.EX_OK else 'FAIL',
-            "details": self.test.details,
-            "installer": os.environ['INSTALLER_TYPE'],
-            "pod_name": os.environ['NODE_NAME'],
-            "project_name": self.test.project_name,
-            "scenario": os.environ['DEPLOY_SCENARIO'],
-            "start_date": datetime.fromtimestamp(
-                self.test.start_time).strftime('%Y-%m-%d %H:%M:%S'),
-            "stop_date": datetime.fromtimestamp(
-                self.test.stop_time).strftime('%Y-%m-%d %H:%M:%S'),
-            "version": "master"}
-
-    @mock.patch('requests.post')
-    def _test_pushdb_version(self, mock_function=None, **kwargs):
-        payload = self._get_data()
-        payload["version"] = kwargs.get("version", "unknown")
-        self.assertEqual(self.test.push_to_db(), testcase.TestCase.EX_OK)
-        mock_function.assert_called_once_with(
-            os.environ['TEST_DB_URL'],
-            data=json.dumps(payload, sort_keys=True),
-            headers=self._headers)
-
-    def test_pushdb_daily_job(self):
-        self._test_pushdb_version(version="master")
-
-    def test_pushdb_weekly_job(self):
-        os.environ['BUILD_TAG'] = 'foo-weekly-master-bar'
-        self._test_pushdb_version(version="master")
-
-    def test_pushdb_random_build_tag(self):
-        os.environ['BUILD_TAG'] = 'whatever'
-        self._test_pushdb_version(version="unknown")
-
-    @mock.patch('requests.post', return_value=mock.Mock(
-        raise_for_status=mock.Mock(
-            side_effect=requests.exceptions.HTTPError)))
-    def test_pushdb_http_errors(self, mock_function=None):
-        self.assertEqual(
-            self.test.push_to_db(),
-            testcase.TestCase.EX_PUSH_TO_DB_ERROR)
-        mock_function.assert_called_once_with(
-            os.environ['TEST_DB_URL'],
-            data=json.dumps(self._get_data(), sort_keys=True),
-            headers=self._headers)
-
-    def test_check_criteria_missing(self):
-        self.test.criteria = None
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_check_result_missing(self):
-        self.test.result = None
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_check_result_failed(self):
-        # Backward compatibility
-        # It must be removed as soon as TestCase subclasses
-        # stop setting result = 'PASS' or 'FAIL'.
-        self.test.result = 'FAIL'
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_check_result_pass(self):
-        # Backward compatibility
-        # It must be removed as soon as TestCase subclasses
-        # stop setting result = 'PASS' or 'FAIL'.
-        self.test.result = 'PASS'
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_OK)
-
-    def test_check_result_lt(self):
-        self.test.result = 50
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_check_result_eq(self):
-        self.test.result = 100
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_OK)
-
-    def test_check_result_gt(self):
-        self.test.criteria = 50
-        self.test.result = 100
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_OK)
-
-    def test_check_result_zero(self):
-        self.test.criteria = 0
-        self.test.result = 0
-        self.assertEqual(self.test.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_get_duration_start_ko(self):
-        self.test.start_time = None
-        self.assertEqual(self.test.get_duration(), "XX:XX")
-        self.test.start_time = 0
-        self.assertEqual(self.test.get_duration(), "XX:XX")
-
-    def test_get_duration_end_ko(self):
-        self.test.stop_time = None
-        self.assertEqual(self.test.get_duration(), "XX:XX")
-        self.test.stop_time = 0
-        self.assertEqual(self.test.get_duration(), "XX:XX")
-
-    def test_get_invalid_duration(self):
-        self.test.start_time = 2
-        self.test.stop_time = 1
-        self.assertEqual(self.test.get_duration(), "XX:XX")
-
-    def test_get_zero_duration(self):
-        self.test.start_time = 2
-        self.test.stop_time = 2
-        self.assertEqual(self.test.get_duration(), "00:00")
-
-    def test_get_duration(self):
-        self.test.start_time = 1
-        self.test.stop_time = 180
-        self.assertEqual(self.test.get_duration(), "02:59")
-
-    def test_str_project_name_ko(self):
-        self.test.project_name = None
-        self.assertIn("<functest.core.testcase.TestCase object at",
-                      str(self.test))
-
-    def test_str_case_name_ko(self):
-        self.test.case_name = None
-        self.assertIn("<functest.core.testcase.TestCase object at",
-                      str(self.test))
-
-    def test_str_pass(self):
-        duration = '01:01'
-        with mock.patch.object(self.test, 'get_duration',
-                               return_value=duration), \
-                mock.patch.object(self.test, 'is_successful',
-                                  return_value=testcase.TestCase.EX_OK):
-            message = str(self.test)
-        self.assertIn(self._project_name, message)
-        self.assertIn(self._case_name, message)
-        self.assertIn(duration, message)
-        self.assertIn('PASS', message)
-
-    def test_str_fail(self):
-        duration = '00:59'
-        with mock.patch.object(self.test, 'get_duration',
-                               return_value=duration), \
-                mock.patch.object(
-                    self.test, 'is_successful',
-                    return_value=testcase.TestCase.EX_TESTCASE_FAILED):
-            message = str(self.test)
-        self.assertIn(self._project_name, message)
-        self.assertIn(self._case_name, message)
-        self.assertIn(duration, message)
-        self.assertIn('FAIL', message)
-
-    def test_clean(self):
-        self.assertEqual(self.test.clean(), None)
-
-
-if __name__ == "__main__":
-    logging.disable(logging.CRITICAL)
-    unittest.main(verbosity=2)
diff --git a/functest/tests/unit/core/test_unit.py b/functest/tests/unit/core/test_unit.py
deleted file mode 100644
index ca73de672..000000000
--- a/functest/tests/unit/core/test_unit.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# pylint: disable=missing-docstring
-
-import logging
-import unittest
-
-import mock
-
-from functest.core import unit
-from functest.core import testcase
-
-
-class PyTestSuiteRunnerTesting(unittest.TestCase):
-
-    def setUp(self):
-        self.psrunner = unit.Suite()
-        self.psrunner.suite = "foo"
-
-    @mock.patch('unittest.TestLoader')
-    def _test_run(self, mock_class=None, result=mock.Mock(),
-                  status=testcase.TestCase.EX_OK):
-        with mock.patch('functest.core.unit.unittest.TextTestRunner.run',
-                        return_value=result):
-            self.assertEqual(self.psrunner.run(), status)
-            mock_class.assert_not_called()
-
-    def test_check_suite_null(self):
-        self.assertEqual(unit.Suite().suite, None)
-        self.psrunner.suite = None
-        self._test_run(result=mock.Mock(),
-                       status=testcase.TestCase.EX_RUN_ERROR)
-
-    def test_run_no_ut(self):
-        mock_result = mock.Mock(testsRun=0, errors=[], failures=[])
-        self._test_run(result=mock_result,
-                       status=testcase.TestCase.EX_RUN_ERROR)
-        self.assertEqual(self.psrunner.result, 0)
-        self.assertEqual(self.psrunner.details,
-                         {'errors': 0, 'failures': 0, 'stream': '',
-                          'testsRun': 0})
-        self.assertEqual(self.psrunner.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_run_result_ko(self):
-        self.psrunner.criteria = 100
-        mock_result = mock.Mock(testsRun=50, errors=[('test1', 'error_msg1')],
-                                failures=[('test2', 'failure_msg1')])
-        self._test_run(result=mock_result)
-        self.assertEqual(self.psrunner.result, 96)
-        self.assertEqual(self.psrunner.details,
-                         {'errors': 1, 'failures': 1, 'stream': '',
-                          'testsRun': 50})
-        self.assertEqual(self.psrunner.is_successful(),
-                         testcase.TestCase.EX_TESTCASE_FAILED)
-
-    def test_run_result_ok(self):
-        mock_result = mock.Mock(testsRun=50, errors=[],
-                                failures=[])
-        self._test_run(result=mock_result)
-        self.assertEqual(self.psrunner.result, 100)
-        self.assertEqual(self.psrunner.details,
-                         {'errors': 0, 'failures': 0, 'stream': '',
-                          'testsRun': 50})
-        self.assertEqual(self.psrunner.is_successful(),
-                         testcase.TestCase.EX_OK)
-
-    @mock.patch('unittest.TestLoader')
-    def test_run_name_exc(self, mock_class=None):
-        mock_obj = mock.Mock(side_effect=ImportError)
-        mock_class.side_effect = mock_obj
-        self.assertEqual(self.psrunner.run(name='foo'),
-                         testcase.TestCase.EX_RUN_ERROR)
-        mock_class.assert_called_once_with()
-        mock_obj.assert_called_once_with()
-
-    @mock.patch('unittest.TestLoader')
-    def test_run_name(self, mock_class=None):
-        mock_result = mock.Mock(testsRun=50, errors=[],
-                                failures=[])
-        mock_obj = mock.Mock()
-        mock_class.side_effect = mock_obj
-        with mock.patch('functest.core.unit.unittest.TextTestRunner.run',
-                        return_value=mock_result):
-            self.assertEqual(self.psrunner.run(name='foo'),
-                             testcase.TestCase.EX_OK)
-        mock_class.assert_called_once_with()
-        mock_obj.assert_called_once_with()
-
-
-if __name__ == "__main__":
-    logging.disable(logging.CRITICAL)
-    unittest.main(verbosity=2)
diff --git a/functest/tests/unit/core/test_vnf.py b/functest/tests/unit/core/test_vnf.py
index dbdcc0f05..81d9eef76 100644
--- a/functest/tests/unit/core/test_vnf.py
+++ b/functest/tests/unit/core/test_vnf.py
@@ -13,13 +13,12 @@ import logging
 import unittest
 
 import mock
+from snaps.openstack.os_credentials import OSCreds
+from xtesting.core import testcase
 
 from functest.core import vnf
-from functest.core import testcase
 from functest.utils import constants
 
-from snaps.openstack.os_credentials import OSCreds
-
 
 class VnfBaseTesting(unittest.TestCase):
     """The class testing VNF."""