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
5 # http://www.apache.org/licenses/LICENSE-2.0
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
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
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.'
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')
47 class ToscaDefTest(TestCase):
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")
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,
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)
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
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
85 ['tosca.capabilities.Node',
86 'tosca.capabilities.network.Linkable'],
87 sorted([c.type for c in network_type.get_capabilities_objects()]))
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
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]))
104 os_props = self._get_capability_properties_def_objects(
105 compute_type.get_capabilities_objects(),
106 'tosca.capabilities.OperatingSystem')
108 [('architecture', False), ('distribution', False), ('type', False),
110 sorted([(p.name, p.required) for p in os_props]))
112 host_props = self._get_capability_properties_def_objects(
113 compute_type.get_capabilities_objects(),
114 'tosca.capabilities.Container')
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')
125 endpoint_admin_properties,
126 sorted([p.name for p in endpoint_admin_props_def_objects]))
128 def _get_capability_properties_def_objects(self, caps, type):
129 properties_def = None
132 properties_def = cap.get_properties_def_objects()
134 return properties_def
136 def _get_capability_properties_def(self, caps, type):
137 properties_def = None
140 properties_def = cap.get_properties_def()
142 return properties_def
144 def test_properties_def(self):
146 ['name', 'password', 'port', 'user'],
147 sorted(database_type.get_properties_def().keys()))
149 def test_attributes_def(self):
151 ['networks', 'ports', 'private_address', 'public_address',
152 'state', 'tosca_id', 'tosca_name'],
153 sorted(compute_type.get_attributes_def().keys()))
155 def test_requirements(self):
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'}}
165 [r for r in component_type.requirements])
167 def test_relationship(self):
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()]))
174 ('tosca.relationships.HostedOn', ['tosca.capabilities.Container']),
175 [(relation.type, relation.valid_target_types) for
176 relation in list(component_type.relationship.keys())])
178 ('tosca.relationships.network.BindsTo', 'tosca.nodes.Compute'),
179 [(relation.type, node.type) for
180 relation, node in network_port_type.relationship.items()])
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()])
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)
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)))
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',
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)))
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',
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)))
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',
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)))
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',
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 '
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)))
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',
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)))
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 '
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)))
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 '
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)))
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 '
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)))
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)))
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')
344 sorted(['protocol', 'target', 'target_range', 'source',
346 sorted(properties.keys()))