#!/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 classes required to fully cover odl."""

import errno
import logging
import os
import unittest

from keystoneauth1.exceptions import auth_plugins
import mock
from robot.errors import DataError, RobotError
from robot.result import model
from robot.utils.robottime import timestamp_to_secs
import six
from six.moves import urllib

from functest.core import testcase
from functest.opnfv_tests.sdn.odl import odl

__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"


class ODLVisitorTesting(unittest.TestCase):

    """The class testing ODLResultVisitor."""
    # pylint: disable=missing-docstring

    def setUp(self):
        self.visitor = odl.ODLResultVisitor()

    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 ODLTesting(unittest.TestCase):

    """The super class which testing classes could inherit."""
    # pylint: disable=missing-docstring

    logging.disable(logging.CRITICAL)

    _keystone_ip = "127.0.0.1"
    _neutron_url = "http://127.0.0.2:9696"
    _sdn_controller_ip = "127.0.0.3"
    _os_auth_url = "http://{}:5000/v3".format(_keystone_ip)
    _os_projectname = "admin"
    _os_username = "admin"
    _os_password = "admin"
    _odl_webport = "8080"
    _odl_restconfport = "8181"
    _odl_username = "admin"
    _odl_password = "admin"
    _os_userdomainname = 'Default'
    _os_projectdomainname = 'Default'

    def setUp(self):
        for var in ("INSTALLER_TYPE", "SDN_CONTROLLER", "SDN_CONTROLLER_IP"):
            if var in os.environ:
                del os.environ[var]
        os.environ["OS_AUTH_URL"] = self._os_auth_url
        os.environ["OS_USERNAME"] = self._os_username
        os.environ["OS_USER_DOMAIN_NAME"] = self._os_userdomainname
        os.environ["OS_PASSWORD"] = self._os_password
        os.environ["OS_PROJECT_NAME"] = self._os_projectname
        os.environ["OS_PROJECT_DOMAIN_NAME"] = self._os_projectdomainname
        os.environ["OS_PASSWORD"] = self._os_password
        self.test = odl.ODLTests(case_name='odl', project_name='functest')
        self.defaultargs = {'odlusername': self._odl_username,
                            'odlpassword': self._odl_password,
                            'neutronurl': "http://{}:9696".format(
                                self._keystone_ip),
                            'osauthurl': self._os_auth_url,
                            'osusername': self._os_username,
                            'osuserdomainname': self._os_userdomainname,
                            'osprojectname': self._os_projectname,
                            'osprojectdomainname': self._os_projectdomainname,
                            'ospassword': self._os_password,
                            'odlip': self._keystone_ip,
                            'odlwebport': self._odl_webport,
                            'odlrestconfport': self._odl_restconfport,
                            'pushtodb': False}


class ODLParseResultTesting(ODLTesting):

    """The class testing ODLTests.parse_results()."""
    # pylint: disable=missing-docstring

    _config = {'name': 'dummy', 'starttime': '20161216 16:00:00.000',
               'endtime': '20161216 16:00:01.000'}

    @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(odl.ODLTests.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 ODLRobotTesting(ODLTesting):

    """The class testing ODLTests.set_robotframework_vars()."""
    # pylint: disable=missing-docstring

    @mock.patch('fileinput.input', side_effect=Exception())
    def test_set_vars_ko(self, mock_method):
        self.assertFalse(self.test.set_robotframework_vars())
        mock_method.assert_called_once_with(
            os.path.join(odl.ODLTests.odl_test_repo,
                         'csit/variables/Variables.robot'), inplace=True)

    @mock.patch('fileinput.input', return_value=[])
    def test_set_vars_empty(self, mock_method):
        self.assertTrue(self.test.set_robotframework_vars())
        mock_method.assert_called_once_with(
            os.path.join(odl.ODLTests.odl_test_repo,
                         'csit/variables/Variables.robot'), inplace=True)

    @mock.patch('sys.stdout', new_callable=six.StringIO)
    def _test_set_vars(self, msg1, msg2, *args):
        line = mock.MagicMock()
        line.__iter__.return_value = [msg1]
        with mock.patch('fileinput.input', return_value=line) as mock_method:
            self.assertTrue(self.test.set_robotframework_vars())
            mock_method.assert_called_once_with(
                os.path.join(odl.ODLTests.odl_test_repo,
                             'csit/variables/Variables.robot'), inplace=True)
            self.assertEqual(args[0].getvalue(), "{}\n".format(msg2))

    def test_set_vars_auth_default(self):
        self._test_set_vars(
            "@{AUTH} ",
            "@{AUTH}           admin    admin")

    def test_set_vars_auth1(self):
        self._test_set_vars(
            "@{AUTH1}           foo    bar",
            "@{AUTH1}           foo    bar")

    @mock.patch('sys.stdout', new_callable=six.StringIO)
    def test_set_vars_auth_foo(self, *args):
        line = mock.MagicMock()
        line.__iter__.return_value = ["@{AUTH} "]
        with mock.patch('fileinput.input', return_value=line) as mock_method:
            self.assertTrue(self.test.set_robotframework_vars('foo', 'bar'))
            mock_method.assert_called_once_with(
                os.path.join(odl.ODLTests.odl_test_repo,
                             'csit/variables/Variables.robot'), inplace=True)
            self.assertEqual(
                args[0].getvalue(),
                "@{AUTH}           foo    bar\n")


class ODLMainTesting(ODLTesting):

    """The class testing ODLTests.run_suites()."""
    # pylint: disable=missing-docstring

    def _get_run_suites_kwargs(self, key=None):
        kwargs = {'odlusername': self._odl_username,
                  'odlpassword': self._odl_password,
                  'neutronurl': self._neutron_url,
                  'osauthurl': self._os_auth_url,
                  'osusername': self._os_username,
                  'osuserdomainname': self._os_userdomainname,
                  'osprojectname': self._os_projectname,
                  'osprojectdomainname': self._os_projectdomainname,
                  'ospassword': self._os_password,
                  'odlip': self._sdn_controller_ip,
                  'odlwebport': self._odl_webport,
                  'odlrestconfport': self._odl_restconfport}
        if key:
            del kwargs[key]
        return kwargs

    def _test_run_suites(self, status, *args):
        kwargs = self._get_run_suites_kwargs()
        self.assertEqual(self.test.run_suites(**kwargs), status)
        if len(args) > 0:
            args[0].assert_called_once_with(
                odl.ODLTests.res_dir)
        if len(args) > 1:
            variable = [
                'KEYSTONEURL:{}://{}'.format(
                    urllib.parse.urlparse(self._os_auth_url).scheme,
                    urllib.parse.urlparse(self._os_auth_url).netloc),
                'NEUTRONURL:{}'.format(self._neutron_url),
                'OS_AUTH_URL:"{}"'.format(self._os_auth_url),
                'OSUSERNAME:"{}"'.format(self._os_username),
                'OSUSERDOMAINNAME:"{}"'.format(self._os_userdomainname),
                'OSTENANTNAME:"{}"'.format(self._os_projectname),
                'OSPROJECTDOMAINNAME:"{}"'.format(self._os_projectdomainname),
                'OSPASSWORD:"{}"'.format(self._os_password),
                'ODL_SYSTEM_IP:{}'.format(self._sdn_controller_ip),
                'PORT:{}'.format(self._odl_webport),
                'RESTCONFPORT:{}'.format(self._odl_restconfport)]
            args[1].assert_called_once_with(
                odl.ODLTests.basic_suite_dir,
                odl.ODLTests.neutron_suite_dir,
                log='NONE',
                output=os.path.join(odl.ODLTests.res_dir, 'output.xml'),
                report='NONE',
                stdout=mock.ANY,
                variable=variable)
        if len(args) > 2:
            args[2].assert_called_with(
                os.path.join(odl.ODLTests.res_dir, 'stdout.txt'))

    def _test_no_keyword(self, key):
        kwargs = self._get_run_suites_kwargs(key)
        self.assertEqual(self.test.run_suites(**kwargs),
                         testcase.TestCase.EX_RUN_ERROR)

    def test_no_odlusername(self):
        self._test_no_keyword('odlusername')

    def test_no_odlpassword(self):
        self._test_no_keyword('odlpassword')

    def test_no_neutronurl(self):
        self._test_no_keyword('neutronurl')

    def test_no_osauthurl(self):
        self._test_no_keyword('osauthurl')

    def test_no_osusername(self):
        self._test_no_keyword('osusername')

    def test_no_osprojectname(self):
        self._test_no_keyword('osprojectname')

    def test_no_ospassword(self):
        self._test_no_keyword('ospassword')

    def test_no_odlip(self):
        self._test_no_keyword('odlip')

    def test_no_odlwebport(self):
        self._test_no_keyword('odlwebport')

    def test_no_odlrestconfport(self):
        self._test_no_keyword('odlrestconfport')

    def test_set_vars_ko(self):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=False) as mock_object:
            self._test_run_suites(testcase.TestCase.EX_RUN_ERROR)
            mock_object.assert_called_once_with(
                self._odl_username, self._odl_password)

    @mock.patch('os.makedirs', side_effect=Exception)
    def test_makedirs_exc(self, mock_method):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                self.assertRaises(Exception):
            self._test_run_suites(testcase.TestCase.EX_RUN_ERROR,
                                  mock_method)

    @mock.patch('os.makedirs', side_effect=OSError)
    def test_makedirs_oserror(self, mock_method):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True):
            self._test_run_suites(testcase.TestCase.EX_RUN_ERROR,
                                  mock_method)

    @mock.patch('robot.run', side_effect=RobotError)
    @mock.patch('os.makedirs')
    def test_run_ko(self, *args):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                self.assertRaises(RobotError):
            self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)

    @mock.patch('robot.run')
    @mock.patch('os.makedirs')
    def test_parse_results_ko(self, *args):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                mock.patch.object(self.test, 'parse_results',
                                  side_effect=RobotError):
            self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)

    @mock.patch('robot.run')
    @mock.patch('os.makedirs')
    def test_ok(self, *args):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                mock.patch.object(self.test, 'parse_results'):
            self._test_run_suites(testcase.TestCase.EX_OK, *args)

    @mock.patch('robot.run')
    @mock.patch('os.makedirs', side_effect=OSError(errno.EEXIST, ''))
    def test_makedirs_oserror17(self, *args):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                mock.patch.object(self.test, 'parse_results'):
            self._test_run_suites(testcase.TestCase.EX_OK, *args)

    @mock.patch('robot.run', return_value=1)
    @mock.patch('os.makedirs')
    def test_testcases_in_failure(self, *args):
        with mock.patch.object(self.test, 'set_robotframework_vars',
                               return_value=True), \
                mock.patch.object(self.test, 'parse_results'):
            self._test_run_suites(testcase.TestCase.EX_OK, *args)


class ODLRunTesting(ODLTesting):

    """The class testing ODLTests.run()."""
    # pylint: disable=missing-docstring

    def _test_no_env_var(self, var):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            del os.environ[var]
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def _test_run(self, status=testcase.TestCase.EX_OK,
                  exception=None, **kwargs):
        odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3'
        odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080'
        odlrestconfport = (kwargs['odlrestconfport']
                           if 'odlrestconfport' in kwargs else '8181')

        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            if exception:
                self.test.run_suites = mock.Mock(side_effect=exception)
            else:
                self.test.run_suites = mock.Mock(return_value=status)
            self.assertEqual(self.test.run(), status)
            self.test.run_suites.assert_called_once_with(
                odl.ODLTests.default_suites,
                neutronurl=self._neutron_url,
                odlip=odlip, odlpassword=self._odl_password,
                odlrestconfport=odlrestconfport,
                odlusername=self._odl_username, odlwebport=odlwebport,
                osauthurl=self._os_auth_url,
                ospassword=self._os_password,
                osprojectname=self._os_projectname,
                osusername=self._os_username,
                osprojectdomainname=self._os_projectdomainname,
                osuserdomainname=self._os_userdomainname)

    def _test_multiple_suites(self, suites,
                              status=testcase.TestCase.EX_OK, **kwargs):
        odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3'
        odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080'
        odlrestconfport = (kwargs['odlrestconfport']
                           if 'odlrestconfport' in kwargs else '8181')
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            self.test.run_suites = mock.Mock(return_value=status)
            self.assertEqual(self.test.run(suites=suites), status)
            self.test.run_suites.assert_called_once_with(
                suites,
                neutronurl=self._neutron_url,
                odlip=odlip, odlpassword=self._odl_password,
                odlrestconfport=odlrestconfport,
                odlusername=self._odl_username, odlwebport=odlwebport,
                osauthurl=self._os_auth_url,
                ospassword=self._os_password,
                osprojectname=self._os_projectname,
                osusername=self._os_username,
                osprojectdomainname=self._os_projectdomainname,
                osuserdomainname=self._os_userdomainname)

    def test_exc(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        side_effect=auth_plugins.MissingAuthPlugin()):
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_no_os_auth_url(self):
        self._test_no_env_var("OS_AUTH_URL")

    def test_no_os_username(self):
        self._test_no_env_var("OS_USERNAME")

    def test_no_os_password(self):
        self._test_no_env_var("OS_PASSWORD")

    def test_no_os__name(self):
        self._test_no_env_var("OS_PROJECT_NAME")

    def test_run_suites_false(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        self._test_run(testcase.TestCase.EX_RUN_ERROR,
                       odlip=self._sdn_controller_ip,
                       odlwebport=self._odl_webport)

    def test_run_suites_exc(self):
        with self.assertRaises(Exception):
            os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
            self._test_run(status=testcase.TestCase.EX_RUN_ERROR,
                           exception=Exception(),
                           odlip=self._sdn_controller_ip,
                           odlwebport=self._odl_webport)

    def test_no_sdn_controller_ip(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_without_installer_type(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=self._sdn_controller_ip,
                       odlwebport=self._odl_webport)

    def test_suites(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        self._test_multiple_suites(
            [odl.ODLTests.basic_suite_dir],
            testcase.TestCase.EX_OK,
            odlip=self._sdn_controller_ip,
            odlwebport=self._odl_webport)

    def test_fuel(self):
        os.environ["INSTALLER_TYPE"] = "fuel"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=urllib.parse.urlparse(self._neutron_url).hostname,
                       odlwebport='8181',
                       odlrestconfport='8282')

    def test_apex_no_controller_ip(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            os.environ["INSTALLER_TYPE"] = "apex"
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_apex(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        os.environ["INSTALLER_TYPE"] = "apex"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=self._sdn_controller_ip, odlwebport='8081',
                       odlrestconfport='8081')

    def test_netvirt_no_controller_ip(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            os.environ["INSTALLER_TYPE"] = "netvirt"
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_netvirt(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        os.environ["INSTALLER_TYPE"] = "netvirt"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=self._sdn_controller_ip, odlwebport='8081',
                       odlrestconfport='8081')

    def test_joid_no_controller_ip(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            os.environ["INSTALLER_TYPE"] = "joid"
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_joid(self):
        os.environ["SDN_CONTROLLER"] = self._sdn_controller_ip
        os.environ["INSTALLER_TYPE"] = "joid"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=self._sdn_controller_ip, odlwebport='8080')

    def test_compass(self):
        os.environ["INSTALLER_TYPE"] = "compass"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=urllib.parse.urlparse(self._neutron_url).hostname,
                       odlrestconfport='8080')

    def test_daisy_no_controller_ip(self):
        with mock.patch('functest.utils.openstack_utils.get_endpoint',
                        return_value=ODLTesting._neutron_url):
            os.environ["INSTALLER_TYPE"] = "daisy"
            self.assertEqual(self.test.run(),
                             testcase.TestCase.EX_RUN_ERROR)

    def test_daisy(self):
        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
        os.environ["INSTALLER_TYPE"] = "daisy"
        self._test_run(testcase.TestCase.EX_OK,
                       odlip=self._sdn_controller_ip, odlwebport='8181',
                       odlrestconfport='8087')


class ODLArgParserTesting(ODLTesting):

    """The class testing ODLParser."""
    # pylint: disable=missing-docstring

    def setUp(self):
        self.parser = odl.ODLParser()
        super(ODLArgParserTesting, self).setUp()

    def test_default(self):
        self.assertEqual(self.parser.parse_args(), self.defaultargs)

    def test_basic(self):
        self.defaultargs['neutronurl'] = self._neutron_url
        self.defaultargs['odlip'] = self._sdn_controller_ip
        self.assertEqual(
            self.parser.parse_args(
                ["--neutronurl={}".format(self._neutron_url),
                 "--odlip={}".format(self._sdn_controller_ip)]),
            self.defaultargs)

    @mock.patch('sys.stderr', new_callable=six.StringIO)
    def test_fail(self, mock_method):
        self.defaultargs['foo'] = 'bar'
        with self.assertRaises(SystemExit):
            self.parser.parse_args(["--foo=bar"])
        self.assertTrue(mock_method.getvalue().startswith("usage:"))

    def _test_arg(self, arg, value):
        self.defaultargs[arg] = value
        self.assertEqual(
            self.parser.parse_args(["--{}={}".format(arg, value)]),
            self.defaultargs)

    def test_odlusername(self):
        self._test_arg('odlusername', 'foo')

    def test_odlpassword(self):
        self._test_arg('odlpassword', 'foo')

    def test_osauthurl(self):
        self._test_arg('osauthurl', 'http://127.0.0.4:5000/v2')

    def test_neutronurl(self):
        self._test_arg('neutronurl', 'http://127.0.0.4:9696')

    def test_osusername(self):
        self._test_arg('osusername', 'foo')

    def test_osuserdomainname(self):
        self._test_arg('osuserdomainname', 'domain')

    def test_osprojectname(self):
        self._test_arg('osprojectname', 'foo')

    def test_osprojectdomainname(self):
        self._test_arg('osprojectdomainname', 'domain')

    def test_ospassword(self):
        self._test_arg('ospassword', 'foo')

    def test_odlip(self):
        self._test_arg('odlip', '127.0.0.4')

    def test_odlwebport(self):
        self._test_arg('odlwebport', '80')

    def test_odlrestconfport(self):
        self._test_arg('odlrestconfport', '80')

    def test_pushtodb(self):
        self.defaultargs['pushtodb'] = True
        self.assertEqual(self.parser.parse_args(["--{}".format('pushtodb')]),
                         self.defaultargs)

    def test_multiple_args(self):
        self.defaultargs['neutronurl'] = self._neutron_url
        self.defaultargs['odlip'] = self._sdn_controller_ip
        self.assertEqual(
            self.parser.parse_args(
                ["--neutronurl={}".format(self._neutron_url),
                 "--odlip={}".format(self._sdn_controller_ip)]),
            self.defaultargs)


if __name__ == "__main__":
    logging.disable(logging.CRITICAL)
    unittest.main(verbosity=2)

[((2053, 2086), 'logging.disable', 'logging.disable', (['logging.CRITICAL'], {}), '(logging.CRITICAL)\n', (2068, 2086), False, 'import logging\n'), ((4340, 4402), 'mock.patch', 'mock.patch', (['"""robot.api.ExecutionResult"""'], {'side_effect': 'DataError'}), "('robot.api.ExecutionResult', side_effect=DataError)\n", (4350, 4402), False, 'import mock\n'), ((6605, 6651), 'mock.patch', 'mock.patch', (['"""fileinput.input"""'], {'return_value': '[]'}), "('fileinput.input', return_value=[])\n", (6615, 6651), False, 'import mock\n'), ((6939, 6990), 'mock.patch', 'mock.patch', (['"""sys.stdout"""'], {'new_callable': 'six.StringIO'}), "('sys.stdout', new_callable=six.StringIO)\n", (6949, 6990), False, 'import mock\n'), ((7818, 7869), 'mock.patch', 'mock.patch', (['"""sys.stdout"""'], {'new_callable': 'six.StringIO'}), "('sys.stdout', new_callable=six.StringIO)\n", (7828, 7869), False, 'import mock\n'), ((12327, 12375), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {'side_effect': 'Exception'}), "('os.makedirs', side_effect=Exception)\n", (12337, 12375), False, 'import mock\n'), ((12709, 12755), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {'side_effect': 'OSError'}), "('os.makedirs', side_effect=OSError)\n", (12719, 12755), False, 'import mock\n'), ((13045, 13092), 'mock.patch', 'mock.patch', (['"""robot.run"""'], {'side_effect': 'RobotError'}), "('robot.run', side_effect=RobotError)\n", (13055, 13092), False, 'import mock\n'), ((13098, 13123), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {}), "('os.makedirs')\n", (13108, 13123), False, 'import mock\n'), ((13406, 13429), 'mock.patch', 'mock.patch', (['"""robot.run"""'], {}), "('robot.run')\n", (13416, 13429), False, 'import mock\n'), ((13435, 13460), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {}), "('os.makedirs')\n", (13445, 13460), False, 'import mock\n'), ((13827, 13850), 'mock.patch', 'mock.patch', (['"""robot.run"""'], {}), "('robot.run')\n", (13837, 13850), False, 'import mock\n'), ((13856, 13881), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {}), "('os.makedirs')\n", (13866, 13881), False, 'import mock\n'), ((14169, 14192), 'mock.patch', 'mock.patch', (['"""robot.run"""'], {}), "('robot.run')\n", (14179, 14192), False, 'import mock\n'), ((14566, 14605), 'mock.patch', 'mock.patch', (['"""robot.run"""'], {'return_value': '(1)'}), "('robot.run', return_value=1)\n", (14576, 14605), False, 'import mock\n'), ((14611, 14636), 'mock.patch', 'mock.patch', (['"""os.makedirs"""'], {}), "('os.makedirs')\n", (14621, 14636), False, 'import mock\n'), ((23894, 23945), 'mock.patch', 'mock.patch', (['"""sys.stderr"""'], {'new_callable': 'six.StringIO'}), "('sys.stderr', new_callable=six.StringIO)\n", (23904, 23945), False, 'import mock\n'), ((25987, 26020), 'logging.disable', 'logging.disable', (['logging.CRITICAL'], {}), '(logging.CRITICAL)\n', (26002, 26020), False, 'import logging\n'), ((26025, 26051), 'unittest.main', 'unittest.main', ([], {'verbosity': '(2)'}), '(verbosity=2)\n', (26038, 26051), False, 'import unittest\n'), ((971, 993), 'functest.opnfv_tests.sdn.odl.odl.ODLResultVisitor', 'odl.ODLResultVisitor', ([], {}), '()\n', (991, 993), False, 'from functest.opnfv_tests.sdn.odl import odl\n'), ((1426, 1563), 'robot.result.model.TestCase', 'model.TestCase', ([], {'name': "data['name']", 'status': "data['status']", 'message': "data['text']", 'starttime': "data['starttime']", 'endtime': "data['endtime']"}), "(name=data['name'], status=data['status'], message=data[\n    'text'], starttime=data['starttime'], endtime=data['endtime'])\n", (1440, 1563), False, 'from robot.result import model\n'), ((1606, 1617), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (1615, 1617), False, 'import mock\n'), ((3138, 3192), 'functest.opnfv_tests.sdn.odl.odl.ODLTests', 'odl.ODLTests', ([], {'case_name': '"""odl"""', 'project_name': '"""functest"""'}), "(case_name='odl', project_name='functest')\n", (3150, 3192), False, 'from functest.opnfv_tests.sdn.odl import odl\n'), ((4696, 4707), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (4705, 4707), False, 'import mock\n'), ((7055, 7071), 'mock.MagicMock', 'mock.MagicMock', ([], {}), '()\n', (7069, 7071), False, 'import mock\n'), ((7930, 7946), 'mock.MagicMock', 'mock.MagicMock', ([], {}), '()\n', (7944, 7946), False, 'import mock\n'), ((23360, 23375), 'functest.opnfv_tests.sdn.odl.odl.ODLParser', 'odl.ODLParser', ([], {}), '()\n', (23373, 23375), False, 'from functest.opnfv_tests.sdn.odl import odl\n'), ((4585, 4633), 'os.path.join', 'os.path.join', (['odl.ODLTests.res_dir', '"""output.xml"""'], {}), "(odl.ODLTests.res_dir, 'output.xml')\n", (4597, 4633), False, 'import os\n'), ((6484, 6558), 'os.path.join', 'os.path.join', (['odl.ODLTests.odl_test_repo', '"""csit/variables/Variables.robot"""'], {}), "(odl.ODLTests.odl_test_repo, 'csit/variables/Variables.robot')\n", (6496, 6558), False, 'import os\n'), ((6818, 6892), 'os.path.join', 'os.path.join', (['odl.ODLTests.odl_test_repo', '"""csit/variables/Variables.robot"""'], {}), "(odl.ODLTests.odl_test_repo, 'csit/variables/Variables.robot')\n", (6830, 6892), False, 'import os\n'), ((7129, 7177), 'mock.patch', 'mock.patch', (['"""fileinput.input"""'], {'return_value': 'line'}), "('fileinput.input', return_value=line)\n", (7139, 7177), False, 'import mock\n'), ((8010, 8058), 'mock.patch', 'mock.patch', (['"""fileinput.input"""'], {'return_value': 'line'}), "('fileinput.input', return_value=line)\n", (8020, 8058), False, 'import mock\n'), ((12027, 12102), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(False)'}), "(self.test, 'set_robotframework_vars', return_value=False)\n", (12044, 12102), False, 'import mock\n'), ((12435, 12509), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (12452, 12509), False, 'import mock\n'), ((12819, 12893), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (12836, 12893), False, 'import mock\n'), ((13171, 13245), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (13188, 13245), False, 'import mock\n'), ((13518, 13592), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (13535, 13592), False, 'import mock\n'), ((13643, 13712), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""parse_results"""'], {'side_effect': 'RobotError'}), "(self.test, 'parse_results', side_effect=RobotError)\n", (13660, 13712), False, 'import mock\n'), ((13925, 13999), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (13942, 13999), False, 'import mock\n'), ((14050, 14095), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""parse_results"""'], {}), "(self.test, 'parse_results')\n", (14067, 14095), False, 'import mock\n'), ((14322, 14396), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (14339, 14396), False, 'import mock\n'), ((14447, 14492), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""parse_results"""'], {}), "(self.test, 'parse_results')\n", (14464, 14492), False, 'import mock\n'), ((14698, 14772), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""set_robotframework_vars"""'], {'return_value': '(True)'}), "(self.test, 'set_robotframework_vars', return_value=True)\n", (14715, 14772), False, 'import mock\n'), ((14823, 14868), 'mock.patch.object', 'mock.patch.object', (['self.test', '"""parse_results"""'], {}), "(self.test, 'parse_results')\n", (14840, 14868), False, 'import mock\n'), ((15107, 15207), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (15117, 15207), False, 'import mock\n'), ((15757, 15857), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (15767, 15857), False, 'import mock\n'), ((17164, 17264), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (17174, 17264), False, 'import mock\n'), ((17320, 17350), 'mock.Mock', 'mock.Mock', ([], {'return_value': 'status'}), '(return_value=status)\n', (17329, 17350), False, 'import mock\n'), ((19338, 19438), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (19348, 19438), False, 'import mock\n'), ((20472, 20572), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (20482, 20572), False, 'import mock\n'), ((21115, 21215), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (21125, 21215), False, 'import mock\n'), ((21764, 21864), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (21774, 21864), False, 'import mock\n'), ((22608, 22708), 'mock.patch', 'mock.patch', (['"""functest.utils.openstack_utils.get_endpoint"""'], {'return_value': 'ODLTesting._neutron_url'}), "('functest.utils.openstack_utils.get_endpoint', return_value=\n    ODLTesting._neutron_url)\n", (22618, 22708), False, 'import mock\n'), ((5035, 5073), 'robot.utils.robottime.timestamp_to_secs', 'timestamp_to_secs', (["config['starttime']"], {}), "(config['starttime'])\n", (5052, 5073), False, 'from robot.utils.robottime import timestamp_to_secs\n'), ((5154, 5190), 'robot.utils.robottime.timestamp_to_secs', 'timestamp_to_secs', (["config['endtime']"], {}), "(config['endtime'])\n", (5171, 5190), False, 'from robot.utils.robottime import timestamp_to_secs\n'), ((7324, 7398), 'os.path.join', 'os.path.join', (['odl.ODLTests.odl_test_repo', '"""csit/variables/Variables.robot"""'], {}), "(odl.ODLTests.odl_test_repo, 'csit/variables/Variables.robot')\n", (7336, 7398), False, 'import os\n'), ((8217, 8291), 'os.path.join', 'os.path.join', (['odl.ODLTests.odl_test_repo', '"""csit/variables/Variables.robot"""'], {}), "(odl.ODLTests.odl_test_repo, 'csit/variables/Variables.robot')\n", (8229, 8291), False, 'import os\n'), ((10931, 10979), 'os.path.join', 'os.path.join', (['odl.ODLTests.res_dir', '"""stdout.txt"""'], {}), "(odl.ODLTests.res_dir, 'stdout.txt')\n", (10943, 10979), False, 'import os\n'), ((15943, 15975), 'mock.Mock', 'mock.Mock', ([], {'side_effect': 'exception'}), '(side_effect=exception)\n', (15952, 15975), False, 'import mock\n'), ((16033, 16063), 'mock.Mock', 'mock.Mock', ([], {'return_value': 'status'}), '(return_value=status)\n', (16042, 16063), False, 'import mock\n'), ((4837, 4859), 'mock.Mock', 'mock.Mock', ([], {'suite': 'suite'}), '(suite=suite)\n', (4846, 4859), False, 'import mock\n'), ((10700, 10748), 'os.path.join', 'os.path.join', (['odl.ODLTests.res_dir', '"""output.xml"""'], {}), "(odl.ODLTests.res_dir, 'output.xml')\n", (10712, 10748), False, 'import os\n'), ((18170, 18202), 'keystoneauth1.exceptions.auth_plugins.MissingAuthPlugin', 'auth_plugins.MissingAuthPlugin', ([], {}), '()\n', (18200, 18202), False, 'from keystoneauth1.exceptions import auth_plugins\n'), ((20276, 20316), 'six.moves.urllib.parse.urlparse', 'urllib.parse.urlparse', (['self._neutron_url'], {}), '(self._neutron_url)\n', (20297, 20316), False, 'from six.moves import urllib\n'), ((22453, 22493), 'six.moves.urllib.parse.urlparse', 'urllib.parse.urlparse', (['self._neutron_url'], {}), '(self._neutron_url)\n', (22474, 22493), False, 'from six.moves import urllib\n'), ((9743, 9783), 'six.moves.urllib.parse.urlparse', 'urllib.parse.urlparse', (['self._os_auth_url'], {}), '(self._os_auth_url)\n', (9764, 9783), False, 'from six.moves import urllib\n'), ((9812, 9852), 'six.moves.urllib.parse.urlparse', 'urllib.parse.urlparse', (['self._os_auth_url'], {}), '(self._os_auth_url)\n', (9833, 9852), False, 'from six.moves import urllib\n')]