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_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_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_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_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