tosca2heat/tosca-parser/toscaparser/tests/test_toscatplvalidation.py

   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
  16 from toscaparser.common import exception
  17 from toscaparser.imports import ImportsLoader
  18 from toscaparser.nodetemplate import NodeTemplate
  19 from toscaparser.parameters import Input
  20 from toscaparser.parameters import Output
  21 from toscaparser.policy import Policy
  22 from toscaparser.relationship_template import RelationshipTemplate
  23 from toscaparser.repositories import Repository
  24 from toscaparser.tests.base import TestCase
  25 from toscaparser.topology_template import TopologyTemplate
  26 from toscaparser.tosca_template import ToscaTemplate
  27 from toscaparser.triggers import Triggers
  28 from toscaparser.utils.gettextutils import _
  29 import toscaparser.utils.yamlparser
  30
  31
  32 class ToscaTemplateValidationTest(TestCase):
  33
  34     def test_well_defined_template(self):
  35         tpl_path = os.path.join(
  36             os.path.dirname(os.path.abspath(__file__)),
  37             "data/tosca_single_instance_wordpress.yaml")
  38         self.assertIsNotNone(ToscaTemplate(tpl_path))
  39
  40     def test_first_level_sections(self):
  41         tpl_path = os.path.join(
  42             os.path.dirname(os.path.abspath(__file__)),
  43             "data/test_tosca_top_level_error1.yaml")
  44         self.assertRaises(exception.ValidationError, ToscaTemplate, tpl_path)
  45         exception.ExceptionCollector.assertExceptionMessage(
  46             exception.MissingRequiredFieldError,
  47             _('Template is missing required field '
  48               '"tosca_definitions_version".'))
  49
  50         tpl_path = os.path.join(
  51             os.path.dirname(os.path.abspath(__file__)),
  52             "data/test_tosca_top_level_error2.yaml")
  53         self.assertRaises(exception.ValidationError, ToscaTemplate, tpl_path)
  54         exception.ExceptionCollector.assertExceptionMessage(
  55             exception.UnknownFieldError,
  56             _('Template contains unknown field "node_template". Refer to the '
  57               'definition to verify valid values.'))
  58
  59     def test_template_with_imports_validation(self):
  60         tpl_path = os.path.join(
  61             os.path.dirname(os.path.abspath(__file__)),
  62             "data/tosca_imports_validation.yaml")
  63         self.assertRaises(exception.ValidationError, ToscaTemplate, tpl_path)
  64         exception.ExceptionCollector.assertExceptionMessage(
  65             exception.UnknownFieldError,
  66             _('Template custom_types/imported_sample.yaml contains unknown '
  67               'field "descriptions". Refer to the definition'
  68               ' to verify valid values.'))
  69         exception.ExceptionCollector.assertExceptionMessage(
  70             exception.UnknownFieldError,
  71             _('Template custom_types/imported_sample.yaml contains unknown '
  72               'field "node_typess". Refer to the definition to '
  73               'verify valid values.'))
  74         exception.ExceptionCollector.assertExceptionMessage(
  75             exception.UnknownFieldError,
  76             _('Template custom_types/imported_sample.yaml contains unknown '
  77               'field "tosca1_definitions_version". Refer to the definition'
  78               ' to verify valid values.'))
  79         exception.ExceptionCollector.assertExceptionMessage(
  80             exception.InvalidTemplateVersion,
  81             _('The template version "tosca_simple_yaml_1_10 in '
  82               'custom_types/imported_sample.yaml" is invalid. '
  83               'Valid versions are "tosca_simple_yaml_1_0, '
  84               'tosca_simple_profile_for_nfv_1_0_0".'))
  85         exception.ExceptionCollector.assertExceptionMessage(
  86             exception.UnknownFieldError,
  87             _('Template custom_types/imported_sample.yaml contains unknown '
  88               'field "policy_types1". Refer to the definition to '
  89               'verify valid values.'))
  90         exception.ExceptionCollector.assertExceptionMessage(
  91             exception.UnknownFieldError,
  92             _('Nodetype"tosca.nodes.SoftwareComponent.Logstash" contains '
  93               'unknown field "capabilities1". Refer to the definition '
  94               'to verify valid values.'))
  95         exception.ExceptionCollector.assertExceptionMessage(
  96             exception.UnknownFieldError,
  97             _('Policy "mycompany.mytypes.myScalingPolicy" contains unknown '
  98               'field "derived1_from". Refer to the definition to '
  99               'verify valid values.'))
 100
 101     def test_inputs(self):
 102         tpl_snippet = '''
 103         inputs:
 104           cpus:
 105             type: integer
 106             description: Number of CPUs for the server.
 107             constraint:
 108               - valid_values: [ 1, 2, 4 ]
 109             required: yes
 110             status: supported
 111         '''
 112         inputs = (toscaparser.utils.yamlparser.
 113                   simple_parse(tpl_snippet)['inputs'])
 114         name, attrs = list(inputs.items())[0]
 115         input = Input(name, attrs)
 116         err = self.assertRaises(exception.UnknownFieldError, input.validate)
 117         self.assertEqual(_('Input "cpus" contains unknown field "constraint". '
 118                            'Refer to the definition to verify valid values.'),
 119                          err.__str__())
 120
 121     def _imports_content_test(self, tpl_snippet, path, custom_type_def):
 122         imports = (toscaparser.utils.yamlparser.
 123                    simple_parse(tpl_snippet)['imports'])
 124         loader = ImportsLoader(imports, path, custom_type_def)
 125         return loader.get_custom_defs()
 126
 127     def test_imports_without_templates(self):
 128         tpl_snippet = '''
 129         imports:
 130           # omitted here for brevity
 131         '''
 132         path = 'toscaparser/tests/data/tosca_elk.yaml'
 133         errormsg = _('"imports" keyname is defined without including '
 134                      'templates.')
 135         err = self.assertRaises(exception.ValidationError,
 136                                 self._imports_content_test,
 137                                 tpl_snippet,
 138                                 path,
 139                                 "node_types")
 140         self.assertEqual(errormsg, err.__str__())
 141
 142     def test_imports_with_name_without_templates(self):
 143         tpl_snippet = '''
 144         imports:
 145           - some_definitions:
 146         '''
 147         path = 'toscaparser/tests/data/tosca_elk.yaml'
 148         errormsg = _('A template file name is not provided with import '
 149                      'definition "some_definitions".')
 150         err = self.assertRaises(exception.ValidationError,
 151                                 self._imports_content_test,
 152                                 tpl_snippet, path, None)
 153         self.assertEqual(errormsg, err.__str__())
 154
 155     def test_imports_without_import_name(self):
 156         tpl_snippet = '''
 157         imports:
 158           - custom_types/paypalpizzastore_nodejs_app.yaml
 159           - https://raw.githubusercontent.com/openstack/\
 160 tosca-parser/master/toscaparser/tests/data/custom_types/wordpress.yaml
 161         '''
 162         path = 'toscaparser/tests/data/tosca_elk.yaml'
 163         custom_defs = self._imports_content_test(tpl_snippet,
 164                                                  path,
 165                                                  "node_types")
 166         self.assertTrue(custom_defs)
 167
 168     def test_imports_wth_import_name(self):
 169         tpl_snippet = '''
 170         imports:
 171           - some_definitions: custom_types/paypalpizzastore_nodejs_app.yaml
 172           - more_definitions:
 173               file: 'https://raw.githubusercontent.com/openstack/tosca-parser\
 174 /master/toscaparser/tests/data/custom_types/wordpress.yaml'
 175               namespace_prefix: single_instance_wordpress
 176         '''
 177         path = 'toscaparser/tests/data/tosca_elk.yaml'
 178         custom_defs = self._imports_content_test(tpl_snippet,
 179                                                  path,
 180                                                  "node_types")
 181         self.assertTrue(custom_defs.get("single_instance_wordpress.tosca."
 182                                         "nodes.WebApplication.WordPress"))
 183
 184     def test_imports_wth_namespace_prefix(self):
 185         tpl_snippet = '''
 186         imports:
 187           - more_definitions:
 188               file: custom_types/nested_rsyslog.yaml
 189               namespace_prefix: testprefix
 190         '''
 191         path = 'toscaparser/tests/data/tosca_elk.yaml'
 192         custom_defs = self._imports_content_test(tpl_snippet,
 193                                                  path,
 194                                                  "node_types")
 195         self.assertTrue(custom_defs.get("testprefix.Rsyslog"))
 196
 197     def test_imports_with_no_main_template(self):
 198         tpl_snippet = '''
 199         imports:
 200           - some_definitions: https://raw.githubusercontent.com/openstack/\
 201 tosca-parser/master/toscaparser/tests/data/custom_types/wordpress.yaml
 202           - some_definitions:
 203               file: my_defns/my_typesdefs_n.yaml
 204         '''
 205         errormsg = _('Input tosca template is not provided.')
 206         err = self.assertRaises(exception.ValidationError,
 207                                 self._imports_content_test,
 208                                 tpl_snippet, None, None)
 209         self.assertEqual(errormsg, err.__str__())
 210
 211     def test_imports_duplicate_name(self):
 212         tpl_snippet = '''
 213         imports:
 214           - some_definitions: https://raw.githubusercontent.com/openstack/\
 215 tosca-parser/master/toscaparser/tests/data/custom_types/wordpress.yaml
 216           - some_definitions:
 217               file: my_defns/my_typesdefs_n.yaml
 218         '''
 219         errormsg = _('Duplicate import name "some_definitions" was found.')
 220         path = 'toscaparser/tests/data/tosca_elk.yaml'
 221         err = self.assertRaises(exception.ValidationError,
 222                                 self._imports_content_test,
 223                                 tpl_snippet, path, None)
 224         self.assertEqual(errormsg, err.__str__())
 225
 226     def test_imports_missing_req_field_in_def(self):
 227         tpl_snippet = '''
 228         imports:
 229           - more_definitions:
 230               file1: my_defns/my_typesdefs_n.yaml
 231               repository: my_company_repo
 232               namespace_uri: http://mycompany.com/ns/tosca/2.0
 233               namespace_prefix: mycompany
 234         '''
 235         errormsg = _('Import of template "more_definitions" is missing '
 236                      'required field "file".')
 237         path = 'toscaparser/tests/data/tosca_elk.yaml'
 238         err = self.assertRaises(exception.MissingRequiredFieldError,
 239                                 self._imports_content_test,
 240                                 tpl_snippet, path, None)
 241         self.assertEqual(errormsg, err.__str__())
 242
 243     def test_imports_file_with_uri(self):
 244         tpl_snippet = '''
 245         imports:
 246           - more_definitions:
 247               file: https://raw.githubusercontent.com/openstack/\
 248 tosca-parser/master/toscaparser/tests/data/custom_types/wordpress.yaml
 249         '''
 250         path = 'https://raw.githubusercontent.com/openstack/\
 251 tosca-parser/master/toscaparser/tests/data/\
 252 tosca_single_instance_wordpress_with_url_import.yaml'
 253         custom_defs = self._imports_content_test(tpl_snippet,
 254                                                  path,
 255                                                  "node_types")
 256         self.assertTrue(custom_defs.get("tosca.nodes."
 257                                         "WebApplication.WordPress"))
 258
 259     def test_imports_file_namespace_fields(self):
 260         tpl_snippet = '''
 261         imports:
 262           - more_definitions:
 263              file: https://raw.githubusercontent.com/openstack/\
 264 heat-translator/master/translator/tests/data/custom_types/wordpress.yaml
 265              namespace_prefix: mycompany
 266              namespace_uri: http://docs.oasis-open.org/tosca/ns/simple/yaml/1.0
 267         '''
 268         path = 'toscaparser/tests/data/tosca_elk.yaml'
 269         custom_defs = self._imports_content_test(tpl_snippet,
 270                                                  path,
 271                                                  "node_types")
 272         self.assertTrue(custom_defs.get("mycompany.tosca.nodes."
 273                                         "WebApplication.WordPress"))
 274
 275     def test_import_error_file_uri(self):
 276         tpl_snippet = '''
 277         imports:
 278           - more_definitions:
 279              file: mycompany.com/ns/tosca/2.0/toscaparser/tests/data\
 280 /tosca_elk.yaml
 281              namespace_prefix: mycompany
 282              namespace_uri: http://docs.oasis-open.org/tosca/ns/simple/yaml/1.0
 283         '''
 284         path = 'toscaparser/tests/data/tosca_elk.yaml'
 285         self.assertRaises(ImportError,
 286                           self._imports_content_test,
 287                           tpl_snippet, path, None)
 288
 289     def test_import_single_line_error(self):
 290         tpl_snippet = '''
 291         imports:
 292           - some_definitions: abc.com/tests/data/tosca_elk.yaml
 293         '''
 294         errormsg = _('Import "abc.com/tests/data/tosca_elk.yaml" is not '
 295                      'valid.')
 296         path = 'toscaparser/tests/data/tosca_elk.yaml'
 297         err = self.assertRaises(ImportError,
 298                                 self._imports_content_test,
 299                                 tpl_snippet, path, None)
 300         self.assertEqual(errormsg, err.__str__())
 301
 302     def test_outputs(self):
 303         tpl_snippet = '''
 304         outputs:
 305           server_address:
 306             description: IP address of server instance.
 307             values: { get_property: [server, private_address] }
 308         '''
 309         outputs = (toscaparser.utils.yamlparser.
 310                    simple_parse(tpl_snippet)['outputs'])
 311         name, attrs = list(outputs.items())[0]
 312         output = Output(name, attrs)
 313         try:
 314             output.validate()
 315         except Exception as err:
 316             self.assertTrue(
 317                 isinstance(err, exception.MissingRequiredFieldError))
 318             self.assertEqual(_('Output "server_address" is missing required '
 319                                'field "value".'), err.__str__())
 320
 321         tpl_snippet = '''
 322         outputs:
 323           server_address:
 324             descriptions: IP address of server instance.
 325             value: { get_property: [server, private_address] }
 326         '''
 327         outputs = (toscaparser.utils.yamlparser.
 328                    simple_parse(tpl_snippet)['outputs'])
 329         name, attrs = list(outputs.items())[0]
 330         output = Output(name, attrs)
 331         try:
 332             output.validate()
 333         except Exception as err:
 334             self.assertTrue(isinstance(err, exception.UnknownFieldError))
 335             self.assertEqual(_('Output "server_address" contains unknown '
 336                                'field "descriptions". Refer to the definition '
 337                                'to verify valid values.'),
 338                              err.__str__())
 339
 340     def _repo_content(self, path):
 341         repositories = path['repositories']
 342         reposit = []
 343         for name, val in repositories.items():
 344             reposits = Repository(name, val)
 345             reposit.append(reposits)
 346         return reposit
 347
 348     def test_repositories(self):
 349         tpl_snippet = '''
 350         repositories:
 351            repo_code0: https://raw.githubusercontent.com/nandinivemula/intern
 352            repo_code1:
 353               description: My project's code Repository in github usercontent.
 354               url: https://github.com/nandinivemula/intern
 355               credential:
 356                  user: nandini
 357                  password: tcs@12345
 358            repo_code2:
 359               description: My Project's code Repository in github.
 360               url: https://github.com/nandinivemula/intern
 361               credential:
 362                  user: xyzw
 363                  password: xyz@123
 364         '''
 365         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 366         repoobject = self._repo_content(tpl)
 367         actualrepo_names = []
 368         for repo in repoobject:
 369             repos = repo.name
 370             actualrepo_names.append(repos)
 371         reposname = list(tpl.values())
 372         reposnames = reposname[0]
 373         expected_reponames = list(reposnames.keys())
 374         self.assertEqual(expected_reponames, actualrepo_names)
 375
 376     def test_repositories_with_missing_required_field(self):
 377         tpl_snippet = '''
 378         repositories:
 379            repo_code0: https://raw.githubusercontent.com/nandinivemula/intern
 380            repo_code1:
 381               description: My project's code Repository in github usercontent.
 382               credential:
 383                  user: nandini
 384                  password: tcs@12345
 385            repo_code2:
 386               description: My Project's code Repository in github.
 387               url: https://github.com/nandinivemula/intern
 388               credential:
 389                  user: xyzw
 390                  password: xyz@123
 391         '''
 392         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 393         err = self.assertRaises(exception.MissingRequiredFieldError,
 394                                 self._repo_content, tpl)
 395         expectedmessage = _('Repository "repo_code1" is missing '
 396                             'required field "url".')
 397         self.assertEqual(expectedmessage, err.__str__())
 398
 399     def test_repositories_with_unknown_field(self):
 400         tpl_snippet = '''
 401         repositories:
 402            repo_code0: https://raw.githubusercontent.com/nandinivemula/intern
 403            repo_code1:
 404               description: My project's code Repository in github usercontent.
 405               url: https://github.com/nandinivemula/intern
 406               credential:
 407                  user: nandini
 408                  password: tcs@12345
 409            repo_code2:
 410               descripton: My Project's code Repository in github.
 411               url: https://github.com/nandinivemula/intern
 412               credential:
 413                  user: xyzw
 414                  password: xyz@123
 415         '''
 416         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 417         err = self.assertRaises(exception.UnknownFieldError,
 418                                 self._repo_content, tpl)
 419         expectedmessage = _('repositories "repo_code2" contains unknown field'
 420                             ' "descripton". Refer to the definition to verify'
 421                             ' valid values.')
 422         self.assertEqual(expectedmessage, err.__str__())
 423
 424     def test_repositories_with_invalid_url(self):
 425         tpl_snippet = '''
 426         repositories:
 427            repo_code0: https://raw.githubusercontent.com/nandinivemula/intern
 428            repo_code1:
 429               description: My project's code Repository in github usercontent.
 430               url: h
 431               credential:
 432                  user: nandini
 433                  password: tcs@12345
 434            repo_code2:
 435               description: My Project's code Repository in github.
 436               url: https://github.com/nandinivemula/intern
 437               credential:
 438                  user: xyzw
 439                  password: xyz@123
 440         '''
 441         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 442         err = self.assertRaises(exception.URLException,
 443                                 self._repo_content, tpl)
 444         expectedmessage = _('repsositories "repo_code1" Invalid Url')
 445         self.assertEqual(expectedmessage, err.__str__())
 446
 447     def test_groups(self):
 448         tpl_snippet = '''
 449         node_templates:
 450           server:
 451             type: tosca.nodes.Compute
 452             requirements:
 453               - log_endpoint:
 454                   capability: log_endpoint
 455
 456           mysql_dbms:
 457             type: tosca.nodes.DBMS
 458             properties:
 459               root_password: aaa
 460               port: 3376
 461
 462         groups:
 463           webserver_group:
 464             type: tosca.groups.Root
 465             members: [ server, mysql_dbms ]
 466         '''
 467         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 468         TopologyTemplate(tpl, None)
 469
 470     def test_groups_with_missing_required_field(self):
 471         tpl_snippet = '''
 472         node_templates:
 473           server:
 474             type: tosca.nodes.Compute
 475             requirements:
 476               - log_endpoint:
 477                   capability: log_endpoint
 478
 479           mysql_dbms:
 480             type: tosca.nodes.DBMS
 481             properties:
 482               root_password: aaa
 483               port: 3376
 484
 485         groups:
 486           webserver_group:
 487               members: ['server', 'mysql_dbms']
 488         '''
 489         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 490         err = self.assertRaises(exception.MissingRequiredFieldError,
 491                                 TopologyTemplate, tpl, None)
 492         expectedmessage = _('Template "webserver_group" is missing '
 493                             'required field "type".')
 494         self.assertEqual(expectedmessage, err.__str__())
 495
 496     def test_groups_with_unknown_target(self):
 497         tpl_snippet = '''
 498         node_templates:
 499           server:
 500             type: tosca.nodes.Compute
 501             requirements:
 502               - log_endpoint:
 503                   capability: log_endpoint
 504
 505           mysql_dbms:
 506             type: tosca.nodes.DBMS
 507             properties:
 508               root_password: aaa
 509               port: 3376
 510
 511         groups:
 512           webserver_group:
 513             type: tosca.groups.Root
 514             members: [ serv, mysql_dbms ]
 515         '''
 516         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 517         expectedmessage = _('"Target member "serv" is not found in '
 518                             'node_templates"')
 519         err = self.assertRaises(exception.InvalidGroupTargetException,
 520                                 TopologyTemplate, tpl, None)
 521         self.assertEqual(expectedmessage, err.__str__())
 522
 523     def test_groups_with_repeated_targets(self):
 524         tpl_snippet = '''
 525         node_templates:
 526           server:
 527             type: tosca.nodes.Compute
 528             requirements:
 529               - log_endpoint:
 530                   capability: log_endpoint
 531
 532           mysql_dbms:
 533             type: tosca.nodes.DBMS
 534             properties:
 535               root_password: aaa
 536               port: 3376
 537
 538         groups:
 539           webserver_group:
 540             type: tosca.groups.Root
 541             members: [ server, server, mysql_dbms ]
 542         '''
 543         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 544         expectedmessage = _('"Member nodes '
 545                             '"[\'server\', \'server\', \'mysql_dbms\']" '
 546                             'should be >= 1 and not repeated"')
 547         err = self.assertRaises(exception.InvalidGroupTargetException,
 548                                 TopologyTemplate, tpl, None)
 549         self.assertEqual(expectedmessage, err.__str__())
 550
 551     def test_groups_with_only_one_target(self):
 552         tpl_snippet = '''
 553         node_templates:
 554           server:
 555             type: tosca.nodes.Compute
 556             requirements:
 557               - log_endpoint:
 558                   capability: log_endpoint
 559
 560           mysql_dbms:
 561             type: tosca.nodes.DBMS
 562             properties:
 563               root_password: aaa
 564               port: 3376
 565
 566         groups:
 567           webserver_group:
 568             type: tosca.groups.Root
 569             members: []
 570         '''
 571         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
 572         expectedmessage = _('"Member nodes "[]" should be >= 1 '
 573                             'and not repeated"')
 574         err = self.assertRaises(exception.InvalidGroupTargetException,
 575                                 TopologyTemplate, tpl, None)
 576         self.assertEqual(expectedmessage, err.__str__())
 577
 578     def _custom_types(self):
 579         custom_types = {}
 580         def_file = os.path.join(
 581             os.path.dirname(os.path.abspath(__file__)),
 582             "data/custom_types/wordpress.yaml")
 583         custom_type = toscaparser.utils.yamlparser.load_yaml(def_file)
 584         node_types = custom_type['node_types']
 585         for name in node_types:
 586             defintion = node_types[name]
 587             custom_types[name] = defintion
 588         return custom_types
 589
 590     def _single_node_template_content_test(self, tpl_snippet):
 591         nodetemplates = (toscaparser.utils.yamlparser.
 592                          simple_ordered_parse(tpl_snippet))['node_templates']
 593         name = list(nodetemplates.keys())[0]
 594         nodetemplate = NodeTemplate(name, nodetemplates,
 595                                     self._custom_types())
 596         nodetemplate.validate()
 597         nodetemplate.requirements
 598         nodetemplate.get_capabilities_objects()
 599         nodetemplate.get_properties_objects()
 600         nodetemplate.interfaces
 601
 602     def test_node_templates(self):
 603         tpl_snippet = '''
 604         node_templates:
 605           server:
 606             capabilities:
 607               host:
 608                 properties:
 609                   disk_size: 10
 610                   num_cpus: 4
 611                   mem_size: 4096
 612               os:
 613                 properties:
 614                   architecture: x86_64
 615                   type: Linux
 616                   distribution: Fedora
 617                   version: 18.0
 618         '''
 619         expectedmessage = _('Template "server" is missing required field '
 620                             '"type".')
 621         err = self.assertRaises(
 622             exception.MissingRequiredFieldError,
 623             lambda: self._single_node_template_content_test(tpl_snippet))
 624         self.assertEqual(expectedmessage, err.__str__())
 625
 626     def test_node_template_with_wrong_properties_keyname(self):
 627         """Node template keyname 'properties' given as 'propertiessss'."""
 628         tpl_snippet = '''
 629         node_templates:
 630           mysql_dbms:
 631             type: tosca.nodes.DBMS
 632             propertiessss:
 633               root_password: aaa
 634               port: 3376
 635         '''
 636         expectedmessage = _('Node template "mysql_dbms" contains unknown '
 637                             'field "propertiessss". Refer to the definition '
 638                             'to verify valid values.')
 639         err = self.assertRaises(
 640             exception.UnknownFieldError,
 641             lambda: self._single_node_template_content_test(tpl_snippet))
 642         self.assertEqual(expectedmessage, err.__str__())
 643
 644     def test_node_template_with_wrong_requirements_keyname(self):
 645         """Node template keyname 'requirements' given as 'requirement'."""
 646         tpl_snippet = '''
 647         node_templates:
 648           mysql_dbms:
 649             type: tosca.nodes.DBMS
 650             properties:
 651               root_password: aaa
 652               port: 3376
 653             requirement:
 654               - host: server
 655         '''
 656         expectedmessage = _('Node template "mysql_dbms" contains unknown '
 657                             'field "requirement". Refer to the definition to '
 658                             'verify valid values.')
 659         err = self.assertRaises(
 660             exception.UnknownFieldError,
 661             lambda: self._single_node_template_content_test(tpl_snippet))
 662         self.assertEqual(expectedmessage, err.__str__())
 663
 664     def test_node_template_with_wrong_interfaces_keyname(self):
 665         """Node template keyname 'interfaces' given as 'interfac'."""
 666         tpl_snippet = '''
 667         node_templates:
 668           mysql_dbms:
 669             type: tosca.nodes.DBMS
 670             properties:
 671               root_password: aaa
 672               port: 3376
 673             requirements:
 674               - host: server
 675             interfac:
 676               Standard:
 677                 configure: mysql_database_configure.sh
 678         '''
 679         expectedmessage = _('Node template "mysql_dbms" contains unknown '
 680                             'field "interfac". Refer to the definition to '
 681                             'verify valid values.')
 682         err = self.assertRaises(
 683             exception.UnknownFieldError,
 684             lambda: self._single_node_template_content_test(tpl_snippet))
 685         self.assertEqual(expectedmessage, err.__str__())
 686
 687     def test_node_template_with_wrong_capabilities_keyname(self):
 688         """Node template keyname 'capabilities' given as 'capabilitiis'."""
 689         tpl_snippet = '''
 690         node_templates:
 691           mysql_database:
 692             type: tosca.nodes.Database
 693             properties:
 694               db_name: { get_input: db_name }
 695               db_user: { get_input: db_user }
 696               db_password: { get_input: db_pwd }
 697             capabilitiis:
 698               database_endpoint:
 699                 properties:
 700                   port: { get_input: db_port }
 701         '''
 702         expectedmessage = _('Node template "mysql_database" contains unknown '
 703                             'field "capabilitiis". Refer to the definition to '
 704                             'verify valid values.')
 705         err = self.assertRaises(
 706             exception.UnknownFieldError,
 707             lambda: self._single_node_template_content_test(tpl_snippet))
 708         self.assertEqual(expectedmessage, err.__str__())
 709
 710     def test_node_template_with_wrong_artifacts_keyname(self):
 711         """Node template keyname 'artifacts' given as 'artifactsss'."""
 712         tpl_snippet = '''
 713         node_templates:
 714           mysql_database:
 715             type: tosca.nodes.Database
 716             artifactsss:
 717               db_content:
 718                 implementation: files/my_db_content.txt
 719                 type: tosca.artifacts.File
 720         '''
 721         expectedmessage = _('Node template "mysql_database" contains unknown '
 722                             'field "artifactsss". Refer to the definition to '
 723                             'verify valid values.')
 724         err = self.assertRaises(
 725             exception.UnknownFieldError,
 726             lambda: self._single_node_template_content_test(tpl_snippet))
 727         self.assertEqual(expectedmessage, err.__str__())
 728
 729     def test_node_template_with_multiple_wrong_keynames(self):
 730         """Node templates given with multiple wrong keynames."""
 731         tpl_snippet = '''
 732         node_templates:
 733           mysql_dbms:
 734             type: tosca.nodes.DBMS
 735             propertieees:
 736               root_password: aaa
 737               port: 3376
 738             requirements:
 739               - host: server
 740             interfacs:
 741               Standard:
 742                 configure: mysql_database_configure.sh
 743         '''
 744         expectedmessage = _('Node template "mysql_dbms" contains unknown '
 745                             'field "propertieees". Refer to the definition to '
 746                             'verify valid values.')
 747         err = self.assertRaises(
 748             exception.UnknownFieldError,
 749             lambda: self._single_node_template_content_test(tpl_snippet))
 750         self.assertEqual(expectedmessage, err.__str__())
 751
 752         tpl_snippet = '''
 753         node_templates:
 754           mysql_database:
 755             type: tosca.nodes.Database
 756             properties:
 757               name: { get_input: db_name }
 758               user: { get_input: db_user }
 759               password: { get_input: db_pwd }
 760             capabilitiiiies:
 761               database_endpoint:
 762               properties:
 763                 port: { get_input: db_port }
 764             requirementsss:
 765               - host:
 766                   node: mysql_dbms
 767             interfac:
 768               Standard:
 769                  configure: mysql_database_configure.sh
 770
 771         '''
 772         expectedmessage = _('Node template "mysql_database" contains unknown '
 773                             'field "capabilitiiiies". Refer to the definition '
 774                             'to verify valid values.')
 775         err = self.assertRaises(
 776             exception.UnknownFieldError,
 777             lambda: self._single_node_template_content_test(tpl_snippet))
 778         self.assertEqual(expectedmessage, err.__str__())
 779
 780     def test_node_template_type(self):
 781         tpl_snippet = '''
 782         node_templates:
 783           mysql_database:
 784             type: tosca.nodes.Databases
 785             properties:
 786               db_name: { get_input: db_name }
 787               db_user: { get_input: db_user }
 788               db_password: { get_input: db_pwd }
 789             capabilities:
 790               database_endpoint:
 791                 properties:
 792                   port: { get_input: db_port }
 793             requirements:
 794               - host: mysql_dbms
 795             interfaces:
 796               Standard:
 797                  configure: mysql_database_configure.sh
 798         '''
 799         expectedmessage = _('Type "tosca.nodes.Databases" is not '
 800                             'a valid type.')
 801         err = self.assertRaises(
 802             exception.InvalidTypeError,
 803             lambda: self._single_node_template_content_test(tpl_snippet))
 804         self.assertEqual(expectedmessage, err.__str__())
 805
 806     def test_node_template_requirements(self):
 807         tpl_snippet = '''
 808         node_templates:
 809           webserver:
 810             type: tosca.nodes.WebServer
 811             requirements:
 812               host: server
 813             interfaces:
 814               Standard:
 815                 create: webserver_install.sh
 816                 start: d.sh
 817         '''
 818         expectedmessage = _('"requirements" of template "webserver" must be '
 819                             'of type "list".')
 820         err = self.assertRaises(
 821             exception.TypeMismatchError,
 822             lambda: self._single_node_template_content_test(tpl_snippet))
 823         self.assertEqual(expectedmessage, err.__str__())
 824
 825         tpl_snippet = '''
 826         node_templates:
 827           mysql_database:
 828             type: tosca.nodes.Database
 829             properties:
 830               db_name: { get_input: db_name }
 831               db_user: { get_input: db_user }
 832               db_password: { get_input: db_pwd }
 833             capabilities:
 834               database_endpoint:
 835                 properties:
 836                   port: { get_input: db_port }
 837             requirements:
 838               - host: mysql_dbms
 839               - database_endpoint: mysql_database
 840             interfaces:
 841               Standard:
 842                  configure: mysql_database_configure.sh
 843         '''
 844         expectedmessage = _('"requirements" of template "mysql_database" '
 845                             'contains unknown field "database_endpoint". '
 846                             'Refer to the definition to verify valid values.')
 847         err = self.assertRaises(
 848             exception.UnknownFieldError,
 849             lambda: self._single_node_template_content_test(tpl_snippet))
 850         self.assertEqual(expectedmessage, err.__str__())
 851
 852     def test_node_template_requirements_with_wrong_node_keyname(self):
 853         """Node template requirements keyname 'node' given as 'nodes'."""
 854         tpl_snippet = '''
 855         node_templates:
 856           mysql_database:
 857             type: tosca.nodes.Database
 858             requirements:
 859               - host:
 860                   nodes: mysql_dbms
 861
 862         '''
 863         expectedmessage = _('"requirements" of template "mysql_database" '
 864                             'contains unknown field "nodes". Refer to the '
 865                             'definition to verify valid values.')
 866         err = self.assertRaises(
 867             exception.UnknownFieldError,
 868             lambda: self._single_node_template_content_test(tpl_snippet))
 869         self.assertEqual(expectedmessage, err.__str__())
 870
 871     def test_node_template_requirements_with_wrong_capability_keyname(self):
 872         """Incorrect node template requirements keyname
 873
 874         Node template requirements keyname 'capability' given as
 875         'capabilityy'.
 876         """
 877         tpl_snippet = '''
 878         node_templates:
 879           mysql_database:
 880             type: tosca.nodes.Database
 881             requirements:
 882               - host:
 883                   node: mysql_dbms
 884               - log_endpoint:
 885                   node: logstash
 886                   capabilityy: log_endpoint
 887                   relationship:
 888                     type: tosca.relationships.ConnectsTo
 889
 890         '''
 891         expectedmessage = _('"requirements" of template "mysql_database" '
 892                             'contains unknown field "capabilityy". Refer to '
 893                             'the definition to verify valid values.')
 894         err = self.assertRaises(
 895             exception.UnknownFieldError,
 896             lambda: self._single_node_template_content_test(tpl_snippet))
 897         self.assertEqual(expectedmessage, err.__str__())
 898
 899     def test_node_template_requirements_with_wrong_relationship_keyname(self):
 900         """Incorrect node template requirements keyname
 901
 902         Node template requirements keyname 'relationship' given as
 903         'relationshipppp'.
 904         """
 905         tpl_snippet = '''
 906         node_templates:
 907           mysql_database:
 908             type: tosca.nodes.Database
 909             requirements:
 910               - host:
 911                   node: mysql_dbms
 912               - log_endpoint:
 913                   node: logstash
 914                   capability: log_endpoint
 915                   relationshipppp:
 916                     type: tosca.relationships.ConnectsTo
 917
 918         '''
 919         expectedmessage = _('"requirements" of template "mysql_database" '
 920                             'contains unknown field "relationshipppp". Refer '
 921                             'to the definition to verify valid values.')
 922         err = self.assertRaises(
 923             exception.UnknownFieldError,
 924             lambda: self._single_node_template_content_test(tpl_snippet))
 925         self.assertEqual(expectedmessage, err.__str__())
 926
 927     def test_node_template_requirements_with_wrong_occurrences_keyname(self):
 928         """Incorrect node template requirements keyname
 929
 930         Node template requirements keyname 'occurrences' given as
 931         'occurences'.
 932         """
 933         tpl_snippet = '''
 934         node_templates:
 935           mysql_database:
 936             type: tosca.nodes.Database
 937             requirements:
 938               - host:
 939                   node: mysql_dbms
 940               - log_endpoint:
 941                   node: logstash
 942                   capability: log_endpoint
 943                   relationship:
 944                     type: tosca.relationships.ConnectsTo
 945                   occurences: [0, UNBOUNDED]
 946         '''
 947         expectedmessage = _('"requirements" of template "mysql_database" '
 948                             'contains unknown field "occurences". Refer to '
 949                             'the definition to verify valid values.')
 950         err = self.assertRaises(
 951             exception.UnknownFieldError,
 952             lambda: self._single_node_template_content_test(tpl_snippet))
 953         self.assertEqual(expectedmessage, err.__str__())
 954
 955     def test_node_template_requirements_with_multiple_wrong_keynames(self):
 956         """Node templates given with multiple wrong requirements keynames."""
 957         tpl_snippet = '''
 958         node_templates:
 959           mysql_database:
 960             type: tosca.nodes.Database
 961             requirements:
 962               - host:
 963                   node: mysql_dbms
 964               - log_endpoint:
 965                   nod: logstash
 966                   capabilit: log_endpoint
 967                   relationshipppp:
 968                     type: tosca.relationships.ConnectsTo
 969
 970         '''
 971         expectedmessage = _('"requirements" of template "mysql_database" '
 972                             'contains unknown field "nod". Refer to the '
 973                             'definition to verify valid values.')
 974         err = self.assertRaises(
 975             exception.UnknownFieldError,
 976             lambda: self._single_node_template_content_test(tpl_snippet))
 977         self.assertEqual(expectedmessage, err.__str__())
 978
 979         tpl_snippet = '''
 980         node_templates:
 981           mysql_database:
 982             type: tosca.nodes.Database
 983             requirements:
 984               - host:
 985                   node: mysql_dbms
 986               - log_endpoint:
 987                   node: logstash
 988                   capabilit: log_endpoint
 989                   relationshipppp:
 990                     type: tosca.relationships.ConnectsTo
 991
 992         '''
 993         expectedmessage = _('"requirements" of template "mysql_database" '
 994                             'contains unknown field "capabilit". Refer to the '
 995                             'definition to verify valid values.')
 996         err = self.assertRaises(
 997             exception.UnknownFieldError,
 998             lambda: self._single_node_template_content_test(tpl_snippet))
 999         self.assertEqual(expectedmessage, err.__str__())
1000
1001     def test_node_template_requirements_invalid_occurrences(self):
1002         tpl_snippet = '''
1003         node_templates:
1004           server:
1005             type: tosca.nodes.Compute
1006             requirements:
1007               - log_endpoint:
1008                   capability: log_endpoint
1009                   occurrences: [0, -1]
1010         '''
1011         expectedmessage = _('Value of property "[0, -1]" is invalid.')
1012         err = self.assertRaises(
1013             exception.InvalidPropertyValueError,
1014             lambda: self._single_node_template_content_test(tpl_snippet))
1015         self.assertEqual(expectedmessage, err.__str__())
1016
1017         tpl_snippet = '''
1018         node_templates:
1019           server:
1020             type: tosca.nodes.Compute
1021             requirements:
1022               - log_endpoint:
1023                   capability: log_endpoint
1024                   occurrences: [a, w]
1025         '''
1026         expectedmessage = _('"a" is not an integer.')
1027         err = self.assertRaises(
1028             ValueError,
1029             lambda: self._single_node_template_content_test(tpl_snippet))
1030         self.assertEqual(expectedmessage, err.__str__())
1031
1032         tpl_snippet = '''
1033         node_templates:
1034           server:
1035             type: tosca.nodes.Compute
1036             requirements:
1037               - log_endpoint:
1038                   capability: log_endpoint
1039                   occurrences: -1
1040         '''
1041         expectedmessage = _('"-1" is not a list.')
1042         err = self.assertRaises(
1043             ValueError,
1044             lambda: self._single_node_template_content_test(tpl_snippet))
1045         self.assertEqual(expectedmessage, err.__str__())
1046
1047         tpl_snippet = '''
1048         node_templates:
1049           server:
1050             type: tosca.nodes.Compute
1051             requirements:
1052               - log_endpoint:
1053                   capability: log_endpoint
1054                   occurrences: [5, 1]
1055         '''
1056         expectedmessage = _('Value of property "[5, 1]" is invalid.')
1057         err = self.assertRaises(
1058             exception.InvalidPropertyValueError,
1059             lambda: self._single_node_template_content_test(tpl_snippet))
1060         self.assertEqual(expectedmessage, err.__str__())
1061
1062         tpl_snippet = '''
1063         node_templates:
1064           server:
1065             type: tosca.nodes.Compute
1066             requirements:
1067               - log_endpoint:
1068                   capability: log_endpoint
1069                   occurrences: [0, 0]
1070         '''
1071         expectedmessage = _('Value of property "[0, 0]" is invalid.')
1072         err = self.assertRaises(
1073             exception.InvalidPropertyValueError,
1074             lambda: self._single_node_template_content_test(tpl_snippet))
1075         self.assertEqual(expectedmessage, err.__str__())
1076
1077     def test_node_template_requirements_valid_occurrences(self):
1078         tpl_snippet = '''
1079         node_templates:
1080           server:
1081             type: tosca.nodes.Compute
1082             requirements:
1083               - log_endpoint:
1084                   capability: log_endpoint
1085                   occurrences: [2, 2]
1086         '''
1087         self._single_node_template_content_test(tpl_snippet)
1088
1089     def test_node_template_capabilities(self):
1090         tpl_snippet = '''
1091         node_templates:
1092           mysql_database:
1093             type: tosca.nodes.Database
1094             properties:
1095               db_name: { get_input: db_name }
1096               db_user: { get_input: db_user }
1097               db_password: { get_input: db_pwd }
1098             capabilities:
1099               http_endpoint:
1100                 properties:
1101                   port: { get_input: db_port }
1102             requirements:
1103               - host: mysql_dbms
1104             interfaces:
1105               Standard:
1106                  configure: mysql_database_configure.sh
1107         '''
1108         expectedmessage = _('"capabilities" of template "mysql_database" '
1109                             'contains unknown field "http_endpoint". Refer to '
1110                             'the definition to verify valid values.')
1111         err = self.assertRaises(
1112             exception.UnknownFieldError,
1113             lambda: self._single_node_template_content_test(tpl_snippet))
1114         self.assertEqual(expectedmessage, err.__str__())
1115
1116     def test_node_template_properties(self):
1117         tpl_snippet = '''
1118         node_templates:
1119           server:
1120             type: tosca.nodes.Compute
1121             properties:
1122               os_image: F18_x86_64
1123             capabilities:
1124               host:
1125                 properties:
1126                   disk_size: 10 GB
1127                   num_cpus: { get_input: cpus }
1128                   mem_size: 4096 MB
1129               os:
1130                 properties:
1131                   architecture: x86_64
1132                   type: Linux
1133                   distribution: Fedora
1134                   version: 18.0
1135         '''
1136         expectedmessage = _('"properties" of template "server" contains '
1137                             'unknown field "os_image". Refer to the '
1138                             'definition to verify valid values.')
1139         err = self.assertRaises(
1140             exception.UnknownFieldError,
1141             lambda: self._single_node_template_content_test(tpl_snippet))
1142         self.assertEqual(expectedmessage, err.__str__())
1143
1144     def test_node_template_interfaces(self):
1145         tpl_snippet = '''
1146         node_templates:
1147           wordpress:
1148             type: tosca.nodes.WebApplication.WordPress
1149             requirements:
1150               - host: webserver
1151               - database_endpoint: mysql_database
1152             interfaces:
1153               Standards:
1154                  create: wordpress_install.sh
1155                  configure:
1156                    implementation: wordpress_configure.sh
1157                    inputs:
1158                      wp_db_name: { get_property: [ mysql_database, db_name ] }
1159                      wp_db_user: { get_property: [ mysql_database, db_user ] }
1160                      wp_db_password: { get_property: [ mysql_database, \
1161                      db_password ] }
1162                      wp_db_port: { get_property: [ SELF, \
1163                      database_endpoint, port ] }
1164         '''
1165         expectedmessage = _('"interfaces" of template "wordpress" contains '
1166                             'unknown field "Standards". Refer to the '
1167                             'definition to verify valid values.')
1168         err = self.assertRaises(
1169             exception.UnknownFieldError,
1170             lambda: self._single_node_template_content_test(tpl_snippet))
1171         self.assertEqual(expectedmessage, err.__str__())
1172
1173         tpl_snippet = '''
1174         node_templates:
1175           wordpress:
1176             type: tosca.nodes.WebApplication.WordPress
1177             requirements:
1178               - host: webserver
1179               - database_endpoint: mysql_database
1180             interfaces:
1181               Standard:
1182                  create: wordpress_install.sh
1183                  config:
1184                    implementation: wordpress_configure.sh
1185                    inputs:
1186                      wp_db_name: { get_property: [ mysql_database, db_name ] }
1187                      wp_db_user: { get_property: [ mysql_database, db_user ] }
1188                      wp_db_password: { get_property: [ mysql_database, \
1189                      db_password ] }
1190                      wp_db_port: { get_property: [ SELF, \
1191                      database_endpoint, port ] }
1192         '''
1193         expectedmessage = _('"interfaces" of template "wordpress" contains '
1194                             'unknown field "config". Refer to the definition '
1195                             'to verify valid values.')
1196         err = self.assertRaises(
1197             exception.UnknownFieldError,
1198             lambda: self._single_node_template_content_test(tpl_snippet))
1199         self.assertEqual(expectedmessage, err.__str__())
1200
1201         tpl_snippet = '''
1202         node_templates:
1203           wordpress:
1204             type: tosca.nodes.WebApplication.WordPress
1205             requirements:
1206               - host: webserver
1207               - database_endpoint: mysql_database
1208             interfaces:
1209               Standard:
1210                  create: wordpress_install.sh
1211                  configure:
1212                    implementation: wordpress_configure.sh
1213                    input:
1214                      wp_db_name: { get_property: [ mysql_database, db_name ] }
1215                      wp_db_user: { get_property: [ mysql_database, db_user ] }
1216                      wp_db_password: { get_property: [ mysql_database, \
1217                      db_password ] }
1218                      wp_db_port: { get_ref_property: [ database_endpoint, \
1219                      database_endpoint, port ] }
1220         '''
1221         expectedmessage = _('"interfaces" of template "wordpress" contains '
1222                             'unknown field "input". Refer to the definition '
1223                             'to verify valid values.')
1224         err = self.assertRaises(
1225             exception.UnknownFieldError,
1226             lambda: self._single_node_template_content_test(tpl_snippet))
1227         self.assertEqual(expectedmessage, err.__str__())
1228
1229     def test_relationship_template_properties(self):
1230         tpl_snippet = '''
1231         relationship_templates:
1232             storage_attachto:
1233                 type: AttachesTo
1234                 properties:
1235                   device: test_device
1236         '''
1237         expectedmessage = _('"properties" of template "storage_attachto" is '
1238                             'missing required field "[\'location\']".')
1239         rel_template = (toscaparser.utils.yamlparser.
1240                         simple_parse(tpl_snippet))['relationship_templates']
1241         name = list(rel_template.keys())[0]
1242         rel_template = RelationshipTemplate(rel_template[name], name)
1243         err = self.assertRaises(exception.MissingRequiredFieldError,
1244                                 rel_template.validate)
1245         self.assertEqual(expectedmessage, six.text_type(err))
1246
1247     def test_invalid_template_version(self):
1248         tosca_tpl = os.path.join(
1249             os.path.dirname(os.path.abspath(__file__)),
1250             "data/test_invalid_template_version.yaml")
1251         self.assertRaises(exception.ValidationError, ToscaTemplate, tosca_tpl)
1252         valid_versions = ', '.join(ToscaTemplate.VALID_TEMPLATE_VERSIONS)
1253         exception.ExceptionCollector.assertExceptionMessage(
1254             exception.InvalidTemplateVersion,
1255             (_('The template version "tosca_xyz" is invalid. Valid versions '
1256                'are "%s".') % valid_versions))
1257
1258     def test_node_template_capabilities_properties(self):
1259         # validating capability property values
1260         tpl_snippet = '''
1261         node_templates:
1262           server:
1263             type: tosca.nodes.WebServer
1264             capabilities:
1265               data_endpoint:
1266                 properties:
1267                   initiator: test
1268         '''
1269         expectedmessage = _('The value "test" of property "initiator" is '
1270                             'not valid. Expected a value from "[source, '
1271                             'target, peer]".')
1272
1273         err = self.assertRaises(
1274             exception.ValidationError,
1275             lambda: self._single_node_template_content_test(tpl_snippet))
1276         self.assertEqual(expectedmessage, err.__str__())
1277
1278         tpl_snippet = '''
1279         node_templates:
1280           server:
1281             type: tosca.nodes.Compute
1282             capabilities:
1283               host:
1284                 properties:
1285                   disk_size: 10 GB
1286                   num_cpus: { get_input: cpus }
1287                   mem_size: 4096 MB
1288               os:
1289                 properties:
1290                   architecture: x86_64
1291                   type: Linux
1292                   distribution: Fedora
1293                   version: 18.0
1294               scalable:
1295                 properties:
1296                   min_instances: 1
1297                   max_instances: 3
1298                   default_instances: 5
1299         '''
1300         expectedmessage = _('"properties" of template "server": '
1301                             '"default_instances" value is not between '
1302                             '"min_instances" and "max_instances".')
1303         err = self.assertRaises(
1304             exception.ValidationError,
1305             lambda: self._single_node_template_content_test(tpl_snippet))
1306         self.assertEqual(expectedmessage, err.__str__())
1307
1308     def test_node_template_objectstorage_without_required_property(self):
1309         tpl_snippet = '''
1310         node_templates:
1311           server:
1312             type: tosca.nodes.ObjectStorage
1313             properties:
1314               maxsize: 1 GB
1315         '''
1316         expectedmessage = _('"properties" of template "server" is missing '
1317                             'required field "[\'name\']".')
1318         err = self.assertRaises(
1319             exception.MissingRequiredFieldError,
1320             lambda: self._single_node_template_content_test(tpl_snippet))
1321         self.assertEqual(expectedmessage, err.__str__())
1322
1323     def test_node_template_objectstorage_with_invalid_scalar_unit(self):
1324         tpl_snippet = '''
1325         node_templates:
1326           server:
1327             type: tosca.nodes.ObjectStorage
1328             properties:
1329               name: test
1330               maxsize: -1
1331         '''
1332         expectedmessage = _('"-1" is not a valid scalar-unit.')
1333         err = self.assertRaises(
1334             ValueError,
1335             lambda: self._single_node_template_content_test(tpl_snippet))
1336         self.assertEqual(expectedmessage, err.__str__())
1337
1338     def test_node_template_objectstorage_with_invalid_scalar_type(self):
1339         tpl_snippet = '''
1340         node_templates:
1341           server:
1342             type: tosca.nodes.ObjectStorage
1343             properties:
1344               name: test
1345               maxsize: 1 XB
1346         '''
1347         expectedmessage = _('"1 XB" is not a valid scalar-unit.')
1348         err = self.assertRaises(
1349             ValueError,
1350             lambda: self._single_node_template_content_test(tpl_snippet))
1351         self.assertEqual(expectedmessage, err.__str__())
1352
1353     def test_special_keywords(self):
1354         """Test special keywords
1355
1356            Test that special keywords, e.g. metadata, which are not part
1357            of specification do not throw any validation error.
1358         """
1359         tpl_snippet_metadata_map = '''
1360         node_templates:
1361           server:
1362             type: tosca.nodes.Compute
1363             metadata:
1364               name: server A
1365               role: master
1366         '''
1367         self._single_node_template_content_test(tpl_snippet_metadata_map)
1368
1369         tpl_snippet_metadata_inline = '''
1370         node_templates:
1371           server:
1372             type: tosca.nodes.Compute
1373             metadata: none
1374         '''
1375         self._single_node_template_content_test(tpl_snippet_metadata_inline)
1376
1377     def test_policy_valid_keynames(self):
1378         tpl_snippet = '''
1379         policies:
1380           - servers_placement:
1381               type: tosca.policies.Placement
1382               description: Apply placement policy to servers
1383               metadata: { user1: 1001, user2: 1002 }
1384               targets: [ serv1, serv2 ]
1385         '''
1386         policies = (toscaparser.utils.yamlparser.
1387                     simple_parse(tpl_snippet))['policies'][0]
1388         name = list(policies.keys())[0]
1389         Policy(name, policies[name], None, None)
1390
1391     def test_policy_invalid_keyname(self):
1392         tpl_snippet = '''
1393         policies:
1394           - servers_placement:
1395               type: tosca.policies.Placement
1396               testkey: testvalue
1397         '''
1398         policies = (toscaparser.utils.yamlparser.
1399                     simple_parse(tpl_snippet))['policies'][0]
1400         name = list(policies.keys())[0]
1401
1402         expectedmessage = _('Policy "servers_placement" contains '
1403                             'unknown field "testkey". Refer to the '
1404                             'definition to verify valid values.')
1405         err = self.assertRaises(
1406             exception.UnknownFieldError,
1407             lambda: Policy(name, policies[name], None, None))
1408         self.assertEqual(expectedmessage, err.__str__())
1409
1410     def test_policy_trigger_valid_keyname(self):
1411         tpl_snippet = '''
1412         triggers:
1413          - resize_compute:
1414              description: trigger
1415              event_type: tosca.events.resource.utilization
1416              schedule:
1417                start_time: "2015-05-07T07:00:00Z"
1418                end_time: "2015-06-07T07:00:00Z"
1419              target_filter:
1420                node: master-container
1421                requirement: host
1422                capability: Container
1423              condition:
1424                constraint: utilization greater_than 50%
1425                period: 60
1426                evaluations: 1
1427                method : average
1428              action:
1429                resize: # Operation name
1430                 inputs:
1431                  strategy: LEAST_USED
1432                  implementation: Senlin.webhook()
1433         '''
1434         triggers = (toscaparser.utils.yamlparser.
1435                     simple_parse(tpl_snippet))['triggers'][0]
1436         name = list(triggers.keys())[0]
1437         Triggers(name, triggers[name])
1438
1439     def test_policy_trigger_invalid_keyname(self):
1440         tpl_snippet = '''
1441         triggers:
1442          - resize_compute:
1443              description: trigger
1444              event_type: tosca.events.resource.utilization
1445              schedule:
1446                start_time: "2015-05-07T07:00:00Z"
1447                end_time: "2015-06-07T07:00:00Z"
1448              target_filter1:
1449                node: master-container
1450                requirement: host
1451                capability: Container
1452              condition:
1453                constraint: utilization greater_than 50%
1454                period1: 60
1455                evaluations: 1
1456                method: average
1457              action:
1458                resize: # Operation name
1459                 inputs:
1460                  strategy: LEAST_USED
1461                  implementation: Senlin.webhook()
1462         '''
1463         triggers = (toscaparser.utils.yamlparser.
1464                     simple_parse(tpl_snippet))['triggers'][0]
1465         name = list(triggers.keys())[0]
1466         expectedmessage = _(
1467             'Triggers "resize_compute" contains unknown field '
1468             '"target_filter1". Refer to the definition '
1469             'to verify valid values.')
1470         err = self.assertRaises(
1471             exception.UnknownFieldError,
1472             lambda: Triggers(name, triggers[name]))
1473         self.assertEqual(expectedmessage, err.__str__())
1474
1475     def test_policy_missing_required_keyname(self):
1476         tpl_snippet = '''
1477         policies:
1478           - servers_placement:
1479               description: test description
1480         '''
1481         policies = (toscaparser.utils.yamlparser.
1482                     simple_parse(tpl_snippet))['policies'][0]
1483         name = list(policies.keys())[0]
1484
1485         expectedmessage = _('Template "servers_placement" is missing '
1486                             'required field "type".')
1487         err = self.assertRaises(
1488             exception.MissingRequiredFieldError,
1489             lambda: Policy(name, policies[name], None, None))
1490         self.assertEqual(expectedmessage, err.__str__())
1491
1492     def test_credential_datatype(self):
1493         tosca_tpl = os.path.join(
1494             os.path.dirname(os.path.abspath(__file__)),
1495             "data/test_credential_datatype.yaml")
1496         self.assertIsNotNone(ToscaTemplate(tosca_tpl))
1497
1498     def test_invalid_default_value(self):
1499         tpl_path = os.path.join(
1500             os.path.dirname(os.path.abspath(__file__)),
1501             "data/test_invalid_input_defaults.yaml")
1502         self.assertRaises(exception.ValidationError, ToscaTemplate, tpl_path)
1503         exception.ExceptionCollector.assertExceptionMessage(
1504             ValueError, _('"two" is not an integer.'))
1505
1506     def test_invalid_capability(self):
1507         tpl_snippet = '''
1508         node_templates:
1509           server:
1510             type: tosca.nodes.Compute
1511             capabilities:
1512                 oss:
1513                     properties:
1514                         architecture: x86_64
1515         '''
1516         tpl = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet))
1517         err = self.assertRaises(exception.UnknownFieldError,
1518                                 TopologyTemplate, tpl, None)
1519         expectedmessage = _('"capabilities" of template "server" contains '
1520                             'unknown field "oss". Refer to the definition '
1521                             'to verify valid values.')
1522         self.assertEqual(expectedmessage, err.__str__())