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 testParseUnitFoldersFromGoodFiles(self):
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file, self.local_subfields_file])
subfield_universe = subfield_lib.SubfieldUniverse(subfield_folders)
unit_folders = parse.ParseUnitFoldersFromFiles(
[self.global_units_file, self.local_units_file],
subfield_universe=subfield_universe)
self.assertLen(unit_folders, 2)
for folder in unit_folders:
self.assertEmpty(folder.GetFindings())
units_map = folder.local_namespace.units
if not folder.local_namespace.namespace:
# global namespace
self.assertEqual(units_map['amperes'],
unit_lib.Unit('amperes', 'current', True))
self.assertEqual(units_map['milliamperes'],
unit_lib.Unit('milliamperes', 'current'))
else:
# local namespace
self.assertEqual(folder.local_namespace.namespace, 'GOOD')
self.assertEqual(units_map['kelvins'],
unit_lib.Unit('kelvins', 'temperature', True))
self.assertEqual(
units_map['degrees_celsius'],
unit_lib.Unit('degrees_celsius', 'temperature'))
self.assertEqual(
units_map['degrees_fahrenheit'],
unit_lib.Unit('degrees_fahrenheit', 'temperature'))
def testParseUnitFoldersFromGoodFiles(self):
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file, self.local_subfields_file])
subfield_universe = subfield_lib.SubfieldUniverse(subfield_folders)
unit_folders = parse.ParseUnitFoldersFromFiles(
[self.global_units_file], subfield_universe=subfield_universe)
self.assertTrue(unit_folders)
for folder in unit_folders:
self.assertEmpty(folder.GetFindings())
current_units = folder.local_namespace.GetUnitsForMeasurement(
'current')
temperature_units = folder.local_namespace.GetUnitsForMeasurement(
'temperature')
if not folder.local_namespace.namespace:
# global namespace
self.assertEqual(current_units['amperes'],
unit_lib.Unit('amperes', True))
self.assertEqual(current_units['milliamperes'],
unit_lib.Unit('milliamperes'))
self.assertEqual(temperature_units['kelvins'],
unit_lib.Unit('kelvins', True))
self.assertEqual(temperature_units['degrees_celsius'],
unit_lib.Unit('degrees_celsius'))
self.assertEqual(temperature_units['degrees_fahrenheit'],
unit_lib.Unit('degrees_fahrenheit'))
def testParseSubfieldFoldersFromBadFileDuplicateFields(self):
bad_subfields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/subfields/duplicate_subfield_keys.yaml')
subfield_folders = parse.ParseSubfieldFoldersFromFiles([bad_subfields])
# should have 1 folder.
self.assertLen(subfield_folders, 1)
subfield_folder = subfield_folders[0]
self.assertTrue(
subfield_folder.HasFindingTypes([findings_lib.DuplicateKeyError]))
def testParseSubfieldFoldersFromGlobalFileWithUnitValidation(self):
unit_folders = parse.ParseUnitFoldersFromFiles(
[self.global_units_file])
unit_universe = unit_lib.UnitUniverse(unit_folders)
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file])
local_folder = subfield_folders[0]
local_folder.ValidateUnits(unit_universe)
self.assertEmpty(local_folder.GetFindings())
def testParseSubfieldFoldersFromBadFile(self):
bad_subfields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/subfields/bad_local_subfields.yaml')
subfield_folders = parse.ParseSubfieldFoldersFromFiles([bad_subfields])
# should have 1 folder.
self.assertLen(subfield_folders, 1)
subfield_folder = subfield_folders[0]
self.assertTrue(
subfield_folder.local_namespace.HasFindingTypes(
[findings_lib.DuplicateSubfieldDefinitionError]))
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 testParseUnitFoldersFromBadFileWithSubfieldUniverse(self):
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file, self.local_subfields_file])
subfield_universe = subfield_lib.SubfieldUniverse(subfield_folders)
bad_units = base_lib.PathParts(
root=self.base_dir, relative_path='BAD/units/bad_units.yaml')
unit_folders = parse.ParseUnitFoldersFromFiles(
[bad_units], subfield_universe=subfield_universe)
local_folder = unit_folders[0]
self.assertTrue(
local_folder.HasFindingTypes(
[findings_lib.UnknownMeasurementTypeError]))
def testParseSubfieldFoldersFromBadFileWithUnitValidation(self):
unit_folders = parse.ParseUnitFoldersFromFiles(
[self.global_units_file])
unit_universe = unit_lib.UnitUniverse(unit_folders)
bad_subfields = base_lib.PathParts(
root=self.base_dir,
relative_path='BAD/subfields/missing_unit_subfields.yaml')
subfield_folders = parse.ParseSubfieldFoldersFromFiles([bad_subfields])
local_folder = subfield_folders[0]
local_folder.ValidateUnits(unit_universe)
self.assertTrue(subfield_folders[0].HasFindingTypes(
[findings_lib.MissingUnitError]))
def testParseSubfieldFoldersFromGoodFiles(self):
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
[self.global_subfields_file, self.local_subfields_file])
# Should have two folder objects
self.assertLen(subfield_folders, 2)
for folder in subfield_folders:
self.assertEmpty(folder.GetFindings())
subfields_map = folder.local_namespace.subfields
if not folder.local_namespace.namespace:
# check global namespace
self.assertIn('fan', subfields_map)
self.assertIn('dryer', subfields_map)
self.assertIn('current', subfields_map)
self.assertIn('run', subfields_map)
self.assertIn('sensor', subfields_map)
self.assertIn('status', subfields_map)
self.assertIn('command', subfields_map)
else:
# check local namespace
self.assertEqual(folder.local_namespace.namespace, 'GOOD')
self.assertIn('zone', subfields_map)
self.assertIn('air', subfields_map)
self.assertIn('temperature', subfields_map)
