def mock_model_with_conversion():
model = Mock()
model.name = 'test_model'
model.parameters = ParameterList()
model.parameters.add_parameter({
'name': 'smart_meter_savings',
'description': 'The savings from smart meters',
'absolute_range': (0, 100),
'suggested_range': (3, 10),
'default_value': 3,
'units': '%',
'parent': None
})
regions = Mock()
regions.name = 'test_regions'
intervals = Mock()
intervals.name = 'test_intervals'
model.inputs = MetadataSet(
[Metadata('test', regions, intervals, 'liters')])
source_model = Mock()
source_model.name = 'test_source'
model.deps = {
'test':
Dependency(source_model,
Metadata('test_output', regions, intervals, 'milliliters'),
Metadata('test', regions, intervals, 'liters'))
}
return model
def test_access_region_names_with_register(self, region_set, interval_set):
"""Metadata should expose region names when a register is available
"""
rreg = region_set
metadata = Metadata("total_lane_kilometres", region_set, interval_set, "unparseable")
metadata.region_register = rreg
assert metadata.get_region_names() == ["a", "b"]
def test_metadata_order(self, interval_set, region_set):
"""Expect list of Metadata to be sorted by name
"""
metadata_list = [
{
"name": "total_lane_kilometres",
"spatial_resolution": region_set,
"temporal_resolution": interval_set,
"units": "kilometer"
},
{
"name": "heat_demand",
"spatial_resolution": region_set,
"temporal_resolution": interval_set,
"units": "kilowatt"
},
]
metadata_set = MetadataSet(metadata_list)
assert len(metadata_set) == 2
assert metadata_set.metadata == [
Metadata("heat_demand", region_set, interval_set, "kilowatt"),
Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
]
def test_access_interval_names(self, interval_set, region_set):
"""Metadata should expose interval names when a register is available
"""
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"unparseable")
assert metadata.get_interval_names() == [
"winter", "spring", "summer", "autumn"
]
def test_metadata_equality(self):
"""Metadata with same attributes should compare equal
"""
one_m = Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
other = Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
assert one_m == other
def test_serialise_metadata(self, interval_set, region_set):
"""Create Metadata to hold name, spatial and temporal resolution, and units
"""
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
actual = metadata.as_dict()
expected = {
'name': 'total_lane_kilometres',
'spatial_resolution': 'half_squares',
'temporal_resolution': 'seasons',
'units': 'kilometer'
}
assert actual == expected
def test_hanging_inputs(self, get_sector_model):
"""
sos_model_high
sos_model_lo
-> em
"""
SectorModel = get_sector_model
energy_model = SectorModel('energy_sector_model')
input_metadata = {
'name': 'electricity_demand_input',
'spatial_resolution': Mock(),
'temporal_resolution': Mock(),
'units': 'unit'
}
energy_model._inputs = MetadataSet([input_metadata])
sos_model_lo = SosModel('lower')
sos_model_lo.add_model(energy_model)
expected = Metadata(input_metadata['name'],
input_metadata['spatial_resolution'],
input_metadata['temporal_resolution'],
input_metadata['units'])
assert energy_model.free_inputs.names == ['electricity_demand_input']
assert sos_model_lo.free_inputs.names == ['electricity_demand_input']
sos_model_high = SosModel('higher')
sos_model_high.add_model(sos_model_lo)
actual = sos_model_high.free_inputs['electricity_demand_input']
assert actual == expected
def test_create_metadata_set(self, interval_set, region_set):
"""Create MetadataSet to hold a list of Metadata
"""
metadata_list = [{
"name": "heat_demand",
"spatial_resolution": region_set,
"temporal_resolution": interval_set,
"units": "kilowatt"
}]
metadata_set = MetadataSet(metadata_list)
# direct access to single metadata
metadata = metadata_set["heat_demand"]
assert metadata.name == "heat_demand"
assert metadata.spatial_resolution == region_set
assert metadata.temporal_resolution == interval_set
assert metadata.units == "kilowatt"
# direct access to list of contained metadata
assert len(metadata_set) == 1
assert metadata_set.metadata == [
Metadata("heat_demand", region_set, interval_set, "kilowatt")
]
# access single metadata attribute
assert metadata_set.get_spatial_res("heat_demand") == region_set
assert metadata_set.get_temporal_res("heat_demand") == interval_set
assert metadata_set.get_units("heat_demand") == "kilowatt"
# access list of metadata attributes
assert metadata_set.names == ["heat_demand"]
assert metadata_set.spatial_resolutions == [region_set]
assert metadata_set.temporal_resolutions == [interval_set]
assert metadata_set.units == ["kilowatt"]
def test_one_free_input(self, get_sector_model):
SectorModel = get_sector_model
energy_model = SectorModel('energy_sector_model')
expected = Metadata('electricity_demand_input', Mock(), Mock(), 'unit')
energy_model._inputs = MetadataSet([expected])
actual = energy_model.free_inputs['electricity_demand_input']
assert actual == expected
def test_create_metadata(self, interval_set, region_set):
"""Create Metadata to hold name, spatial and temporal resolution, and units
"""
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
assert metadata.name == "total_lane_kilometres"
assert metadata.spatial_resolution == region_set
assert metadata.temporal_resolution == interval_set
assert metadata.units == "kilometer"
def test_add_meta_object(self):
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"kilometer")
metadata_set = MetadataSet([])
metadata_set.add_metadata_object(metadata)
# access list of metadata attributes
assert metadata_set.names == ["total_lane_kilometres"]
assert metadata_set.spatial_resolutions == [region_set]
assert metadata_set.temporal_resolutions == [interval_set]
assert metadata_set.units == ["kilometer"]
def test_add_input(self):
model = EmptySectorModel('test_model')
model.add_input('input_name', [], [], 'units')
inputs = model.model_inputs
assert inputs.names == ['input_name']
assert inputs.units == ['units']
assert inputs['input_name'] == Metadata('input_name', [], [], 'units')
def test_iterate_over_populated(self):
metadata_list = [
{
"name": "total_lane_kilometres",
"spatial_resolution": region_set,
"temporal_resolution": interval_set,
"units": "kilometers"
}
]
metadata_set = MetadataSet(metadata_list)
actual = metadata_set.metadata
assert actual == [Metadata("total_lane_kilometres",
region_set,
interval_set,
"kilometers")]
assert [x for x in metadata_set] == [Metadata("total_lane_kilometres",
region_set,
interval_set,
"kilometers")]
def test_iterate_over_populated(self):
"""Should initialise with list of metadata if provided
"""
metadata_list = [{
"name": "total_lane_kilometres",
"spatial_resolution": region_set,
"temporal_resolution": interval_set,
"units": "kilometers"
}]
metadata_set = MetadataSet(metadata_list)
expected_metadata = Metadata("total_lane_kilometres", region_set,
interval_set, "kilometers")
actual = metadata_set.metadata
assert actual == [expected_metadata]
actual = [(k, v) for k, v in metadata_set.items()]
assert actual == [("total_lane_kilometres", expected_metadata)]
def test_unit_normalisation(self):
"""Expect units to be set to full names from abbreviation
"""
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"km")
assert metadata.units == "kilometer"
def test_unit_unparseable(self):
"""Expect unrecognised units to be passed through unchanged
"""
metadata = Metadata("total_lane_kilometres", region_set, interval_set,
"unparseable")
assert metadata.units == "unparseable"
