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('tosca.artifacts.Root',
 192                          artif_file_type.parent_type)
 193         self.assertEqual({}, artif_file_type.parent_artifacts)
 194         self.assertEqual(sorted(['tosca.artifacts.Root'],
 195                                 key=lambda x: str(x)),
 196                          sorted([artif_file_type.get_artifact(name)
 197                                 for name in artif_file_type.defs],
 198                                 key=lambda x: str(x)))
 199
 200         self.assertEqual('tosca.artifacts.Implementation',
 201                          artif_bash_type.parent_type)
 202         self.assertEqual({'tosca.artifacts.Implementation':
 203                           {'derived_from': 'tosca.artifacts.Root',
 204                            'description':
 205                            'TOSCA base type for implementation artifacts'}},
 206                          artif_bash_type.parent_artifacts)
 207         self.assertEqual(sorted([['sh'], 'tosca.artifacts.Implementation',
 208                                  'Script artifact for the Unix Bash shell',
 209                                  'application/x-sh'], key=lambda x: str(x)),
 210                          sorted([artif_bash_type.get_artifact(name)
 211                                 for name in artif_bash_type.defs],
 212                                 key=lambda x: str(x)))
 213
 214         self.assertEqual('tosca.artifacts.Implementation',
 215                          artif_python_type.parent_type)
 216         self.assertEqual({'tosca.artifacts.Implementation':
 217                           {'derived_from': 'tosca.artifacts.Root',
 218                            'description':
 219                            'TOSCA base type for implementation artifacts'}},
 220                          artif_python_type.parent_artifacts)
 221         self.assertEqual(sorted([['py'], 'tosca.artifacts.Implementation',
 222                                  'Artifact for the interpreted Python'
 223                                  ' language', 'application/x-python'],
 224                                 key=lambda x: str(x)),
 225                          sorted([artif_python_type.get_artifact(name)
 226                                 for name in artif_python_type.defs],
 227                                 key=lambda x: str(x)))
 228
 229         self.assertEqual('tosca.artifacts.Deployment.Image',
 230                          artif_container_docker_type.parent_type)
 231         self.assertEqual({'tosca.artifacts.Deployment':
 232                           {'derived_from': 'tosca.artifacts.Root',
 233                            'description':
 234                            'TOSCA base type for deployment artifacts'},
 235                           'tosca.artifacts.Deployment.Image':
 236                           {'derived_from': 'tosca.artifacts.Deployment'}},
 237                          artif_container_docker_type.parent_artifacts)
 238         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 239                                  'Docker container image'],
 240                                 key=lambda x: str(x)),
 241                          sorted([artif_container_docker_type.
 242                                 get_artifact(name) for name in
 243                                 artif_container_docker_type.defs],
 244                                 key=lambda x: str(x)))
 245
 246         self.assertEqual('tosca.artifacts.Deployment.Image',
 247                          artif_vm_iso_type.parent_type)
 248         self.assertEqual({'tosca.artifacts.Deployment':
 249                           {'derived_from': 'tosca.artifacts.Root',
 250                            'description':
 251                            'TOSCA base type for deployment artifacts'},
 252                           'tosca.artifacts.Deployment.Image':
 253                           {'derived_from': 'tosca.artifacts.Deployment'}},
 254                          artif_vm_iso_type.parent_artifacts)
 255         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 256                                  'Virtual Machine (VM) image in '
 257                                  'ISO disk format',
 258                                  'application/octet-stream', ['iso']],
 259                                 key=lambda x: str(x)),
 260                          sorted([artif_vm_iso_type.
 261                                 get_artifact(name) for name in
 262                                 artif_vm_iso_type.defs],
 263                                 key=lambda x: str(x)))
 264
 265         self.assertEqual('tosca.artifacts.Deployment.Image',
 266                          artif_vm_qcow2_type.parent_type)
 267         self.assertEqual({'tosca.artifacts.Deployment':
 268                           {'derived_from': 'tosca.artifacts.Root',
 269                            'description':
 270                            'TOSCA base type for deployment artifacts'},
 271                           'tosca.artifacts.Deployment.Image':
 272                           {'derived_from': 'tosca.artifacts.Deployment'}},
 273                          artif_vm_qcow2_type.parent_artifacts)
 274         self.assertEqual(sorted(['tosca.artifacts.Deployment.Image',
 275                                  'Virtual Machine (VM) image in QCOW v2 '
 276                                  'standard disk format',
 277                                  'application/octet-stream', ['qcow2']],
 278                                 key=lambda x: str(x)),
 279                          sorted([artif_vm_qcow2_type.
 280                                 get_artifact(name) for name in
 281                                 artif_vm_qcow2_type.defs],
 282                                 key=lambda x: str(x)))
 283
 284     def test_policies(self):
 285         self.assertEqual(policy_root_type.parent_type, None)
 286         self.assertEqual('tosca.policies.Root',
 287                          policy_placement_type.parent_type.type)
 288         self.assertEqual({}, policy_placement_type.parent_policies)
 289         self.assertEqual(sorted(['tosca.policies.Root',
 290                                  'The TOSCA Policy Type definition that is '
 291                                  'used to govern placement of TOSCA nodes or '
 292                                  'groups of nodes.'],
 293                                 key=lambda x: str(x)),
 294                          sorted([policy_placement_type.get_policy(name)
 295                                 for name in policy_placement_type.defs],
 296                                 key=lambda x: str(x)))
 297
 298         self.assertEqual('tosca.policies.Root',
 299                          policy_scaling_type.parent_type.type)
 300         self.assertEqual({}, policy_scaling_type.parent_policies)
 301         self.assertEqual(sorted(['tosca.policies.Root',
 302                                  'The TOSCA Policy Type definition that is '
 303                                  'used to govern scaling of TOSCA nodes or '
 304                                  'groups of nodes.'],
 305                                 key=lambda x: str(x)),
 306                          sorted([policy_scaling_type.get_policy(name)
 307                                 for name in policy_scaling_type.defs],
 308                                 key=lambda x: str(x)))
 309
 310         self.assertEqual('tosca.policies.Root',
 311                          policy_update_type.parent_type.type)
 312         self.assertEqual({}, policy_update_type.parent_policies)
 313         self.assertEqual(sorted(['tosca.policies.Root',
 314                                  'The TOSCA Policy Type definition that is '
 315                                  'used to govern update of TOSCA nodes or '
 316                                  'groups of nodes.'],
 317                                 key=lambda x: str(x)),
 318                          sorted([policy_update_type.get_policy(name)
 319                                 for name in policy_update_type.defs],
 320                                 key=lambda x: str(x)))
 321
 322         self.assertEqual('tosca.policies.Root',
 323                          policy_performance_type.parent_type.type)
 324         self.assertEqual({}, policy_performance_type.parent_policies)
 325         self.assertEqual(sorted(['tosca.policies.Root',
 326                                  'The TOSCA Policy Type definition that is '
 327                                  'used to declare performance requirements '
 328                                  'for TOSCA nodes or groups of nodes.'],
 329                                 key=lambda x: str(x)),
 330                          sorted([policy_performance_type.get_policy(name)
 331                                 for name in policy_performance_type.defs],
 332                                 key=lambda x: str(x)))
 333
 334     def test_port_spec(self):
 335         tosca_def = EntityType.TOSCA_DEF
 336         port_spec = tosca_def.get('tosca.datatypes.network.PortSpec')
 337         self.assertEqual(port_spec.get('derived_from'),
 338                          'tosca.datatypes.Root')
 339         properties = port_spec.get('properties')
 340         self.assertEqual(
 341             sorted(['protocol', 'target', 'target_range', 'source',
 342                     'source_range']),
 343             sorted(properties.keys()))