def test_data_enhance(self, m):
json = {
'input': {
'search_id': 'IL-12568670',
'search_id_type': 'voterbase'
},
'error': None,
'output': output_list,
'output_size': 1,
'match_found': True,
'gateway_id': 'b8c86f27-fb32-11e8-9cc1-45bc340a4d22',
'function_id': 'b8c98093-fb32-11e8-8b25-e99c70f6fe74'
}
expected = [
'vb.tsmart_zip', 'vb.vf_g2014', 'vb.vf_g2016',
'vb.tsmart_middle_name', 'ts.tsmart_midterm_general_turnout_score',
'vb.tsmart_name_suffix', 'vb.voterbase_gender', 'vb.tsmart_city',
'vb.tsmart_full_address', 'vb.voterbase_phone',
'vb.tsmart_partisan_score', 'vb.tsmart_last_name',
'vb.voterbase_id', 'vb.tsmart_first_name', 'vb.voterid',
'vb.voterbase_age', 'vb.tsmart_state',
'vb.voterbase_registration_status'
]
m.get(self.ts.connection.uri + 'person/data-enhance', json=json)
# Assert response is expected structure
self.assertTrue(
validate_list(expected, self.ts.data_enhance('IL-12568678')))
# Assert exception on missing state
with self.assertRaises(Exception):
self.ts.data_enhance('vb0001', search_id_type='votebuilder')
# Assert exception on missing state
with self.assertRaises(Exception):
self.ts.data_enhance('vb0001', search_id_type='smartvan')
# Assert exception on missing state
with self.assertRaises(Exception):
self.ts.data_enhance('vb0001', search_id_type='voter')
# Assert works with state provided
for i in ['votebuilder', 'voter', 'smartvan']:
self.assertTrue(
validate_list(
expected,
self.ts.data_enhance('IL-12568678',
search_id_type=i,
state='IL')))
def test_get_signups(self, m):
json = {'items': [signup], 'nextPageLink': None, 'count': 1}
m.get(self.van.connection.uri + 'signups', json=json)
self.assertTrue(
validate_list(signup_expected,
self.van.get_event_signups(event_id=750001004)))
self.assertTrue(
validate_list(signup_expected,
self.van.get_person_signups(vanid=750000849)))
def test_get_signup_statuses(self, m):
m.get(self.van.connection.uri + 'signups/statuses', json=signup_status)
# Test events lookup
self.assertTrue(
validate_list(['statusId', 'name'],
self.van.get_signups_statuses(event_id=750000849)))
# Test event type lookup
self.assertTrue(
validate_list(
['statusId', 'name'],
self.van.get_signups_statuses(event_type_id=750000849)))
def test_get_organizations(self, m):
json = {
"count": 38,
"next": None,
"previous": "https://events.mobilizeamerica.io/api/v1/organizations?updated_since=1543644000",
"data": [
{
"id": 1251,
"name": "Mike Blake for New York City",
"slug": "mikefornyc",
"is_coordinated": 'True',
"is_independent": 'True',
"is_primary_campaign": 'False',
"state": "",
"district": "",
"candidate_name": "",
"race_type": "OTHER_LOCAL",
"event_feed_url": "https://events.mobilizeamerica.io/mikefornyc/",
"created_date": 1545885434,
"modified_date": 1546132256
}
]
}
m.get(self.ma.uri + 'organizations', json=json)
expected = ['id', 'name', 'slug', 'is_coordinated', 'is_independent', 'is_primary_campaign',
'state', 'district', 'candidate_name', 'race_type', 'event_feed_url', 'created_date',
'modified_date']
# Assert response is expected structure
self.assertTrue(validate_list(expected, self.ma.get_organizations()))
def test_radius_search(self, m):
m.get(self.ts.connection.uri + 'person/radius-search',
json=radius_response)
expected = [
'similarity_score', 'distance_km', 'distance_meters',
'distance_miles', 'distance_feet', 'proximity_score',
'composite_score', 'uniqueness_score', 'confidence_indicator',
'ts.tsmart_midterm_general_turnout_score', 'vb.tsmart_city',
'vb.tsmart_first_name', 'vb.tsmart_full_address',
'vb.tsmart_last_name', 'vb.tsmart_middle_name',
'vb.tsmart_name_suffix', 'vb.tsmart_partisan_score',
'vb.tsmart_precinct_id', 'vb.tsmart_precinct_name',
'vb.tsmart_state', 'vb.tsmart_zip', 'vb.tsmart_zip4',
'vb.vf_earliest_registration_date', 'vb.vf_g2014', 'vb.vf_g2016',
'vb.vf_precinct_id', 'vb.vf_precinct_name',
'vb.vf_reg_cass_address_full', 'vb.vf_reg_cass_city',
'vb.vf_reg_cass_state', 'vb.vf_reg_cass_zip',
'vb.vf_reg_cass_zip4', 'vb.vf_registration_date',
'vb.voterbase_age', 'vb.voterbase_gender', 'vb.voterbase_id',
'vb.voterbase_phone', 'vb.voterbase_registration_status',
'vb.voterid'
]
# Assert response is expected structure
def rad_search():
return self.ts.radius_search(
'BILLY',
'Burchard',
radius_size=100,
address='908 N Washtenaw, Chicago, IL')
self.assertTrue(validate_list(expected, rad_search()))
def test_groups(self, m):
xml = ('<?xml version="1.0" encoding="UTF-8"?>'
'<response success="true">'
' <groups>'
' <group id="15084" type="FilteredGroup" status="active">'
' <name>CA California</name>'
' <size>4896</size>'
' </group>'
' <group id="18674" type="UploadedGroup" status="inactive">'
' <name>Capps Callers</name>'
' <size>90</size>'
' </group>'
' <group id="20094" type="UploadedGroup" status="inactive">'
' <name>Lockyer Callers</name>'
' <size>28</size>'
' </group>'
' </groups>'
'</response>')
m.get(self.mc.connection.uri + 'groups', text=xml)
# Expected Structure
expected = ['id', 'type', 'status', 'name', 'size']
self.assertTrue(validate_list(expected, self.mc.groups()))
def test_get_users(self, m):
expected = [
'id', 'first-name', 'middle-name', 'last-name', 'phone', 'email',
'registered-address-street', 'registered-address-street-2',
'registered-address-city', 'registered-address-state',
'registered-address-zip', 'mailing-address-street',
'mailing-address-street-2', 'mailing-address-city',
'mailing-address-state', 'mailing-address-zip', 'dob',
'language-preference', 'hostname', 'referral-code',
'partner-comms-opt-in', 'created-at', 'updated-at',
'voter-registration-status', 'voter-registration-source',
'voter-registration-method', 'voting-method-preference',
'email subscribed', 'sms subscribed'
]
with open(f'{_dir}/users.txt', 'r') as users_text:
# Mock endpoints
m.post(self.tv.uri + 'login', json=fake_token)
m.get(self.tv.uri +
f'partners/{self.tv.subdomain}.turbovote.org/users',
text=users_text.read())
self.assertTrue(validate_list(expected, self.tv.get_users()))
def test_get_scores(self, m):
json = {
u'count':
2,
u'items': [{
u'origin': None,
u'scoreId': 2716,
u'name': u'Democratic Party Support',
u'maxValue': 100.0,
u'minValue': 1.0,
u'state': None,
u'shortName': u'Dem Support',
u'description': None
}],
u'nextPageLink':
None
}
m.get(self.van.connection.uri + 'scores', json=json)
expected = [
'origin', 'scoreId', 'name', 'maxValue', 'minValue', 'state',
'shortName', 'description'
]
self.assertTrue(validate_list(expected, self.van.get_scores()))
def test_get_targets(self, m):
# Create response
json = {
u'count':
2,
u'items': [{
u'targetId': 12827,
u'type': u'TEST CODE',
u'name': u'TEST CODE',
u'description': None,
u'points': 20,
u'areSubgroupsSticky': False,
u'status': u'Active',
u'subgroups': None,
u'markedSubgroup': None
}],
u'nextPageLink':
None
}
m.get(self.van.connection.uri + 'targets', json=json)
# Expected Structure
expected = [
'targetId', 'type', 'name', 'description', 'points',
'areSubgroupsSticky', 'status', 'subgroups', 'markedSubgroup'
]
# Assert response is expected structure
self.assertTrue(validate_list(expected, self.van.get_targets()))
def test_get_survey_questions(self, m):
json = {u'count': 67, u'items': [{
"status": "Active",
"responses": [
{"shortName": "1",
"surveyResponseId": 1288926,
"name": "1-Strong Walz",
"mediumName": "1"},
{"shortName": "2",
"surveyResponseId": 1288928,
"name": "2-Lean Walz",
"mediumName": "2"}],
"scriptQuestion": "Who do you support for Governor?",
"name": "MN Governor Gen",
"surveyQuestionId": 311838,
"mediumName": "MNGovG",
"shortName": "MGG",
"type": "Candidate",
"cycle": 2018
}],
u'nextPageLink': None}
m.get(self.van.connection.uri + 'surveyQuestions', json=json)
expected = ['status', 'responses', 'scriptQuestion', 'name',
'surveyQuestionId', 'mediumName', 'shortName',
'type', 'cycle']
self.assertTrue(validate_list(expected, self.van.get_survey_questions()))
def test_get_tables(self):
tbls_list = self.rs.get_tables(schema=self.temp_schema)
exp = ['schemaname', 'tablename', 'tableowner', 'tablespace', 'hasindexes',
'hasrules', 'hastriggers']
self.assertTrue(validate_list(exp, tbls_list))
def test_campaigns(self, m):
# Create response
xml = (
'<?xml version="1.0" encoding="UTF-8"?>'
'<response success="true">'
' <campaigns>'
' <campaign id="168866" active="true">'
' <name>FWA-SaleforceTestAccount Master Campaign</name>'
' <description/>'
' <tags>'
' </tags>'
' </campaign>'
' <campaign id="184679" active="true">'
' <name>TEST Campagin</name>'
' <description>Test campaign created by Daniel Bravo</description>'
' <tags>'
' <tag>[email protected]</tag>'
' </tags>'
' </campaign>'
' </campaigns>'
'</response>')
m.get(self.mc.connection.uri + 'campaigns', text=xml)
# Expected Structure
expected = ['id', 'active', 'name', 'description', 'tags']
# Assert response is expected structure
self.assertTrue(validate_list(expected, self.mc.campaigns()))
def test_get_activist_codes(self, m):
# Create response
json = {
u'count':
43,
u'items': [{
u'status': u'Active',
u'scriptQuestion': None,
u'name': u'TEST CODE',
u'mediumName': u'TEST CODE',
u'activistCodeId': 4388538,
u'shortName': u'TC',
u'type': u'Action',
u'description': None
}],
u'nextPageLink':
None
}
m.get(self.van.connection.uri + 'activistCodes', json=json)
# Expected Structure
expected = [
'status', 'scriptQuestion', 'name', 'mediumName', 'activistCodeId',
'shortName', 'type', 'description'
]
# Assert response is expected structure
self.assertTrue(validate_list(expected, self.van.get_activist_codes()))
def test_get_queries(self):
# Validate that columns match expected columns
queries_list = self.rs.get_queries()
exp = ['user', 'pid', 'xid', 'query', 'service_class', 'slot', 'start', 'state',
'queue_sec', 'exec_sec', 'cpu_sec', 'read_mb', 'spill_mb', 'return_rows',
'nl_rows', 'sql', 'alert']
self.assertTrue(validate_list(exp, queries_list))
def test_district_zip(self, m):
# Test Zips
m.get(self.ts.connection.uri + 'service/district', json=district_zip)
self.assertTrue(
validate_list(
zip_expected,
self.ts.district(search_type='zip', zip5='60622',
zip4='7194')))
def test_get_advocates(self, m):
m.get(self.p2a.client.uri + 'advocates', json=adv_json)
adv_exp = ['id', 'prefix', 'firstname', 'middlename',
'lastname', 'suffix', 'notes', 'stage', 'connections',
'created_at', 'updated_at',
'address_city', 'address_county', 'address_latitude',
'address_longitude', 'address_state', 'address_street1',
'address_street2', 'address_zip4', 'address_zip5',
'districts_cityCouncil', 'districts_congressional',
'districts_stateHouse', 'districts_stateSenate']
self.assertTrue(validate_list(adv_exp, self.p2a.get_advocates()['advocates']))
ids_exp = ['advocate_id', 'ids']
self.assertTrue(validate_list(ids_exp, self.p2a.get_advocates()['ids']))
phone_exp = ['advocate_id', 'phones_address', 'phones_id', 'phones_subscribed']
self.assertTrue(validate_list(phone_exp, self.p2a.get_advocates()['phones']))
tags_exp = ['advocate_id', 'tags']
self.assertTrue(validate_list(tags_exp, self.p2a.get_advocates()['tags']))
email_exp = ['advocate_id', 'emails_address', 'emails_id', 'emails_subscribed']
self.assertTrue(validate_list(email_exp, self.p2a.get_advocates()['emails']))
member_exp = ['advocate_id', 'memberships_campaignid', 'memberships_created_at',
'memberships_id', 'memberships_name', 'memberships_source']
self.assertTrue(validate_list(member_exp, self.p2a.get_advocates()['memberships']))
fields_exp = ['advocate_id', 'fields']
self.assertTrue(validate_list(fields_exp, self.p2a.get_advocates()['fields']))
def test_district_address(self, m):
# Test Address
m.get(self.ts.connection.uri + 'service/district',
json=address_response)
self.assertTrue(
validate_list(
district_expected,
self.ts.district(search_type='address',
address='908 N Main St, Chicago, IL 60611')))
def test_phone(self, m):
# Test phone
m.get(self.ts.connection.uri + 'person/phone-search',
json=phone_response)
self.assertTrue(
validate_list(phone_expected,
self.ts.phone(Table([{
'phone': 4435705355
}]))))
def test_district_point(self, m):
# Test Points
m.get(self.ts.connection.uri + 'service/district', json=district_point)
self.assertTrue(
validate_list(
district_expected,
self.ts.district(search_type='point',
latitude='41.898369',
longitude='-87.694382')))
def test_get_events(self, m):
json = {'count': 1, 'next': None, 'previous': None, 'data': [{'id': 86738, 'description': 'Join our team of volunteers and learn how to engage students in local high schools, communicate our mission, and register young voters.', 'timezone': 'America/Chicago', 'title': 'Student Voter Initiative Training', 'summary': '', 'featured_image_url': 'https://mobilizeamerica.imgix.net/uploads/event/40667432145_6188839fe3_o_20190102224312253645.jpeg', 'sponsor': {'id': 1076, 'name': 'Battleground Texas', 'slug': 'battlegroundtexas', 'is_coordinated': True, 'is_independent': False, 'is_primary_campaign': False, 'state': '', 'district': '', 'candidate_name': '', 'race_type': None, 'event_feed_url': 'https://events.mobilizeamerica.io/battlegroundtexas/',
'created_date': 1538590930, 'modified_date': 1546468308}, 'timeslots': [{'id': 526226, 'start_date': 1547330400, 'end_date': 1547335800}], 'location': {'venue': 'Harris County Democratic Party HQ', 'address_lines': ['4619 Lyons Ave', ''], 'locality': 'Houston', 'region': 'TX', 'postal_code': '77020', 'location': {'latitude': 29.776446, 'longitude': -95.323037}, 'congressional_district': '18', 'state_leg_district': '142', 'state_senate_district': None}, 'event_type': 'TRAINING', 'created_date': 1546469706, 'modified_date': 1547335800, 'browser_url': 'https://events.mobilizeamerica.io/battlegroundtexas/event/86738/', 'high_priority': None, 'contact': None, 'visibility': 'PUBLIC'}]}
m.get(self.ma.uri + 'events', json=json)
expected = ['id', 'description', 'timezone', 'title', 'summary', 'featured_image_url', 'event_type', 'created_date', 'modified_date', 'browser_url', 'high_priority', 'contact', 'visibility', 'sponsor_candidate_name', 'sponsor_created_date', 'sponsor_district', 'sponsor_event_feed_url', 'sponsor_id', 'sponsor_is_coordinated', 'sponsor_is_independent',
'sponsor_is_primary_campaign', 'sponsor_modified_date', 'sponsor_name', 'sponsor_race_type', 'sponsor_slug', 'sponsor_state', 'address_lines', 'congressional_district', 'locality', 'postal_code', 'region', 'state_leg_district', 'state_senate_district', 'venue', 'latitude', 'longitude', 'timeslots_0_end_date', 'timeslots_0_id', 'timeslots_0_start_date']
# Assert response is expected structure
self.assertTrue(validate_list(expected, self.ma.get_events()))
def test_export_job_types(self, m):
json = {u'count': 1, u'items':
[{u'exportJobTypeId': 4, u'name': u'SavedListExport'}],
u'nextPageLink': None}
m.get(self.van.connection.uri + 'exportJobTypes', json=json)
expected = ['exportJobTypeId', 'name']
self.assertTrue(validate_list(expected, self.van.get_export_job_types()))
def test_get_petitions(self, m):
m.post(f'{self.hostname}/oauth/token', json={'access_token': '123'})
cs = Controlshift(hostname=self.hostname,
client_id='1234',
client_secret='1234')
m.get(f'{self.hostname}/api/v1/petitions',
json=test_data.petition_test_data)
tbl = cs.get_petitions()
self.assertTrue(validate_list(test_data.expected_petition_columns,
tbl))
def test_get_campaigns(self, m):
camp_exp = ['id', 'name', 'display_name', 'subtitle',
'public', 'topic', 'type', 'link', 'restrict_allow',
'updated_at_date', 'updated_at_timezone',
'updated_at_timezone_type', 'content_background_image',
'content_call_to_action', 'content_introduction',
'content_summary', 'content_thank_you']
m.get(self.p2a.client.uri + 'campaigns', json=camp_json)
self.assertTrue(validate_list(camp_exp, self.p2a.get_campaigns()))
def test_get_score_updates(self, m):
json = {
'items': [{
'scoreUpdateId': 58319,
'score': {
'scoreId': 29817,
'name': 'TargetSmart Gun Ownership',
'shortName': None,
'description': None,
'minValue': 0.0,
'maxValue': 100.0,
'state': 'MT',
'origin': None
},
'updateStatistics': {
'totalRows': 856644,
'duplicateRows': 0,
'matchedRows': 856644,
'matchPercent': 100.0,
'increasedBy': 441264,
'decreasedBy': 280588,
'nulledOut': 3649,
'added': 115129,
'outOfRange': 0,
'badValues': 0,
'maxValue': 95.9,
'minValue': 11.2,
'averageValue': 72.3338,
'medianValue': 76.3
},
'loadStatus': 'Completed',
'dateProcessed': '2019-09-10T02:07:00Z'
}],
'nextPageLink':
None,
'count':
306
}
m.get(self.van.connection.uri + 'scoreUpdates', json=json)
expected = [
'scoreUpdateId', 'loadStatus', 'dateProcessed', 'added',
'averageValue', 'badValues', 'decreasedBy', 'duplicateRows',
'increasedBy', 'matchPercent', 'matchedRows', 'maxValue',
'medianValue', 'minValue', 'nulledOut', 'outOfRange', 'totalRows',
'description', 'maxValue', 'minValue', 'name', 'origin', 'scoreId',
'shortName', 'state'
]
self.assertTrue(validate_list(expected, self.van.get_score_updates()))
def test_get_table_stats(self):
tbls_list = self.rs.get_table_stats(schema=self.temp_schema)
exp = [
'database', 'schema', 'table_id', 'table', 'encoded', 'diststyle', 'sortkey1',
'max_varchar', 'sortkey1_enc', 'sortkey_num', 'size', 'pct_used', 'empty',
'unsorted', 'stats_off', 'tbl_rows', 'skew_sortkey1', 'skew_rows',
'estimated_visible_rows', 'risk_event', 'vacuum_sort_benefit']
# Having some issues testing that the filter is working correctly, as it
# takes a little bit of time for a table to show in this table and is beating
# the test suite. I feel confident that it works though.
self.assertTrue(validate_list(exp, tbls_list))
def test_get_saved_lists(self, m):
json = {'count': 1, 'items': [
{"savedListId": 517612,
"listCount": 974656,
"name": "LikelyParents(16andunder)_DWID_S... - MN",
"doorCount": 520709,
"description": "null"
}
], 'nextPageLink': None}
m.get(self.van.connection.uri + 'savedLists', json=json)
expected = ['savedListId', 'listCount', 'name', 'doorCount', 'description']
self.assertTrue(validate_list(expected, self.van.get_saved_lists()))
def test_get_events_deleted(self, m):
json = {'count': 2,
'next': None,
'previous': None,
'data': [{'id': 86765,
'deleted_date': 1546705971},
{'id': 86782,
'deleted_date': 1546912779}
]
}
m.get(self.ma.uri + 'events/deleted', json=json)
# Assert response is expected structure
self.assertTrue(validate_list(['id', 'deleted_date'], self.ma.get_events_deleted()))
def test_get_events(self, m):
json = {
'count':
6,
'items': [{
"eventId": 1062,
"startDate": "2010-05-25T11:00:00-05:00",
"codes": "null",
"endDate": "2010-05-25T15:00:00-05:00",
"name": "Sample",
"roles": "null",
"isOnlyEditableByCreatingUser": "******",
"ticketCategories": "null",
"eventType": {
"eventTypeId": 29166,
"name": "Confirmation Calls"
},
"notes": "null",
"districtFieldValue": "null",
"locations": "null",
"shifts": "null",
"voterRegistrationBatches": "null",
"createdDate": "2010-05-25T11:55:00Z",
"financialProgram": "null",
"shortName": "Sample",
"isPubliclyViewable": "null",
"isActive": "true",
"description": "This is a sample"
}],
'nextPageLink':
None
}
m.get(self.van.connection.uri + 'events', json=json)
# Expected Structure
expected = [
'eventId', 'startDate', 'codes', 'endDate', 'name', 'roles',
'isOnlyEditableByCreatingUser', 'ticketCategories', 'eventType',
'notes', 'districtFieldValue', 'locations', 'shifts',
'voterRegistrationBatches', 'createdDate', 'financialProgram',
'shortName', 'isPubliclyViewable', 'isActive', 'description'
]
self.assertTrue(validate_list(expected, self.van.get_events()))
def test_get_folders(self, m):
json = {u'count': 2,
u'items': [
{
u'folderId': 5046,
u'name': u'#2018_MN_active_universe'
},
{u'folderId': 2168,
u'name': u'API Generated Lists'
}
], u'nextPageLink': None}
m.get(self.van.connection.uri + 'folders', json=json)
expected = ['folderId', 'name']
self.assertTrue(validate_list(expected, self.van.get_folders()))
def test_group_create(self, m):
# Initial conditions
GROUP_NAME = 'This is a TEST group DB'
xml = (
'<?xml version="1.0" encoding="UTF-8"?>'
'<response success="true">'
' <group name="This is a TEST group DB" id="436568" type="UploadedGroup">'
' </group>'
'</response>')
m.get(self.mc.connection.uri + 'create_group', text=xml)
# Expected Structure
expected = ['id', 'type', 'name']
self.assertTrue(
validate_list(expected, self.mc.group_create(GROUP_NAME)))
