class RoadExposureReportMixinTest(unittest.TestCase):
"""Test the ReportMixin.
.. versionadded:: 3.2
"""
# noinspection PyPep8Naming
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
self.road_mixin.affected_road_categories = ['Flooded']
def tearDown(self):
"""Run after each test."""
del self.road_mixin_blank
del self.road_mixin
def test_0001_generate_report(self):
"""Generate a blank report."""
blank_report = self.road_mixin_blank.generate_report().to_text()
# self.assertListEqual(blank_report, expected_blank_report, message)
self.assertIn('**Road Type**', blank_report)
self.assertIn('**Total (m)**', blank_report)
def test_0002_road_breakdown(self):
"""Test the buildings breakdown."""
roads_breakdown = self.road_mixin.roads_breakdown().to_text()
self.assertIn('**Breakdown by road type**', roads_breakdown)
self.assertIn('Main', roads_breakdown)
self.assertIn('133', roads_breakdown)
self.assertIn('Side', roads_breakdown)
self.assertIn('10', roads_breakdown)
self.assertIn('Bike', roads_breakdown)
self.assertIn('1', roads_breakdown)
def test_0003_total(self):
"""Test general methods."""
default_length = self.road_mixin_blank.total_road_length
length = self.road_mixin.total_road_length
message = 'Default length is not as expected.'
self.assertEqual(default_length, 0, message)
message = 'Real length is not as expected.'
self.assertEqual(length, 144.5, message)
def __init__(self):
"""Constructor."""
super(TsunamiRasterRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
self.add_unaffected_column = False
self.hazard_classes = [
tr('Dry Zone'),
tr('Low Hazard Zone'),
tr('Medium Hazard Zone'),
tr('High Hazard Zone'),
tr('Very High Hazard Zone'),
]
def __init__(self):
"""Constructor."""
super(TsunamiRasterRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
self.add_unaffected_column = False
self.hazard_classes = [
tr('Dry Zone'),
tr('Low Hazard Zone'),
tr('Medium Hazard Zone'),
tr('High Hazard Zone'),
tr('Very High Hazard Zone'),
]
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
self.road_mixin.affected_road_categories = ['Flooded']
def __init__(self):
"""Constructor."""
super(FloodRasterRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
def __init__(self):
"""Constructor."""
super(FloodPolygonRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
# The 'wet' variable
self.wet = 'wet'
def __init__(self):
"""Constructor."""
super(FloodRasterRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
def __init__(self):
"""Constructor."""
super(FloodPolygonRoadsFunction, self).__init__()
RoadExposureReportMixin.__init__(self)
# The 'wet' variable
self.wet = 'wet'
class RoadExposureReportMixinTest(unittest.TestCase):
"""Test the ReportMixin.
.. versionadded:: 3.2
"""
# noinspection PyPep8Naming
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
self.road_mixin.affected_road_categories = ['Flooded']
def tearDown(self):
"""Run after each test."""
del self.road_mixin_blank
del self.road_mixin
def test_0001_generate_blank_data(self):
"""Generate a blank data."""
blank_data = self.road_mixin_blank.generate_data()
expected = {
'action check list': {
'fields': [
'Which roads can be used to evacuate people or to '
'distribute logistics?',
'What type of vehicles can use the unaffected roads?',
'What sort of equipment will be needed to reopen roads & '
'where will we get it?',
'Which government department is responsible for '
'supplying equipment ?'
],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['Unaffected', 'Total'],
'fields': [[0, 0]]},
'impact table': {
'attributes': [
'Road Type', 'Unaffected', 'Total'],
'fields': []
},
'notes': {'fields': [], 'title': 'Notes'},
'question': ''}
self.assertEquals(expected, blank_data)
def test_0002_road_breakdown(self):
"""Test the buildings breakdown."""
roads_breakdown = self.road_mixin.roads_breakdown()['fields']
expected = [
['Main', 2, 131.3, 133.3],
['Side', 5.5, 4.5, 10],
['Bike', 1.2, 0.0, 1.2]
]
self.assertEquals(roads_breakdown, expected)
def test_0003_total(self):
"""Test general methods."""
default_length = self.road_mixin_blank.total_road_length
message = 'Default length is not as expected.'
self.assertEqual(default_length, 0, message)
message = 'Real length is not as expected.'
length = self.road_mixin.total_road_length
self.assertEqual(length, 144.5, message)
def test_0004_generate_data(self):
"""Test generating data."""
self.maxDiff = None
data = self.road_mixin.generate_data()
expected = {
'action check list': {
'fields': [
'Which roads can be used to evacuate people or to '
'distribute logistics?',
'What type of vehicles can use the unaffected roads?',
'What sort of equipment will be needed to reopen roads & '
'where will we get it?',
'Which government department is responsible for '
'supplying equipment ?'
],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['Flooded', 'Unaffected', 'Total'],
'fields': [[8.7, 135.8, 144.5]]
},
'impact table': {
'attributes': [
'Road Type', 'Flooded', 'Unaffected', 'Total'
],
'fields': [
['Main', 2, 131.3, 133.3],
['Side', 5.5, 4.5, 10],
['Bike', 1.2, 0.0, 1.2]
]
},
'notes': {
'fields': [],
'title': 'Notes'
},
'question': ''
}
self.assertEquals(data, expected)
class RoadExposureReportMixinTest(unittest.TestCase):
"""Test the ReportMixin.
.. versionadded:: 3.2
"""
# noinspection PyPep8Naming
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin_blank.question = ''
self.road_mixin.question = ''
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
self.road_mixin.affected_road_categories = ['Flooded']
self.maxDiff = None
def tearDown(self):
"""Run after each test."""
del self.road_mixin_blank
del self.road_mixin
def test_0001_generate_blank_data(self):
"""Generate a blank data."""
blank_data = self.road_mixin_blank.generate_data()
self.maxDiff = None
expected = {
'action check list': {
# I removed the field list here as in
# 3.5 the field list is generated by the IF, not
# the Mixin so it wont be populated as this test
# does not create an IF
'fields': [],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['category', 'value'],
'headings': ['Roads', 'Length'],
'fields': [['Unaffected (m)', 0], ['Total (m)', 0]]},
'impact table': {
'attributes': [
'Road Type', 'Unaffected', 'Total'],
'fields': [['Total (m)', 0, 0]]
},
'notes': {'fields': [], 'title': 'Notes and assumptions'},
'question': ''}
self.assertDictEqual(expected, blank_data)
def test_0002_road_breakdown(self):
"""Test the buildings breakdown."""
roads_breakdown = self.road_mixin.impact_table()['fields']
expected = [
['Main (m)', 2, 131.3, 133.3],
['Side (m)', 5.5, 4.5, 10],
['Bike (m)', 1.2, 0.0, 1.2],
['Total (m)', 8.7, 135.8, 144.5]
]
self.assertEquals(roads_breakdown, expected)
def test_0003_total(self):
"""Test general methods."""
default_length = self.road_mixin_blank.total_road_length
message = 'Default length is not as expected.'
self.assertEqual(default_length, 0, message)
message = 'Real length is not as expected.'
length = self.road_mixin.total_road_length
self.assertEqual(length, 144.5, message)
def test_0004_generate_data(self):
"""Test generating data."""
self.maxDiff = None
data = self.road_mixin.generate_data()
expected = {
'action check list': {
# I removed the field list here as in
# 3.5 the field list is generated by the IF, not
# the Mixin so it wont be populated as this test
# does not create an IF
'fields': [
],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['category', 'value'],
'headings': ['Roads', 'Length'],
'fields': [
['Flooded (m)', 8.7],
['Unaffected (m)', 135.8],
['Total (m)', 144.5]
]
},
'impact table': {
'attributes': [
'Road Type', 'Flooded', 'Unaffected', 'Total'
],
'fields': [
['Main (m)', 2, 131.3, 133.3],
['Side (m)', 5.5, 4.5, 10],
['Bike (m)', 1.2, 0.0, 1.2],
['Total (m)', 8.7, 135.8, 144.5]
]
},
'notes': {
'fields': [],
'title': 'Notes and assumptions'
},
'question': ''
}
self.assertDictEqual(data, expected)
class RoadExposureReportMixinTest(unittest.TestCase):
"""Test the ReportMixin.
.. versionadded:: 3.2
"""
# noinspection PyPep8Naming
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin_blank.question = ''
self.road_mixin.question = ''
self.road_mixin.road_lengths = OrderedDict([('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2
})])
self.road_mixin.affected_road_categories = ['Flooded']
self.maxDiff = None
def tearDown(self):
"""Run after each test."""
del self.road_mixin_blank
del self.road_mixin
def test_0001_generate_blank_data(self):
"""Generate a blank data."""
blank_data = self.road_mixin_blank.generate_data()
self.maxDiff = None
expected = {
'action check list': {
# I removed the field list here as in
# 3.5 the field list is generated by the IF, not
# the Mixin so it wont be populated as this test
# does not create an IF
'fields': [],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['category', 'value'],
'headings': ['Roads', 'Length'],
'fields': [['Unaffected (m)', 0], ['Total (m)', 0]]
},
'impact table': {
'attributes': ['Road Type', 'Unaffected', 'Total'],
'fields': [['Total (m)', 0, 0]]
},
'notes': {
'fields': [],
'title': 'Notes and assumptions'
},
'question': ''
}
self.assertDictEqual(expected, blank_data)
def test_0002_road_breakdown(self):
"""Test the buildings breakdown."""
roads_breakdown = self.road_mixin.impact_table()['fields']
expected = [['Main (m)', 2, 131.3, 133.3], ['Side (m)', 5.5, 4.5, 10],
['Bike (m)', 1.2, 0.0, 1.2],
['Total (m)', 8.7, 135.8, 144.5]]
self.assertEquals(roads_breakdown, expected)
def test_0003_total(self):
"""Test general methods."""
default_length = self.road_mixin_blank.total_road_length
message = 'Default length is not as expected.'
self.assertEqual(default_length, 0, message)
message = 'Real length is not as expected.'
length = self.road_mixin.total_road_length
self.assertEqual(length, 144.5, message)
def test_0004_generate_data(self):
"""Test generating data."""
self.maxDiff = None
data = self.road_mixin.generate_data()
expected = {
'action check list': {
# I removed the field list here as in
# 3.5 the field list is generated by the IF, not
# the Mixin so it wont be populated as this test
# does not create an IF
'fields': [],
'title': 'Action checklist'
},
'exposure': 'road',
'impact summary': {
'attributes': ['category', 'value'],
'headings': ['Roads', 'Length'],
'fields': [['Flooded (m)', 8.7], ['Unaffected (m)', 135.8],
['Total (m)', 144.5]]
},
'impact table': {
'attributes': ['Road Type', 'Flooded', 'Unaffected', 'Total'],
'fields': [['Main (m)', 2, 131.3, 133.3],
['Side (m)', 5.5, 4.5, 10],
['Bike (m)', 1.2, 0.0, 1.2],
['Total (m)', 8.7, 135.8, 144.5]]
},
'notes': {
'fields': [],
'title': 'Notes and assumptions'
},
'question': ''
}
self.assertDictEqual(data, expected)
class RoadExposureReportMixinTest(unittest.TestCase):
"""Test the ReportMixin.
.. versionadded:: 3.2
"""
# noinspection PyPep8Naming
def setUp(self):
"""Fixture run before all tests."""
self.road_mixin_blank = RoadExposureReportMixin()
self.road_mixin = RoadExposureReportMixin()
self.road_mixin.road_lengths = OrderedDict([
('Main', 133.3),
('Side', 10),
('Bike', 1.2)])
self.road_mixin.affected_road_lengths = OrderedDict([
('Flooded', {
'Main': 2,
'Side': 5.5,
'Bike': 1.2})
])
def tearDown(self):
"""Run after each test."""
del self.road_mixin_blank
del self.road_mixin
def test_0001_generate_report(self):
"""Generate a blank report."""
blank_report = self.road_mixin_blank.generate_report()
expected_blank_report = [
{'content': ''},
{'content': ''},
{'content': [u'Road Type', u'Total (m)'], 'header': True},
{'content': [u'All', '0']},
{'content': ''},
{'content': u'Breakdown by road type', 'header': True},
{'content': ''},
{'content': ''}]
message = 'Blank report is not as expected.'
self.assertListEqual(blank_report, expected_blank_report, message)
def test_0002_road_breakdown(self):
"""Test the buildings breakdown."""
roads_breakdown = self.road_mixin.roads_breakdown()
expected_roads_breakdown = [
{'content': u'Breakdown by road type', 'header': True},
{'content': ['Main', '133']},
{'content': ['Side', '10']},
{'content': ['Bike', '1']}]
message = 'roads breakdown is not as expected.'
self.assertListEqual(
roads_breakdown,
expected_roads_breakdown,
message)
def test_0003_total(self):
"""Test general methods."""
default_length = self.road_mixin_blank.total_road_length
length = self.road_mixin.total_road_length
message = 'Default length is not as expected.'
self.assertEqual(default_length, 0, message)
message = 'Real length is not as expected.'
self.assertEqual(length, 144.5, message)
