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