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