functest/tests/unit/odl/test_odl.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016 Orange and others.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9
  10 """Define the classes required to fully cover odl."""
  11
  12 import logging
  13 import os
  14 import unittest
  15
  16 import mock
  17 import munch
  18 from robot.errors import RobotError
  19 import six
  20 from six.moves import urllib
  21 from xtesting.core import testcase
  22
  23 from functest.opnfv_tests.sdn.odl import odl
  24
  25 __author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
  26
  27
  28 class ODLTesting(unittest.TestCase):
  29
  30     """The super class which testing classes could inherit."""
  31     # pylint: disable=missing-docstring
  32
  33     logging.disable(logging.CRITICAL)
  34
  35     _keystone_ip = "127.0.0.1"
  36     _neutron_url = u"https://127.0.0.1:9696"
  37     _neutron_id = u"dummy"
  38     _sdn_controller_ip = "127.0.0.3"
  39     _os_auth_url = "http://{}:5000/v3".format(_keystone_ip)
  40     _os_projectname = "admin"
  41     _os_username = "admin"
  42     _os_password = "admin"
  43     _odl_webport = "8080"
  44     _odl_restconfport = "8181"
  45     _odl_username = "admin"
  46     _odl_password = "admin"
  47     _os_userdomainname = 'Default'
  48     _os_projectdomainname = 'Default'
  49     _os_interface = "public"
  50
  51     def setUp(self):
  52         for var in ("INSTALLER_TYPE", "SDN_CONTROLLER", "SDN_CONTROLLER_IP"):
  53             if var in os.environ:
  54                 del os.environ[var]
  55         os.environ["OS_AUTH_URL"] = self._os_auth_url
  56         os.environ["OS_USERNAME"] = self._os_username
  57         os.environ["OS_USER_DOMAIN_NAME"] = self._os_userdomainname
  58         os.environ["OS_PASSWORD"] = self._os_password
  59         os.environ["OS_PROJECT_NAME"] = self._os_projectname
  60         os.environ["OS_PROJECT_DOMAIN_NAME"] = self._os_projectdomainname
  61         os.environ["OS_PASSWORD"] = self._os_password
  62         os.environ["OS_INTERFACE"] = self._os_interface
  63         self.test = odl.ODLTests(case_name='odl', project_name='functest')
  64         self.defaultargs = {'odlusername': self._odl_username,
  65                             'odlpassword': self._odl_password,
  66                             'neutronurl': "http://{}:9696".format(
  67                                 self._keystone_ip),
  68                             'osauthurl': self._os_auth_url,
  69                             'osusername': self._os_username,
  70                             'osuserdomainname': self._os_userdomainname,
  71                             'osprojectname': self._os_projectname,
  72                             'osprojectdomainname': self._os_projectdomainname,
  73                             'ospassword': self._os_password,
  74                             'odlip': self._keystone_ip,
  75                             'odlwebport': self._odl_webport,
  76                             'odlrestconfport': self._odl_restconfport,
  77                             'pushtodb': False}
  78
  79
  80 class ODLRobotTesting(ODLTesting):
  81
  82     """The class testing ODLTests.set_robotframework_vars()."""
  83     # pylint: disable=missing-docstring
  84
  85     @mock.patch('fileinput.input', side_effect=Exception())
  86     def test_set_vars_ko(self, mock_method):
  87         self.assertFalse(self.test.set_robotframework_vars())
  88         mock_method.assert_called_once_with(
  89             os.path.join(odl.ODLTests.odl_test_repo,
  90                          'csit/variables/Variables.robot'), inplace=True)
  91
  92     @mock.patch('fileinput.input', return_value=[])
  93     def test_set_vars_empty(self, mock_method):
  94         self.assertTrue(self.test.set_robotframework_vars())
  95         mock_method.assert_called_once_with(
  96             os.path.join(odl.ODLTests.odl_test_repo,
  97                          'csit/variables/Variables.robot'), inplace=True)
  98
  99     @mock.patch('sys.stdout', new_callable=six.StringIO)
 100     def _test_set_vars(self, msg1, msg2, *args):
 101         line = mock.MagicMock()
 102         line.__iter__.return_value = [msg1]
 103         with mock.patch('fileinput.input', return_value=line) as mock_method:
 104             self.assertTrue(self.test.set_robotframework_vars())
 105             mock_method.assert_called_once_with(
 106                 os.path.join(odl.ODLTests.odl_test_repo,
 107                              'csit/variables/Variables.robot'), inplace=True)
 108             self.assertEqual(args[0].getvalue(), "{}\n".format(msg2))
 109
 110     def test_set_vars_auth_default(self):
 111         self._test_set_vars(
 112             "@{AUTH} ",
 113             "@{AUTH}           admin    admin")
 114
 115     def test_set_vars_auth1(self):
 116         self._test_set_vars(
 117             "@{AUTH1}           foo    bar",
 118             "@{AUTH1}           foo    bar")
 119
 120     @mock.patch('sys.stdout', new_callable=six.StringIO)
 121     def test_set_vars_auth_foo(self, *args):
 122         line = mock.MagicMock()
 123         line.__iter__.return_value = ["@{AUTH} "]
 124         with mock.patch('fileinput.input', return_value=line) as mock_method:
 125             self.assertTrue(self.test.set_robotframework_vars('foo', 'bar'))
 126             mock_method.assert_called_once_with(
 127                 os.path.join(odl.ODLTests.odl_test_repo,
 128                              'csit/variables/Variables.robot'), inplace=True)
 129             self.assertEqual(
 130                 args[0].getvalue(),
 131                 "@{AUTH}           foo    bar\n")
 132
 133
 134 class ODLMainTesting(ODLTesting):
 135
 136     """The class testing ODLTests.run_suites()."""
 137     # pylint: disable=missing-docstring
 138
 139     def _get_run_suites_kwargs(self, key=None):
 140         kwargs = {'odlusername': self._odl_username,
 141                   'odlpassword': self._odl_password,
 142                   'neutronurl': self._neutron_url,
 143                   'osauthurl': self._os_auth_url,
 144                   'osusername': self._os_username,
 145                   'osuserdomainname': self._os_userdomainname,
 146                   'osprojectname': self._os_projectname,
 147                   'osprojectdomainname': self._os_projectdomainname,
 148                   'ospassword': self._os_password,
 149                   'odlip': self._sdn_controller_ip,
 150                   'odlwebport': self._odl_webport,
 151                   'odlrestconfport': self._odl_restconfport}
 152         if key:
 153             del kwargs[key]
 154         return kwargs
 155
 156     def _test_run_suites(self, status, *args):
 157         kwargs = self._get_run_suites_kwargs()
 158         self.assertEqual(self.test.run_suites(**kwargs), status)
 159         if args:
 160             args[0].assert_called_once_with(self.test.odl_variables_file)
 161         if len(args) > 1:
 162             variable = [
 163                 'KEYSTONEURL:{}://{}'.format(
 164                     urllib.parse.urlparse(self._os_auth_url).scheme,
 165                     urllib.parse.urlparse(self._os_auth_url).netloc),
 166                 'NEUTRONURL:{}'.format(self._neutron_url),
 167                 'OS_AUTH_URL:"{}"'.format(self._os_auth_url),
 168                 'OSUSERNAME:"{}"'.format(self._os_username),
 169                 'OSUSERDOMAINNAME:"{}"'.format(self._os_userdomainname),
 170                 'OSTENANTNAME:"{}"'.format(self._os_projectname),
 171                 'OSPROJECTDOMAINNAME:"{}"'.format(self._os_projectdomainname),
 172                 'OSPASSWORD:"{}"'.format(self._os_password),
 173                 'ODL_SYSTEM_IP:{}'.format(self._sdn_controller_ip),
 174                 'PORT:{}'.format(self._odl_webport),
 175                 'RESTCONFPORT:{}'.format(self._odl_restconfport)]
 176             args[1].assert_called_once_with(
 177                 odl.ODLTests.basic_suite_dir, odl.ODLTests.neutron_suite_dir,
 178                 include=[],
 179                 log='NONE',
 180                 output=os.path.join(self.test.res_dir, 'output.xml'),
 181                 report='NONE', stdout=mock.ANY, variable=variable,
 182                 variablefile=[])
 183
 184     def _test_no_keyword(self, key):
 185         kwargs = self._get_run_suites_kwargs(key)
 186         self.assertEqual(self.test.run_suites(**kwargs),
 187                          testcase.TestCase.EX_RUN_ERROR)
 188
 189     def test_no_odlusername(self):
 190         self._test_no_keyword('odlusername')
 191
 192     def test_no_odlpassword(self):
 193         self._test_no_keyword('odlpassword')
 194
 195     def test_no_neutronurl(self):
 196         self._test_no_keyword('neutronurl')
 197
 198     def test_no_osauthurl(self):
 199         self._test_no_keyword('osauthurl')
 200
 201     def test_no_osusername(self):
 202         self._test_no_keyword('osusername')
 203
 204     def test_no_osprojectname(self):
 205         self._test_no_keyword('osprojectname')
 206
 207     def test_no_ospassword(self):
 208         self._test_no_keyword('ospassword')
 209
 210     def test_no_odlip(self):
 211         self._test_no_keyword('odlip')
 212
 213     def test_no_odlwebport(self):
 214         self._test_no_keyword('odlwebport')
 215
 216     def test_no_odlrestconfport(self):
 217         self._test_no_keyword('odlrestconfport')
 218
 219     @mock.patch('os.path.isfile', return_value=True)
 220     def test_set_vars_ko(self, *args):
 221         with mock.patch.object(self.test, 'set_robotframework_vars',
 222                                return_value=False) as mock_object:
 223             self._test_run_suites(testcase.TestCase.EX_RUN_ERROR)
 224             mock_object.assert_called_once_with(
 225                 self._odl_username, self._odl_password)
 226         args[0].assert_called_once_with(self.test.odl_variables_file)
 227
 228     @mock.patch('os.makedirs')
 229     @mock.patch('robot.run', side_effect=RobotError)
 230     @mock.patch('os.path.isfile', return_value=True)
 231     def test_run_ko(self, *args):
 232         with mock.patch.object(self.test, 'set_robotframework_vars',
 233                                return_value=True), \
 234                 self.assertRaises(RobotError):
 235             self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)
 236
 237     @mock.patch('os.makedirs')
 238     @mock.patch('robot.run')
 239     @mock.patch('os.path.isfile', return_value=True)
 240     def test_parse_results_ko(self, *args):
 241         with mock.patch.object(self.test, 'set_robotframework_vars',
 242                                return_value=True), \
 243                 mock.patch.object(self.test, 'parse_results',
 244                                   side_effect=RobotError):
 245             self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)
 246
 247     @mock.patch('os.makedirs')
 248     @mock.patch('robot.run')
 249     @mock.patch('os.path.isfile', return_value=True)
 250     def test_generate_report_ko(self, *args):
 251         with mock.patch.object(self.test, 'set_robotframework_vars',
 252                                return_value=True), \
 253                 mock.patch.object(self.test, 'parse_results'), \
 254                 mock.patch.object(self.test, 'generate_report',
 255                                   return_value=1):
 256             self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)
 257
 258     @mock.patch('os.makedirs')
 259     @mock.patch('robot.run')
 260     @mock.patch('os.path.isfile', return_value=True)
 261     def test_generate_report_exc(self, *args):
 262         with mock.patch.object(self.test, 'set_robotframework_vars',
 263                                return_value=True), \
 264                 mock.patch.object(self.test, 'parse_results'), \
 265                 mock.patch.object(self.test, 'generate_report',
 266                                   side_effect=Exception):
 267             self._test_run_suites(testcase.TestCase.EX_RUN_ERROR, *args)
 268
 269     @mock.patch('os.makedirs')
 270     @mock.patch('robot.run')
 271     @mock.patch('os.path.isfile', return_value=True)
 272     def test_ok(self, *args):
 273         with mock.patch.object(self.test, 'set_robotframework_vars',
 274                                return_value=True), \
 275                 mock.patch.object(self.test, 'parse_results'), \
 276                 mock.patch.object(self.test, 'generate_report',
 277                                   return_value=0):
 278             self._test_run_suites(testcase.TestCase.EX_OK, *args)
 279
 280     @mock.patch('os.makedirs')
 281     @mock.patch('robot.run')
 282     @mock.patch('os.path.isfile', return_value=False)
 283     def test_ok_no_creds(self, *args):
 284         with mock.patch.object(self.test, 'set_robotframework_vars',
 285                                return_value=True) as mock_method, \
 286                 mock.patch.object(self.test, 'parse_results'), \
 287                 mock.patch.object(self.test, 'generate_report',
 288                                   return_value=0):
 289             self._test_run_suites(testcase.TestCase.EX_OK, *args)
 290             mock_method.assert_not_called()
 291
 292     @mock.patch('os.makedirs')
 293     @mock.patch('robot.run', return_value=1)
 294     @mock.patch('os.path.isfile', return_value=True)
 295     def test_testcases_in_failure(self, *args):
 296         with mock.patch.object(self.test, 'set_robotframework_vars',
 297                                return_value=True), \
 298                 mock.patch.object(self.test, 'parse_results'), \
 299                 mock.patch.object(self.test, 'generate_report',
 300                                   return_value=0):
 301             self._test_run_suites(testcase.TestCase.EX_OK, *args)
 302
 303
 304 class ODLRunTesting(ODLTesting):
 305     """The class testing ODLTests.run()."""
 306     # pylint: disable=too-many-public-methods,missing-docstring
 307
 308     @mock.patch('os_client_config.make_shade', side_effect=Exception)
 309     def test_no_cloud(self, *args):
 310         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 311         args[0].assert_called_once_with()
 312
 313     @mock.patch('os_client_config.make_shade')
 314     def test_no_service1(self, *args):
 315         args[0].return_value.search_services.return_value = None
 316         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 317         args[0].return_value.search_services.assert_called_once_with('neutron')
 318         args[0].return_value.search_endpoints.assert_not_called()
 319
 320     @mock.patch('os_client_config.make_shade')
 321     def test_no_service2(self, *args):
 322         args[0].return_value.search_services.return_value = []
 323         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 324         args[0].return_value.search_services.assert_called_once_with('neutron')
 325         args[0].return_value.search_endpoints.assert_not_called()
 326
 327     @mock.patch('os_client_config.make_shade')
 328     def test_no_service3(self, *args):
 329         args[0].return_value.search_services.return_value = [
 330             munch.Munch()]
 331         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 332         args[0].return_value.search_services.assert_called_once_with('neutron')
 333         args[0].return_value.search_endpoints.assert_not_called()
 334
 335     @mock.patch('os_client_config.make_shade')
 336     def test_no_endpoint1(self, *args):
 337         args[0].return_value.search_services.return_value = [
 338             munch.Munch(id=self._neutron_id)]
 339         args[0].return_value.search_endpoints.return_value = None
 340         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 341         args[0].return_value.search_services.assert_called_once_with('neutron')
 342         args[0].return_value.search_endpoints.assert_called_once_with(
 343             filters={'interface': self._os_interface,
 344                      'service_id': self._neutron_id})
 345
 346     @mock.patch('os_client_config.make_shade')
 347     def test_no_endpoint2(self, *args):
 348         args[0].return_value.search_services.return_value = [
 349             munch.Munch(id=self._neutron_id)]
 350         args[0].return_value.search_endpoints.return_value = []
 351         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 352         args[0].return_value.search_services.assert_called_once_with('neutron')
 353         args[0].return_value.search_endpoints.assert_called_once_with(
 354             filters={'interface': self._os_interface,
 355                      'service_id': self._neutron_id})
 356
 357     @mock.patch('os_client_config.make_shade')
 358     def test_no_endpoint3(self, *args):
 359         args[0].return_value.search_services.return_value = [
 360             munch.Munch(id=self._neutron_id)]
 361         args[0].return_value.search_endpoints.return_value = [munch.Munch()]
 362         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 363         args[0].return_value.search_services.assert_called_once_with('neutron')
 364         args[0].return_value.search_endpoints.assert_called_once_with(
 365             filters={'interface': self._os_interface,
 366                      'service_id': self._neutron_id})
 367
 368     @mock.patch('os_client_config.make_shade')
 369     def test_endpoint_interface(self, *args):
 370         args[0].return_value.search_services.return_value = [
 371             munch.Munch(id=self._neutron_id)]
 372         args[0].return_value.search_endpoints.return_value = [munch.Munch()]
 373         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 374         args[0].return_value.search_services.assert_called_once_with('neutron')
 375         args[0].return_value.search_endpoints.assert_called_once_with(
 376             filters={'interface': self._os_interface,
 377                      'service_id': self._neutron_id})
 378
 379     @mock.patch('os_client_config.make_shade')
 380     def _test_no_env_var(self, var, *args):
 381         del os.environ[var]
 382         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 383         args[0].assert_called_once_with()
 384
 385     @mock.patch('os_client_config.make_shade')
 386     def _test_missing_value(self, *args):
 387         self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR)
 388         args[0].assert_called_once_with()
 389
 390     @mock.patch('os_client_config.make_shade')
 391     def _test_run(self, status=testcase.TestCase.EX_OK,
 392                   exception=None, *args, **kwargs):
 393         # pylint: disable=keyword-arg-before-vararg
 394         args[0].return_value.search_services.return_value = [
 395             munch.Munch(id=self._neutron_id)]
 396         args[0].return_value.search_endpoints.return_value = [
 397             munch.Munch(url=self._neutron_url)]
 398         odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3'
 399         odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080'
 400         odlrestconfport = (kwargs['odlrestconfport']
 401                            if 'odlrestconfport' in kwargs else '8181')
 402         if exception:
 403             self.test.run_suites = mock.Mock(side_effect=exception)
 404         else:
 405             self.test.run_suites = mock.Mock(return_value=status)
 406         self.assertEqual(self.test.run(), status)
 407         self.test.run_suites.assert_called_once_with(
 408             odl.ODLTests.default_suites, neutronurl=self._neutron_url,
 409             odlip=odlip, odlpassword=self._odl_password,
 410             odlrestconfport=odlrestconfport, odlusername=self._odl_username,
 411             odlwebport=odlwebport, osauthurl=self._os_auth_url,
 412             ospassword=self._os_password, osprojectname=self._os_projectname,
 413             osusername=self._os_username,
 414             osprojectdomainname=self._os_projectdomainname,
 415             osuserdomainname=self._os_userdomainname)
 416         args[0].assert_called_once_with()
 417         args[0].return_value.search_services.assert_called_once_with('neutron')
 418         args[0].return_value.search_endpoints.assert_called_once_with(
 419             filters={
 420                 'interface': os.environ.get(
 421                     "OS_INTERFACE", "public").replace('URL', ''),
 422                 'service_id': self._neutron_id})
 423
 424     @mock.patch('os_client_config.make_shade')
 425     def _test_multiple_suites(self, suites,
 426                               status=testcase.TestCase.EX_OK, *args, **kwargs):
 427         # pylint: disable=keyword-arg-before-vararg
 428         args[0].return_value.search_endpoints.return_value = [
 429             munch.Munch(url=self._neutron_url)]
 430         args[0].return_value.search_services.return_value = [
 431             munch.Munch(id=self._neutron_id)]
 432         odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3'
 433         odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080'
 434         odlrestconfport = (kwargs['odlrestconfport']
 435                            if 'odlrestconfport' in kwargs else '8181')
 436         self.test.run_suites = mock.Mock(return_value=status)
 437         self.assertEqual(self.test.run(suites=suites), status)
 438         self.test.run_suites.assert_called_once_with(
 439             suites, neutronurl=self._neutron_url, odlip=odlip,
 440             odlpassword=self._odl_password, odlrestconfport=odlrestconfport,
 441             odlusername=self._odl_username, odlwebport=odlwebport,
 442             osauthurl=self._os_auth_url, ospassword=self._os_password,
 443             osprojectname=self._os_projectname, osusername=self._os_username,
 444             osprojectdomainname=self._os_projectdomainname,
 445             osuserdomainname=self._os_userdomainname)
 446         args[0].assert_called_once_with()
 447         args[0].return_value.search_services.assert_called_once_with('neutron')
 448         args[0].return_value.search_endpoints.assert_called_once_with(
 449             filters={'interface': os.environ.get("OS_INTERFACE", "public"),
 450                      'service_id': self._neutron_id})
 451
 452     def test_exc(self):
 453         with mock.patch('os_client_config.make_shade',
 454                         side_effect=Exception()):
 455             self.assertEqual(self.test.run(),
 456                              testcase.TestCase.EX_RUN_ERROR)
 457
 458     def test_no_os_auth_url(self):
 459         self._test_no_env_var("OS_AUTH_URL")
 460
 461     def test_no_os_username(self):
 462         self._test_no_env_var("OS_USERNAME")
 463
 464     def test_no_os_password(self):
 465         self._test_no_env_var("OS_PASSWORD")
 466
 467     def test_no_os__name(self):
 468         self._test_no_env_var("OS_PROJECT_NAME")
 469
 470     def test_run_suites_false(self):
 471         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 472         self._test_run(testcase.TestCase.EX_RUN_ERROR, None,
 473                        odlip=self._sdn_controller_ip,
 474                        odlwebport=self._odl_webport)
 475
 476     def test_run_suites_exc(self):
 477         with self.assertRaises(Exception):
 478             os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 479             self._test_run(testcase.TestCase.EX_RUN_ERROR,
 480                            Exception(),
 481                            odlip=self._sdn_controller_ip,
 482                            odlwebport=self._odl_webport)
 483
 484     def test_no_sdn_controller_ip(self):
 485         self._test_missing_value()
 486
 487     def test_without_installer_type(self):
 488         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 489         self._test_run(testcase.TestCase.EX_OK, None,
 490                        odlip=self._sdn_controller_ip,
 491                        odlwebport=self._odl_webport)
 492
 493     def test_without_os_interface(self):
 494         del os.environ["OS_INTERFACE"]
 495         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 496         self._test_run(testcase.TestCase.EX_OK, None,
 497                        odlip=self._sdn_controller_ip,
 498                        odlwebport=self._odl_webport)
 499
 500     def test_os_interface_public(self):
 501         os.environ["OS_INTERFACE"] = "public"
 502         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 503         self._test_run(testcase.TestCase.EX_OK, None,
 504                        odlip=self._sdn_controller_ip,
 505                        odlwebport=self._odl_webport)
 506
 507     def test_os_interface_publicurl(self):
 508         os.environ["OS_INTERFACE"] = "publicURL"
 509         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 510         self._test_run(testcase.TestCase.EX_OK, None,
 511                        odlip=self._sdn_controller_ip,
 512                        odlwebport=self._odl_webport)
 513
 514     def test_os_interface_internal(self):
 515         os.environ["OS_INTERFACE"] = "internal"
 516         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 517         self._test_run(testcase.TestCase.EX_OK, None,
 518                        odlip=self._sdn_controller_ip,
 519                        odlwebport=self._odl_webport)
 520
 521     def test_os_interface_admin(self):
 522         os.environ["OS_INTERFACE"] = "admin"
 523         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 524         self._test_run(testcase.TestCase.EX_OK, None,
 525                        odlip=self._sdn_controller_ip,
 526                        odlwebport=self._odl_webport)
 527
 528     def test_suites(self):
 529         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 530         self._test_multiple_suites(
 531             [odl.ODLTests.basic_suite_dir],
 532             testcase.TestCase.EX_OK,
 533             odlip=self._sdn_controller_ip,
 534             odlwebport=self._odl_webport)
 535
 536     def test_apex_no_controller_ip(self):
 537         os.environ["INSTALLER_TYPE"] = "apex"
 538         self._test_missing_value()
 539
 540     def test_apex(self):
 541         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 542         os.environ["INSTALLER_TYPE"] = "apex"
 543         self._test_run(testcase.TestCase.EX_OK, None,
 544                        odlip=self._sdn_controller_ip, odlwebport='8081',
 545                        odlrestconfport='8081')
 546
 547     def test_netvirt_no_controller_ip(self):
 548         os.environ["INSTALLER_TYPE"] = "netvirt"
 549         self._test_missing_value()
 550
 551     def test_netvirt(self):
 552         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 553         os.environ["INSTALLER_TYPE"] = "netvirt"
 554         self._test_run(testcase.TestCase.EX_OK, None,
 555                        odlip=self._sdn_controller_ip, odlwebport='8081',
 556                        odlrestconfport='8081')
 557
 558     def test_compass(self):
 559         os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
 560         os.environ["INSTALLER_TYPE"] = "compass"
 561         self._test_run(testcase.TestCase.EX_OK, None,
 562                        odlip=self._sdn_controller_ip,
 563                        odlrestconfport='8080')
 564
 565     def test_compass_no_controller_ip(self):
 566         os.environ["INSTALLER_TYPE"] = "compass"
 567         self._test_missing_value()
 568
 569
 570 class ODLArgParserTesting(ODLTesting):
 571
 572     """The class testing ODLParser."""
 573     # pylint: disable=missing-docstring
 574
 575     def setUp(self):
 576         self.parser = odl.ODLParser()
 577         super(ODLArgParserTesting, self).setUp()
 578
 579     def test_default(self):
 580         self.assertEqual(self.parser.parse_args(), self.defaultargs)
 581
 582     def test_basic(self):
 583         self.defaultargs['neutronurl'] = self._neutron_url
 584         self.defaultargs['odlip'] = self._sdn_controller_ip
 585         self.assertEqual(
 586             self.parser.parse_args(
 587                 ["--neutronurl={}".format(self._neutron_url),
 588                  "--odlip={}".format(self._sdn_controller_ip)]),
 589             self.defaultargs)
 590
 591     @mock.patch('sys.stderr', new_callable=six.StringIO)
 592     def test_fail(self, mock_method):
 593         self.defaultargs['foo'] = 'bar'
 594         with self.assertRaises(SystemExit):
 595             self.parser.parse_args(["--foo=bar"])
 596         self.assertTrue(mock_method.getvalue().startswith("usage:"))
 597
 598     def _test_arg(self, arg, value):
 599         self.defaultargs[arg] = value
 600         self.assertEqual(
 601             self.parser.parse_args(["--{}={}".format(arg, value)]),
 602             self.defaultargs)
 603
 604     def test_odlusername(self):
 605         self._test_arg('odlusername', 'foo')
 606
 607     def test_odlpassword(self):
 608         self._test_arg('odlpassword', 'foo')
 609
 610     def test_osauthurl(self):
 611         self._test_arg('osauthurl', 'http://127.0.0.4:5000/v2')
 612
 613     def test_neutronurl(self):
 614         self._test_arg('neutronurl', 'http://127.0.0.4:9696')
 615
 616     def test_osusername(self):
 617         self._test_arg('osusername', 'foo')
 618
 619     def test_osuserdomainname(self):
 620         self._test_arg('osuserdomainname', 'domain')
 621
 622     def test_osprojectname(self):
 623         self._test_arg('osprojectname', 'foo')
 624
 625     def test_osprojectdomainname(self):
 626         self._test_arg('osprojectdomainname', 'domain')
 627
 628     def test_ospassword(self):
 629         self._test_arg('ospassword', 'foo')
 630
 631     def test_odlip(self):
 632         self._test_arg('odlip', '127.0.0.4')
 633
 634     def test_odlwebport(self):
 635         self._test_arg('odlwebport', '80')
 636
 637     def test_odlrestconfport(self):
 638         self._test_arg('odlrestconfport', '80')
 639
 640     def test_pushtodb(self):
 641         self.defaultargs['pushtodb'] = True
 642         self.assertEqual(self.parser.parse_args(["--{}".format('pushtodb')]),
 643                          self.defaultargs)
 644
 645     def test_multiple_args(self):
 646         self.defaultargs['neutronurl'] = self._neutron_url
 647         self.defaultargs['odlip'] = self._sdn_controller_ip
 648         self.assertEqual(
 649             self.parser.parse_args(
 650                 ["--neutronurl={}".format(self._neutron_url),
 651                  "--odlip={}".format(self._sdn_controller_ip)]),
 652             self.defaultargs)
 653
 654
 655 if __name__ == "__main__":
 656     logging.disable(logging.CRITICAL)
 657     unittest.main(verbosity=2)