def test_set_encompassing_city_exists(self):
city = Location(name="Wixom").save()
city.encompassed_by.connect(self.state)
self.state.encompasses.connect(city)
res = self.address.set_encompassing()
self.assertTrue(res.encompassed_by.is_connected(city))
city.delete()
def test_google_places_city_without_state(self, m):
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
url = "https://maps.googleapis.com/maps/api/" \
"place/details/json?placeid=%s&key=%s" % (
wixom_without_state_data['place_id'],
settings.GOOGLE_MAPS_API_SERVER)
m.get(url, json=wixom_server_response, status_code=status.HTTP_200_OK)
location = parse_google_places(
wixom_without_state_data['address_components'],
wixom_without_state_data['place_id'])
self.assertEqual(location.name, "Wixom")
res, _ = db.cypher_query('MATCH (a:Location '
'{name: "Michigan"}) RETURN a')
state = Location.inflate(res.one)
res, _ = db.cypher_query(
'MATCH (a:Location '
'{name: "United States of America"}) RETURN a')
country = Location.inflate(res.one)
self.assertTrue(state in location.encompassed_by)
self.assertTrue(location in state.encompasses)
self.assertTrue(country in state.encompassed_by)
self.assertTrue(state in country.encompasses)
def test_address_has_no_lat_long(self):
mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
address = Address(state="MI").save()
res = connect_to_state_districts.apply_async(
kwargs={'object_uuid': address.object_uuid})
self.assertFalse(res.result)
mi.delete()
address.delete()
def test_address_has_lat_long_outside_usa(self):
mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
# lat/long of Greenwich UK
address = Address(state="MI", latitude=51.4800,
longitude=0.0000).save()
res = connect_to_state_districts.apply_async(
kwargs={'object_uuid': address.object_uuid})
self.assertTrue(res.result)
mi.delete()
address.delete()
def test_get_full_name_state_senator(self):
self.position.name = "State Senator"
self.position.level = "state_upper"
self.position.save()
state = Location(name="Michigan", level="federal").save()
district = Location(name="38", level="state_upper").save()
state.encompasses.connect(district)
district.encompassed_by.connect(state)
self.position.location.connect(district)
res = Position.get_full_name(self.position.object_uuid)
self.assertEqual(res['full_name'], "State Senator for Michigan's "
"38th district")
def test_get_full_name_state_house_rep(self):
self.position.name = "State House Representative"
self.position.level = "state_lower"
self.position.save()
state = Location(name="Michigan", level="federal").save()
district = Location(name="15", level="state_lower").save()
state.encompasses.connect(district)
district.encompassed_by.connect(state)
self.position.location.connect(district)
res = Position.get_full_name(self.position.object_uuid)
self.assertEqual(
res['full_name'], "State House Representative"
" for Michigan's 15th district")
def update_address_location(object_uuid):
try:
address = Address.nodes.get(object_uuid=object_uuid)
except (DoesNotExist, Address.DoesNotExist, CypherException, IOError,
ClientError) as e:
raise update_address_location.retry(exc=e,
countdown=3,
max_retries=None)
try:
state = us.states.lookup(address.state)
district = address.congressional_district
query = 'MATCH (a:Address {object_uuid:"%s"})-[r:ENCOMPASSED_BY]->' \
'(l:Location) DELETE r' % object_uuid
db.cypher_query(query)
query = 'MATCH (s:Location {name:"%s"})-[:ENCOMPASSES]->' \
'(d:Location {name:"%s", sector:"federal"}) RETURN d' % \
(state, district)
res, _ = db.cypher_query(query)
if res.one is not None:
district = Location.inflate(res.one)
address.encompassed_by.connect(district)
address.set_encompassing()
except (CypherException, IOError, ClientError) as e:
raise update_address_location.retry(exc=e,
countdown=3,
max_retries=None)
return True
def populate_sectors(self):
skip = 0
while True:
query = 'MATCH (location:Location) RETURN location ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for location in [Location.inflate(row[0]) for row in res]:
if not location.sector:
try:
encompassed_by = Location.nodes.get(
object_uuid=location.get_encompassed_by(
location.object_uuid)[0]).name
except (DoesNotExist, Location.DoesNotExist, IndexError):
encompassed_by = None
try:
int(location.name)
location.sector = "federal"
except ValueError:
if location.name == "United States of America":
location.sector = "federal"
location.save()
continue
state = us.states.lookup(location.name)
if state is None:
location.sector = "local"
elif encompassed_by is not None and state is not None \
and encompassed_by != \
"United States of America":
location.sector = "local"
else:
location.sector = "federal"
location.save()
def test_get_full_name_senator(self):
self.position.name = "Senator"
self.position.level = "federal"
self.position.save()
state = Location(name="Michigan", level="federal").save()
self.position.location.connect(state)
res = Position.get_full_name(self.position.object_uuid)
self.assertEqual(res['full_name'], "Senator of Michigan")
def get_location(self):
from sb_locations.neo_models import Location
query = 'MATCH (a:Mission {object_uuid: "%s"})' \
'-[:WITHIN]->(b:Location) RETURN b' % self.object_uuid
res, _ = db.cypher_query(query)
if res.one:
return Location.inflate(res.one)
else:
return None
def setUp(self):
settings.CELERY_ALWAYS_EAGER = True
query = "MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r"
db.cypher_query(query)
cache.clear()
self.unit_under_test_name = 'quest'
self.email = "*****@*****.**"
self.pleb = create_user_util_test(self.email)
self.user = User.objects.get(email=self.email)
self.url = "http://testserver"
self.quest = Quest(about='Test Bio',
owner_username=self.pleb.username).save()
self.quest.editors.connect(self.pleb)
self.quest.moderators.connect(self.pleb)
self.usa = Location(name="United States of America").save()
self.michigan = Location(name="Michigan").save()
self.d11 = Location(name="11", sector="federal").save()
self.usa.encompasses.connect(self.michigan)
self.michigan.encompassed_by.connect(self.usa)
self.michigan.encompasses.connect(self.d11)
self.d11.encompassed_by.connect(self.michigan)
self.address = Address(street="125 Glenwood Drive",
city="Walled Lake",
state="Michigan",
postal_code="48390",
country="USA",
county="Oakland",
congressional_district=11,
validated=True).save()
self.address.encompassed_by.connect(self.d11)
self.quest.address.connect(self.address)
cache.clear()
self.stripe = stripe
self.stripe.api_key = settings.STRIPE_SECRET_KEY
stripe.api_version = settings.STRIPE_API_VERSION
self.mission = Mission(owner_username=self.pleb.username,
title=str(uuid1()),
focus_name="advocacy",
location_name="11").save()
self.mission.location.connect(self.d11)
self.quest.missions.connect(self.mission)
self.email2 = "*****@*****.**"
self.pleb2 = create_user_util_test(self.email2)
self.user2 = User.objects.get(email=self.email2)
def test_google_places_city(self):
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
location = parse_google_places(wixom_data['address_components'],
wixom_data['place_id'])
self.assertEqual(location.name, "Wixom")
res, _ = db.cypher_query('MATCH (a:Location '
'{name: "Michigan"}) RETURN a')
state = Location.inflate(res.one)
res, _ = db.cypher_query(
'MATCH (a:Location '
'{name: "United States of America"}) RETURN a')
country = Location.inflate(res.one)
self.assertTrue(state in location.encompassed_by)
self.assertTrue(location in state.encompasses)
self.assertTrue(country in state.encompassed_by)
self.assertTrue(state in country.encompasses)
def test_google_places_country_already_exists(self):
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
old_location = Location(name="United States of America").save()
location = parse_google_places(us_data['address_components'],
us_data['place_id'])
self.assertEqual(location.name, "United States of America")
self.assertIsInstance(location, Location)
self.assertEqual(old_location.object_uuid, location.object_uuid)
def setUp(self):
self.address = Address(city="Wixom", state="MI").save()
try:
Location.nodes.get(name="Wixom").delete()
except (Location.DoesNotExist, DoesNotExist):
pass
except MultipleNodesReturned:
query = 'MATCH (a:Location {name:"Wixom"}) RETURN a'
res, _ = db.cypher_query(query)
for location in res[0]:
Location.inflate(location).delete()
try:
self.state = Location.nodes.get(name="Michigan")
except MultipleNodesReturned:
query = 'MATCH (a:Location {name:"Michigan"}) RETURN a'
res, _ = db.cypher_query(query)
for location in res[0]:
Location.inflate(location).delete()
except (Location.DoesNotExist, DoesNotExist):
self.state = Location(name="Michigan").save()
def test_google_places_city_already_exists(self):
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
old_country = Location(name="United States of America").save()
old_state = Location(name="Michigan").save()
old_city = Location(name="Wixom").save()
old_country.encompasses.connect(old_state)
old_state.encompassed_by.connect(old_country)
old_state.encompasses.connect(old_city)
old_city.encompassed_by.connect(old_state)
location = parse_google_places(wixom_data['address_components'],
wixom_data['place_id'])
self.assertEqual(location.name, "Wixom")
self.assertIsInstance(location, Location)
self.assertEqual(old_city.object_uuid, location.object_uuid)
self.assertTrue(old_state in location.encompassed_by)
self.assertTrue(location in old_state.encompasses)
def add_addresses_to_locations(self):
for address in Address.nodes.all():
if not address.encompassed_by.all():
state = us.states.lookup(address.state)
district = address.congressional_district
query = 'MATCH (s:Location {name:"%s"})-[:ENCOMPASSES]->' \
'(d:Location {name:"%s"}) RETURN d' % \
(state, district)
res, _ = db.cypher_query(query)
district = Location.inflate(res[0][0])
address.encompassed_by.connect(district)
def set_encompassing(self):
from .tasks import connect_to_state_districts
try:
encompassed_by = Location.nodes.get(name=self.city)
if Location.get_single_encompassed_by(
encompassed_by.object_uuid) != \
us.states.lookup(self.state).name:
# if a location node exists with an incorrect encompassing
# state
raise DoesNotExist("This Location does not exist")
except (Location.DoesNotExist, DoesNotExist):
encompassed_by = Location(name=self.city, sector="local").save()
try:
city_encompassed = Location.nodes.get(
name=us.states.lookup(self.state).name)
except (Location.DoesNotExist, DoesNotExist):
city_encompassed = Location(name=us.states.lookup(
self.state).name,
sector="federal").save()
if city_encompassed not in encompassed_by.encompassed_by:
encompassed_by.encompassed_by.connect(city_encompassed)
if encompassed_by not in city_encompassed.encompasses:
city_encompassed.encompasses.connect(encompassed_by)
except (MultipleNodesReturned, Exception):
query = 'MATCH (l1:Location {name:"%s"})-[:ENCOMPASSED_BY]->' \
'(l2:Location {name:"%s"}) RETURN l1' % \
(self.city, self.state)
res, _ = db.cypher_query(query)
if res.one is not None:
encompassed_by = Location.inflate(res.one)
else:
encompassed_by = None
if encompassed_by is not None:
if encompassed_by not in self.encompassed_by:
self.encompassed_by.connect(encompassed_by)
# get or create the state level districts and attach them to the
# address
spawn_task(task_func=connect_to_state_districts,
task_param={'object_uuid': self.object_uuid})
return self
def test_multiple_cities_same_name(self):
address = Address(city="Redford", state="Michigan").save()
city = Location(name="Redford").save()
city2 = Location(name="Redford").save()
try:
new_state = Location.nodes.get(name="Washington")
except (Location.DoesNotExist, DoesNotExist):
new_state = Location(name="Washington").save()
self.state.encompasses.connect(city)
city.encompassed_by.connect(self.state)
city2.encompassed_by.connect(new_state)
new_state.encompasses.connect(city2)
res = address.set_encompassing()
self.assertTrue(res.encompassed_by.is_connected(city))
city.delete()
city2.delete()
address.delete()
def connect_to_state_districts(object_uuid):
try:
address = Address.nodes.get(object_uuid=object_uuid)
except (DoesNotExist, Address.DoesNotExist, CypherException, IOError,
ClientError) as e:
raise connect_to_state_districts.retry(exc=e,
countdown=3,
max_retries=None)
try:
lookup_url = settings.OPENSTATES_DISTRICT_SEARCH_URL % \
(address.latitude, address.longitude) \
+ "&apikey=53f7bd2a41df42c082bb2f07bd38e6aa"
except TypeError:
# in case an address doesn't have a latitude or longitude
return False
response = requests.get(
lookup_url, headers={"content-type": 'application/json; charset=utf8'})
response_json = response.json()
try:
for rep in response_json:
try:
sector = 'state_%s' % rep['chamber']
query = 'MATCH (l:Location {name: "%s", sector:"federal"})-' \
'[:ENCOMPASSES]->(district:Location {name:"%s", ' \
'sector:"%s"}) RETURN district ' % \
(us.states.lookup(address.state).name,
rep['district'], sector)
res, _ = db.cypher_query(query)
except KeyError:
return False
try:
res = res[0]
except IndexError as e:
raise connect_to_state_districts.retry(exc=e,
countdown=3,
max_retries=None)
try:
state_district = Location.inflate(res.district)
except (CypherException, ClientError, IOError,
CouldNotCommit) as e:
raise connect_to_state_districts.retry(exc=e,
countdown=3,
max_retries=None)
if state_district not in address.encompassed_by:
address.encompassed_by.connect(state_district)
spawn_task(task_func=create_and_attach_state_level_reps,
task_param={"rep_data": response_json})
return True
except (CypherException, IOError, ClientError, CouldNotCommit) as e:
raise connect_to_state_districts.retry(exc=e,
countdown=3,
max_retries=None)
def test_update_with_matching_location(self):
settings.CELERY_ALWAYS_EAGER = True
self.client.force_authenticate(user=self.user)
url = reverse('address-detail',
kwargs={'object_uuid': self.address.object_uuid})
state = Location(name="Michigan").save()
district = Location(name="10", sector="federal").save()
state.encompasses.connect(district)
district.encompassed_by.connect(state)
data = {
'city': "Walled Lake",
'longitude': -83.48016,
'state': "MI",
'street': "300 Eagle Pond Dr.",
'postal_code': "48390-3071",
'congressional_district': "10",
'latitude': 42.54083
}
response = self.client.put(url, data=data, format='json')
settings.CELERY_ALWAYS_EAGER = False
address = Address.nodes.get(object_uuid=response.data['id'])
self.assertIn(district, address.encompassed_by)
def test_google_places_state(self):
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
location = parse_google_places(quebec_data['address_components'],
quebec_data['place_id'])
self.assertEqual(location.name, "Quebec")
res, _ = db.cypher_query('MATCH (a:Location '
'{name: "Canada"}) RETURN a')
country = Location.inflate(res.one)
self.assertTrue(country in location.encompassed_by)
self.assertTrue(location in country.encompasses)
def setUp(self):
self.unit_under_test_name = 'location'
self.email = "*****@*****.**"
create_user_util_test(self.email)
self.pleb = Pleb.nodes.get(email=self.email)
self.user = User.objects.get(email=self.email)
self.url = "http://testserver"
query = 'MATCH (a:Position) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
query = 'MATCH (a:Location) OPTIONAL MATCH (a)-[r]-() DELETE a, r'
db.cypher_query(query)
self.location = Location(name="Michigan").save()
self.city = Location(name="Walled Lake").save()
self.senator = Position(name="Senator").save()
self.house_rep = Position(name="House Rep").save()
self.school = Position(name="School Board", level="local").save()
self.location.encompasses.connect(self.city)
self.city.encompassed_by.connect(self.location)
self.senator.location.connect(self.location)
self.house_rep.location.connect(self.location)
self.school.location.connect(self.city)
cache.clear()
def setUp(self):
settings.CELERY_ALWAYS_EAGER = True
self.email = "*****@*****.**"
self.pleb = create_user_util_test(self.email)
self.user = User.objects.get(email=self.email)
self.headers = {"content-type": 'application/json; charset=utf8'}
with open("sb_public_official/tests/michigan_reps.json") as json_file:
self.json_data = json.load(json_file)
self.mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
self.lower = Location(name='38', sector='state_lower').save()
self.upper = Location(name='15', sector='state_upper').save()
self.mi.encompasses.connect(self.lower)
self.lower.encompassed_by.connect(self.mi)
self.mi.encompasses.connect(self.upper)
self.upper.encompassed_by.connect(self.mi)
self.lower_pos = Position().save()
self.lower_pos.location.connect(self.lower)
self.upper_pos = Position().save()
self.upper_pos.location.connect(self.upper)
def populate_location_data(self):
try:
usa = Location.nodes.get(name='United States of America')
except (DoesNotExist, Location.DoesNotExist):
usa = Location(name="United States of America").save()
query = 'MATCH (a:Location {object_uuid: "%s"})-' \
'[:POSITIONS_AVAILABLE]->' \
'(p:Position) RETURN p.name' % usa.object_uuid
res, _ = db.cypher_query(query)
positions = [row[0] for row in res]
if "President" not in positions:
pres = Position(name="President").save()
pres.location.connect(usa)
for root, dirs, files in \
os.walk('sb_locations/management/commands/states/'):
if not dirs:
_, state = root.split("states/")
state_name = us.states.lookup(state).name
with open(root + "/" + files[0]) as geo_data:
file_data = loads(geo_data.read())
try:
state = Location.nodes.get(name=state_name)
except (DoesNotExist, Location.DoesNotExist):
state = Location(name=state_name,
geo_data=dumps(
file_data['coordinates'])).save()
except MultipleNodesReturned:
continue
usa.encompasses.connect(state)
state.encompassed_by.connect(usa)
query = 'MATCH (a:Location {object_uuid: "%s"})-' \
'[:POSITIONS_AVAILABLE]->' \
'(p:Position) RETURN p.name' % state.object_uuid
res, _ = db.cypher_query(query)
positions = [row[0] for row in res]
if "Senator" not in positions:
senator = Position(name='Senator').save()
senator.location.connect(state)
for root, dirs, files in \
os.walk('sb_locations/management/commands/districts/'):
try:
if files[0] != '.DS_Store':
_, district_data = root.split('districts/')
state, district = district_data.split('-')
if not int(district):
district = 1
try:
state_node = Location.nodes.get(
name=us.states.lookup(state).name)
except MultipleNodesReturned:
continue
with open(root + "/shape.geojson") as geo_data:
file_data = loads(geo_data.read())
query = 'MATCH (l:Location {name:"%s"})-' \
'[:ENCOMPASSES]->(d:Location {name:"%s"}) ' \
'RETURN d' % \
(state_node.name, district)
res, _ = db.cypher_query(query)
if not res:
district = Location(
name=int(district),
geo_data=dumps(
file_data['coordinates'])).save()
district.encompassed_by.connect(state_node)
usa.encompasses.connect(district)
state_node.encompasses.connect(district)
query = 'MATCH (a:Location {object_uuid: "%s"})-' \
'[:POSITIONS_AVAILABLE]->' \
'(p:Position) ' \
'RETURN p.name' % district.object_uuid
res, _ = db.cypher_query(query)
positions = [row[0] for row in res]
if "House Representative" not in positions:
house_rep = Position(
name="House Representative").save()
house_rep.location.connect(district)
except IndexError:
pass
return True
def test_create_state_districts_already_exist(self):
mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
address = Address(state="MI", latitude=42.532020,
longitude=-83.496500).save()
upper = Location(name="15", sector="state_upper").save()
lower = Location(name="38", sector="state_lower").save()
address.encompassed_by.connect(lower)
address.encompassed_by.connect(upper)
mi.encompasses.connect(upper)
upper.encompassed_by.connect(mi)
mi.encompasses.connect(lower)
lower.encompassed_by.connect(mi)
res = connect_to_state_districts.apply_async(
kwargs={'object_uuid': address.object_uuid})
self.assertTrue(res.result)
query = 'MATCH (l:Location {name:"38", sector:"state_lower"}), ' \
'(l2:Location {name:"15", sector:"state_upper"}) RETURN l, l2'
res, _ = db.cypher_query(query)
lower = Location.inflate(res[0].l)
upper = Location.inflate(res[0].l2)
self.assertTrue(lower in address.encompassed_by)
self.assertTrue(upper in address.encompassed_by)
res = connect_to_state_districts.apply_async(
kwargs={'object_uuid': address.object_uuid})
self.assertTrue(res.result)
query = 'MATCH (l:Location {name:"38", sector:"state_lower"}), ' \
'(l2:Location {name:"15", sector:"state_upper"}) RETURN l, l2'
res, _ = db.cypher_query(query)
self.assertEqual(len(res[0]), 2) # assert only two nodes returned
self.assertEqual(lower, Location.inflate(res[0].l))
# assert only one lower node
self.assertEqual(upper, Location.inflate(res[0].l2))
# assert only one upper node
mi.delete()
address.delete()
upper.delete()
lower.delete()
def test_create_state_districts(self):
mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
address = Address(state="MI", latitude=42.532020,
longitude=-83.496500).save()
lower = Location(name='38', sector='state_lower').save()
upper = Location(name='15', sector='state_upper').save()
mi.encompasses.connect(lower)
lower.encompassed_by.connect(mi)
mi.encompasses.connect(upper)
upper.encompassed_by.connect(mi)
res = connect_to_state_districts.apply_async(
kwargs={'object_uuid': address.object_uuid})
self.assertTrue(res.result)
self.assertTrue(lower in address.encompassed_by)
self.assertTrue(upper in address.encompassed_by)
mi.delete()
address.delete()
upper.delete()
lower.delete()
def test_get_location(self):
location = Location().save()
self.mission.location.connect(location)
res = self.mission.get_location()
self.assertEqual(res.object_uuid, location.object_uuid)
class TestCreateStateDistricts(TestCase):
def setUp(self):
settings.CELERY_ALWAYS_EAGER = True
self.email = "*****@*****.**"
self.pleb = create_user_util_test(self.email)
self.user = User.objects.get(email=self.email)
self.headers = {"content-type": 'application/json; charset=utf8'}
with open("sb_public_official/tests/michigan_reps.json") as json_file:
self.json_data = json.load(json_file)
self.mi = Location(name=us.states.lookup("MI").name,
sector="federal").save()
self.lower = Location(name='38', sector='state_lower').save()
self.upper = Location(name='15', sector='state_upper').save()
self.mi.encompasses.connect(self.lower)
self.lower.encompassed_by.connect(self.mi)
self.mi.encompasses.connect(self.upper)
self.upper.encompassed_by.connect(self.mi)
self.lower_pos = Position().save()
self.lower_pos.location.connect(self.lower)
self.upper_pos = Position().save()
self.upper_pos.location.connect(self.upper)
def tearDown(self):
settings.CELERY_ALWAYS_EAGER = False
self.mi.delete()
self.lower.delete()
self.upper.delete()
self.upper_pos.delete()
self.lower_pos.delete()
def test_success(self):
res = create_and_attach_state_level_reps.apply_async(
kwargs={'rep_data': self.json_data})
while not res.ready():
time.sleep(1)
self.assertTrue(res.result)
def test_rep_already_exists(self):
try:
official = PublicOfficial.nodes.get(bioguideid="MIL000290")
except (PublicOfficial.DoesNotExist, DoesNotExist):
official = PublicOfficial(bioguideid="MIL000290",
first_name="Kathy",
last_name="Crawford",
state_district="38",
state_chamber="lower",
state="mi").save()
res = create_and_attach_state_level_reps.apply_async(
kwargs={'rep_data': self.json_data})
while not res.ready():
time.sleep(1)
self.assertTrue(res.result)
camp = official.get_quest()
self.assertTrue(camp in official.quest)
official.delete()
camp.delete()
def test_rep_already_has_campaign(self):
try:
official = PublicOfficial.nodes.get(bioguideid="MIL000290")
official.delete()
except (PublicOfficial.DoesNotExist, DoesNotExist):
pass
official = PublicOfficial(bioguideid="MIL000290",
first_name="Kathy",
last_name="Crawford",
state_district="38",
state_chamber="lower",
state="mi").save()
campaign = Quest(first_name=official.first_name,
last_name=official.last_name).save()
official.quest.connect(campaign)
res = create_and_attach_state_level_reps.apply_async(
kwargs={'rep_data': self.json_data})
while not res.ready():
time.sleep(1)
self.assertTrue(res.result)
official.delete()
campaign.delete()
