def test_is_valid(self):
"""Test is_valid."""
impact_functions = [
# Earthquake
EarthquakeBuildingFunction(),
ITBFatalityFunction(),
PAGFatalityFunction(),
ITBBayesianFatalityFunction(),
# Generic
ClassifiedPolygonHazardBuildingFunction(),
ClassifiedPolygonHazardLandCoverFunction(),
ClassifiedPolygonHazardPopulationFunction(),
ClassifiedPolygonHazardPolygonPeopleFunction(),
ClassifiedRasterHazardBuildingFunction(),
ClassifiedRasterHazardPopulationFunction(),
ContinuousHazardPopulationFunction(),
# Inundation
FloodEvacuationVectorHazardFunction(),
FloodPolygonRoadsFunction(),
FloodRasterBuildingFunction(),
FloodEvacuationRasterHazardFunction(),
FloodRasterRoadsFunction(),
FloodPolygonBuildingFunction(),
# Tsunami
TsunamiEvacuationFunction(),
TsunamiRasterRoadsFunction(),
TsunamiRasterLandcoverFunction(),
TsunamiRasterBuildingFunction(),
# Volcanic
VolcanoPointBuildingFunction(),
VolcanoPointPopulationFunction(),
VolcanoPolygonBuildingFunction(),
VolcanoPolygonPopulationFunction(),
# Volcanic Ash
AshRasterLandCoverFunction(),
AshRasterPlacesFunction(),
AshRasterPopulationFunction()
]
self.assertEqual(len(impact_functions), len(EXPECTED_IF))
for impact_function in impact_functions:
valid = impact_function.metadata().is_valid()
impact_function_name = impact_function.__class__.__name__
message = '%s is invalid because %s' % (impact_function_name,
valid[1])
self.assertTrue(valid[0], message)
if valid[0]:
# print '%s has a valid metadata.' % impact_function_name
continue
def test_run(self):
"""TestClassifiedPolygonPeopleFunction: Test running the IF."""
# 1. Initializing function with necessary data
function = ClassifiedPolygonHazardPolygonPeopleFunction.instance()
hazard_path = test_data_path(
'hazard', 'classified_generic_polygon.shp')
exposure_path = test_data_path('exposure', 'census.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsVectorLayer(hazard_path, 'Hazard', 'ogr')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Exposure', 'ogr')
# 1.1 Asserting if the provided data are valid
self.assertEqual(hazard_layer.isValid(), True)
self.assertEqual(exposure_layer.isValid(), True)
# 2.Choosing the extent to run analysis
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
function.hazard = hazard_layer
function.exposure = exposure_layer
function.requested_extent = rect_extent
# 3. Running the analysis
function.run()
impact = function.impact
impact = safe_to_qgis_layer(impact)
# Asserting for the number of features in the impact
# layer
self.assertEqual(impact.dataProvider().featureCount(), 6L)
# 4. Asserting about the results found
features = {}
for feature in impact.getFeatures():
area = feature.geometry().area() * 1e8
features[feature['id']] = round(area, 1)
# expected features changes accordingly
# to the impact features
expected_features = {
1: 6438.5,
2: 5894.1,
3: 8534.3
}
self.assertEqual(features, expected_features)
expected_results = [
[u'High Hazard Zone', 7271.431538053051],
[u'Medium Hazard Zone', 72852.05080801852],
[u'Low Hazard Zone', 11459.170311153292],
[u'Total affected people', 91583.0],
[u'Unaffected people', 17269.0],
[u'Total people', 108852]
]
result = function.generate_data()['impact summary']['fields']
for expected_result in expected_results:
self.assertIn(expected_result, result)
def test_run(self):
"""TestClassifiedPolygonPeopleFunction: Test running the IF."""
# 1. Initializing function with necessary data
function = ClassifiedPolygonHazardPolygonPeopleFunction.instance()
hazard_path = standard_data_path('hazard',
'classified_generic_polygon.shp')
exposure_path = standard_data_path('exposure', 'census.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsVectorLayer(hazard_path, 'Hazard', 'ogr')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Exposure', 'ogr')
# 1.1 Asserting if the provided data are valid
self.assertEqual(hazard_layer.isValid(), True)
self.assertEqual(exposure_layer.isValid(), True)
# 2.Choosing the extent to run analysis
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(),
extent.yMaximum(),
extent.xMaximum(),
extent.yMinimum()
]
function.hazard = hazard_layer
function.exposure = exposure_layer
function.requested_extent = rect_extent
# 3. Running the analysis
function.run()
impact = function.impact
impact = safe_to_qgis_layer(impact)
# Asserting for the number of features in the impact
# layer
self.assertEqual(impact.dataProvider().featureCount(), 6L)
# 4. Asserting about the results found
features = {}
for feature in impact.getFeatures():
area = feature.geometry().area() * 1e8
features[feature['id']] = round(area, 1)
# expected features changes accordingly
# to the impact features
expected_features = {1: 6438.5, 2: 5894.1, 3: 8534.3}
self.assertEqual(features, expected_features)
expected_results = [[u'High Hazard Zone', 7271.431538053051],
[u'Medium Hazard Zone', 72852.05080801852],
[u'Low Hazard Zone', 11459.170311153292],
[u'Total affected people', 91583.0],
[u'Unaffected people', 17269.0],
[u'Total people', 108852]]
result = function.generate_data()['impact summary']['fields']
for expected_result in expected_results:
self.assertIn(expected_result, result)
def test_run(self):
"""TestClassifiedPolygonPeopleFunction: Test running the IF."""
# 1. Initializing function with necessary data
function = ClassifiedPolygonHazardPolygonPeopleFunction.instance()
hazard_path = test_data_path(
'hazard', 'classified_generic_polygon.shp')
exposure_path = test_data_path('exposure', 'census.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsVectorLayer(hazard_path, 'Hazard', 'ogr')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Exposure', 'ogr')
# 1.1 Asserting if the provided data are valid
self.assertEqual(hazard_layer.isValid(), True)
self.assertEqual(exposure_layer.isValid(), True)
# 2.Choosing the extent to run analysis
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(), extent.yMaximum(),
extent.xMaximum(), extent.yMinimum()]
function.hazard = hazard_layer
function.exposure = exposure_layer
function.requested_extent = rect_extent
# 3. Running the analysis
function.run()
impact = function.impact
impact = safe_to_qgis_layer(impact)
# Asserting for the number of features in the impact
# layer
self.assertEqual(impact.dataProvider().featureCount(), 6L)
# 4. Asserting about the results found
features = {}
for feature in impact.getFeatures():
area = feature.geometry().area() * 1e8
features[feature['id']] = round(area, 1)
# expected features changes accordingly
# to the impact features
expected_features = {
1: 6438.5,
2: 5894.1,
3: 8534.3
}
self.assertEqual(features, expected_features)
expected_impact_summary = [
'**High Hazard Zone**, 4,600------',
'**Medium Hazard Zone**, 65,700------',
'**Low Hazard Zone**, 11,500------',
'**Total affected people**, 81,600------',
'**Unaffected people**, 17,300------',
'**Total people**, 98,900---'
]
for row in expected_impact_summary:
self.assertIn(row, function.impact_summary().to_text())
def test_run(self):
"""TestClassifiedPolygonPeopleFunction: Test running the IF."""
# 1. Initializing function with necessary data
function = ClassifiedPolygonHazardPolygonPeopleFunction.instance()
hazard_path = test_data_path('hazard',
'classified_generic_polygon.shp')
exposure_path = test_data_path('exposure', 'census.shp')
# noinspection PyCallingNonCallable
hazard_layer = QgsVectorLayer(hazard_path, 'Hazard', 'ogr')
# noinspection PyCallingNonCallable
exposure_layer = QgsVectorLayer(exposure_path, 'Exposure', 'ogr')
# 1.1 Asserting if the provided data are valid
self.assertEqual(hazard_layer.isValid(), True)
self.assertEqual(exposure_layer.isValid(), True)
# 2.Choosing the extent to run analysis
extent = hazard_layer.extent()
rect_extent = [
extent.xMinimum(),
extent.yMaximum(),
extent.xMaximum(),
extent.yMinimum()
]
function.hazard = hazard_layer
function.exposure = exposure_layer
function.requested_extent = rect_extent
# 3. Running the analysis
function.run()
impact = function.impact
impact = safe_to_qgis_layer(impact)
# Asserting for the number of features in the impact
# layer
self.assertEqual(impact.dataProvider().featureCount(), 6L)
# 4. Asserting about the results found
features = {}
for feature in impact.getFeatures():
area = feature.geometry().area() * 1e8
features[feature['id']] = round(area, 1)
# expected features changes accordingly
# to the impact features
expected_features = {1: 6438.5, 2: 5894.1, 3: 8534.3}
self.assertEqual(features, expected_features)
expected_impact_summary = [
'**High Hazard Zone**, 4,600------',
'**Medium Hazard Zone**, 65,700------',
'**Low Hazard Zone**, 11,500------',
'**Total affected people**, 81,600------',
'**Unaffected people**, 17,300------',
'**Total people**, 98,900---'
]
for row in expected_impact_summary:
self.assertIn(row, function.impact_summary().to_text())