def testParseFieldFoldersFromGoodFilesWithSubfieldUniverse(self):
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file, self.local_subfields_file])
subfield_universe = subfield_lib.SubfieldUniverse(subfield_folders)
field_folders = parse.ParseFieldFoldersFromFiles(
[self.global_fields_file, self.local_fields_file],
subfield_universe=subfield_universe)
# Should have two namespace objects
self.assertLen(field_folders, 2)
for folder in field_folders:
self.assertEmpty(folder.GetFindings())
if folder.parent_namespace is None:
# check global namespace
# Should have 4 fields in global namespace
global_fields = folder.local_namespace.fields
self.assertLen(global_fields, 4)
self.assertIn(frozenset({'fan', 'run', 'status'}),
global_fields)
self.assertIn(frozenset({'dryer', 'run', 'status'}),
global_fields)
self.assertIn(frozenset({'command', 'fan', 'run'}),
global_fields)
self.assertIn(frozenset({'current', 'sensor'}), global_fields)
else:
# check local namespace
self.assertIn(
frozenset({'air', 'sensor', 'temperature', 'zone'}),
folder.local_namespace.fields)
def testParseFieldFoldersFromBadFileDuplicateKeys(self):
bad_fields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/fields/duplicate_literal_fields.yaml')
field_folders = parse.ParseFieldFoldersFromFiles([bad_fields])
# Error is added to the folder it is found in, even if fields may uplevel
local_folder = field_folders[1]
self.assertTrue(
local_folder.HasFindingTypes([findings_lib.DuplicateKeyError]))
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 testParseFieldFoldersFromBadFile(self):
bad_fields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/fields/bad_local_fields.yaml')
field_folders = parse.ParseFieldFoldersFromFiles([bad_fields])
# should have 2 folders. (global folder is created automatically)
self.assertLen(field_folders, 2)
# Field in bad_local will be upleveled to global ns
global_folder = field_folders[0]
self.assertTrue(
global_folder.local_namespace.HasFindingTypes(
[findings_lib.DuplicateFieldDefinitionError]))
def testParseFieldFoldersFromBadFileWithStateUniverse(self):
state_folders = parse.ParseStateFoldersFromFiles(
[self.global_states_file, self.local_states_file])
state_universe = state_lib.StateUniverse(state_folders)
bad_fields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/fields/bad_state_fields.yaml')
field_folders = parse.ParseFieldFoldersFromFiles(
[bad_fields], state_universe=state_universe)
local_folder = field_folders[1]
self.assertTrue(
local_folder.HasFindingTypes(
[findings_lib.InvalidStateFormatError]))
self.assertTrue(
local_folder.HasFindingTypes([findings_lib.DuplicateStateError]))
self.assertTrue(
local_folder.HasFindingTypes([findings_lib.MissingStateError]))
def testParseFieldFoldersFromGoodFilesWithStateUniverse(self):
state_folders = parse.ParseStateFoldersFromFiles(
[self.global_states_file, self.local_states_file])
state_universe = state_lib.StateUniverse(state_folders)
field_folders = parse.ParseFieldFoldersFromFiles(
[self.state_fields_file], state_universe=state_universe)
self.assertLen(field_folders, 2)
for folder in field_folders:
self.assertEmpty(folder.GetFindings())
if folder.parent_namespace is not None:
# field_two uses local states and isn't up-leveled
self.assertSameElements([frozenset({'field', 'two'})],
folder.local_namespace.fields)
else:
self.assertSameElements([
frozenset({'field', 'one'}),
frozenset({'field', 'three'})
], folder.local_namespace.fields)
def testParseFieldFoldersFromGoodFilesNoSubfieldUniverse(self):
field_folders = parse.ParseFieldFoldersFromFiles(
[self.global_fields_file, self.local_fields_file])
# Should have two namespace objects
self.assertLen(field_folders, 2)
for folder in field_folders:
self.assertFalse(folder.GetFindings())
if folder.parent_namespace is None:
# check global namespace
# All the fields should be global. The field in local_fields_file is
# upleveled
# Should have 5 fields in global namespace
global_fields = folder.local_namespace.fields
self.assertLen(global_fields, 5)
self.assertIn(frozenset({'fan', 'run', 'status'}),
global_fields)
self.assertIn(frozenset({'dryer', 'run', 'status'}),
global_fields)
self.assertIn(frozenset({'command', 'fan', 'run'}),
global_fields)
self.assertIn(
frozenset({'air', 'sensor', 'temperature', 'zone'}),
global_fields)
self.assertIn(frozenset({'current', 'sensor'}), global_fields)
