gerrit.onap Code Review - sdc/sdc-distribution-client.git/blob

   1 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   2 #    not use this file except in compliance with the License. You may obtain
   3 #    a copy of the License at
   4 #
   5 #         http://www.apache.org/licenses/LICENSE-2.0
   6 #
   7 #    Unless required by applicable law or agreed to in writing, software
   8 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   9 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  10 #    License for the specific language governing permissions and limitations
  11 #    under the License.
  12
  13 import os
  14 import six
  15 from toscaparser.common import exception
  16 import toscaparser.elements.interfaces as ifaces
  17 from toscaparser.elements.nodetype import NodeType
  18 from toscaparser.elements.portspectype import PortSpec
  19 from toscaparser.functions import GetInput
  20 from toscaparser.functions import GetProperty
  21 from toscaparser.nodetemplate import NodeTemplate
  22 from toscaparser.tests.base import TestCase
  23 from toscaparser.tosca_template import ToscaTemplate
  24 from toscaparser.utils.gettextutils import _
  25 import toscaparser.utils.yamlparser
  26
  27
  28 class ToscaTemplateTest(TestCase):
  29     '''TOSCA template.'''
  30     tosca_tpl = os.path.join(
  31         os.path.dirname(os.path.abspath(__file__)),
  32         "data/tosca_single_instance_wordpress.yaml")
  33     params = {'db_name': 'my_wordpress', 'db_user': 'my_db_user',
  34               'db_root_pwd': '12345678'}
  35     tosca = ToscaTemplate(tosca_tpl, parsed_params=params)
  36     tosca_elk_tpl = os.path.join(
  37         os.path.dirname(os.path.abspath(__file__)),
  38         "data/tosca_elk.yaml")
  39     tosca_repo_tpl = os.path.join(
  40         os.path.dirname(os.path.abspath(__file__)),
  41         "data/repositories/tosca_repositories_test_definition.yaml")
  42
  43     def test_version(self):
  44         self.assertEqual(self.tosca.version, "tosca_simple_yaml_1_0")
  45
  46     def test_description(self):
  47         expected_description = "TOSCA simple profile with wordpress, " \
  48                                "web server and mysql on the same server."
  49         self.assertEqual(self.tosca.description, expected_description)
  50
  51     def test_inputs(self):
  52         self.assertEqual(
  53             ['cpus', 'db_name', 'db_port',
  54              'db_pwd', 'db_root_pwd', 'db_user'],
  55             sorted([input.name for input in self.tosca.inputs]))
  56
  57         input_name = "db_port"
  58         expected_description = "Port for the MySQL database."
  59         for input in self.tosca.inputs:
  60             if input.name == input_name:
  61                 self.assertEqual(input.description, expected_description)
  62
  63     def test_node_tpls(self):
  64         '''Test nodetemplate names.'''
  65         self.assertEqual(
  66             ['mysql_database', 'mysql_dbms', 'server',
  67              'webserver', 'wordpress'],
  68             sorted([tpl.name for tpl in self.tosca.nodetemplates]))
  69
  70         tpl_name = "mysql_database"
  71         expected_type = "tosca.nodes.Database"
  72         expected_properties = ['name', 'password', 'user']
  73         expected_capabilities = ['database_endpoint', 'feature']
  74         expected_requirements = [{'host': 'mysql_dbms'}]
  75         ''' TODO: needs enhancement in tosca_elk.yaml..
  76         expected_relationshp = ['tosca.relationships.HostedOn']
  77         expected_host = ['mysql_dbms']
  78         '''
  79         expected_interface = [ifaces.LIFECYCLE_SHORTNAME]
  80
  81         for tpl in self.tosca.nodetemplates:
  82             if tpl_name == tpl.name:
  83                 '''Test node type.'''
  84                 self.assertEqual(tpl.type, expected_type)
  85
  86                 '''Test properties.'''
  87                 self.assertEqual(
  88                     expected_properties,
  89                     sorted(tpl.get_properties().keys()))
  90
  91                 '''Test capabilities.'''
  92                 self.assertEqual(
  93                     expected_capabilities,
  94                     sorted(tpl.get_capabilities().keys()))
  95
  96                 '''Test requirements.'''
  97                 self.assertEqual(
  98                     expected_requirements, tpl.requirements)
  99
 100                 '''Test relationship.'''
 101                 ''' needs enhancements in tosca_elk.yaml
 102                 self.assertEqual(
 103                     expected_relationshp,
 104                     [x.type for x in tpl.relationships.keys()])
 105                 self.assertEqual(
 106                     expected_host,
 107                     [y.name for y in tpl.relationships.values()])
 108                 '''
 109                 '''Test interfaces.'''
 110                 self.assertEqual(
 111                     expected_interface,
 112                     [x.type for x in tpl.interfaces])
 113
 114             if tpl.name == 'server':
 115                 '''Test property value'''
 116                 props = tpl.get_properties()
 117                 if props and 'mem_size' in props.keys():
 118                     self.assertEqual(props['mem_size'].value, '4096 MB')
 119                 '''Test capability'''
 120                 caps = tpl.get_capabilities()
 121                 self.assertIn('os', caps.keys())
 122                 os_props_objs = None
 123                 os_props = None
 124                 os_type_prop = None
 125                 if caps and 'os' in caps.keys():
 126                     capability = caps['os']
 127                     os_props_objs = capability.get_properties_objects()
 128                     os_props = capability.get_properties()
 129                     os_type_prop = capability.get_property_value('type')
 130                     break
 131                 self.assertEqual(
 132                     ['Linux'],
 133                     [p.value for p in os_props_objs if p.name == 'type'])
 134                 self.assertEqual(
 135                     'Linux',
 136                     os_props['type'].value if 'type' in os_props else '')
 137                 self.assertEqual('Linux', os_props['type'].value)
 138                 self.assertEqual('Linux', os_type_prop)
 139
 140     def test_node_inheritance_type(self):
 141         wordpress_node = [
 142             node for node in self.tosca.nodetemplates
 143             if node.name == 'wordpress'][0]
 144         self.assertTrue(
 145             wordpress_node.is_derived_from("tosca.nodes.WebApplication"))
 146         self.assertTrue(
 147             wordpress_node.is_derived_from("tosca.nodes.Root"))
 148         self.assertFalse(
 149             wordpress_node.is_derived_from("tosca.policies.Root"))
 150
 151     def test_outputs(self):
 152         self.assertEqual(
 153             ['website_url'],
 154             sorted([output.name for output in self.tosca.outputs]))
 155
 156     def test_interfaces(self):
 157         wordpress_node = [
 158             node for node in self.tosca.nodetemplates
 159             if node.name == 'wordpress'][0]
 160         interfaces = wordpress_node.interfaces
 161         self.assertEqual(2, len(interfaces))
 162         for interface in interfaces:
 163             if interface.name == 'create':
 164                 self.assertEqual(ifaces.LIFECYCLE_SHORTNAME,
 165                                  interface.type)
 166                 self.assertEqual('wordpress/wordpress_install.sh',
 167                                  interface.implementation)
 168                 self.assertIsNone(interface.inputs)
 169             elif interface.name == 'configure':
 170                 self.assertEqual(ifaces.LIFECYCLE_SHORTNAME,
 171                                  interface.type)
 172                 self.assertEqual('wordpress/wordpress_configure.sh',
 173                                  interface.implementation)
 174                 self.assertEqual(3, len(interface.inputs))
 175                 TestCase.skip(self, 'bug #1440247')
 176                 wp_db_port = interface.inputs['wp_db_port']
 177                 self.assertIsInstance(wp_db_port, GetProperty)
 178                 self.assertEqual('get_property', wp_db_port.name)
 179                 self.assertEqual(['SELF',
 180                                   'database_endpoint',
 181                                   'port'],
 182                                  wp_db_port.args)
 183                 result = wp_db_port.result()
 184                 self.assertIsInstance(result, GetInput)
 185             else:
 186                 raise AssertionError(
 187                     'Unexpected interface: {0}'.format(interface.name))
 188
 189     def test_normative_type_by_short_name(self):
 190         # test template with a short name Compute
 191         template = os.path.join(
 192             os.path.dirname(os.path.abspath(__file__)),
 193             "data/test_tosca_normative_type_by_shortname.yaml")
 194
 195         tosca_tpl = ToscaTemplate(template)
 196         expected_type = "tosca.nodes.Compute"
 197         for tpl in tosca_tpl.nodetemplates:
 198             self.assertEqual(tpl.type, expected_type)
 199         for tpl in tosca_tpl.nodetemplates:
 200             compute_type = NodeType(tpl.type)
 201             self.assertEqual(
 202                 sorted(['tosca.capabilities.Container',
 203                         'tosca.capabilities.Endpoint.Admin',
 204                         'tosca.capabilities.Node',
 205                         'tosca.capabilities.OperatingSystem',
 206                         'tosca.capabilities.network.Bindable',
 207                         'tosca.capabilities.Scalable']),
 208                 sorted([c.type
 209                         for c in compute_type.get_capabilities_objects()]))
 210
 211     def test_template_with_no_inputs(self):
 212         tosca_tpl = self._load_template('test_no_inputs_in_template.yaml')
 213         self.assertEqual(0, len(tosca_tpl.inputs))
 214
 215     def test_template_with_no_outputs(self):
 216         tosca_tpl = self._load_template('test_no_outputs_in_template.yaml')
 217         self.assertEqual(0, len(tosca_tpl.outputs))
 218
 219     def test_relationship_interface(self):
 220         template = ToscaTemplate(self.tosca_elk_tpl)
 221         for node_tpl in template.nodetemplates:
 222             if node_tpl.name == 'logstash':
 223                 config_interface = 'Configure'
 224                 artifact = 'logstash/configure_elasticsearch.py'
 225                 relation = node_tpl.relationships
 226                 for key in relation.keys():
 227                     rel_tpl = relation.get(key).get_relationship_template()
 228                     if rel_tpl:
 229                         self.assertTrue(rel_tpl[0].is_derived_from(
 230                             "tosca.relationships.Root"))
 231                         interfaces = rel_tpl[0].interfaces
 232                         for interface in interfaces:
 233                             self.assertEqual(config_interface,
 234                                              interface.type)
 235                             self.assertEqual('pre_configure_source',
 236                                              interface.name)
 237                             self.assertEqual(artifact,
 238                                              interface.implementation)
 239
 240     def test_relationship(self):
 241         template = ToscaTemplate(self.tosca_elk_tpl)
 242         for node_tpl in template.nodetemplates:
 243             if node_tpl.name == 'paypal_pizzastore':
 244                 expected_relationships = ['tosca.relationships.ConnectsTo',
 245                                           'tosca.relationships.HostedOn']
 246                 expected_hosts = ['tosca.nodes.Database',
 247                                   'tosca.nodes.WebServer']
 248                 self.assertEqual(len(node_tpl.relationships), 2)
 249                 self.assertEqual(
 250                     expected_relationships,
 251                     sorted([k.type for k in node_tpl.relationships.keys()]))
 252                 self.assertEqual(
 253                     expected_hosts,
 254                     sorted([v.type for v in node_tpl.relationships.values()]))
 255
 256     def test_repositories(self):
 257         template = ToscaTemplate(self.tosca_repo_tpl)
 258         self.assertEqual(
 259             ['repo_code0', 'repo_code1', 'repo_code2'],
 260             sorted([input.name for input in template.repositories]))
 261
 262         input_name = "repo_code2"
 263         expected_url = "https://github.com/nandinivemula/intern/master"
 264         for input in template.repositories:
 265             if input.name == input_name:
 266                 self.assertEqual(input.url, expected_url)
 267
 268     def test_template_macro(self):
 269         template = ToscaTemplate(self.tosca_elk_tpl)
 270         for node_tpl in template.nodetemplates:
 271             if node_tpl.name == 'mongo_server':
 272                 self.assertEqual(
 273                     ['disk_size', 'mem_size', 'num_cpus'],
 274                     sorted(node_tpl.get_capability('host').
 275                            get_properties().keys()))
 276
 277     def test_template_requirements(self):
 278         """Test different formats of requirements
 279
 280         The requirements can be defined in few different ways,
 281         1. Requirement expressed as a capability with an implicit relationship.
 282         2. Requirement expressed with explicit relationship.
 283         3. Requirement expressed with a relationship template.
 284         4. Requirement expressed via TOSCA types to provision a node
 285            with explicit relationship.
 286         5. Requirement expressed via TOSCA types with a filter.
 287         """
 288         tosca_tpl = os.path.join(
 289             os.path.dirname(os.path.abspath(__file__)),
 290             "data/requirements/test_requirements.yaml")
 291         tosca = ToscaTemplate(tosca_tpl)
 292         for node_tpl in tosca.nodetemplates:
 293             if node_tpl.name == 'my_app':
 294                 expected_relationship = [
 295                     ('tosca.relationships.ConnectsTo', 'mysql_database'),
 296                     ('tosca.relationships.HostedOn', 'my_webserver')]
 297                 actual_relationship = sorted([
 298                     (relation.type, node.name) for
 299                     relation, node in node_tpl.relationships.items()])
 300                 self.assertEqual(expected_relationship, actual_relationship)
 301             if node_tpl.name == 'mysql_database':
 302                     self.assertEqual(
 303                         [('tosca.relationships.HostedOn', 'my_dbms')],
 304                         [(relation.type, node.name) for
 305                          relation,
 306                          node in node_tpl.relationships.items()])
 307             if node_tpl.name == 'my_server':
 308                     self.assertEqual(
 309                         [('tosca.relationships.AttachesTo', 'my_storage')],
 310                         [(relation.type, node.name) for
 311                          relation,
 312                          node in node_tpl.relationships.items()])
 313
 314     def test_template_requirements_not_implemented(self):
 315         # TODO(spzala): replace this test with new one once TOSCA types look up
 316         # support is implemented.
 317         """Requirements that yet need to be implemented
 318
 319         The following requirement formats are not yet implemented,
 320         due to look up dependency:
 321         1. Requirement expressed via TOSCA types to provision a node
 322            with explicit relationship.
 323         2. Requirement expressed via TOSCA types with a filter.
 324         """
 325         tpl_snippet_1 = '''
 326         node_templates:
 327           mysql_database:
 328             type: tosca.nodes.Database
 329             description: Requires a particular node type and relationship.
 330                         To be full-filled via lookup into node repository.
 331             requirements:
 332               - req1:
 333                   node: tosca.nodes.DBMS
 334                   relationship: tosca.relationships.HostedOn
 335         '''
 336
 337         tpl_snippet_2 = '''
 338         node_templates:
 339           my_webserver:
 340             type: tosca.nodes.WebServer
 341             description: Requires a particular node type with a filter.
 342                          To be full-filled via lookup into node repository.
 343             requirements:
 344               - req1:
 345                   node: tosca.nodes.Compute
 346                   target_filter:
 347                     properties:
 348                       num_cpus: { in_range: [ 1, 4 ] }
 349                       mem_size: { greater_or_equal: 2 }
 350                     capabilities:
 351                       - tosca.capabilities.OS:
 352                           properties:
 353                             architecture: x86_64
 354                             type: linux
 355         '''
 356
 357         tpl_snippet_3 = '''
 358         node_templates:
 359           my_webserver2:
 360             type: tosca.nodes.WebServer
 361             description: Requires a node type with a particular capability.
 362                          To be full-filled via lookup into node repository.
 363             requirements:
 364               - req1:
 365                   node: tosca.nodes.Compute
 366                   relationship: tosca.relationships.HostedOn
 367                   capability: tosca.capabilities.Container
 368         '''
 369         self._requirements_not_implemented(tpl_snippet_1, 'mysql_database')
 370         self._requirements_not_implemented(tpl_snippet_2, 'my_webserver')
 371         self._requirements_not_implemented(tpl_snippet_3, 'my_webserver2')
 372
 373     def _requirements_not_implemented(self, tpl_snippet, tpl_name):
 374         nodetemplates = (toscaparser.utils.yamlparser.
 375                          simple_parse(tpl_snippet))['node_templates']
 376         self.assertRaises(
 377             NotImplementedError,
 378             lambda: NodeTemplate(tpl_name, nodetemplates).relationships)
 379
 380     # Test the following:
 381     # 1. Custom node type derived from 'WebApplication' named 'TestApp'
 382     #    with a custom Capability Type 'TestCapability'
 383     # 2. Same as #1, but referencing a custom 'TestCapability' Capability Type
 384     #    that is not defined
 385     def test_custom_capability_type_definition(self):
 386         tpl_snippet = '''
 387         node_templates:
 388           test_app:
 389             type: tosca.nodes.WebApplication.TestApp
 390             capabilities:
 391               test_cap:
 392                 properties:
 393                   test: 1
 394         '''
 395         # custom node type definition with custom capability type definition
 396         custom_def = '''
 397         tosca.nodes.WebApplication.TestApp:
 398           derived_from: tosca.nodes.WebApplication
 399           capabilities:
 400             test_cap:
 401                type: tosca.capabilities.TestCapability
 402         tosca.capabilities.TestCapability:
 403           derived_from: tosca.capabilities.Root
 404           properties:
 405             test:
 406               type: integer
 407               required: false
 408         '''
 409         expected_capabilities = ['app_endpoint', 'feature', 'test_cap']
 410         nodetemplates = (toscaparser.utils.yamlparser.
 411                          simple_parse(tpl_snippet))['node_templates']
 412         custom_def = (toscaparser.utils.yamlparser.
 413                       simple_parse(custom_def))
 414         name = list(nodetemplates.keys())[0]
 415         tpl = NodeTemplate(name, nodetemplates, custom_def)
 416         self.assertEqual(
 417             expected_capabilities,
 418             sorted(tpl.get_capabilities().keys()))
 419
 420         # custom definition without valid capability type definition
 421         custom_def = '''
 422         tosca.nodes.WebApplication.TestApp:
 423           derived_from: tosca.nodes.WebApplication
 424           capabilities:
 425             test_cap:
 426                type: tosca.capabilities.TestCapability
 427         '''
 428         custom_def = (toscaparser.utils.yamlparser.
 429                       simple_parse(custom_def))
 430         tpl = NodeTemplate(name, nodetemplates, custom_def)
 431         err = self.assertRaises(
 432             exception.InvalidTypeError,
 433             lambda: NodeTemplate(name, nodetemplates,
 434                                  custom_def).get_capabilities_objects())
 435         self.assertEqual('Type "tosca.capabilities.TestCapability" is not '
 436                          'a valid type.', six.text_type(err))
 437
 438     def test_local_template_with_local_relpath_import(self):
 439         tosca_tpl = os.path.join(
 440             os.path.dirname(os.path.abspath(__file__)),
 441             "data/tosca_single_instance_wordpress.yaml")
 442         params = {'db_name': 'my_wordpress', 'db_user': 'my_db_user',
 443                   'db_root_pwd': '12345678'}
 444         tosca = ToscaTemplate(tosca_tpl, parsed_params=params)
 445         self.assertTrue(tosca.topology_template.custom_defs)
 446
 447     def test_local_template_with_url_import(self):
 448         tosca_tpl = os.path.join(
 449             os.path.dirname(os.path.abspath(__file__)),
 450             "data/tosca_single_instance_wordpress_with_url_import.yaml")
 451         tosca = ToscaTemplate(tosca_tpl,
 452                               parsed_params={'db_root_pwd': '123456'})
 453         self.assertTrue(tosca.topology_template.custom_defs)
 454
 455     def test_url_template_with_local_relpath_import(self):
 456         tosca_tpl = ('https://raw.githubusercontent.com/openstack/'
 457                      'tosca-parser/master/toscaparser/tests/data/'
 458                      'tosca_single_instance_wordpress.yaml')
 459         tosca = ToscaTemplate(tosca_tpl, a_file=False,
 460                               parsed_params={"db_name": "mysql",
 461                                              "db_user": "mysql",
 462                                              "db_root_pwd": "1234",
 463                                              "db_pwd": "5678",
 464                                              "db_port": 3306,
 465                                              "cpus": 4})
 466         self.assertTrue(tosca.topology_template.custom_defs)
 467
 468     def test_url_template_with_local_abspath_import(self):
 469         tosca_tpl = ('https://raw.githubusercontent.com/openstack/'
 470                      'tosca-parser/master/toscaparser/tests/data/'
 471                      'tosca_single_instance_wordpress_with_local_abspath_'
 472                      'import.yaml')
 473         self.assertRaises(exception.ValidationError, ToscaTemplate, tosca_tpl,
 474                           None, False)
 475         err_msg = (_('Absolute file name "/tmp/tosca-parser/toscaparser/tests'
 476                      '/data/custom_types/wordpress.yaml" cannot be used in a '
 477                      'URL-based input template "%(tpl)s".')
 478                    % {'tpl': tosca_tpl})
 479         exception.ExceptionCollector.assertExceptionMessage(ImportError,
 480                                                             err_msg)
 481
 482     def test_url_template_with_url_import(self):
 483         tosca_tpl = ('https://raw.githubusercontent.com/openstack/'
 484                      'tosca-parser/master/toscaparser/tests/data/'
 485                      'tosca_single_instance_wordpress_with_url_import.yaml')
 486         tosca = ToscaTemplate(tosca_tpl, a_file=False,
 487                               parsed_params={"db_root_pwd": "1234"})
 488         self.assertTrue(tosca.topology_template.custom_defs)
 489
 490     def test_csar_parsing_wordpress(self):
 491         csar_archive = os.path.join(
 492             os.path.dirname(os.path.abspath(__file__)),
 493             'data/CSAR/csar_wordpress.zip')
 494         self.assertTrue(ToscaTemplate(csar_archive,
 495                                       parsed_params={"db_name": "mysql",
 496                                                      "db_user": "mysql",
 497                                                      "db_root_pwd": "1234",
 498                                                      "db_pwd": "5678",
 499                                                      "db_port": 3306,
 500                                                      "cpus": 4}))
 501
 502     def test_csar_parsing_elk_url_based(self):
 503         csar_archive = ('https://github.com/openstack/tosca-parser/raw/master/'
 504                         'toscaparser/tests/data/CSAR/csar_elk.zip')
 505         self.assertTrue(ToscaTemplate(csar_archive, a_file=False,
 506                                       parsed_params={"my_cpus": 4}))
 507
 508     def test_nested_imports_in_templates(self):
 509         tosca_tpl = os.path.join(
 510             os.path.dirname(os.path.abspath(__file__)),
 511             "data/test_instance_nested_imports.yaml")
 512         tosca = ToscaTemplate(tosca_tpl)
 513         expected_custom_types = ['tosca.nodes.WebApplication.WordPress',
 514                                  'test_namespace_prefix.Rsyslog',
 515                                  'Test2ndRsyslogType',
 516                                  'test_2nd_namespace_prefix.Rsyslog',
 517                                  'tosca.nodes.SoftwareComponent.Logstash',
 518                                  'tosca.nodes.SoftwareComponent.Rsyslog.'
 519                                  'TestRsyslogType']
 520         self.assertItemsEqual(tosca.topology_template.custom_defs.keys(),
 521                               expected_custom_types)
 522
 523     def test_invalid_template_file(self):
 524         template_file = 'invalid template file'
 525         expected_msg = (_('"%s" is not a valid file.') % template_file)
 526         self.assertRaises(
 527             exception.ValidationError,
 528             ToscaTemplate, template_file, None, False)
 529         exception.ExceptionCollector.assertExceptionMessage(ValueError,
 530                                                             expected_msg)
 531
 532     def test_multiple_validation_errors(self):
 533         tosca_tpl = os.path.join(
 534             os.path.dirname(os.path.abspath(__file__)),
 535             "data/test_multiple_validation_errors.yaml")
 536         self.assertRaises(exception.ValidationError, ToscaTemplate, tosca_tpl,
 537                           None)
 538         valid_versions = ', '.join(ToscaTemplate.VALID_TEMPLATE_VERSIONS)
 539         err1_msg = (_('The template version "tosca_simple_yaml_1" is invalid. '
 540                       'Valid versions are "%s".') % valid_versions)
 541         exception.ExceptionCollector.assertExceptionMessage(
 542             exception.InvalidTemplateVersion, err1_msg)
 543
 544         err2_msg = _('Import "custom_types/not_there.yaml" is not valid.')
 545         exception.ExceptionCollector.assertExceptionMessage(
 546             ImportError, err2_msg)
 547
 548         err3_msg = _('Type "tosca.nodes.WebApplication.WordPress" is not a '
 549                      'valid type.')
 550         exception.ExceptionCollector.assertExceptionMessage(
 551             exception.InvalidTypeError, err3_msg)
 552
 553         err4_msg = _('Node template "wordpress" contains unknown field '
 554                      '"requirement". Refer to the definition to verify valid '
 555                      'values.')
 556         exception.ExceptionCollector.assertExceptionMessage(
 557             exception.UnknownFieldError, err4_msg)
 558
 559         err5_msg = _('\'Property "passwords" was not found in node template '
 560                      '"mysql_database".\'')
 561         exception.ExceptionCollector.assertExceptionMessage(
 562             KeyError, err5_msg)
 563
 564         err6_msg = _('Template "mysql_dbms" is missing required field "type".')
 565         exception.ExceptionCollector.assertExceptionMessage(
 566             exception.MissingRequiredFieldError, err6_msg)
 567
 568         err7_msg = _('Node template "mysql_dbms" contains unknown field '
 569                      '"type1". Refer to the definition to verify valid '
 570                      'values.')
 571         exception.ExceptionCollector.assertExceptionMessage(
 572             exception.UnknownFieldError, err7_msg)
 573
 574         err8_msg = _('\'Node template "server1" was not found.\'')
 575         exception.ExceptionCollector.assertExceptionMessage(
 576             KeyError, err8_msg)
 577
 578         err9_msg = _('"relationship" used in template "webserver" is missing '
 579                      'required field "type".')
 580         exception.ExceptionCollector.assertExceptionMessage(
 581             exception.MissingRequiredFieldError, err9_msg)
 582
 583     def test_invalid_section_names(self):
 584         tosca_tpl = os.path.join(
 585             os.path.dirname(os.path.abspath(__file__)),
 586             "data/test_invalid_section_names.yaml")
 587         self.assertRaises(exception.ValidationError, ToscaTemplate, tosca_tpl,
 588                           None)
 589         err1_msg = _('Template contains unknown field '
 590                      '"tosca_definitions_versions". Refer to the definition '
 591                      'to verify valid values.')
 592         exception.ExceptionCollector.assertExceptionMessage(
 593             exception.UnknownFieldError, err1_msg)
 594
 595         err2_msg = _('Template contains unknown field "descriptions". '
 596                      'Refer to the definition to verify valid values.')
 597         exception.ExceptionCollector.assertExceptionMessage(
 598             exception.UnknownFieldError, err2_msg)
 599
 600         err3_msg = _('Template contains unknown field "import". Refer to '
 601                      'the definition to verify valid values.')
 602         exception.ExceptionCollector.assertExceptionMessage(
 603             exception.UnknownFieldError, err3_msg)
 604
 605         err4_msg = _('Template contains unknown field "topology_templates". '
 606                      'Refer to the definition to verify valid values.')
 607         exception.ExceptionCollector.assertExceptionMessage(
 608             exception.UnknownFieldError, err4_msg)
 609
 610     def test_csar_with_alternate_extenstion(self):
 611         tosca_tpl = os.path.join(
 612             os.path.dirname(os.path.abspath(__file__)),
 613             "data/CSAR/csar_elk.csar")
 614         tosca = ToscaTemplate(tosca_tpl, parsed_params={"my_cpus": 2})
 615         self.assertTrue(tosca.topology_template.custom_defs)
 616
 617     def test_available_rel_tpls(self):
 618         tosca_tpl = os.path.join(
 619             os.path.dirname(os.path.abspath(__file__)),
 620             "data/test_available_rel_tpls.yaml")
 621         tosca = ToscaTemplate(tosca_tpl)
 622         for node in tosca.nodetemplates:
 623             for relationship, target in node.relationships.items():
 624                 try:
 625                     target.relationships
 626                 except TypeError as error:
 627                     self.fail(error)
 628
 629     def test_no_input(self):
 630         self.assertRaises(exception.ValidationError, ToscaTemplate, None,
 631                           None, False, None)
 632         err_msg = (('No path or yaml_dict_tpl was provided. '
 633                     'There is nothing to parse.'))
 634         exception.ExceptionCollector.assertExceptionMessage(ValueError,
 635                                                             err_msg)
 636
 637     def test_path_and_yaml_dict_tpl_input(self):
 638         test_tpl = os.path.join(
 639             os.path.dirname(os.path.abspath(__file__)),
 640             "data/tosca_helloworld.yaml")
 641
 642         yaml_dict_tpl = toscaparser.utils.yamlparser.load_yaml(test_tpl)
 643
 644         tosca = ToscaTemplate(test_tpl, yaml_dict_tpl=yaml_dict_tpl)
 645
 646         self.assertEqual(tosca.version, "tosca_simple_yaml_1_0")
 647
 648     def test_yaml_dict_tpl_input(self):
 649         test_tpl = os.path.join(
 650             os.path.dirname(os.path.abspath(__file__)),
 651             "data/tosca_helloworld.yaml")
 652
 653         yaml_dict_tpl = toscaparser.utils.yamlparser.load_yaml(test_tpl)
 654
 655         tosca = ToscaTemplate(yaml_dict_tpl=yaml_dict_tpl)
 656
 657         self.assertEqual(tosca.version, "tosca_simple_yaml_1_0")
 658
 659     def test_yaml_dict_tpl_with_params_and_url_import(self):
 660         test_tpl = os.path.join(
 661             os.path.dirname(os.path.abspath(__file__)),
 662             "data/tosca_single_instance_wordpress_with_url_import.yaml")
 663
 664         yaml_dict_tpl = toscaparser.utils.yamlparser.load_yaml(test_tpl)
 665
 666         params = {'db_name': 'my_wordpress', 'db_user': 'my_db_user',
 667                   'db_root_pwd': 'mypasswd'}
 668
 669         tosca = ToscaTemplate(parsed_params=params,
 670                               yaml_dict_tpl=yaml_dict_tpl)
 671
 672         self.assertEqual(tosca.version, "tosca_simple_yaml_1_0")
 673
 674     def test_yaml_dict_tpl_with_rel_import(self):
 675         test_tpl = os.path.join(
 676             os.path.dirname(os.path.abspath(__file__)),
 677             "data/tosca_single_instance_wordpress.yaml")
 678
 679         yaml_dict_tpl = toscaparser.utils.yamlparser.load_yaml(test_tpl)
 680         params = {'db_name': 'my_wordpress', 'db_user': 'my_db_user',
 681                   'db_root_pwd': '12345678'}
 682         self.assertRaises(exception.ValidationError, ToscaTemplate, None,
 683                           params, False, yaml_dict_tpl)
 684         err_msg = (_('Relative file name "custom_types/wordpress.yaml" '
 685                      'cannot be used in a pre-parsed input template.'))
 686         exception.ExceptionCollector.assertExceptionMessage(ImportError,
 687                                                             err_msg)
 688
 689     def test_yaml_dict_tpl_with_fullpath_import(self):
 690         test_tpl = os.path.join(
 691             os.path.dirname(os.path.abspath(__file__)),
 692             "data/tosca_single_instance_wordpress.yaml")
 693
 694         yaml_dict_tpl = toscaparser.utils.yamlparser.load_yaml(test_tpl)
 695
 696         yaml_dict_tpl['imports'] = [os.path.join(os.path.dirname(
 697             os.path.abspath(__file__)), "data/custom_types/wordpress.yaml")]
 698
 699         params = {'db_name': 'my_wordpress', 'db_user': 'my_db_user',
 700                   'db_root_pwd': 'mypasswd'}
 701
 702         tosca = ToscaTemplate(parsed_params=params,
 703                               yaml_dict_tpl=yaml_dict_tpl)
 704
 705         self.assertEqual(tosca.version, "tosca_simple_yaml_1_0")
 706
 707     def test_policies_for_node_templates(self):
 708         tosca_tpl = os.path.join(
 709             os.path.dirname(os.path.abspath(__file__)),
 710             "data/policies/tosca_policy_template.yaml")
 711         tosca = ToscaTemplate(tosca_tpl)
 712
 713         for policy in tosca.topology_template.policies:
 714             self.assertTrue(
 715                 policy.is_derived_from("tosca.policies.Root"))
 716             if policy.name == 'my_compute_placement_policy':
 717                 self.assertEqual('tosca.policies.Placement', policy.type)
 718                 self.assertEqual(['my_server_1', 'my_server_2'],
 719                                  policy.targets)
 720                 self.assertEqual('node_templates', policy.get_targets_type())
 721                 for node in policy.targets_list:
 722                     if node.name == 'my_server_1':
 723                         '''Test property value'''
 724                         props = node.get_properties()
 725                         if props and 'mem_size' in props.keys():
 726                             self.assertEqual(props['mem_size'].value,
 727                                              '4096 MB')
 728
 729     def test_policies_for_groups(self):
 730         tosca_tpl = os.path.join(
 731             os.path.dirname(os.path.abspath(__file__)),
 732             "data/policies/tosca_policy_template.yaml")
 733         tosca = ToscaTemplate(tosca_tpl)
 734
 735         for policy in tosca.topology_template.policies:
 736             self.assertTrue(
 737                 policy.is_derived_from("tosca.policies.Root"))
 738             if policy.name == 'my_groups_placement':
 739                 self.assertEqual('mycompany.mytypes.myScalingPolicy',
 740                                  policy.type)
 741                 self.assertEqual(['webserver_group'], policy.targets)
 742                 self.assertEqual('groups', policy.get_targets_type())
 743                 group = policy.get_targets_list()[0]
 744                 for node in group.get_member_nodes():
 745                     if node.name == 'my_server_2':
 746                         '''Test property value'''
 747                         props = node.get_properties()
 748                         if props and 'mem_size' in props.keys():
 749                             self.assertEqual(props['mem_size'].value,
 750                                              '4096 MB')
 751
 752     def test_node_filter(self):
 753         tosca_tpl = os.path.join(
 754             os.path.dirname(os.path.abspath(__file__)),
 755             "data/node_filter/test_node_filter.yaml")
 756         ToscaTemplate(tosca_tpl)
 757
 758     def test_attributes_inheritance(self):
 759         tosca_tpl = os.path.join(
 760             os.path.dirname(os.path.abspath(__file__)),
 761             "data/test_attributes_inheritance.yaml")
 762         ToscaTemplate(tosca_tpl)
 763
 764     def test_repositories_definition(self):
 765         tosca_tpl = os.path.join(
 766             os.path.dirname(os.path.abspath(__file__)),
 767             "data/repositories/test_repositories_definition.yaml")
 768         ToscaTemplate(tosca_tpl)
 769
 770     def test_custom_caps_def(self):
 771         tosca_tpl = os.path.join(
 772             os.path.dirname(os.path.abspath(__file__)),
 773             "data/test_custom_caps_def.yaml")
 774         ToscaTemplate(tosca_tpl)
 775
 776     def test_custom_rel_with_script(self):
 777         tosca_tpl = os.path.join(
 778             os.path.dirname(os.path.abspath(__file__)),
 779             "data/test_tosca_custom_rel_with_script.yaml")
 780         tosca = ToscaTemplate(tosca_tpl)
 781         rel = tosca.relationship_templates[0]
 782         self.assertEqual(rel.type, "tosca.relationships.HostedOn")
 783         self.assertTrue(rel.is_derived_from("tosca.relationships.Root"))
 784         self.assertEqual(len(rel.interfaces), 1)
 785         self.assertEqual(rel.interfaces[0].type, "Configure")
 786
 787     def test_various_portspec_errors(self):
 788         tosca_tpl = os.path.join(
 789             os.path.dirname(os.path.abspath(__file__)),
 790             "data/datatypes/test_datatype_portspec_add_req.yaml")
 791         self.assertRaises(exception.ValidationError, ToscaTemplate, tosca_tpl,
 792                           None)
 793
 794         # TODO(TBD) find way to reuse error messages from constraints.py
 795         msg = (_('The value "%(pvalue)s" of property "%(pname)s" is out of '
 796                  'range "(min:%(vmin)s, max:%(vmax)s)".') %
 797                dict(pname=PortSpec.SOURCE,
 798                     pvalue='0',
 799                     vmin='1',
 800                     vmax='65535'))
 801         exception.ExceptionCollector.assertExceptionMessage(
 802             exception.ValidationError, msg)
 803
 804         # Test value below range min.
 805         msg = (_('The value "%(pvalue)s" of property "%(pname)s" is out of '
 806                  'range "(min:%(vmin)s, max:%(vmax)s)".') %
 807                dict(pname=PortSpec.SOURCE,
 808                     pvalue='1',
 809                     vmin='2',
 810                     vmax='65534'))
 811         exception.ExceptionCollector.assertExceptionMessage(
 812             exception.RangeValueError, msg)
 813
 814         # Test value above range max.
 815         msg = (_('The value "%(pvalue)s" of property "%(pname)s" is out of '
 816                  'range "(min:%(vmin)s, max:%(vmax)s)".') %
 817                dict(pname=PortSpec.SOURCE,
 818                     pvalue='65535',
 819                     vmin='2',
 820                     vmax='65534'))
 821         exception.ExceptionCollector.assertExceptionMessage(
 822             exception.RangeValueError, msg)
 823
 824     def test_containers(self):
 825         tosca_tpl = os.path.join(
 826             os.path.dirname(os.path.abspath(__file__)),
 827             "data/containers/test_container_docker_mysql.yaml")
 828         ToscaTemplate(tosca_tpl, parsed_params={"mysql_root_pwd": "12345678"})
 829
 830     def test_endpoint_on_compute(self):
 831         tosca_tpl = os.path.join(
 832             os.path.dirname(os.path.abspath(__file__)),
 833             "data/test_endpoint_on_compute.yaml")
 834         ToscaTemplate(tosca_tpl)
 835
 836     def test_nested_dsl_def(self):
 837         tosca_tpl = os.path.join(
 838             os.path.dirname(os.path.abspath(__file__)),
 839             "data/dsl_definitions/test_nested_dsl_def.yaml")
 840         self.assertIsNotNone(ToscaTemplate(tosca_tpl))