def test_built_in_datatype(self):
        value_snippet = '''
        private_network:
          network_name: private
          network_id: 3e54214f-5c09-1bc9-9999-44100326da1b
          addresses: [ 10.111.128.10 ]
        '''
        value = yamlparser.simple_parse(value_snippet)
        data = DataEntity('tosca.datatypes.network.NetworkInfo',
                          value.get('private_network'))
        self.assertIsNotNone(data.validate())

        value_snippet = '''
        portspec_valid:
          protocol: tcp
        '''
        value = yamlparser.simple_parse(value_snippet)
        data = DataEntity('tosca.datatypes.network.PortSpec',
                          value.get('portspec_valid'))
        self.assertIsNotNone(data.validate())

        value_snippet = '''
        portspec_invalid:
          protocol: xyz
        '''
        value = yamlparser.simple_parse(value_snippet)
        data = DataEntity('tosca.datatypes.network.PortSpec',
                          value.get('portspec_invalid'))
        err = self.assertRaises(exception.ValidationError, data.validate)
        self.assertEqual(_('The value "xyz" of property "protocol" is not '
                           'valid. Expected a value from "[udp, tcp, igmp]".'
                           ),
                         err.__str__())

    def test_constraint_for_scalar_unit(self):
        tpl_snippet = '''
        server:
          type: tosca.my.nodes.Compute
          properties:
            cpu_frequency: 0.05 GHz
            disk_size: 500 MB
            mem_size: 1 MB
        '''
        nodetemplates = yamlparser.simple_parse(tpl_snippet)
        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
        props = nodetemplate.get_properties()
        if 'cpu_frequency' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['cpu_frequency'].validate)
            self.assertEqual('cpu_frequency: 0.05 GHz must be greater or '
                             'equal to "0.1 GHz".', error.__str__())
        if 'disk_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['disk_size'].validate)
            self.assertEqual('disk_size: 500 MB must be greater or '
                             'equal to "1 GB".', error.__str__())

        if 'mem_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['mem_size'].validate)
            self.assertEqual('mem_size: 1 MB is out of range '
                             '(min:1 MiB, '
                             'max:1 GiB).', error.__str__())

    def test_incorrect_field_in_datatype(self):
        tpl_snippet = '''
        tosca_definitions_version: tosca_simple_yaml_1_0
        topology_template:
          node_templates:
            server:
              type: tosca.nodes.Compute

            webserver:
              type: tosca.nodes.WebServer
              properties:
                admin_credential:
                  user: username
                  token: some_pass
                  some_field: value
              requirements:
                - host: server
        '''
        tpl = yamlparser.simple_parse(tpl_snippet)
        err = self.assertRaises(exception.ValidationError, ToscaTemplate,
                                None, None, None, tpl)
        self.assertIn(_('The pre-parsed input failed validation with the '
                        'following error(s): \n\n\tUnknownFieldError: Data '
                        'value of type "tosca.datatypes.Credential" contains'
                        ' unknown field "some_field". Refer to the definition'
                        ' to verify valid values'), err.__str__())

    def test_proprety_inheritance(self):
        from toscaparser.nodetemplate import NodeTemplate

        tosca_custom_def = '''
          tosca.nodes.SoftwareComponent.MySoftware:
            derived_from: SoftwareComponent
            properties:
              install_path:
                required: false
                type: string
                default: /opt/mysoftware
        '''

        tosca_node_template = '''
          node_templates:
            mysoftware_instance:
              type: tosca.nodes.SoftwareComponent.MySoftware
              properties:
                component_version: 3.1
        '''

        expected_properties = ['component_version',
                               'install_path']

        nodetemplates = yamlparser.\
            simple_parse(tosca_node_template)['node_templates']
        custom_def = yamlparser.simple_parse(tosca_custom_def)
        name = list(nodetemplates.keys())[0]
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        self.assertIsNone(tpl.validate())
        self.assertEqual(expected_properties,
                         sorted(tpl.get_properties().keys()))

    def test_constraint_for_scalar_unit(self):
        tpl_snippet = '''
        server:
          type: tosca.my.nodes.Compute
          properties:
            cpu_frequency: 0.05 GHz
            disk_size: 500 MB
            mem_size: 1 MB
        '''
        nodetemplates = yamlparser.simple_parse(tpl_snippet)
        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
        props = nodetemplate.get_properties()
        if 'cpu_frequency' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['cpu_frequency'].validate)
            self.assertEqual(_('The value "0.05 GHz" of property '
                               '"cpu_frequency" must be greater than or equal '
                               'to "0.1 GHz".'), error.__str__())
        if 'disk_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['disk_size'].validate)
            self.assertEqual(_('The value "500 MB" of property "disk_size" '
                               'must be greater than or equal to "1 GB".'),
                             error.__str__())

        if 'mem_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['mem_size'].validate)
            self.assertEqual(_('The value "1 MB" of property "mem_size" is '
                               'out of range "(min:1 MiB, max:1 GiB)".'),
                             error.__str__())

 def test_range_unbounded(self):
     value_snippet = '''
     temperature: [-100, 999999]
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.my.datatypes.TestLab', value,
                       DataTypeTest.custom_type_def)
     self.assertIsNotNone(data.validate())

 def test_schema_none_description(self):
     tpl_snippet = '''
     cpus:
       type: integer
     '''
     schema = yamlparser.simple_parse(tpl_snippet)
     cpus_schema = Schema('cpus', schema['cpus'])
     self.assertEqual('', cpus_schema.description)

 def _get_nodetemplate(self, tpl_snippet,
                       custom_def_snippet=None):
     nodetemplates = yamlparser.\
         simple_parse(tpl_snippet)['node_templates']
     custom_def = yamlparser.simple_parse(custom_def_snippet)
     name = list(nodetemplates.keys())[0]
     tpl = NodeTemplate(name, nodetemplates, custom_def)
     return tpl

 def test_schema_miss_type(self):
     tpl_snippet = '''
     cpus:
       description: Number of CPUs for the server.
     '''
     schema = yamlparser.simple_parse(tpl_snippet)
     error = self.assertRaises(exception.InvalidSchemaError, Schema,
                               'cpus', schema['cpus'])
     self.assertEqual('Schema cpus must have type.', str(error))

 def test_custom_datatype(self):
     value_snippet = '''
     name: Mike
     gender: male
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.my.datatypes.PeopleBase', value,
                       DataTypeTest.custom_type_def)
     self.assertIsNotNone(data.validate())

 def test_built_in_datatype_without_properties(self):
     value_snippet = '''
     2
     '''
     value = yamlparser.simple_parse(value_snippet)
     datatype = DataType('PortDef')
     self.assertEqual('integer', datatype.value_type)
     data = DataEntity('PortDef', value)
     self.assertIsNotNone(data.validate())

 def test_default_field_in_dataentity(self):
     value_snippet = '''
     name: Mike
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.my.datatypes.PeopleBase', value,
                       DataTypeTest.custom_type_def)
     data = data.validate()
     self.assertEqual('unknown', data.get('gender'))

 def test_built_in_nested_datatype(self):
     value_snippet = '''
     user_port:
       protocol: tcp
       target: [50000]
       source: [9000]
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('PortSpec', value.get('user_port'))
     self.assertIsNotNone(data.validate())

    def test_valid_ranges_against_constraints(self):

        # The TestLab range type has max=UNBOUNDED
        value_snippet = '''
        temperature1: [-255, 999999]
        '''
        value = yamlparser.simple_parse(value_snippet)
        data = DataEntity('tosca.my.datatypes.TestLab', value,
                          DataTypeTest.custom_type_def)
        self.assertIsNotNone(data.validate())

        # The TestLab range type has min=UNBOUNDED
        value_snippet = '''
        temperature2: [-999999, 255]
        '''
        value = yamlparser.simple_parse(value_snippet)
        data = DataEntity('tosca.my.datatypes.TestLab', value,
                          DataTypeTest.custom_type_def)
        self.assertIsNotNone(data.validate())

 def test_functions_datatype(self):
     value_snippet = '''
     admin_credential:
       user: username
       token: { get_input: password }
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.datatypes.Credential',
                       value.get('admin_credential'))
     self.assertIsNotNone(data.validate())

 def test_schema_not_dict(self):
     tpl_snippet = '''
     cpus:
       - type: integer
       - description: Number of CPUs for the server.
     '''
     schema = yamlparser.simple_parse(tpl_snippet)
     error = self.assertRaises(exception.InvalidSchemaError, Schema,
                               'cpus', schema['cpus'])
     self.assertEqual('Schema cpus must be a dict.', str(error))

 def test_valid_range_type(self):
     value_snippet = '''
     user_port:
       protocol: tcp
       target_range:  [20000, 60000]
       source_range:  [1000, 3000]
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('PortSpec', value.get('user_port'))
     self.assertIsNotNone(data.validate())

 def test_type_error_in_dataentity(self):
     value_snippet = '''
     name: 123
     gender: male
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.my.datatypes.PeopleBase', value,
                       DataTypeTest.custom_type_def)
     error = self.assertRaises(ValueError, data.validate)
     self.assertEqual('"123" is not a string.', error.__str__())

 def test_non_dict_value_for_datatype(self):
     value_snippet = '''
     [Tom, Jerry]
     '''
     value = yamlparser.simple_parse(value_snippet)
     data = DataEntity('tosca.my.datatypes.PeopleBase', value,
                       DataTypeTest.custom_type_def)
     error = self.assertRaises(exception.TypeMismatchError, data.validate)
     self.assertEqual('[\'Tom\', \'Jerry\'] must be of type: '
                      '"tosca.my.datatypes.PeopleBase".', error.__str__())

 def test_scenario_scalar_unit_positive(self):
     tpl = self.tpl_snippet
     nodetemplates = yamlparser.simple_parse(tpl)
     nodetemplate = NodeTemplate('server', nodetemplates)
     props = nodetemplate.get_capability('host').get_properties()
     prop_name = self.property
     if props and prop_name in props.keys():
         prop = props[prop_name]
         self.assertIsNone(prop.validate())
         resolved = prop.value
     self.assertEqual(resolved, self.expected)