コード例 #1
0
ファイル: base_tests.py プロジェクト: russss/EveryElection
    def _create_models(self):
        self.date = date.today()
        self.date_str = self.date.strftime("%Y-%m-%d")

        self.election_type1 = ElectionType.objects.get(election_type='local', )
        self.org1 = Organisation.objects.create(
            official_identifier='TEST1',
            organisation_type='local-authority',
            official_name="Test Council",
            gss="X00000001",
            slug="test",
            territory_code="ENG",
            election_name="Test Council local elections",
        )

        self.elected_role1 = ElectedRole.objects.create(
            election_type=self.election_type1,
            organisation=self.org1,
            elected_title="Local Councillor",
            elected_role_name="Councillor for Test Council",
        )
        self.org_div_1 = OrganisationDivisionFactory(organisation=self.org1,
                                                     name="Test Div 1",
                                                     slug="test-div")
        self.org_div_2 = OrganisationDivisionFactory(organisation=self.org1,
                                                     name="Test Div 2",
                                                     slug="test-div-2")

        self.base_data = {
            'election_organisation': [
                self.org1,
            ],
            'election_type': self.election_type1,
            'date': self.date,
        }
コード例 #2
0
ファイル: base_tests.py プロジェクト: iblisbuu/EveryElection
    def _create_models(self):
        self.date = date.today()
        self.date_str = self.date.strftime("%Y-%m-%d")

        self.election_type1 = ElectionType.objects.get(election_type="local")
        self.org1 = Organisation.objects.create(
            official_identifier="TEST1",
            organisation_type="local-authority",
            official_name="Test Council",
            slug="test",
            territory_code="ENG",
            election_name="Test Council local elections",
            start_date=date(2016, 10, 1),
        )

        self.elected_role1 = ElectedRole.objects.create(
            election_type=self.election_type1,
            organisation=self.org1,
            elected_title="Local Councillor",
            elected_role_name="Councillor for Test Council",
        )
        self.org_div_1 = OrganisationDivisionFactory(
            organisation=self.org1, name="Test Div 1", slug="test-div", seats_total=3
        )
        self.org_div_2 = OrganisationDivisionFactory(
            organisation=self.org1, name="Test Div 2", slug="test-div-2"
        )

        self.base_data = {
            "election_organisation": [self.org1],
            "election_type": self.election_type1,
            "date": self.date,
        }
コード例 #3
0
ファイル: test_admin.py プロジェクト: pmk01/EveryElection
 def test_all_ok(self):
     div = OrganisationDivisionFactory()
     div.official_identifier = "gss:X01000001"
     div.save()
     dg = DivisionGeographyFactory(division=div)
     dg.source = "this is totally fine"
     dg.save()
     self.assertEqual(len(DivisionProblem.objects.all()), 0)
コード例 #4
0
ファイル: test_admin.py プロジェクト: pmk01/EveryElection
 def test_no_geography(self):
     div = OrganisationDivisionFactory()
     div.official_identifier = "gss:X01000001"
     div.save()
     self.assertEqual(len(DivisionProblem.objects.all()), 1)
     problem = DivisionProblem.objects.all()[0]
     self.assertFalse(problem.no_gss_code)
     self.assertTrue(problem.no_geography)
     self.assertTrue(problem.invalid_source)
     self.assertEqual("No associated DivisionGeography",
                      problem.problem_text)
コード例 #5
0
ファイル: test_admin.py プロジェクト: pmk01/EveryElection
 def test_all_broken(self):
     div = OrganisationDivisionFactory()
     div.save()
     dg = DivisionGeographyFactory(division=div)
     dg.source = ""
     dg.save()
     self.assertEqual(len(DivisionProblem.objects.all()), 1)
     problem = DivisionProblem.objects.all()[0]
     self.assertTrue(problem.no_gss_code)
     self.assertTrue(problem.invalid_source)
     self.assertTrue(problem.invalid_source)
     self.assertEqual("No GSS code", problem.problem_text)
コード例 #6
0
ファイル: test_admin.py プロジェクト: pmk01/EveryElection
 def test_invalid_source(self):
     div = OrganisationDivisionFactory()
     div.official_identifier = "gss:X01000001"
     div.save()
     dg = DivisionGeographyFactory(division=div)
     dg.source = "unknown"
     dg.save()
     self.assertEqual(len(DivisionProblem.objects.all()), 1)
     problem = DivisionProblem.objects.all()[0]
     self.assertFalse(problem.no_gss_code)
     self.assertFalse(problem.no_geography)
     self.assertTrue(problem.invalid_source)
     self.assertEqual("Boundary source is invalid", problem.problem_text)
コード例 #7
0
    def test_invalid_division_wrong_subtype(self):
        naw_election_type = ElectionType.objects.get(election_type="naw")
        region_sub_type = ElectionSubType.objects.get(
            election_subtype="r", election_type=naw_election_type)
        naw_org = Organisation.objects.create(
            official_identifier="naw",
            organisation_type="naw",
            official_name="naw",
            slug="naw",
            territory_code="WLS",
            election_name="National Assembly for Wales elections",
            start_date=date(2016, 10, 1),
        )
        ElectedRole.objects.create(
            election_type=naw_election_type,
            organisation=naw_org,
            elected_title="Assembly Member",
            elected_role_name="Assembly Member for Foo",
        )
        constituency_div = OrganisationDivisionFactory(
            organisation=naw_org,
            name="Test Div",
            slug="test-div",
            division_election_sub_type="c",
        )
        builder = (ElectionBuilder("naw", "2017-06-08").with_organisation(
            naw_org).with_subtype(region_sub_type))

        # constituency_div is a constituency
        # but this builder object expects a region
        with self.assertRaises(OrganisationDivision.ValidationError):
            builder.with_division(constituency_div)
コード例 #8
0
 def test_import_div_geog_exists(self):
     cmd = ConcreteOsniCommand()
     div = OrganisationDivisionFactory()
     DivisionGeographyFactory(division=div, source="unknown")
     cmd.import_div_geography(div, fake_record)
     self.assertEqual(fake_record["geometry"], div.geography.geography)
     self.assertEqual(cmd.source, div.geography.source)
コード例 #9
0
def test_division_set_by_date(db):
    """
    Test that we can get a division set by a given date
    """

    END_DATE = "2025-05-03"
    FUTURE_DATE = "2025-05-05"

    ds = OrganisationDivisionSetFactory(end_date=END_DATE)

    for i in range(10):
        org_div = OrganisationDivisionFactory(divisionset=ds)

    org = org_div.organisation
    ElectedRoleFactory(organisation=org)

    def _make_ids_for_date(date):
        x = ElectionBuilder("local", date)
        x.with_organisation(org)
        x.with_division(org_div)
        return x

    assert _make_ids_for_date(END_DATE)

    with pytest.raises(ValueError) as excinfo:
        _make_ids_for_date(FUTURE_DATE)
    assert "DivisionSet end date before election date" in str(excinfo.value)
コード例 #10
0
 def test_import_div_doesnt_exist(self):
     cmd = ConcreteOsniCommand()
     div = OrganisationDivisionFactory()
     cmd.import_div_geography(div, fake_record)
     dg = DivisionGeography.objects.all().get(division_id=div.id)
     self.assertEqual(fake_record["geometry"], dg.geography)
     self.assertEqual(cmd.source, dg.source)
コード例 #11
0
ファイル: test_admin.py プロジェクト: chris48s/EveryElection
 def test_no_gss_code(self):
     div = OrganisationDivisionFactory()
     dg = DivisionGeographyFactory(division=div)
     dg.source = 'this is totally fine'
     dg.save()
     self.assertEqual(len(DivisionProblem.objects.all()), 1)
     problem = DivisionProblem.objects.all()[0]
     self.assertTrue(problem.no_gss_code)
     self.assertFalse(problem.no_geography)
     self.assertFalse(problem.invalid_source)
     self.assertEqual('No GSS code', problem.problem_text)
コード例 #12
0
    def test_creates_ids_two_orgs(self):
        org2 = Organisation.objects.create(
            official_identifier='TEST2',
            organisation_type='local-authority',
            official_name="Test Council 2",
            slug="test2",
            territory_code="ENG",
            election_name="Test Council 2 local elections",
            start_date=date(2016, 10, 1),
        )
        ElectedRole.objects.create(
            election_type=self.election_type1,
            organisation=org2,
            elected_title="Local Councillor",
            elected_role_name="Councillor for Test Council 2",
        )
        div3 = OrganisationDivisionFactory(
            organisation=org2,
            name="Test Div 3",
            slug="test-div-3"
        )

        all_data = self.base_data
        all_data['election_organisation'] = [self.org1, org2]
        all_data.update({
            self.make_div_id(): 'contested',
            self.make_div_id(org=org2, div=div3): 'contested',
        })
        expected_ids = [
            'local.'+self.date_str,
            'local.test.'+self.date_str,
            'local.test2.'+self.date_str,
            'local.test.test-div.'+self.date_str,
            'local.test2.test-div-3.'+self.date_str,
        ]
        expected_titles = [
            'Local elections',
            'Test Council local elections',
            'Test Council 2 local elections',
            'Test Council local elections Test Div 1',
            'Test Council 2 local elections Test Div 3',
        ]

        self.run_test_with_data(
            all_data,
            expected_ids,
            expected_titles
        )
コード例 #13
0
    def test_creates_ids_two_orgs(self):
        org2 = Organisation.objects.create(
            official_identifier="TEST2",
            organisation_type="local-authority",
            official_name="Test Council 2",
            slug="test2",
            territory_code="ENG",
            election_name="Test Council 2 local elections",
            start_date=date(2016, 10, 1),
        )
        ElectedRole.objects.create(
            election_type=self.election_type1,
            organisation=org2,
            elected_title="Local Councillor",
            elected_role_name="Councillor for Test Council 2",
        )
        div_set2 = OrganisationDivisionSetFactory(organisation=org2)
        div3 = OrganisationDivisionFactory(
            divisionset=div_set2, name="Test Div 3", slug="test-div-3"
        )

        all_data = self.base_data
        all_data["election_organisation"] = [self.org1, org2]
        all_data.update(
            {
                self.make_div_id(): "contested",
                self.make_div_id(org=org2, div=div3): "contested",
            }
        )
        expected_ids = [
            "local." + self.date_str,
            "local.test." + self.date_str,
            "local.test2." + self.date_str,
            "local.test.test-div." + self.date_str,
            "local.test2.test-div-3." + self.date_str,
        ]
        expected_titles = [
            "Local elections",
            "Test Council local elections",
            "Test Council 2 local elections",
            "Test Council local elections Test Div 1",
            "Test Council 2 local elections Test Div 3",
        ]

        self.run_test_with_data(all_data, expected_ids, expected_titles)
コード例 #14
0
 def test_format_geography_valid(self):
     self.assertEqual(
         'https://mapit.mysociety.org/code/gss/X01000001',
         OrganisationDivisionFactory(
             official_identifier='gss:X01000001').format_geography_link())
コード例 #15
0
 def test_format_geography_not_gss(self):
     self.assertIsNone(
         OrganisationDivisionFactory(
             official_identifier='foo:X01000001').format_geography_link())
コード例 #16
0
 def test_format_geography_empty(self):
     self.assertIsNone(
         OrganisationDivisionFactory(
             official_identifier='').format_geography_link())
コード例 #17
0
    def test_all_expected_fields_returned(self):
        org = OrganisationFactory()
        org_div = OrganisationDivisionFactory(organisation=org,
                                              territory_code="ENG")
        ElectionFactory(group=None, organisation=org, division=org_div)

        resp = self.client.get("/api/elections/")

        assert resp.json() == json.loads("""
        {
            "next": null,
            "previous": null,
            "results": [
                {
                    "group_type": null,
                    "current": false,
                    "poll_open_date": "2017-03-23",
                    "election_id": "local.place-name-0.2017-03-23",
                    "group": null,
                    "division": {
                        "name": "Division 0",
                        "slug": "0",
                        "geography_curie": "test:0",
                        "divisionset": {
                            "start_date": "2017-05-04",
                            "legislation_url": "https://example.com/the-law",
                            "short_title": "Made up boundary changes",
                            "notes": "This is just for testing.",
                            "end_date": "2025-05-03",
                            "consultation_url": "https://example.com/consultation",
                            "mapit_generation_id": ""
                        },
                        "mapit_generation_high": null,
                        "seats_total": null,
                        "division_election_sub_type": "",
                        "division_subtype": "",
                        "mapit_generation_low": null,
                        "division_type": "test",
                        "official_identifier": "0",
                        "territory_code": "ENG"
                    },
                    "election_type": {
                        "name": "Local elections",
                        "election_type": "local"
                    },
                    "explanation": null,
                    "voting_system": {
                        "slug": "",
                        "name": "",
                        "uses_party_lists": false
                    },
                    "children": [],
                    "election_subtype": null,
                    "organisation": {
                        "slug": "org-0",
                        "territory_code": "ENG",
                        "organisation_subtype": "",
                        "common_name": "Organisation 0",
                        "official_name": "The Organisation 0 Council",
                        "organisation_type": "local-authority",
                        "election_name": "",
                        "official_identifier": "0",
                        "gss": "E000000"
                    },
                    "election_title": "Election 0",
                    "elected_role": "Councillor",
                    "seats_contested": 1,
                    "tmp_election_id": null,
                    "metadata": null
                }
            ],
            "count": 1
        }
        """)
コード例 #18
0
 def test_format_geography_invalid(self):
     self.assertIsNone(
         OrganisationDivisionFactory(
             official_identifier="foo").format_geography_link())
コード例 #19
0
    def test_creates_naw_id(self):
        naw_org = Organisation.objects.create(
            official_identifier="naw",
            organisation_type="naw",
            official_name="naw",
            slug="naw",
            territory_code="WLS",
            election_name="National Assembly for Wales elections",
            start_date=date(2016, 10, 1),
        )
        naw_election_type = ElectionType.objects.get(election_type="naw")
        naw_election_sub_type_c = ElectionSubType.objects.get(
            election_subtype="c", election_type=naw_election_type
        )
        naw_election_sub_type_r = ElectionSubType.objects.get(
            election_subtype="r", election_type=naw_election_type
        )
        ElectedRole.objects.create(
            election_type=naw_election_type,
            organisation=naw_org,
            elected_title="Assembly Member",
            elected_role_name="Assembly Member for Foo",
        )
        naw_div_set = OrganisationDivisionSetFactory(organisation=naw_org)
        org_div_3 = OrganisationDivisionFactory(
            divisionset=naw_div_set,
            name="Test Div 3",
            slug="test-div-3",
            division_election_sub_type="c",
        )
        org_div_4 = OrganisationDivisionFactory(
            divisionset=naw_div_set,
            name="Test Div 4",
            slug="test-div-4",
            division_election_sub_type="c",
        )
        org_div_5 = OrganisationDivisionFactory(
            divisionset=naw_div_set,
            name="Test Div 5",
            slug="test-div-5",
            division_election_sub_type="r",
        )

        all_data = {
            "election_organisation": [naw_org],
            "election_type": naw_election_type,
            "election_subtype": [naw_election_sub_type_c, naw_election_sub_type_r],
            "date": self.date,
        }

        all_data.update(
            {
                self.make_div_id(
                    org=naw_org, div=org_div_3, subtype="c"
                ): "contested",  # contested seat
                self.make_div_id(
                    org=naw_org, div=org_div_4, subtype="c"
                ): "by_election",  # by election
                self.make_div_id(org=naw_org, div=org_div_5, subtype="r"): "contested",
            }
        )

        expected_ids = [
            "naw." + self.date_str,
            "naw.c." + self.date_str,
            "naw.r." + self.date_str,
            "naw.c.test-div-3." + self.date_str,  # no 'by' suffix
            "naw.c.test-div-4.by." + self.date_str,  # 'by' suffix
            "naw.r.test-div-5." + self.date_str,
        ]
        expected_titles = [
            "National Assembly for Wales elections",
            "National Assembly for Wales elections (Constituencies)",
            "National Assembly for Wales elections (Regions)",
            "National Assembly for Wales elections (Constituencies) Test Div 3",
            "National Assembly for Wales elections (Constituencies) Test Div 4 by-election",
            "National Assembly for Wales elections (Regions) Test Div 5",
        ]

        self.run_test_with_data(
            all_data,
            expected_ids,
            expected_titles,
            subtypes=[naw_election_sub_type_c, naw_election_sub_type_r],
        )
コード例 #20
0
    def test_all_expected_fields_returned(self):

        OrganisationFactory.reset_sequence(0)
        OrganisationDivisionFactory.reset_sequence(0)
        org = OrganisationFactory()
        org_div = OrganisationDivisionFactory(organisation=org,
                                              territory_code="ENG")
        ElectionWithStatusFactory(group=None,
                                  organisation=org,
                                  division=org_div)

        self.expected_object = json.loads("""
        {
            "group_type": null,
            "identifier_type": "ballot",
            "current": false,
            "poll_open_date": "2017-03-23",
            "election_id": "local.place-name-0.2017-03-23",
            "group": null,
            "division": {
                "name": "Division 0",
                "slug": "0",
                "divisionset": {
                    "start_date": "2017-05-04",
                    "legislation_url": "https://example.com/the-law",
                    "short_title": "Made up boundary changes",
                    "notes": "This is just for testing.",
                    "end_date": "2025-05-03",
                    "consultation_url": "https://example.com/consultation"
                },
                "seats_total": null,
                "division_election_sub_type": "",
                "division_subtype": "",
                "division_type": "test",
                "official_identifier": "0",
                "territory_code": "ENG"
            },
            "election_type": {
                "name": "Local elections",
                "election_type": "local"
            },
            "explanation": null,
            "voting_system": {
                "slug": "",
                "name": "",
                "uses_party_lists": false
            },
            "children": [],
            "election_subtype": null,
            "organisation": {
                "url": "http://testserver/api/organisations/local-authority/0/2016-10-01/",
                "slug": "org-0",
                "territory_code": "ENG",
                "organisation_subtype": "",
                "common_name": "Organisation 0",
                "official_name": "The Organisation 0 Council",
                "organisation_type": "local-authority",
                "election_name": "",
                "official_identifier": "0",
                "start_date": "2016-10-01",
                "end_date": null
            },
            "election_title": "Election 0",
            "elected_role": "Councillor",
            "seats_contested": 1,
            "tmp_election_id": null,
            "metadata": null,
            "deleted": false,
            "cancelled": false,
            "replaces": null,
            "replaced_by": null
        }
        """)

        resp = self.client.get("/api/elections/")
        data = resp.json()
        self.assertEqual(data["results"][0], self.expected_object)

        resp = self.client.get("/api/elections/local.place-name-0.2017-03-23/")
        data = resp.json()
        self.assertEqual(data, self.expected_object)

        resp = self.client.get(
            "/api/elections/local.place-name-0.2017-03-23/geo/",
            content_type="application/json",
        )
        data = resp.json()
        self.assertEqual(data["properties"], self.expected_object)
コード例 #21
0
 def test_organisation_division_factory(self):
     od = OrganisationDivisionFactory()
     assert od.organisation.slug.startswith("org-")
     assert od.geography_curie == od.official_identifier
コード例 #22
0
    def test_creates_naw_id(self):
        naw_org = Organisation.objects.create(
            official_identifier='naw',
            organisation_type='naw',
            official_name="naw",
            gss="W20000001",
            slug="naw",
            territory_code="WLS",
            election_name="National Assembly for Wales elections",
        )
        naw_election_type = ElectionType.objects.get(election_type='naw', )
        naw_election_sub_type = ElectionSubType.objects.get(
            election_subtype='c',
            election_type=naw_election_type,
        )
        ElectedRole.objects.create(
            election_type=naw_election_type,
            organisation=naw_org,
            elected_title="Assembly Member",
            elected_role_name="Assembly Member for Foo",
        )
        org_div_3 = OrganisationDivisionFactory(organisation=naw_org,
                                                name="Test Div 3",
                                                slug="test-div-3")
        org_div_4 = OrganisationDivisionFactory(organisation=naw_org,
                                                name="Test Div 4",
                                                slug="test-div-4")

        all_data = {
            'election_organisation': [
                naw_org,
            ],
            'election_type': naw_election_type,
            'election_subtype': [
                naw_election_sub_type,
            ],
            'date': self.date,
        }

        all_data.update({
            self.make_div_id(org=naw_org, div=org_div_3):
            'contested',  # contested seat
            self.make_div_id(org=naw_org, div=org_div_4):
            'by_election',  # by election
        })

        expected_ids = [
            'naw.' + self.date_str,
            'naw.c.' + self.date_str,
            'naw.c.test-div-3.' + self.date_str,  # no 'by' suffix
            'naw.c.test-div-4.by.' + self.date_str,  # 'by' suffix
        ]
        expected_titles = [
            'National Assembly for Wales elections',
            'National Assembly for Wales elections (Constituencies)',
            'Test Div 3 (Constituencies)',
            'Test Div 4 (Constituencies) by-election',
        ]

        self.run_test_with_data(all_data,
                                expected_ids,
                                expected_titles,
                                subtypes=[
                                    naw_election_sub_type,
                                ])
コード例 #23
0
ファイル: test_factories.py プロジェクト: pmk01/EveryElection
 def test_organisation_division_factory(self):
     od = OrganisationDivisionFactory()
     assert od.organisation.slug.startswith("org-")
コード例 #24
0
 def test_organisation_division_factory(self):
     od = OrganisationDivisionFactory()
     assert od.organisation.slug.startswith("org-")
     assert od.geography_curie.startswith("test:")
コード例 #25
0
    def test_get_seats_contested(self):
        sp_election_type = ElectionType.objects.get(election_type="sp")
        region_sub_type = ElectionSubType.objects.get(
            election_subtype="r", election_type=sp_election_type
        )
        constituency_sub_type = ElectionSubType.objects.get(
            election_subtype="c", election_type=sp_election_type
        )
        sp_org = Organisation.objects.create(
            official_identifier="sp",
            organisation_type="sp",
            official_name="Scottish Parliament",
            slug="sp",
            election_name="Scottish parliament election",
            territory_code="SCT",
            start_date=date(1999, 5, 6),
        )

        ElectedRole.objects.create(
            election_type=sp_election_type,
            organisation=sp_org,
            elected_title="Member of the Scottish Parliament",
            elected_role_name="Member of the Scottish Parliament",
        )

        sp_div_set = OrganisationDivisionSetFactory(organisation=sp_org)

        sp_r_div = OrganisationDivisionFactory(
            divisionset=sp_div_set,
            name="sp Div 1",
            slug="sp-div-1",
            seats_total=7,
            division_election_sub_type="r",
        )
        sp_c_div = OrganisationDivisionFactory(
            divisionset=sp_div_set,
            name="sp Div 2",
            slug="sp-div-2",
            division_election_sub_type="c",
        )

        builder_1 = (
            ElectionBuilder("sp", "2021-5-06")
            .with_organisation(sp_org)
            .with_division(sp_r_div)
            .with_subtype(region_sub_type)
        )
        builder_2 = (
            ElectionBuilder("sp", "2021-5-06")
            .with_organisation(sp_org)
            .with_division(sp_c_div)
            .with_subtype(constituency_sub_type)
        )

        ballot_1 = builder_1.build_ballot(None)
        ballot_1.save()

        ballot_2 = builder_2.build_ballot(None)
        ballot_2.save()

        self.assertEqual(7, ballot_1.seats_contested)
        self.assertEqual(1, ballot_2.seats_contested)