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,
}
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,
}
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
)
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)
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
}
""")
def test_organisation_division_factory(self):
od = OrganisationDivisionFactory()
assert od.organisation.slug.startswith("org-")
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)
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,
])
def test_format_geography_not_gss(self):
self.assertIsNone(
OrganisationDivisionFactory(
official_identifier='foo:X01000001').format_geography_link())
def test_organisation_division_factory(self):
od = OrganisationDivisionFactory()
assert od.organisation.slug.startswith("org-")
assert od.geography_curie == od.official_identifier
def test_format_geography_empty(self):
self.assertIsNone(
OrganisationDivisionFactory(
official_identifier='').format_geography_link())
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)
def test_format_geography_valid(self):
self.assertEqual(
'https://mapit.mysociety.org/code/gss/X01000001',
OrganisationDivisionFactory(
official_identifier='gss:X01000001').format_geography_link())
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],
)
def test_organisation_division_factory(self):
od = OrganisationDivisionFactory()
assert od.organisation.slug.startswith("org-")
assert od.geography_curie.startswith("test:")
def test_format_geography_invalid(self):
self.assertIsNone(
OrganisationDivisionFactory(
official_identifier="foo").format_geography_link())