tosca2heat/tosca-parser/toscaparser/tests/test_toscadef.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 from toscaparser.common import exception
  14 from toscaparser.elements.artifacttype import ArtifactTypeDef
  15 from toscaparser.elements.entity_type import EntityType
  16 from toscaparser.elements.grouptype import GroupType
  17 import toscaparser.elements.interfaces as ifaces
  18 from toscaparser.elements.nodetype import NodeType
  19 from toscaparser.elements.policytype import PolicyType
  20 from toscaparser.tests.base import TestCase
  21
  22 compute_type = NodeType('tosca.nodes.Compute')
  23 component_type = NodeType('tosca.nodes.SoftwareComponent')
  24 network_type = NodeType('tosca.nodes.network.Network')
  25 network_port_type = NodeType('tosca.nodes.network.Port')
  26 webserver_type = NodeType('tosca.nodes.WebServer')
  27 database_type = NodeType('tosca.nodes.Database')
  28 artif_root_type = ArtifactTypeDef('tosca.artifacts.Root')
  29 artif_file_type = ArtifactTypeDef('tosca.artifacts.File')
  30 artif_bash_type = ArtifactTypeDef('tosca.artifacts.Implementation.Bash')
  31 artif_python_type = ArtifactTypeDef('tosca.artifacts.Implementation.Python')
  32 artif_container_docker_type = ArtifactTypeDef('tosca.artifacts.'
  33                                               'Deployment.Image.'
  34                                               'Container.Docker')
  35 artif_vm_iso_type = ArtifactTypeDef('tosca.artifacts.'
  36                                     'Deployment.Image.VM.ISO')
  37 artif_vm_qcow2_type = ArtifactTypeDef('tosca.artifacts.'
  38                                       'Deployment.Image.VM.QCOW2')
  39 policy_root_type = PolicyType('tosca.policies.Root')
  40 policy_placement_type = PolicyType('tosca.policies.Placement')
  41 policy_scaling_type = PolicyType('tosca.policies.Scaling')
  42 policy_update_type = PolicyType('tosca.policies.Update')
  43 policy_performance_type = PolicyType('tosca.policies.Performance')
  44 group_type = GroupType('tosca.groups.Root')
  45
  46
  47 class ToscaDefTest(TestCase):
  48     def test_type(self):
  49         self.assertEqual(compute_type.type, "tosca.nodes.Compute")
  50         self.assertRaises(exception.InvalidTypeError, NodeType,
  51                           'tosca.nodes.Invalid')
  52         self.assertEqual(network_type.type, "tosca.nodes.network.Network")
  53         self.assertEqual(network_port_type.type, "tosca.nodes.network.Port")
  54
  55     def test_parent_type(self):
  56         self.assertEqual(compute_type.parent_type.type, "tosca.nodes.Root")
  57         self.assertEqual(network_type.parent_type.type, "tosca.nodes.Root")
  58         self.assertEqual(network_port_type.parent_type.type,
  59                          "tosca.nodes.Root")
  60
  61     def test_group(self):
  62         self.assertEqual(group_type.type, "tosca.groups.Root")
  63         self.assertIsNone(group_type.parent_type)
  64         self.assertIn(ifaces.LIFECYCLE_SHORTNAME, group_type.interfaces)
  65
  66     def test_capabilities(self):
  67         # Assure the normative Compute node type
  68         # has all the required Capability types
  69         # regardless of symbloc name
  70         # TODO(Matt) - since Compute IS a normative node type
  71         # we SHOULD test symbolic capability names as well
  72         self.assertEqual(
  73             ['tosca.capabilities.Container',
  74              'tosca.capabilities.Endpoint.Admin',
  75              'tosca.capabilities.Node',
  76              'tosca.capabilities.OperatingSystem',
  77              'tosca.capabilities.Scalable',
  78              'tosca.capabilities.network.Bindable'],
  79             sorted([c.type for c in compute_type.get_capabilities_objects()]))
  80         # Assure the normative Network node type
  81         # hsa all the required Capability types
  82         # TODO(Matt) - since Network IS a normative node type
  83         # we SHOULD test symbolic capability names as well
  84         self.assertEqual(
  85             ['tosca.capabilities.Node',
  86              'tosca.capabilities.network.Linkable'],
  87             sorted([c.type for c in network_type.get_capabilities_objects()]))
  88
  89         # Assure the normative WebServer node type's
  90         # Endpoint cap. has all required property names
  91         # Note: we are testing them in alphabetic sort order
  92         endpoint_props_def_objects = \
  93             self._get_capability_properties_def_objects(
  94                 webserver_type.get_capabilities_objects(),
  95                 'tosca.capabilities.Endpoint')
  96         # Assure WebServer's Endpoint capability's properties have their
  97         # required keyname value set correctly
  98         self.assertEqual(
  99             [('initiator', False), ('network_name', False), ('port', False),
 100              ('port_name', False), ('ports', False), ('protocol', True),
 101              ('secure', False), ('url_path', False)],
 102             sorted([(p.name, p.required) for p in endpoint_props_def_objects]))
 103
 104         os_props = self._get_capability_properties_def_objects(
 105             compute_type.get_capabilities_objects(),
 106             'tosca.capabilities.OperatingSystem')
 107         self.assertEqual(
 108             [('architecture', False), ('distribution', False), ('type', False),
 109              ('version', False)],
 110             sorted([(p.name, p.required) for p in os_props]))
 111
 112         host_props = self._get_capability_properties_def_objects(
 113             compute_type.get_capabilities_objects(),
 114             'tosca.capabilities.Container')
 115         self.assertEqual(
 116             [('cpu_frequency', False), ('disk_size', False),
 117              ('mem_size', False), ('num_cpus', False)],
 118             sorted([(p.name, p.required) for p in host_props]))
 119         endpoint_admin_properties = 'secure'
 120         endpoint_admin_props_def_objects = \
 121             self._get_capability_properties_def_objects(
 122                 webserver_type.get_capabilities_objects(),
 123                 'tosca.capabilities.Endpoint.Admin')
 124         self.assertIn(
 125             endpoint_admin_properties,
 126             sorted([p.name for p in endpoint_admin_props_def_objects]))
 127
 128     def _get_capability_properties_def_objects(self, caps, type):
 129         properties_def = None
 130         for cap in caps:
 131             if cap.type == type:
 132                 properties_def = cap.get_properties_def_objects()
 133                 break
 134         return properties_def
 135
 136     def _get_capability_properties_def(self, caps, type):
 137         properties_def = None
 138         for cap in caps:
 139             if cap.type == type:
 140                 properties_def = cap.get_properties_def()
 141                 break
 142         return properties_def
 143
 144     def test_properties_def(self):
 145         self.assertEqual(
 146             ['name', 'password', 'port', 'user'],
 147             sorted(database_type.get_properties_def().keys()))
 148
 149     def test_attributes_def(self):
 150         self.assertEqual(
 151             ['networks', 'ports', 'private_address', 'public_address',
 152              'state', 'tosca_id', 'tosca_name'],
 153             sorted(compute_type.get_attributes_def().keys()))
 154
 155     def test_requirements(self):
 156         self.assertEqual(
 157             [{'host': {'capability': 'tosca.capabilities.Container',
 158                        'node': 'tosca.nodes.Compute',
 159                        'relationship': 'tosca.relationships.HostedOn'}},
 160              {'dependency': {'capability': 'tosca.capabilities.Node',
 161                              'node': 'tosca.nodes.Root',
 162                              'occurrences': [0, 'UNBOUNDED'],
 163                              'relationship': 'tosca.relationships.DependsOn'}}
 164              ],
 165             [r for r in component_type.requirements])
 166
 167     def test_relationship(self):
 168         self.assertEqual(
 169             [('tosca.relationships.DependsOn', 'tosca.nodes.Root'),
 170              ('tosca.relationships.HostedOn', 'tosca.nodes.Compute')],
 171             sorted([(relation.type, node.type) for
 172                    relation, node in component_type.relationship.items()]))
 173         self.assertIn(
 174             ('tosca.relationships.HostedOn', ['tosca.capabilities.Container']),
 175             [(relation.type, relation.valid_target_types) for
 176              relation in list(component_type.relationship.keys())])
 177         self.assertIn(
 178             ('tosca.relationships.network.BindsTo', 'tosca.nodes.Compute'),
 179             [(relation.type, node.type) for
 180              relation, node in network_port_type.relationship.items()])
 181         self.assertIn(
 182             ('tosca.relationships.network.LinksTo',
 183              'tosca.nodes.network.Network'),
 184             [(relation.type, node.type) for
 185              relation, node in network_port_type.relationship.items()])
 186
 187     def test_interfaces(self):
 188         self.assertIsNone(compute_type.interfaces)
 189         root_node = NodeType('tosca.nodes.Root')
 190         self.assertIn(ifaces.LIFECYCLE_SHORTNAME, root_node.interfaces)
 191
 192     def test_artifacts(self):
 193         self.assertIsNone(artif_root_type.parent_type)
 194         self.assertEqual('tosca.artifacts.Root',
 195                          artif_file_type.parent_type.type)
 196         self.assertEqual({}, artif_file_type.parent_artifacts)
 197         self.assertEqual(sorted(['tosca.artifacts.Root'],
 198                                 key=lambda x: str(x)),
 199                          sorted([artif_file_type.get_artifact(name)
 200                                 for name in artif_file_type.defs],
 201                                 key=lambda x: str(x)))
 202
 203         self.assertEqual('tosca.artifacts.Implementation',
 204                          artif_bash_type.parent_type.type)
 205         self.assertEqual({'tosca.artifacts.Implementation':
 206                           {'derived_from': 'tosca.artifacts.Root',
 207                            'description':
 208                            'TOSCA base type for implementation artifacts'}},
 209                          artif_bash_type.parent_artifacts)
 210         self.assertEqual(sorted([['sh'], 'tosca.artifacts.Implementation',
 211                                  'Script artifact for the Unix Bash shell',
 212                                  'application/x-sh'], key=lambda x: str(x)),
 213                          sorted([artif_bash_type.get_artifact(name)
 214                                 for name in artif_bash_type.defs],
 215                                 key=lambda x: str(x)))
 216
 217         self.assertEqual('tosca.artifacts.Implementation',
 218                          artif_python_type.parent_type.type)
 219         self.assertEqual({'tosca.artifacts.Implementation':
 220                           {'derived_from': 'tosca.artifacts.Root',
 221                            'description':
 222                            'TOSCA base type for implementation artifacts'}},
 223                          artif_python_type.parent_artifacts)
 224         self.assertEqual(sorted([['py'], 'tosca.artifacts.Implementation',
 225                                  'Artifact for the interpreted Python'
 226                                  ' language', 'application/x-python'],
 227                                 key=lambda x: str(x)),
 228                          sorted([artif_python_type.get_artifact(name)
 229                                 for name in artif_python_type.defs],
 230                                 key=lambda x: str(x)))
 231
 232         self.assertEqual('tosca.artifacts.Deployment.Image',
 233                          artif_container_docker_type.parent_type.type)
 234         self.assertEqual({'tosca.artifacts.Deployment':
 235                           {'derived_from': 'tosca.artifacts.Root',
 236                            'description':
 237                            'TOSCA base type for deployment artifacts'},
 238                           'tosca.artifacts.Deployment.Image':
 239                           {'derived_from': 'tosca.artifacts.Deployment'}},
 240                          artif_container_docker_type.parent_artifacts)
 241         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 242                                  'Docker container image'],
 243                                 key=lambda x: str(x)),
 244                          sorted([artif_container_docker_type.
 245                                 get_artifact(name) for name in
 246                                 artif_container_docker_type.defs],
 247                                 key=lambda x: str(x)))
 248
 249         self.assertEqual('tosca.artifacts.Deployment.Image',
 250                          artif_vm_iso_type.parent_type.type)
 251         self.assertEqual({'tosca.artifacts.Deployment':
 252                           {'derived_from': 'tosca.artifacts.Root',
 253                            'description':
 254                            'TOSCA base type for deployment artifacts'},
 255                           'tosca.artifacts.Deployment.Image':
 256                           {'derived_from': 'tosca.artifacts.Deployment'}},
 257                          artif_vm_iso_type.parent_artifacts)
 258         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 259                                  'Virtual Machine (VM) image in '
 260                                  'ISO disk format',
 261                                  'application/octet-stream', ['iso']],
 262                                 key=lambda x: str(x)),
 263                          sorted([artif_vm_iso_type.
 264                                 get_artifact(name) for name in
 265                                 artif_vm_iso_type.defs],
 266                                 key=lambda x: str(x)))
 267
 268         self.assertEqual('tosca.artifacts.Deployment.Image',
 269                          artif_vm_qcow2_type.parent_type.type)
 270         self.assertEqual({'tosca.artifacts.Deployment':
 271                           {'derived_from': 'tosca.artifacts.Root',
 272                            'description':
 273                            'TOSCA base type for deployment artifacts'},
 274                           'tosca.artifacts.Deployment.Image':
 275                           {'derived_from': 'tosca.artifacts.Deployment'}},
 276                          artif_vm_qcow2_type.parent_artifacts)
 277         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 278                                  'Virtual Machine (VM) image in QCOW v2 '
 279                                  'standard disk format',
 280                                  'application/octet-stream', ['qcow2']],
 281                                 key=lambda x: str(x)),
 282                          sorted([artif_vm_qcow2_type.
 283                                 get_artifact(name) for name in
 284                                 artif_vm_qcow2_type.defs],
 285                                 key=lambda x: str(x)))
 286
 287     def test_policies(self):
 288         self.assertIsNone(policy_root_type.parent_type)
 289         self.assertEqual('tosca.policies.Root',
 290                          policy_placement_type.parent_type.type)
 291         self.assertEqual({}, policy_placement_type.parent_policies)
 292         self.assertEqual(sorted(['tosca.policies.Root',
 293                                  'The TOSCA Policy Type definition that is '
 294                                  'used to govern placement of TOSCA nodes or '
 295                                  'groups of nodes.'],
 296                                 key=lambda x: str(x)),
 297                          sorted([policy_placement_type.get_policy(name)
 298                                 for name in policy_placement_type.defs],
 299                                 key=lambda x: str(x)))
 300
 301         self.assertEqual('tosca.policies.Root',
 302                          policy_scaling_type.parent_type.type)
 303         self.assertEqual({}, policy_scaling_type.parent_policies)
 304         self.assertEqual(sorted(['tosca.policies.Root',
 305                                  'The TOSCA Policy Type definition that is '
 306                                  'used to govern scaling of TOSCA nodes or '
 307                                  'groups of nodes.'],
 308                                 key=lambda x: str(x)),
 309                          sorted([policy_scaling_type.get_policy(name)
 310                                 for name in policy_scaling_type.defs],
 311                                 key=lambda x: str(x)))
 312
 313         self.assertEqual('tosca.policies.Root',
 314                          policy_update_type.parent_type.type)
 315         self.assertEqual({}, policy_update_type.parent_policies)
 316         self.assertEqual(sorted(['tosca.policies.Root',
 317                                  'The TOSCA Policy Type definition that is '
 318                                  'used to govern update of TOSCA nodes or '
 319                                  'groups of nodes.'],
 320                                 key=lambda x: str(x)),
 321                          sorted([policy_update_type.get_policy(name)
 322                                 for name in policy_update_type.defs],
 323                                 key=lambda x: str(x)))
 324
 325         self.assertEqual('tosca.policies.Root',
 326                          policy_performance_type.parent_type.type)
 327         self.assertEqual({}, policy_performance_type.parent_policies)
 328         self.assertEqual(sorted(['tosca.policies.Root',
 329                                  'The TOSCA Policy Type definition that is '
 330                                  'used to declare performance requirements '
 331                                  'for TOSCA nodes or groups of nodes.'],
 332                                 key=lambda x: str(x)),
 333                          sorted([policy_performance_type.get_policy(name)
 334                                 for name in policy_performance_type.defs],
 335                                 key=lambda x: str(x)))
 336
 337     def test_port_spec(self):
 338         tosca_def = EntityType.TOSCA_DEF
 339         port_spec = tosca_def.get('tosca.datatypes.network.PortSpec')
 340         self.assertEqual(port_spec.get('derived_from'),
 341                          'tosca.datatypes.Root')
 342         properties = port_spec.get('properties')
 343         self.assertEqual(
 344             sorted(['protocol', 'target', 'target_range', 'source',
 345                     'source_range']),
 346             sorted(properties.keys()))