def test_push_to_realtime(self):
# only do the test if realtime test server is configured
if is_realtime_rest_configured():
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(working_dir=working_dir, event_id=SHAKE_ID, locale="en", data_is_local_flag=True)
# generate report
shake_event.render_map()
# push to realtime django
push_shake_event_to_rest(shake_event)
# check shake event exists
session = get_realtime_session()
earthquake_url = generate_earthquake_detail_url(SHAKE_ID)
response = session.get(earthquake_url)
self.assertEqual(response.status_code, requests.codes.ok)
event_dict = shake_event.event_dict()
earthquake_data = {
"shake_id": shake_event.event_id,
"magnitude": float(event_dict.get("mmi")),
"depth": float(event_dict.get("depth-value")),
"time": shake_event.shake_grid.time.strftime(INASAFE_REALTIME_DATETIME_FORMAT),
"location": {
"type": "Point",
"coordinates": [shake_event.shake_grid.longitude, shake_event.shake_grid.latitude],
},
"location_description": event_dict.get("place-name"),
}
for key, value in earthquake_data.iteritems():
self.assertEqual(response.json()[key], value)
def test_eventParser(self):
"""Test eventFilePath works (using cached data)"""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
self.assertEquals(26, myShakeEvent.day)
self.assertEquals(7, myShakeEvent.month)
self.assertEquals(2012, myShakeEvent.year)
self.assertEquals(2, myShakeEvent.hour)
self.assertEquals(15, myShakeEvent.minute)
self.assertEquals(35, myShakeEvent.second)
self.assertEquals('WIB', myShakeEvent.timeZone)
self.assertEquals(124.45, myShakeEvent.longitude)
self.assertEquals(-0.21, myShakeEvent.latitude)
self.assertEquals(11.0, myShakeEvent.depth)
self.assertEquals('Southern Molucca Sea', myShakeEvent.location)
self.assertEquals(122.45, myShakeEvent.xMinimum)
self.assertEquals(126.45, myShakeEvent.xMaximum)
self.assertEquals(-2.21, myShakeEvent.yMinimum)
self.assertEquals(1.79, myShakeEvent.yMaximum)
myGridXmlData = myShakeEvent.mmiData
self.assertEquals(25921, len(myGridXmlData))
myDelimitedString = myShakeEvent.mmiDataToDelimitedText()
self.assertEqual(578234, len(myDelimitedString))
def test_bearing_to_cardinal(self):
"""Test we can convert a bearing to a cardinal direction."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
# Ints should work
expected_result = 'SSE'
result = shake_event.bearing_to_cardinal(160)
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
assert result == expected_result, message
# Floats should work
expected_result = 'SW'
result = shake_event.bearing_to_cardinal(225.4)
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
assert result == expected_result, message
# non numeric data as input should return None
expected_result = None
result = shake_event.bearing_to_cardinal('foo')
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
assert result == expected_result, message
def testI18n(self):
"""See if internationalisation is working."""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId, theLocale='id')
myShaking = myShakeEvent.mmiShaking(5)
myExpectedShaking = 'Sedang'
self.assertEqual(myExpectedShaking, myShaking)
def test_sorted_impacted_cities(self):
"""Test getting impacted cities sorted by mmi then population."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID,
data_is_local_flag=True)
table = shake_event.sorted_impacted_cities()
file_path = unique_filename(
prefix='test_sorted_impacted_cities',
suffix='.txt',
dir=temp_dir('test'))
cities_file = file(file_path, 'w')
cities_file.writelines(str(table))
cities_file.close()
table = str(table).replace(', \'', ',\n\'')
table += '\n'
fixture_path = os.path.join(
data_dir(), 'tests', 'test_sorted_impacted_cities.txt')
cities_file = file(fixture_path)
expected_string = cities_file.read()
cities_file.close()
expected_string = expected_string.replace(', \'', ',\n\'')
self.max_diff = None
message = 'Expectation:\n%s, Got\n%s' % (expected_string, table)
self.assertEqual(expected_string, table, message)
def test_sorted_impacted_cities(self):
"""Test getting impacted cities sorted by mmi then population."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
table = shake_event.sorted_impacted_cities()
file_path = unique_filename(
prefix='test_sorted_impacted_cities',
suffix='.txt',
dir=temp_dir('test'))
cities_file = file(file_path, 'w')
cities_file.writelines(str(table))
cities_file.close()
table = str(table).replace(', \'', ',\n\'')
table += '\n'
fixture_path = os.path.join(
data_dir(), 'tests', 'test_sorted_impacted_cities.txt')
cities_file = file(fixture_path)
expected_string = cities_file.read()
cities_file.close()
expected_string = expected_string.replace(', \'', ',\n\'')
self.max_diff = None
self.assertEqual(expected_string, table)
def testCalculateFatalities(self):
"""Test that we can calculate fatalities."""
LOGGER.debug(QGIS_APP.showSettings())
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myResult, myFatalitiesHtml = myShakeEvent.calculateImpacts()
myExpectedResult = (
'/tmp/inasafe/realtime/shakemaps-extracted'
'/20120726022003/impact-nearest.tif')
myMessage = 'Got:\n%s\nExpected:\n%s\n' % (myResult, myExpectedResult)
assert myResult == myExpectedResult, myMessage
myExpectedResult = (
'/tmp/inasafe/realtime/shakemaps-extracted'
'/20120726022003/impacts.html')
myMessage = 'Got:\n%s\nExpected:\n%s\n' % (
myFatalitiesHtml,
myExpectedResult)
assert myFatalitiesHtml == myExpectedResult, myMessage
myExpectedFatalities = {2: 0.0, # rounded from 0.47386375223673427,
3: 0.0, # rounded from 0.024892573693488258,
4: 0.0,
5: 0.0,
6: 0.0,
7: 0.0,
8: 0.0,
9: 0.0}
myMessage = 'Got:\n%s\nExpected:\n%s\n' % (
myShakeEvent.fatalityCounts, myExpectedFatalities)
assert myShakeEvent.fatalityCounts == myExpectedFatalities, myMessage
def test_bearing_to_cardinal(self):
"""Test we can convert a bearing to a cardinal direction."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID,
data_is_local_flag=True)
# Ints should work
expected_result = 'SSE'
result = shake_event.bearing_to_cardinal(160)
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
self.assertEqual(result, expected_result, message)
# Floats should work
expected_result = 'SW'
result = shake_event.bearing_to_cardinal(225.4)
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
self.assertEqual(result, expected_result, message)
# non numeric data as input should return None
expected_result = None
result = shake_event.bearing_to_cardinal('foo')
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
self.assertEqual(result, expected_result, message)
def test_grid_file_path(self):
"""Test grid_file_path works using cached data."""
expected_path = os.path.join(
shakemap_extract_dir(), SHAKE_ID, 'grid.xml')
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
grid_path = shake_event.grid_file_path()
self.assertEquals(expected_path, grid_path)
def test_event_info_dict(self):
"""Test we can get a dictionary of location info nicely."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
result = shake_event.event_dict()
#noinspection PyUnresolvedReferences
expected_dict = {
'place-name': u'n/a',
'depth-name': u'Depth',
'fatalities-name': u'Estimated fatalities',
'fatalities-count': u'0', # 44 only after render
'elapsed-time': u'', # empty as it will change
'legend-name': u'Population density',
'fatalities-range': '0 - 100',
'longitude-name': u'Longitude',
'located-label': u'Located',
'distance-unit': u'km',
'bearing-compass': u'n/a',
'elapsed-time-name': u'Elapsed time since event',
'exposure-table-name': u'Estimated number of people '
u'affected by each MMI level',
'longitude-value': u'140\xb037\'12.00"E',
'city-table-name': u'Places Affected',
'bearing-text': u'bearing',
'limitations': (
u'This impact estimation is automatically generated and only '
u'takes into account the population and cities affected by '
u'different levels of ground shaking. The estimate is based '
u'on ground shaking data from BMKG, population density data '
u'from asiapop.org, place information from geonames.org and '
u'software developed by BNPB. Limitations in the estimates of '
u'ground shaking, population data and place names datasets '
u'may result in significant misrepresentation of the '
u'on-the-ground situation in the figures shown here. '
u'Consequently decisions should not be made solely on the '
u'information presented here and should always be verified by '
u'ground truthing and other reliable information sources. The '
u'fatality calculation assumes that no fatalities occur for '
u'shake levels below MMI 4. Fatality counts of less than 50 '
u'are disregarded.'),
'depth-unit': u'km',
'latitude-name': u'Latitude',
'mmi': '3.6',
'map-name': u'Estimated Earthquake Impact',
'date': '5-11-2013',
'bearing-degrees': '0.00\xb0',
'formatted-date-time': '05-Nov-13 06:08:09 ',
'distance': '0.00',
'direction-relation': u'of',
'credits': (
u'Supported by the Australia-Indonesia Facility for Disaster '
u'Reduction, Geoscience Australia and the World Bank-GFDRR.'),
'latitude-value': u'2\xb025\'48.00"S',
'time': '6:8:9',
'depth-value': '10.0'}
result['elapsed-time'] = u''
message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_dict)
self.max_diff = None
difference = DictDiffer(result, expected_dict)
print difference.all()
self.assertDictEqual(expected_dict, result, message)
def test_i18n(self):
"""See if internationalisation is working."""
shake_event = ShakeEvent(
SHAKE_ID, locale='id', data_is_local_flag=True)
shaking = shake_event.mmi_shaking(5)
expected_shaking = 'Sedang'
self.assertEqual(expected_shaking, shaking)
def test_i18n(self):
"""See if internationalisation is working."""
shake_event = ShakeEvent(
SHAKE_ID, locale='id', data_is_local_flag=True)
shaking = shake_event.mmi_shaking(5)
expected_shaking = 'Sedang'
self.assertEqual(expected_shaking, shaking)
def test_calculate_fatalities(self):
"""Test that we can calculate fatalities."""
LOGGER.debug(QGIS_APP.showSettings())
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
result, fatalities_html = shake_event.calculate_impacts()
# Get the os environment INASAFE_WORK_DIR if it exists
inasafe_work_dir = base_data_dir()
expected_result = ('%s/shakemaps-extracted/20131105060809/impact'
'-nearest.tif') % inasafe_work_dir
message = 'Got: %s, Expected: %s' % (result, expected_result)
self.assertEqual(result, expected_result, message)
expected_result = ('%s/shakemaps-extracted/20131105060809/impacts'
'.html') % inasafe_work_dir
message = 'Got: %s, Expected: %s' % (fatalities_html, expected_result)
self.assertEqual(fatalities_html, expected_result, message)
expected_fatalities = {2: 0.0,
3: 0.0,
4: 0.000036387775168847936,
5: 0.0,
6: 0.0,
7: 0.0,
8: 0.0,
9: 0.0}
message = 'Got: %s, Expected: %s' % (
shake_event.fatality_counts, expected_fatalities)
self.assertEqual(
shake_event.fatality_counts, expected_fatalities, message)
def test_i18n(self):
"""See if internationalisation is working."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(working_dir=working_dir, event_id=SHAKE_ID, locale="id", data_is_local_flag=True)
shaking = shake_event.mmi_shaking(5)
expected_shaking = "Sedang"
self.assertEqual(expected_shaking, shaking)
def test_sorted_impacted_cities(self):
"""Test getting impacted cities sorted by mmi then population."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
table = shake_event.sorted_impacted_cities()
file_path = unique_filename(
prefix='test_sorted_impacted_cities',
suffix='.txt',
dir=temp_dir('test'))
cities_file = file(file_path, 'w')
cities_file.writelines(str(table))
cities_file.close()
table = str(table).replace(', \'', ',\n\'')
table += '\n'
fixture_path = os.path.join(
data_dir(), 'tests', 'test_sorted_impacted_cities.txt')
cities_file = file(fixture_path)
expected_string = cities_file.read()
cities_file.close()
expected_string = expected_string.replace(', \'', ',\n\'')
self.max_diff = None
message = 'Expectation:\n%s, Got\n%s' % (expected_string, table)
self.assertEqual(expected_string, table, message)
def test_render_map(self):
"""Test render_map function in shake_event."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(working_dir=working_dir, event_id=SHAKE_ID, data_is_local_flag=True)
# Render Map
shake_event.render_map()
# There should be exist:
# 1. SHAKE_ID-en.pdf
# 2. SHAKE_ID-en.png
# 3. SHAKE_ID-thumb-en.png
# 4. SHAKE_ID-metadata-en.pickle
# 5. mmi-cities.shp, shx, dbf, prj, qml
# 6. mmi-contours-nearest.shp, shx, dbf, prj, qml
# 7. city-search-boxes.shp, shx, dbf, prj, qml
# 8. composer-template.qpt
# 9. project.qgs
target_dir = os.path.join(shakemap_extract_dir(), SHAKE_ID)
shapefile_extension = ["shp", "shx", "dbf", "prj", "qml"]
# 1
pdf_path = os.path.join(target_dir, "%s-en.pdf" % SHAKE_ID)
message = "PDF Report is not generated successfully in %s" % pdf_path
self.assertTrue(os.path.exists(pdf_path), message)
# 2
png_path = os.path.join(target_dir, "%s-en.png" % SHAKE_ID)
message = "PNG Report is not generated successfully in %s" % png_path
self.assertTrue(os.path.exists(png_path), message)
# 3
thumbnail_path = os.path.join(target_dir, "%s-thumb-en.png" % SHAKE_ID)
message = "PNG Thumbnail is not generated successfully in %s" % (thumbnail_path)
self.assertTrue(os.path.exists(thumbnail_path), message)
# 4
metadata_path = os.path.join(target_dir, "%s-metadata-en.pickle" % SHAKE_ID)
message = "Metadata file is not generated successfully in %s" % (metadata_path)
self.assertTrue(os.path.exists(metadata_path), message)
# 5. mmi-cities.shp, shx, dbf, prj, qml
mmi_cities_path = os.path.join(target_dir, "mmi-cities.shp")
for extension in shapefile_extension:
file_path = mmi_cities_path.replace("shp", extension)
message = "mmi-cities.%s is not generated successfully in %s" % (extension, file_path)
self.assertTrue(os.path.exists(file_path), message)
# 6. mmi-contours-nearest.shp, shx, dbf, prj, qml
mmi_contours_path = os.path.join(target_dir, "mmi-contours-nearest.shp")
for extension in shapefile_extension:
file_path = mmi_contours_path.replace("shp", extension)
message = ("mmi-contours-nearest.%s is not generated successfully in " "%s") % (extension, file_path)
self.assertTrue(os.path.exists(file_path), message)
# 7. city-search-boxes.shp, shx, dbf, prj, qml
city_search_boxes_path = os.path.join(target_dir, "city-search-boxes.shp")
for extension in shapefile_extension:
file_path = city_search_boxes_path.replace("shp", extension)
message = ("city-search-boxes.%s is not generated successfully in " "%s") % (extension, file_path)
self.assertTrue(os.path.exists(file_path), message)
# 8
composer_template_path = os.path.join(target_dir, "composer-template.qpt")
message = "Composer template file is not generated successfully in %s" % composer_template_path
self.assertTrue(os.path.exists(composer_template_path), message)
# 9
qgs_project_path = os.path.join(target_dir, "project.qgs")
message = "QGIS Project file is not generated successfully in %s" % (qgs_project_path)
self.assertTrue(os.path.exists(qgs_project_path), message)
def test_calculate_fatalities(self):
"""Test that we can calculate fatalities."""
LOGGER.debug(QGIS_APP.showSettings())
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
result, fatalities_html = shake_event.calculate_impacts()
# Get the os environment INASAFE_WORK_DIR if it exists
inasafe_work_dir = base_data_dir()
expected_result = ('%s/shakemaps-extracted/20131105060809/impact'
'-nearest.tif') % inasafe_work_dir
message = 'Got: %s, Expected: %s' % (result, expected_result)
self.assertEqual(result, expected_result, message)
expected_result = ('%s/shakemaps-extracted/20131105060809/impacts'
'.html') % inasafe_work_dir
message = 'Got: %s, Expected: %s' % (fatalities_html, expected_result)
self.assertEqual(fatalities_html, expected_result, message)
expected_fatalities = {2: 0.0,
3: 0.0,
4: 0.000036387775168853676,
5: 0.0,
6: 0.0,
7: 0.0,
8: 0.0,
9: 0.0}
message = 'Got: %s, Expected: %s' % (
shake_event.fatality_counts, expected_fatalities)
self.assertEqual(
shake_event.fatality_counts, expected_fatalities, message)
def test_calculate_fatalities(self):
"""Test that we can calculate fatalities."""
LOGGER.debug(QGIS_APP.showSettings())
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
result, fatalities_html = shake_event.calculate_impacts()
expected_result = (
'/tmp/inasafe/realtime/shakemaps-extracted'
'/20120726022003/impact-nearest.tif')
message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_result)
assert result == expected_result, message
expected_result = (
'/tmp/inasafe/realtime/shakemaps-extracted'
'/20120726022003/impacts.html')
message = 'Got:\n%s\nExpected:\n%s\n' % (
fatalities_html,
expected_result)
assert fatalities_html == expected_result, message
expected_fatalities = {2: 0.0, # rounded from 0.47386375223673427,
3: 0.0, # rounded from 0.024892573693488258,
4: 0.0,
5: 0.0,
6: 0.0,
7: 0.0,
8: 0.0,
9: 0.0}
message = 'Got:\n%s\nExpected:\n%s\n' % (
shake_event.fatality_counts, expected_fatalities)
assert shake_event.fatality_counts == expected_fatalities, message
def testSortedImpactedCities(self):
"""Test getting impacted cities sorted by mmi then population."""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myTable = myShakeEvent.sortedImpactedCities()
myFilePath = unique_filename(
prefix='testSortedImpactedCities',
suffix='.txt',
dir=temp_dir('test'))
myFile = file(myFilePath, 'wt')
myFile.writelines(str(myTable))
myFile.close()
myTable = str(myTable).replace(', \'', ',\n\'')
myTable += '\n'
myFixturePath = os.path.join(
dataDir(), 'tests', 'testSortedImpactedCities.txt')
myFile = file(myFixturePath, 'rt')
myExpectedString = myFile.read()
myFile.close()
myExpectedString = myExpectedString.replace(', \'', ',\n\'')
self.maxDiff = None
self.assertEqual(myExpectedString, myTable)
def test_event_parser(self):
"""Test eventFilePath works (using cached data)"""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
self.assertEquals(26, shake_event.day)
self.assertEquals(7, shake_event.month)
self.assertEquals(2012, shake_event.year)
self.assertEquals(2, shake_event.hour)
self.assertEquals(15, shake_event.minute)
self.assertEquals(35, shake_event.second)
self.assertEquals('WIB', shake_event.timezone)
self.assertEquals(124.45, shake_event.longitude)
self.assertEquals(-0.21, shake_event.latitude)
self.assertEquals(11.0, shake_event.depth)
self.assertEquals('Southern Molucca Sea', shake_event.location)
self.assertEquals(122.45, shake_event.x_minimum)
self.assertEquals(126.45, shake_event.x_maximum)
self.assertEquals(-2.21, shake_event.y_minimum)
self.assertEquals(1.79, shake_event.y_maximum)
grid_xml_data = shake_event.mmi_data
self.assertEquals(25921, len(grid_xml_data))
delimited_string = shake_event.mmi_data_to_delimited_text()
self.assertEqual(578234, len(delimited_string))
def testBearingToCardinal(self):
"""Test we can convert a bearing to a cardinal direction."""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
# Ints should work
myExpectedResult = 'SSE'
myResult = myShakeEvent.bearingToCardinal(160)
myMessage = ('Got:\n%s\nExpected:\n%s\n' %
(myResult, myExpectedResult))
assert myResult == myExpectedResult, myMessage
# Floats should work
myExpectedResult = 'SW'
myResult = myShakeEvent.bearingToCardinal(225.4)
myMessage = ('Got:\n%s\nExpected:\n%s\n' %
(myResult, myExpectedResult))
assert myResult == myExpectedResult, myMessage
# non numeric data as input should return None
myExpectedResult = None
myResult = myShakeEvent.bearingToCardinal('foo')
myMessage = ('Got:\n%s\nExpected:\n%s\n' %
(myResult, myExpectedResult))
assert myResult == myExpectedResult, myMessage
def test_i18n(self):
"""See if internationalisation is working."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id, locale='id')
shaking = shake_event.mmi_shaking(5)
expected_shaking = 'Sedang'
self.assertEqual(expected_shaking, shaking)
def test_grid_file_path(self):
"""Test grid_file_path works using cached data."""
expected_path = os.path.join(
shakemap_extract_dir(), SHAKE_ID, 'grid.xml')
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
grid_path = shake_event.grid_file_path()
self.assertEquals(expected_path, grid_path)
def test_cities_search_boxes_to_shape(self):
"""Test that we can retrieve the search boxes used to find cities."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(working_dir=working_dir,
event_id=SHAKE_ID,
data_is_local_flag=True)
file_path = shake_event.city_search_boxes_to_shapefile()
self.assertTrue(os.path.exists(file_path))
def test_eventGridToCsv(self):
"""Test grid data can be written to csv"""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myPath = myShakeEvent.mmiDataToDelimitedFile(theForceFlag=True)
myFile = file(myPath, 'rt')
myString = myFile.readlines()
myFile.close()
self.assertEqual(25922, len(myString))
def test_gridXmlFilePath(self):
"""Test eventFilePath works(using cached data)"""
myShakeId = '20120726022003'
myExpectedPath = os.path.join(shakemapExtractDir(),
myShakeId,
'grid.xml')
myShakeEvent = ShakeEvent(myShakeId)
myPath = myShakeEvent.gridFilePath()
self.assertEquals(myExpectedPath, myPath)
def test_cities_search_boxes_to_shape(self):
"""Test that we can retrieve the search boxes used to find cities."""
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID,
data_is_local_flag=True)
file_path = shake_event.city_search_boxes_to_shapefile()
self.assertTrue(os.path.exists(file_path))
def testEventToShapefile(self):
"""Check we can convert the shake event to a raster"""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myPath = myShakeEvent.mmiDataToShapefile(theForceFlag=True)
assert os.path.exists(myPath)
myExpectedQml = myPath.replace('shp', 'qml')
myMessage = '%s not found' % myExpectedQml
assert os.path.exists(myExpectedQml), myMessage
def test_event_to_shapefile(self):
"""Check we can convert the shake event to a raster"""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
file_path = shake_event.mmi_data_to_shapefile(force_flag=True)
assert os.path.exists(file_path)
expected_qml = file_path.replace('shp', 'qml')
message = '%s not found' % expected_qml
assert os.path.exists(expected_qml), message
def test_grid_xml_file_path(self):
"""Test eventFilePath works(using cached data)."""
shake_id = '20120726022003'
expected_path = os.path.join(shakemap_extract_dir(),
shake_id,
'grid.xml')
shake_event = ShakeEvent(shake_id)
grid_path = shake_event.grid_file_path()
self.assertEquals(expected_path, grid_path)
def test_event_grid_to_csv(self):
"""Test grid data can be written to csv"""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
file_path = shake_event.mmi_data_to_delimited_file(force_flag=True)
delimited_file = file(file_path)
delimited_string = delimited_file.readlines()
delimited_file.close()
self.assertEqual(25922, len(delimited_string))
def test_bounds_to_rect(self):
"""Test that we can calculate the event bounds properly"""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
bounds = shake_event.bounds_to_rectangle().toString()
expected_result = (
'122.4500000000000028,-2.2100000000000000 : '
'126.4500000000000028,1.7900000000000000')
message = 'Got:\n%s\nExpected:\n%s\n' % (bounds, expected_result)
assert bounds == expected_result, message
def testBoundsToRect(self):
"""Test that we can calculate the event bounds properly"""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myBounds = myShakeEvent.boundsToRectangle().toString()
myExpectedResult = (
'122.4500000000000028,-2.2100000000000000 : '
'126.4500000000000028,1.7900000000000000')
myMessage = 'Got:\n%s\nExpected:\n%s\n' % (myBounds, myExpectedResult)
assert myBounds == myExpectedResult, myMessage
def testRomanize(self):
"""Test we can convert MMI values to float."""
myShakeId = '20120726022003'
myShakeEvent = ShakeEvent(myShakeId)
myValues = range(2, 10)
myExpectedResult = ['II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']
myResult = []
for myValue in myValues:
myResult.append(myShakeEvent.romanize(myValue))
myMessage = 'Got:\n%s\nExpected:\n%s\n' % (myResult, myExpectedResult)
assert myResult == myExpectedResult, myMessage
def test_mmi_potential_damage(self):
"""Test mmi_potential_damage function."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
values = range(1, 11)
expected_result = ['None', 'None', 'None', 'None', 'Very light',
'Light', 'Moderate', 'Mod/Heavy', 'Heavy',
'Very heavy']
result = []
for value in values:
result.append(shake_event.mmi_potential_damage(value))
message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_result)
self.assertEqual(result, expected_result, message)
def test_mmi_potential_damage(self):
"""Test mmi_potential_damage function."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
values = range(1, 11)
expected_result = ['None', 'None', 'None', 'None', 'Very light',
'Light', 'Moderate', 'Mod/Heavy', 'Heavy',
'Very heavy']
result = []
for value in values:
result.append(shake_event.mmi_potential_damage(value))
message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_result)
self.assertEqual(result, expected_result, message)
def test_romanize(self):
"""Test we can convert MMI values to float."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
values = range(2, 10)
expected_result = ['II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']
result = []
for value in values:
result.append(shake_event.romanize(value))
message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_result)
assert result == expected_result, message
def test_event_info_string(self):
"""Test we can get a location info string nicely."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
degree_symbol = unichr(176)
expected_result = (
'M 3.6 5-11-2013 6:8:9 Latitude: 2%s25\'48.00"S Longitude: '
'140%s37\'12.00"E Depth: 10.0km Located 0.00km n/a of n/a'
% (degree_symbol, degree_symbol))
result = shake_event.event_info()
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
self.assertEqual(result, expected_result, message)
def test_event_info_string(self):
"""Test we can get a location info string nicely."""
shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
degree_symbol = unichr(176)
expected_result = (
'M 3.6 5-11-2013 6:8:9 Latitude: 2%s25\'48.00"S Longitude: '
'140%s37\'12.00"E Depth: 10.0km Located 0.00km n/a of n/a'
% (degree_symbol, degree_symbol))
result = shake_event.event_info()
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
self.assertEqual(result, expected_result, message)
def test_event_info_string(self):
"""Test we can get a location info string nicely."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
degree_symbol = unichr(176)
expected_result = (
'M 5.0 26-7-2012 2:15:35 Latitude: 0%s12\'36.00"S Longitude: '
'124%s27\'0.00"E Depth: 11.0km Located 0.00km n/a of n/a'
% (degree_symbol, degree_symbol))
result = shake_event.event_info()
message = ('Got:\n%s\nExpected:\n%s\n' %
(result, expected_result))
assert result == expected_result, message
def test_fatalities_table(self):
"""Test rendering a fatalities table."""
shake_id = '20120726022003'
shake_event = ShakeEvent(shake_id)
shake_event.calculate_impacts()
result = shake_event.impact_table()
# TODO compare actual content of impact table...
expected_result = (
'/tmp/inasafe/realtime/shakemaps-extracted/'
'20120726022003/impacts.html')
message = ('Got:\n%s\nExpected:\n%s' %
(result, expected_result))
assert result == expected_result, message
