def testParseTypeFoldersFromFilesNoFieldsUniverse(self):
type_folders = parse.ParseTypeFoldersFromFiles(
[self.good_types_file, self.good_types_file_2])
# should have 1 folder for GOOD_TYPES namespace
self.assertLen(type_folders, 1)
# folder should have 4 types
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertLen(valid_types, 4)
def BuildUniverse(config):
"""Verifies that the ontology config is consistent and valid.
Args:
config: a Config namedtuple containing lists of localpaths to config files.
Returns:
A ConfigUniverse that is fully populated with all content specified in the
config.
"""
# Parse state files
state_universe = None
if config.states:
state_folders = parse.ParseStateFoldersFromFiles(config.states)
state_universe = state_lib.StateUniverse(state_folders)
connections_universe = None
if config.connections:
connection_folders = parse.ParseConnectionFoldersFromFiles(
config.connections)
connections_universe = connection_lib.ConnectionUniverse(
connection_folders)
# Parse subfield files
subfields_universe = None
if config.subfields:
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
config.subfields)
subfields_universe = subfield_lib.SubfieldUniverse(subfield_folders)
# Parse unit files
unit_universe = None
if config.units:
unit_folders = parse.ParseUnitFoldersFromFiles(config.units,
subfields_universe)
unit_universe = unit_lib.UnitUniverse(unit_folders)
if subfields_universe:
subfields_universe.ValidateUnits(unit_universe)
# Parse fields files
fields_universe = None
if config.fields:
field_folders = parse.ParseFieldFoldersFromFiles(
config.fields, subfields_universe, state_universe)
fields_universe = field_lib.FieldUniverse(field_folders)
# Parse typedef files
type_folders = parse.ParseTypeFoldersFromFiles(config.type_defs,
fields_universe)
types_universe = entity_type_lib.EntityTypeUniverse(type_folders)
# return findings_list, result_namespaces
return ConfigUniverse(types_universe, fields_universe, subfields_universe,
state_universe, connections_universe, unit_universe)
def testParseTypeFoldersFromFilesWithFieldsUniverse(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('current_sensor', 'fan_run_status', 'dryer_run_status',
'fan_run_command'),
'GOOD': ('zone_air_temperature_sensor')
}
type_folders = parse.ParseTypeFoldersFromFiles(
[self.good_types_file, self.good_types_file_2], fields_universe)
# should have 1 folder for GOOD namespace
self.assertLen(type_folders, 1)
# folder should have 4 types
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertLen(valid_types, 4)
def testParseTypeFoldersFromFileUndefinedFields(self):
bad_type_file = base_lib.PathParts(
root=self.base_dir, relative_path='BAD/entity_types/bad3.yaml')
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('current_sensor', 'fan_run_command')
}
type_folders = parse.ParseTypeFoldersFromFiles([bad_type_file],
fields_universe)
# should have 1 folder
self.assertLen(type_folders, 1)
self.assertTrue(type_folders[0].local_namespace.HasFindingTypes(
[findings_lib.UndefinedFieldError]))
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertFalse(valid_types)
def testParseTypeFoldersFromFileBadFormat(self):
bad_types_file = base_lib.PathParts(
root=self.base_dir, relative_path='BAD/entity_types/bad1.yaml')
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('dryer_run_status', 'fan_run_command')
}
type_folders = parse.ParseTypeFoldersFromFiles([bad_types_file],
fields_universe)
# should have 1 folder
self.assertLen(type_folders, 1)
type_folder = type_folders[0]
# Should find 4 errors
self.assertLen(type_folder.GetFindings(), 3)
self.assertTrue(
type_folder.HasFindingTypes([findings_lib.DuplicateFieldError]))
self.assertTrue(
type_folder.HasFindingTypes(
[findings_lib.UnrecognizedFieldFormatError]))
self.assertTrue(
type_folder.HasFindingTypes([findings_lib.DuplicateParentError]))
def testParseTypeFoldersFromFilesDuplicateTypes(self):
type_folders = parse.ParseTypeFoldersFromFiles(
[self.duplicate_types_file])
self.assertTrue(type_folders[0].HasFindingTypes(
[findings_lib.DuplicateKeyError]))
def testParseTypeFoldersFromFilesEmptyConfig(self):
type_folders = parse.ParseTypeFoldersFromFiles([self.empty_types_file])
self.assertLen(type_folders, 1)
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertEmpty(valid_types)
