class BuildingExposureReportMixinTest(unittest.TestCase):
    """Test the ReportMixin.

    .. versionadded:: 3.1
    """

    # noinspection PyPep8Naming
    def setUp(self):
        """Fixture run before all tests."""
        self.building_mixin_blank = BuildingExposureReportMixin()
        self.building_mixin = BuildingExposureReportMixin()
        self.building_mixin.buildings = {
            'School': 100,
            'University': 10,
            'Residential': 20000,
            'Religious': 3
        }
        self.building_mixin.affected_buildings = OrderedDict([
            ('Hazard Level 2', {
                'School': OrderedDict([
                    ('Affected', 50),
                    ('Value', 90000000)
                ]),
                'University': OrderedDict([
                    ('Affected', 0),
                    ('Value', 0)
                ]),
                'Residential': OrderedDict([
                    ('Affected', 12000),
                    ('Value', 1234567000)
                ]),
                'Religious': OrderedDict([
                    ('Affected', 0),
                    ('Value', 0)
                ])
            }),
            ('Hazard Level 1', {
                'School': OrderedDict([
                    ('Affected', 25),
                    ('Value', 50000000)
                ]),
                'University': OrderedDict([
                    ('Affected', 1),
                    ('Value', 11111111111)
                ]),
                'Residential': OrderedDict([
                    ('Affected', 1000),
                    ('Value', 123456000)
                ]),
                'Religious': OrderedDict([
                    ('Affected', 1),
                    ('Value', 10000000000)
                ])
            })
        ])

    def tearDown(self):
        """Run after each test."""
        del self.building_mixin_blank
        del self.building_mixin

    def test_0001_generate_report(self):
        """Generate a blank report."""
        blank_report = self.building_mixin_blank.generate_report()
        expected_blank_report = [
            {'content': ''},
            {'content': ''},
            {'content': [u'Hazard Category'], 'header': True},
            {'content': [u'Buildings Not Affected', '0'], 'header': True},
            {'content': [u'All Buildings', '0'], 'header': True},
            {'content': ''},
            {'content': [u'Building type', u'Total'], 'header': True},
            {'content': ''},
            {'content': u'Action Checklist:', 'header': True},
            {'content': u'Are the critical facilities still open?'},
            {'content': (
                u'Which structures have warning capacity (eg. sirens, '
                u'speakers, etc.)?')},
            {'content': u'Which buildings will be evacuation centres?'},
            {'content': u'Where will we locate the operations centre?'},
            {'content': (
                u'Where will we locate warehouse and/or distribution '
                u'centres?')},
            {
                'content': (
                    u'Where will the students from the %s closed schools go '
                    u'to study?'),
                'arguments': ('0',),
                'condition': False
            },
            {
                'content': (
                    u'Where will the patients from the %s closed hospitals '
                    u'go for treatment and how will we transport them?'),
                'arguments': ('0',),
                'condition': False},
            {'content': ''}]
        message = 'Blank report is not as expected.'
        self.assertListEqual(blank_report, expected_blank_report, message)

    def test_0002_action_checklist(self):
        """The default action check list."""
        action_checklist = self.building_mixin_blank.action_checklist()
        expected_action_checklist = [
            {'content': u'Action Checklist:', 'header': True},
            {'content': u'Are the critical facilities still open?'},
            {'content': (
                u'Which structures have warning capacity (eg. sirens, '
                u'speakers, etc.)?')},
            {'content': u'Which buildings will be evacuation centres?'},
            {'content': u'Where will we locate the operations centre?'},
            {'content': (
                u'Where will we locate warehouse and/or distribution '
                u'centres?')},
            {
                'content': (
                    u'Where will the students from the %s closed schools go '
                    u'to study?'),
                'arguments': ('0',),
                'condition': False
            },
            {
                'content': (
                    u'Where will the patients from the %s closed hospitals '
                    u'go for treatment and how will we transport them?'),
                'arguments': ('0',),
                'condition': False}]
        message = 'Default action checklist not as expected.'
        self.assertListEqual(
            action_checklist,
            expected_action_checklist,
            message)

    def test_0003_impact_summary(self):
        """Test the buildings impact summary."""
        impact_summary = self.building_mixin.impact_summary()
        expected_impact_summary = [
            {
                'content': [u'Hazard Category', 'Affected', 'Value'],
                'header': True
            },
            {'content': [u'Hazard Level 2', '12,050', '1,324,567,000']},
            {'content': [u'Hazard Level 1', '1,027', '21,284,567,111']},
            {
                'content': [u'Total Buildings Affected', '13,077'],
                'header': True
            },
            {'content': [u'Buildings Not Affected', '7,036'], 'header': True},
            {'content': [u'All Buildings', '20,113'], 'header': True}]
        message = 'Impact summary is not as expcted.'
        self.assertListEqual(
            impact_summary,
            expected_impact_summary,
            message)

    def test_0004_buildings_breakdown(self):
        """Test the buildings breakdown."""
        buildings_breakdown = self.building_mixin.buildings_breakdown()
        expected_buildings_breakdown = [
            {
                'content': [
                    u'Building type',
                    u'Hazard Level 2',
                    u'Hazard Level 1',
                    u'Total'],
                'header': True
            },
            {'content': ['Religious', '0', '1', '3']},
            {'content': ['Residential', '12,000', '1,000', '20,000']},
            {'content': ['School', '50', '25', '100']},
            {'content': ['University', '0', '1', '10']}]
        message = 'building breakdown is not as expected.'
        self.assertListEqual(
            buildings_breakdown,
            expected_buildings_breakdown,
            message)

    def test_0005_schools_closed(self):
        """Test schools closed as expected."""
        schools_closed_default = self.building_mixin_blank.schools_closed
        schools_closed = self.building_mixin.schools_closed
        message = 'Default should not have any closed schools.'
        self.assertEqual(schools_closed_default, 0, message)
        message = 'Schools closed in scenario not as expected.'
        self.assertEqual(schools_closed, 75, message)

    def test_0006_hospitals_closed(self):
        """Test hospitals closed as expected."""
        hospitals_closed_default = self.building_mixin_blank.hospitals_closed
        hospitals_closed = self.building_mixin.hospitals_closed
        message = 'Default should not have any closed hospitals.'
        self.assertEqual(hospitals_closed_default, 0, message)
        message = 'Hospitals closed in scenario not as expected.'
        self.assertEqual(hospitals_closed, 0, message)

    def test_0007_general_methods(self):
        """Test general methods."""
        default_count_usage = self.building_mixin_blank._count_usage('School')
        message = 'Default count is not as expected.'
        self.assertEqual(default_count_usage, 0, message)
        count_usage = self.building_mixin._count_usage('School')
        message = 'Count is not as expected.'
        self.assertEqual(count_usage, 75, message)
        default_impact_breakdown = self.building_mixin_blank._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(default_impact_breakdown, [], message)
        impact_breakdown = self.building_mixin._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(impact_breakdown, ['Affected', 'Value'], message)
        default_categories = self.building_mixin_blank._affected_categories
        message = 'The default categories should be empty.'
        self.assertListEqual(default_categories, [], message)
        categories = self.building_mixin._affected_categories
        message = 'The categories are not as expected.'
        self.assertListEqual(
            categories,
            ['Hazard Level 2', 'Hazard Level 1'],
            message)

    def test_0008_building_counts(self):
        """Test the building counts."""
        default_affected = self.building_mixin_blank.total_affected_buildings
        default_unaffected = (
            self.building_mixin_blank.total_unaffected_buildings)
        default_total = self.building_mixin_blank.total_buildings
        message = 'Defaults counts should be 0.'
        self.assertEqual(default_total, 0, message)
        self.assertEqual(default_unaffected, 0, message)
        self.assertEqual(default_affected, 0, message)
        affected = self.building_mixin.total_affected_buildings
        unaffected = self.building_mixin.total_unaffected_buildings
        total = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should equal the sum of affected '
            'and unaffected.')
        self.assertEqual(total, unaffected + affected, message)
        message = 'The total number of buildings is not as expected.'
        self.assertEqual(total, 20113, message)
        message = 'The affected number of buildings is not as expected.'
        self.assertEqual(affected, 13077, message)
        message = 'The unaffected number of buildings is not as expected.'
        self.assertEqual(unaffected, 7036, message)

    def test_0009_consolidate_to_other(self):
        """Test consolidating smaller building types to 'other'."""
        total_buildings_before = self.building_mixin.total_buildings
        affected_other_before = self.building_mixin._count_usage('Other')
        message = (
            'There should be no affected buildings of type other before '
            'consolidating.')
        self.assertEqual(affected_other_before, 0, message)
        other_in_buildings_before = (
            'Other' in self.building_mixin.buildings.keys())
        message = (
            'There should be no buildings of type other before '
            'consolidation.')
        self.assertFalse(other_in_buildings_before, message)
        self.building_mixin._consolidate_to_other()
        total_buildings_after = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should remain the same '
            'even after consolidation.')
        self.assertEqual(
            total_buildings_before,
            total_buildings_after,
            message)
        affected_other_after = self.building_mixin._count_usage('Other')
        message = 'The affected other buildings are not as expected.'
        self.assertEqual(affected_other_after, 2, message)
        other_in_buildings_after = (
            'Other' in self.building_mixin.buildings.keys())
        message = 'The type other should be in buildings.'
        self.assertTrue(other_in_buildings_after, message)
        total_other_after = self.building_mixin.buildings['Other']
        message = (
            'The total number of other after consolidation is '
            'not as expected.')
        self.assertEqual(total_other_after, 13, message)
class BuildingExposureReportMixinTest(unittest.TestCase):
    """Test the ReportMixin.

    .. versionadded:: 3.1
    """

    # noinspection PyPep8Naming
    def setUp(self):
        """Fixture run before all tests."""
        self.building_mixin_blank = BuildingExposureReportMixin()
        self.building_mixin = BuildingExposureReportMixin()
        self.building_mixin.buildings = {
            'School': 100,
            'University': 10,
            'Residential': 20000,
            'Religious': 3
        }
        self.building_mixin.affected_buildings = OrderedDict([
            ('Hazard Level 2', {
                'School':
                OrderedDict([('Affected', 50), ('Value', 90000000)]),
                'University':
                OrderedDict([('Affected', 0), ('Value', 0)]),
                'Residential':
                OrderedDict([('Affected', 12000), ('Value', 1234567000)]),
                'Religious':
                OrderedDict([('Affected', 0), ('Value', 0)])
            }),
            ('Hazard Level 1', {
                'School':
                OrderedDict([('Affected', 25), ('Value', 50000000)]),
                'University':
                OrderedDict([('Affected', 1), ('Value', 11111111111)]),
                'Residential':
                OrderedDict([('Affected', 1000), ('Value', 123456000)]),
                'Religious':
                OrderedDict([('Affected', 1), ('Value', 10000000000)])
            })
        ])

    def tearDown(self):
        """Run after each test."""
        del self.building_mixin_blank
        del self.building_mixin

    def test_0001_generate_report(self):
        """Generate a blank report."""
        blank_report = self.building_mixin_blank.generate_report().to_text()
        self.assertIn('**Not affected buildings**, 0', blank_report)
        self.assertIn('**Building type**, **Not Affected**, **Total**',
                      blank_report)

    def test_0002_action_checklist(self):
        """The default action check list."""
        action_checklist = self.building_mixin_blank.action_checklist()
        action_checklist = action_checklist.to_text()
        self.assertIn(
            u'Which structures have warning capacity (eg. sirens, '
            u'speakers, etc.)?', action_checklist)
        self.assertIn(
            u'Are the water and electricity services still operating?',
            action_checklist)
        self.assertIn(u'Are the health centres still open?', action_checklist)
        self.assertIn(u'Are the other public services accessible',
                      action_checklist)
        self.assertIn(u'Which buildings will be evacuation centres?',
                      action_checklist)
        self.assertIn(u'Where will we locate the operations centre?',
                      action_checklist)
        self.assertIn(
            u'Where will we locate warehouse and/or distribution '
            u'centres?', action_checklist)
        self.assertNotIn(
            u'Where will the students from the 0 closed schools go to study?',
            action_checklist)
        self.assertNotIn(
            u'Where will the patients from the %s closed hospitals '
            u'go for treatment and how will we transport them?',
            action_checklist)

    def test_0003_impact_summary(self):
        """Test the buildings impact summary."""
        impact_summary = self.building_mixin.impact_summary()
        impact_summary = impact_summary.to_text()

        self.assertIn(u'**Hazard Level 2**, 12,050, 1,324,567,000',
                      impact_summary)
        self.assertIn(u'**Hazard Level 1**, 1,027, 21,284,567,111',
                      impact_summary)
        self.assertIn(u'**Affected buildings**, 13,077', impact_summary)
        self.assertIn(u'**Not affected buildings**, 7,036', impact_summary)
        self.assertIn(u'**Total**, 20,113', impact_summary)

    def test_0004_buildings_breakdown(self):
        """Test the buildings breakdown."""
        buildings_breakdown = self.building_mixin.buildings_breakdown()
        buildings_breakdown = buildings_breakdown.to_text()
        self.assertIn(u'**Religious**, 0, 1, 2, **3**', buildings_breakdown)
        self.assertIn(u'**Residential**, 12,000, 1,000, 7,000, **20,000**',
                      buildings_breakdown)
        self.assertIn(u'**School**, 50, 25, 25, **100**', buildings_breakdown)
        self.assertIn(u'**University**, 0, 1, 9, **10**', buildings_breakdown)

    def test_0005_schools_closed(self):
        """Test schools closed as expected."""
        schools_closed_default = self.building_mixin_blank.schools_closed
        schools_closed = self.building_mixin.schools_closed
        message = 'Default should not have any closed schools.'
        self.assertEqual(schools_closed_default, 0, message)
        message = 'Schools closed in scenario not as expected.'
        self.assertEqual(schools_closed, 75, message)

    def test_0006_hospitals_closed(self):
        """Test hospitals closed as expected."""
        hospitals_closed_default = self.building_mixin_blank.hospitals_closed
        hospitals_closed = self.building_mixin.hospitals_closed
        message = 'Default should not have any closed hospitals.'
        self.assertEqual(hospitals_closed_default, 0, message)
        message = 'Hospitals closed in scenario not as expected.'
        self.assertEqual(hospitals_closed, 0, message)

    def test_0007_general_methods(self):
        """Test general methods."""
        default_count_usage = self.building_mixin_blank._count_usage('School')
        message = 'Default count is not as expected.'
        self.assertEqual(default_count_usage, 0, message)
        count_usage = self.building_mixin._count_usage('School')
        message = 'Count is not as expected.'
        self.assertEqual(count_usage, 75, message)
        default_impact_breakdown = self.building_mixin_blank._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(default_impact_breakdown, [], message)
        impact_breakdown = self.building_mixin._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(impact_breakdown, ['Affected', 'Value'], message)
        default_categories = self.building_mixin_blank._affected_categories
        message = 'The default categories should be empty.'
        self.assertListEqual(default_categories, [], message)
        categories = self.building_mixin._affected_categories
        message = 'The categories are not as expected.'
        self.assertListEqual(categories, ['Hazard Level 2', 'Hazard Level 1'],
                             message)

    def test_0008_building_counts(self):
        """Test the building counts."""
        default_affected = self.building_mixin_blank.total_affected_buildings
        default_unaffected = (
            self.building_mixin_blank.total_unaffected_buildings)
        default_total = self.building_mixin_blank.total_buildings
        message = 'Defaults counts should be 0.'
        self.assertEqual(default_total, 0, message)
        self.assertEqual(default_unaffected, 0, message)
        self.assertEqual(default_affected, 0, message)
        affected = self.building_mixin.total_affected_buildings
        unaffected = self.building_mixin.total_unaffected_buildings
        total = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should equal the sum of affected '
            'and unaffected.')
        self.assertEqual(total, unaffected + affected, message)
        message = 'The total number of buildings is not as expected.'
        self.assertEqual(total, 20113, message)
        message = 'The affected number of buildings is not as expected.'
        self.assertEqual(affected, 13077, message)
        message = 'The unaffected number of buildings is not as expected.'
        self.assertEqual(unaffected, 7036, message)

    def test_0009_consolidate_to_other(self):
        """Test consolidating smaller building types to 'other'."""
        total_buildings_before = self.building_mixin.total_buildings
        affected_other_before = self.building_mixin._count_usage('Other')
        message = (
            'There should be no affected buildings of type other before '
            'consolidating.')
        self.assertEqual(affected_other_before, 0, message)
        other_in_buildings_before = ('Other'
                                     in self.building_mixin.buildings.keys())
        message = ('There should be no buildings of type other before '
                   'consolidation.')
        self.assertFalse(other_in_buildings_before, message)
        self.building_mixin._consolidate_to_other()
        total_buildings_after = self.building_mixin.total_buildings
        message = ('The total number of buildings should remain the same '
                   'even after consolidation.')
        self.assertEqual(total_buildings_before, total_buildings_after,
                         message)
        affected_other_after = self.building_mixin._count_usage('Other')
        message = 'The affected other buildings are not as expected.'
        self.assertEqual(affected_other_after, 2, message)
        other_in_buildings_after = ('Other'
                                    in self.building_mixin.buildings.keys())
        message = 'The type other should be in buildings.'
        self.assertTrue(other_in_buildings_after, message)
        total_other_after = self.building_mixin.buildings['Other']
        message = ('The total number of other after consolidation is '
                   'not as expected.')
        self.assertEqual(total_other_after, 13, message)
class BuildingExposureReportMixinTest(unittest.TestCase):
    """Test the ReportMixin.

    .. versionadded:: 3.1
    """

    # noinspection PyPep8Naming
    def setUp(self):
        """Fixture run before all tests."""
        self.building_mixin_blank = BuildingExposureReportMixin()
        self.building_mixin = BuildingExposureReportMixin()
        self.building_mixin.buildings = {
            'School': 100,
            'University': 10,
            'Residential': 20000,
            'Religious': 3
        }
        self.building_mixin.affected_buildings = OrderedDict([
            ('Hazard Level 2', {
                'School': OrderedDict([
                    ('Affected', 50),
                    ('Value', 90000000)
                ]),
                'University': OrderedDict([
                    ('Affected', 0),
                    ('Value', 0)
                ]),
                'Residential': OrderedDict([
                    ('Affected', 12000),
                    ('Value', 1234567000)
                ]),
                'Religious': OrderedDict([
                    ('Affected', 0),
                    ('Value', 0)
                ])
            }),
            ('Hazard Level 1', {
                'School': OrderedDict([
                    ('Affected', 25),
                    ('Value', 50000000)
                ]),
                'University': OrderedDict([
                    ('Affected', 1),
                    ('Value', 11111111111)
                ]),
                'Residential': OrderedDict([
                    ('Affected', 1000),
                    ('Value', 123456000)
                ]),
                'Religious': OrderedDict([
                    ('Affected', 1),
                    ('Value', 10000000000)
                ])
            })
        ])

    def tearDown(self):
        """Run after each test."""
        del self.building_mixin_blank
        del self.building_mixin

    def test_0001_generate_report(self):
        """Generate a blank report."""
        blank_report = self.building_mixin_blank.generate_report().to_text()
        self.assertIn('**Not affected buildings**, 0', blank_report)
        self.assertIn(
            '**Building type**, **Not Affected**, **Total**',
            blank_report
        )

    def test_0002_action_checklist(self):
        """The default action check list."""
        action_checklist = self.building_mixin_blank.action_checklist()
        action_checklist = action_checklist.to_text()
        self.assertIn(
            u'Which structures have warning capacity (eg. sirens, '
            u'speakers, etc.)?',
            action_checklist)
        self.assertIn(
            u'Are the water and electricity services still operating?',
            action_checklist)
        self.assertIn(u'Are the health centres still open?', action_checklist)
        self.assertIn(
                u'Are the other public services accessible', action_checklist)
        self.assertIn(
            u'Which buildings will be evacuation centres?',
            action_checklist)
        self.assertIn(
            u'Where will we locate the operations centre?',
            action_checklist
        )
        self.assertIn(
            u'Where will we locate warehouse and/or distribution '
            u'centres?',
            action_checklist
        )
        self.assertNotIn(
            u'Where will the students from the 0 closed schools go to study?',
            action_checklist
        )
        self.assertNotIn(
            u'Where will the patients from the %s closed hospitals '
            u'go for treatment and how will we transport them?',
            action_checklist)

    def test_0003_impact_summary(self):
        """Test the buildings impact summary."""
        impact_summary = self.building_mixin.impact_summary()
        impact_summary = impact_summary.to_text()

        self.assertIn(
            u'**Hazard Level 2**, 12,050, 1,324,567,000', impact_summary)
        self.assertIn(
            u'**Hazard Level 1**, 1,027, 21,284,567,111', impact_summary)
        self.assertIn(u'**Affected buildings**, 13,077', impact_summary)
        self.assertIn(u'**Not affected buildings**, 7,036', impact_summary)
        self.assertIn(u'**Total**, 20,113', impact_summary)

    def test_0004_buildings_breakdown(self):
        """Test the buildings breakdown."""
        buildings_breakdown = self.building_mixin.buildings_breakdown()
        buildings_breakdown = buildings_breakdown.to_text()
        self.assertIn(u'**Religious**, 0, 1, 2, **3**', buildings_breakdown)
        self.assertIn(
            u'**Residential**, 12,000, 1,000, 7,000, **20,000**',
            buildings_breakdown)
        self.assertIn(u'**School**, 50, 25, 25, **100**', buildings_breakdown)
        self.assertIn(u'**University**, 0, 1, 9, **10**', buildings_breakdown)

    def test_0005_schools_closed(self):
        """Test schools closed as expected."""
        schools_closed_default = self.building_mixin_blank.schools_closed
        schools_closed = self.building_mixin.schools_closed
        message = 'Default should not have any closed schools.'
        self.assertEqual(schools_closed_default, 0, message)
        message = 'Schools closed in scenario not as expected.'
        self.assertEqual(schools_closed, 75, message)

    def test_0006_hospitals_closed(self):
        """Test hospitals closed as expected."""
        hospitals_closed_default = self.building_mixin_blank.hospitals_closed
        hospitals_closed = self.building_mixin.hospitals_closed
        message = 'Default should not have any closed hospitals.'
        self.assertEqual(hospitals_closed_default, 0, message)
        message = 'Hospitals closed in scenario not as expected.'
        self.assertEqual(hospitals_closed, 0, message)

    def test_0007_general_methods(self):
        """Test general methods."""
        default_count_usage = self.building_mixin_blank._count_usage('School')
        message = 'Default count is not as expected.'
        self.assertEqual(default_count_usage, 0, message)
        count_usage = self.building_mixin._count_usage('School')
        message = 'Count is not as expected.'
        self.assertEqual(count_usage, 75, message)
        default_impact_breakdown = self.building_mixin_blank._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(default_impact_breakdown, [], message)
        impact_breakdown = self.building_mixin._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(impact_breakdown, ['Affected', 'Value'], message)
        default_categories = self.building_mixin_blank._affected_categories
        message = 'The default categories should be empty.'
        self.assertListEqual(default_categories, [], message)
        categories = self.building_mixin._affected_categories
        message = 'The categories are not as expected.'
        self.assertListEqual(
            categories,
            ['Hazard Level 2', 'Hazard Level 1'],
            message)

    def test_0008_building_counts(self):
        """Test the building counts."""
        default_affected = self.building_mixin_blank.total_affected_buildings
        default_unaffected = (
            self.building_mixin_blank.total_unaffected_buildings)
        default_total = self.building_mixin_blank.total_buildings
        message = 'Defaults counts should be 0.'
        self.assertEqual(default_total, 0, message)
        self.assertEqual(default_unaffected, 0, message)
        self.assertEqual(default_affected, 0, message)
        affected = self.building_mixin.total_affected_buildings
        unaffected = self.building_mixin.total_unaffected_buildings
        total = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should equal the sum of affected '
            'and unaffected.')
        self.assertEqual(total, unaffected + affected, message)
        message = 'The total number of buildings is not as expected.'
        self.assertEqual(total, 20113, message)
        message = 'The affected number of buildings is not as expected.'
        self.assertEqual(affected, 13077, message)
        message = 'The unaffected number of buildings is not as expected.'
        self.assertEqual(unaffected, 7036, message)

    def test_0009_consolidate_to_other(self):
        """Test consolidating smaller building types to 'other'."""
        total_buildings_before = self.building_mixin.total_buildings
        affected_other_before = self.building_mixin._count_usage('Other')
        message = (
            'There should be no affected buildings of type other before '
            'consolidating.')
        self.assertEqual(affected_other_before, 0, message)
        other_in_buildings_before = (
            'Other' in self.building_mixin.buildings.keys())
        message = (
            'There should be no buildings of type other before '
            'consolidation.')
        self.assertFalse(other_in_buildings_before, message)
        self.building_mixin._consolidate_to_other()
        total_buildings_after = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should remain the same '
            'even after consolidation.')
        self.assertEqual(
            total_buildings_before,
            total_buildings_after,
            message)
        affected_other_after = self.building_mixin._count_usage('Other')
        message = 'The affected other buildings are not as expected.'
        self.assertEqual(affected_other_after, 2, message)
        other_in_buildings_after = (
            'Other' in self.building_mixin.buildings.keys())
        message = 'The type other should be in buildings.'
        self.assertTrue(other_in_buildings_after, message)
        total_other_after = self.building_mixin.buildings['Other']
        message = (
            'The total number of other after consolidation is '
            'not as expected.')
        self.assertEqual(total_other_after, 13, message)
class BuildingExposureReportMixinTest(unittest.TestCase):
    """Test the ReportMixin.

    .. versionadded:: 3.1
    """

    # noinspection PyPep8Naming
    def setUp(self):
        """Fixture run before all tests."""
        self.building_mixin_blank = BuildingExposureReportMixin()
        self.building_mixin = BuildingExposureReportMixin()
        self.building_mixin.buildings = {
            'School': 100,
            'University': 10,
            'Residential': 20000,
            'Religious': 3
        }
        self.building_mixin.affected_buildings = OrderedDict([
            ('Hazard Level 2', {
                'School':
                OrderedDict([('Affected', 50), ('Value', 90000000)]),
                'University':
                OrderedDict([('Affected', 0), ('Value', 0)]),
                'Residential':
                OrderedDict([('Affected', 12000), ('Value', 1234567000)]),
                'Religious':
                OrderedDict([('Affected', 0), ('Value', 0)])
            }),
            ('Hazard Level 1', {
                'School':
                OrderedDict([('Affected', 25), ('Value', 50000000)]),
                'University':
                OrderedDict([('Affected', 1), ('Value', 11111111111)]),
                'Residential':
                OrderedDict([('Affected', 1000), ('Value', 123456000)]),
                'Religious':
                OrderedDict([('Affected', 1), ('Value', 10000000000)])
            })
        ])

    def tearDown(self):
        """Run after each test."""
        del self.building_mixin_blank
        del self.building_mixin

    def test_0001_generate_report(self):
        """Generate a blank report."""
        blank_report = self.building_mixin_blank.generate_report()
        expected_blank_report = [{
            'content': ''
        }, {
            'content': ''
        }, {
            'content': [u'Hazard Category'],
            'header': True
        }, {
            'content': [u'Buildings Not Affected', '0'],
            'header': True
        }, {
            'content': [u'All Buildings', '0'],
            'header': True
        }, {
            'content': ''
        }, {
            'content': [u'Building type', u'Total'],
            'header': True
        }, {
            'content': ''
        }, {
            'content': u'Action Checklist:',
            'header': True
        }, {
            'content':
            u'Are the critical facilities still open?'
        }, {
            'content': (u'Which structures have warning capacity (eg. sirens, '
                        u'speakers, etc.)?')
        }, {
            'content':
            u'Which buildings will be evacuation centres?'
        }, {
            'content':
            u'Where will we locate the operations centre?'
        }, {
            'content': (u'Where will we locate warehouse and/or distribution '
                        u'centres?')
        }, {
            'content':
            (u'Where will the students from the %s closed schools go '
             u'to study?'),
            'arguments': ('0', ),
            'condition':
            False
        }, {
            'content':
            (u'Where will the patients from the %s closed hospitals '
             u'go for treatment and how will we transport them?'),
            'arguments': ('0', ),
            'condition':
            False
        }, {
            'content': ''
        }]
        message = 'Blank report is not as expected.'
        self.assertListEqual(blank_report, expected_blank_report, message)

    def test_0002_action_checklist(self):
        """The default action check list."""
        action_checklist = self.building_mixin_blank.action_checklist()
        expected_action_checklist = [{
            'content': u'Action Checklist:',
            'header': True
        }, {
            'content':
            u'Are the critical facilities still open?'
        }, {
            'content': (u'Which structures have warning capacity (eg. sirens, '
                        u'speakers, etc.)?')
        }, {
            'content':
            u'Which buildings will be evacuation centres?'
        }, {
            'content':
            u'Where will we locate the operations centre?'
        }, {
            'content': (u'Where will we locate warehouse and/or distribution '
                        u'centres?')
        }, {
            'content':
            (u'Where will the students from the %s closed schools go '
             u'to study?'),
            'arguments': ('0', ),
            'condition':
            False
        }, {
            'content':
            (u'Where will the patients from the %s closed hospitals '
             u'go for treatment and how will we transport them?'),
            'arguments': ('0', ),
            'condition':
            False
        }]
        message = 'Default action checklist not as expected.'
        self.assertListEqual(action_checklist, expected_action_checklist,
                             message)

    def test_0003_impact_summary(self):
        """Test the buildings impact summary."""
        impact_summary = self.building_mixin.impact_summary()
        expected_impact_summary = [{
            'content': [u'Hazard Category', 'Affected', 'Value'],
            'header':
            True
        }, {
            'content': [u'Hazard Level 2', '12,050', '1,324,567,000']
        }, {
            'content': [u'Hazard Level 1', '1,027', '21,284,567,111']
        }, {
            'content': [u'Total Buildings Affected', '13,077'],
            'header':
            True
        }, {
            'content': [u'Buildings Not Affected', '7,036'],
            'header':
            True
        }, {
            'content': [u'All Buildings', '20,113'],
            'header': True
        }]
        message = 'Impact summary is not as expcted.'
        self.assertListEqual(impact_summary, expected_impact_summary, message)

    def test_0004_buildings_breakdown(self):
        """Test the buildings breakdown."""
        buildings_breakdown = self.building_mixin.buildings_breakdown()
        expected_buildings_breakdown = [{
            'content':
            [u'Building type', u'Hazard Level 2', u'Hazard Level 1', u'Total'],
            'header':
            True
        }, {
            'content': ['Religious', '0', '1', '1']
        }, {
            'content': ['Residential', '12,000', '1,000', '13,000']
        }, {
            'content': ['School', '50', '25', '75']
        }, {
            'content': ['University', '0', '1', '1']
        }]
        message = 'building breakdown is not as expected.'
        self.assertListEqual(buildings_breakdown, expected_buildings_breakdown,
                             message)

    def test_0005_schools_closed(self):
        """Test schools closed as expected."""
        schools_closed_default = self.building_mixin_blank.schools_closed
        schools_closed = self.building_mixin.schools_closed
        message = 'Default should not have any closed schools.'
        self.assertEqual(schools_closed_default, 0, message)
        message = 'Schools closed in scenario not as expected.'
        self.assertEqual(schools_closed, 75, message)

    def test_0006_hospitals_closed(self):
        """Test hospitals closed as expected."""
        hospitals_closed_default = self.building_mixin_blank.hospitals_closed
        hospitals_closed = self.building_mixin.hospitals_closed
        message = 'Default should not have any closed hospitals.'
        self.assertEqual(hospitals_closed_default, 0, message)
        message = 'Hospitals closed in scenario not as expected.'
        self.assertEqual(hospitals_closed, 0, message)

    def test_0007_general_methods(self):
        """Test general methods."""
        default_count_usage = self.building_mixin_blank._count_usage('School')
        message = 'Default count is not as expected.'
        self.assertEqual(default_count_usage, 0, message)
        count_usage = self.building_mixin._count_usage('School')
        message = 'Count is not as expected.'
        self.assertEqual(count_usage, 75, message)
        default_impact_breakdown = self.building_mixin_blank._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(default_impact_breakdown, [], message)
        impact_breakdown = self.building_mixin._impact_breakdown
        message = 'The default impact breakdown should be empty.'
        self.assertListEqual(impact_breakdown, ['Affected', 'Value'], message)
        default_categories = self.building_mixin_blank._affected_categories
        message = 'The default categories should be empty.'
        self.assertListEqual(default_categories, [], message)
        categories = self.building_mixin._affected_categories
        message = 'The categories are not as expected.'
        self.assertListEqual(categories, ['Hazard Level 2', 'Hazard Level 1'],
                             message)

    def test_0008_building_counts(self):
        """Test the building counts."""
        default_affected = self.building_mixin_blank.total_affected_buildings
        default_unaffected = (
            self.building_mixin_blank.total_unaffected_buildings)
        default_total = self.building_mixin_blank.total_buildings
        message = 'Defaults counts should be 0.'
        self.assertEqual(default_total, 0, message)
        self.assertEqual(default_unaffected, 0, message)
        self.assertEqual(default_affected, 0, message)
        affected = self.building_mixin.total_affected_buildings
        unaffected = self.building_mixin.total_unaffected_buildings
        total = self.building_mixin.total_buildings
        message = (
            'The total number of buildings should equal the sum of affected '
            'and unaffected.')
        self.assertEqual(total, unaffected + affected, message)
        message = 'The total number of buildings is not as expected.'
        self.assertEqual(total, 20113, message)
        message = 'The affected number of buildings is not as expected.'
        self.assertEqual(affected, 13077, message)
        message = 'The unaffected number of buildings is not as expected.'
        self.assertEqual(unaffected, 7036, message)

    def test_0009_consolidate_to_other(self):
        """Test consolidating smaller building types to 'other'."""
        total_buildings_before = self.building_mixin.total_buildings
        affected_other_before = self.building_mixin._count_usage('Other')
        message = (
            'There should be no affected buildings of type other before '
            'consolidating.')
        self.assertEqual(affected_other_before, 0, message)
        other_in_buildings_before = ('Other'
                                     in self.building_mixin.buildings.keys())
        message = ('There should be no buildings of type other before '
                   'consolidation.')
        self.assertFalse(other_in_buildings_before, message)
        self.building_mixin._consolidate_to_other()
        total_buildings_after = self.building_mixin.total_buildings
        message = ('The total number of buildings should remain the same '
                   'even after consolidation.')
        self.assertEqual(total_buildings_before, total_buildings_after,
                         message)
        affected_other_after = self.building_mixin._count_usage('Other')
        message = 'The affected other buildings are not as expected.'
        self.assertEqual(affected_other_after, 2, message)
        other_in_buildings_after = ('Other'
                                    in self.building_mixin.buildings.keys())
        message = 'The type other should be in buildings.'
        self.assertTrue(other_in_buildings_after, message)
        total_other_after = self.building_mixin.buildings['Other']
        message = ('The total number of other after consolidation is '
                   'not as expected.')
        self.assertEqual(total_other_after, 13, message)