class MyTests(unittest.TestCase):
# pylint: disable=R0904
def setUp(self):
ip = '192.168.56.101' # was '192.168.1.124'
url = "%s/drupal7/sites/all/modules/civicrm/" % ip
site_key = '371cfadc834d2784a35e4f4ab20c1316'
api_key = 'b734df56706432bb514ed737465424c3'
self.cc = CiviCRM(url, site_key, api_key, use_ssl=False)
self.contact_id = 202 # id for a valid civicrm user
def tearDown(self):
pass
def test_example(self):
pass
def test_add_options(self):
results = self.cc._add_options({}, limit=1,offset=0)
expected = {u'options[limit]' : 1, u'options[offset]' : 0}
self.assertEquals(expected['options[limit]'], 1)
def test_add_single_option(self):
results = self.cc._add_options({}, limit=1)
self.assertEquals(len(results), 1)
def test__construct_payload(self):
payload = self.cc._construct_payload('get', 'Contact',
{'json' : 0, 'contact_id': 2})
self.assertEquals(payload['json'], 1)
self.assertEquals(payload['contact_id'], 2)
def test__check_results(self):
results = self.cc._check_results({'is_error' : 0, 'result' : 1})
self.assertEquals(results, 1)
def test__check_results_raises_exception(self):
self.assertRaises(CivicrmError, self.cc._check_results,
{'is_error' : 1, 'error_message' : 'test', 'result' : 1})
def test_is_valid_option_id_is_valid(self):
result = self.cc.is_valid_option(
'Activity', 'activity_is_test', 0)
self.assertEquals(result, 0)
def test_is_valid_option_id_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', 2)
def test_is_valid_option_label_is_valid(self):
result = self.cc.is_valid_option(
'Activity', 'activity_is_test', 'Yes')
self.assertEquals(result, '1')
def test_is_valid_option_label_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', 'Not Valid')
def test_is_valid_option_label_is_none(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', None)
def test__get(self):
results = self.cc._get('get', 'Contact')
self.assertGreater(len(results), 1)
def test__post(self):
results = self.cc._post('get', 'Contact')
self.assertGreater(len(results), 1)
def test_get(self):
results = self.cc.get('Contact')
self.assertGreater(len(results), 1)
def test_get_with_params(self):
results = self.cc.get('Contact', contact_id=2)
result = results[0]
self.assertEquals(result['sort_name'], 'Terry, Brittney')
def test_get_with__multiple_params(self):
results = self.cc.get('Contact', **{'contact_type': 'Individual',
'Country' : 'United States'})
self.assertGreater(len(results), 1)
def test_get_with_limit_offset(self):
results = self.cc.get('Contact', **{'contact_type': 'Individual','Country' : 'United States', 'limit': 2, 'offset': 0})
result = results[0]
self.assertEquals(result['sort_name'], 'Terry, Brittney')
self.assertEquals(len(results), 2)
def test_get_null_set(self):
results = self.cc.get('Contact', contact_id=100000)
self.assertEquals(results, [])
def test_get_invalid_option(self):
self.assertRaises(CivicrmError,self.cc.get,
'Contact', contact_id='a')
def test_getsingle(self):
results = self.cc.getsingle('Contact',contact_id=2)
self.assertEquals(results['sort_name'], 'Terry, Brittney')
def test_getsingle_multiple_results(self):
self.assertRaises(CivicrmError, self.cc.getsingle,
'Contact', country='United States')
def test_getvalue(self):
results = self.cc.getvalue('Contact', 'sort_name', contact_id=2)
self.assertEquals(type(results), unicode)
self.assertEquals(results, 'Terry, Brittney')
def test_getvalue_multiple_results(self):
self.assertRaises(CivicrmError, self.cc.getvalue,
'Contact', 'sort_name', country='United States')
def test_create(self):
results = self.cc.create('Contact',
contact_type='individual', display_name='bar, foo')
self.cc.delete('Contact', results[0]['id'], True)
self.assertEquals(results[0]['display_name'], 'bar, foo')
def test_delete(self):
cresults = self.cc.create('Contact',
contact_type='individual', display_name='bar, foo')
results = self.cc.delete('Contact', cresults[0]['id'], True)
self.assertEquals(results, 1)
def test_update(self):
cresults = self.cc.create('Contact',
contact_type='individual', display_name='bar, foo')
myid = cresults[0]['id']
results = self.cc.update('Contact', myid, display_name='foo, bar')
self.cc.delete('Contact', myid, True)
self.assertEquals(results[0]['display_name'], 'foo, bar')
def test_setvalue(self):
cresults = self.cc.create('Contact',
contact_type='individual', display_name='bar, foo')
myid = cresults[0]['id']
results = self.cc.setvalue('Contact', myid,
'display_name', 'foo, bar')
self.cc.delete('Contact', myid, True)
self.assertEquals(results['display_name'], 'foo, bar')
def test_getcount(self):
count = self.cc.getcount('Contact', contact_id=2)
self.assertEquals(count, 1)
def test_getfields(self):
results = self.cc.getfields('Contact')
self.assertIn('id', results)
def test_getoptions(self):
results = self.cc.getoptions('Contact', 'contact_type')
self.assertIn('Organization', results)
def test_getoptions_raises_error(self):
self.assertRaises(CivicrmError, self.cc.getoptions, 'Contact', 'city')
def test_doaction(self):
results = self.cc.doaction('get', 'Contact')
self.assertGreater(len(results), 1)
def test_add_contact(self):
results = self.cc.add_contact(
contact_type='Individual', display_name='test')
self.cc.delete('Contact', results['id'], True)
self.assertEquals(results['display_name'], 'test')
def test_add_contact_required_field_missing(self):
self.assertRaisesRegexp(CivicrmError, 'fields must exist',
self.cc.add_contact, contact_type='Individual')
def test_add_contact_wrong_type(self):
self.assertRaisesRegexp(CivicrmError,' not a valid option',
self.cc.add_contact, 'not a contact type',
display_name='test')
def test_add_relationship_by_id(self):
result = self.cc.add_relationship(101, 102, 1)
self.cc.delete('Relationship', result['id'], True)
self.assertEquals(result['relationship_type_id'], '1')
def test_add_relationship_by_type(self):
result = self.cc.add_relationship(101, 102, 'Partner of')
self.cc.delete('Relationship', result['id'], True)
self.assertEquals(result['relationship_type_id'], '3')
def test_add_relationship_type_not_found(self):
self.assertRaises(CivicrmError,
self.cc.add_relationship, 101, 102, 'Aunt of')
def test_add_activity_type(self):
result = self.cc.add_activity_type('test_activity_type',
is_active=1)
atypes = self.cc.get('ActivityType')
self.cc.delete('ActivityType', result['id'], True)
self.assertIn('test_activity_type', atypes)
def test_add_activity_by_status_id(self):
result = self.cc.add_activity("Meeting", self.contact_id,
subject = "test", status = 2, is_test=1)
self.cc.delete('Activity', result['id'], True)
self.assertEquals(result['activity_type_id'], '1')
def test_add_activity_by_status_type(self):
result = self.cc.add_activity("Meeting", self.contact_id,
subject = "test", activity_status = "Completed",
status = "Cancelled", is_test=1)
self.cc.delete('Activity', result['id'], True)
self.assertEquals(result['activity_type_id'], '1')
def test_add_activity_invalid_label(self):
self.assertRaises(CivicrmError,
self.cc.add_activity,"Not A Meeting", self.contact_id,
"test", "0000", 2)
def test_add_activity_invalid_status_id(self):
self.assertRaises(CivicrmError,
self.cc.add_activity,"Meeting", self.contact_id,
"test", "0000", 10)
def test_add_activity_invalid_status_type(self):
self.assertRaises(CivicrmError,
self.cc.add_activity,"Meeting", self.contact_id,
"test", "0000", "test")
def test_add_contribution_by_id(self):
result = self.cc.add_contribution(self.contact_id, 100, 1, is_test=1)
self.cc.delete('Contribution', result['id'], True)
self.assertEquals(result['total_amount'], '100')
def test_add_contribution_by_type(self):
result = self.cc.add_contribution(self.contact_id,
100, 'Donation', is_test=1)
self.cc.delete('Contribution', result['id'], True)
self.assertEquals(result['total_amount'], '100')
def test_add_contribution_invalid_financial_type(self):
self.assertRaises(CivicrmError,
self.cc.add_contribution,self.contact_id,
100, 'Not Valid', is_test=1)
def test_add_email(self):
result = self.cc.add_email(self.contact_id, '*****@*****.**')
self.cc.delete('Email', result['id'], True)
self.assertEquals(result['email'], '*****@*****.**')
def test_add_email_is_not_email_like(self):
self.assertRaises(CivicrmError, self.cc.add_email,
self.contact_id, 'invalid.address', True)
def test_add_note(self):
result = self.cc.add_note(self.contact_id, 'test')
self.cc.delete('Note', result['id'], True)
self.assertEquals(result['note'], 'test')
def test_add_tag(self):
result = self.cc.add_tag('test')
self.cc.delete('Tag', result['id'], True)
self.assertEquals(result['name'], 'test')
def test_add_entity_tag(self):
result = self.cc.add_entity_tag(self.contact_id, 1)
self.cc.doaction('delete', 'EntityTag', tag_id=1,
entity_id=202)
self.assertEquals(result['added'], 1)
def test_add_group(self):
result = self.cc.add_group(title='test')
self.cc.delete('Group', result['id'], True)
self.assertEquals(result['title'], 'test')
def test_add_group_contact(self):
result = self.cc.add_group_contact(self.contact_id, 5)
self.cc.doaction('delete', 'GroupContact', group_id=5,
contact_id=self.contact_id)
self.assertEquals(result['added'], 1)
def test_add_phone(self):
result = self.cc.add_phone(self.contact_id, '111-111-1111')
self.cc.delete('Phone', result['id'], True)
self.assertEquals(result['phone'], '111-111-1111')
def test_add_address_by_location_type_id(self):
result = self.cc.add_address(self.contact_id, 1)
self.cc.delete('Address', result['id'], True)
self.assertEquals(result['location_type_id'], '1')
def test_add_address_by_location_type(self):
result = self.cc.add_address(self.contact_id, 'Home')
self.cc.delete('Address', result['id'], True)
self.assertEquals(result['location_type_id'], '1')
def test_matches_required_no_match(self):
required = ['exists']
params = {'does not exist' : True}
results = matches_required(required, params)
self.assertEquals(results, ['exists'])
def test_matches_required_matches(self):
required = ['exists']
params = {'exists' : True}
results = matches_required(required, params)
self.assertEquals(results, None)
file_records_2017 = donations_2015[donations_2015['Date'].str.contains("2017")]
# For each new record in Civi from uploaded file and the year 2015
for i, r in civi_records_2015.iterrows():
# Get the Civi associated Contribution record ID
cont_id = r['contribution_id']
cont_id = int(cont_id)
# Iterate through donations data
for x, y in file_records_2015.iterrows():
# Find matching record of Civi Contribution and record in uploaded file
if r['contact_id'] == y['contact_id'] and r['total_amount'] == y['Gross']:
# Check if file record contribution was PayPal
if y['Method'] == "PayPal":
# If it is, set Civi Contribution field 'Payment Method' to PayPal
civicrm.setvalue(entity='Contribution', db_id=cont_id, field='payment_instrument_id', value=1)
civicrm.update(entity='Contribution', db_id=cont_id)
# Else leave it as check and continue
# TEST CODE ##################################################################################
# test = contributions.tail(1)
# test.columns.values
# get contribution ID
# cont_id = test['contribution_id'].values[0]
# cont_id = int(cont_id)
# changes from check to PayPal
# civicrm.setvalue(entity='Contribution', db_id=cont_id, field='payment_instrument_id', value=1)
# confirm update
site_key = os.environ['CIVI_SITE_KEY']
api_key = os.environ['CIVI_API_KEY']
url = os.environ['CIVI_API_URL']
civicrm = CiviCRM(url, site_key, api_key, True)
members = load_all(civicrm, 1, 200)
#run through all contacts and determine the current highest member id
print('Determining highest current member id...');
high_member_id = 0
for member in members:
print('Current member id ' + str(member.member_id))
print('Highest member id ' + str(high_member_id))
if member.member_id > high_member_id:
high_member_id = member.member_id
print('Highest assigned member id is currently ' + str(high_member_id))
exit
#run through all contacts and assign new member ids where necessary
print('Assigning new member ids...');
for member in members:
if len(member.memberships) > 0 and member.member_id < 1:
high_member_id = high_member_id + 1
member.member_id = str(high_member_id)
civicrm.update('Contact', str(member.civi_id), external_identifier=str(member.member_id))
print('Assiging member id ' + str(member.member_id) + ' to contact ' + str(member.civi_id))
print('Highest assigned member id is currently ' + str(high_member_id))
class MyTests(unittest.TestCase):
# pylint: disable=R0904
def setUp(self):
ip = IP_ADDR
url = "%s/drupal7/sites/all/modules/civicrm/" % ip
site_key = SITE_KEY
api_key = API_KEY
self.cc = CiviCRM(url, site_key, api_key, timeout=1, use_ssl=False)
self.contact_id = 202 # id for a valid civicrm user
def tearDown(self):
pass
def test__get(self):
results = self.cc._get('get', 'Contact')
self.assertGreater(len(results), 1)
def test__post(self):
results = self.cc._post('get', 'Contact')
self.assertGreater(len(results), 1)
def test_get(self):
results = self.cc.get('Contact')
self.assertGreater(len(results), 1)
def test_get_with_params(self):
results = self.cc.get('Contact', contact_id=2)
result = results[0]
self.assertEquals(result['sort_name'], 'Terry, Brittney')
def test_get_with__multiple_params(self):
results = self.cc.get(
'Contact', **{
'contact_type': 'Individual',
'Country': 'United States'
})
self.assertGreater(len(results), 1)
def test_get_with_limit_offset(self):
results = self.cc.get(
'Contact', **{
'contact_type': 'Individual',
'Country': 'United States',
'limit': 2,
'offset': 0
})
result = results[0]
self.assertEquals(result['sort_name'], 'Terry, Brittney')
self.assertEquals(len(results), 2)
def test_get_null_set(self):
results = self.cc.get('Contact', contact_id=100000)
self.assertEquals(results, [])
def test_get_invalid_option(self):
self.assertRaises(CivicrmError, self.cc.get, 'Contact', contact_id='a')
def test_getsingle(self):
results = self.cc.getsingle('Contact', contact_id=2)
self.assertEquals(results['sort_name'], 'Terry, Brittney')
def test_getsingle_multiple_results(self):
self.assertRaises(CivicrmError,
self.cc.getsingle,
'Contact',
country='United States')
def test_getvalue(self):
results = self.cc.getvalue('Contact', 'sort_name', contact_id=2)
self.assertEquals(type(results), unicode)
self.assertEquals(results, 'Terry, Brittney')
def test_getvalue_multiple_results(self):
self.assertRaises(CivicrmError,
self.cc.getvalue,
'Contact',
'sort_name',
country='United States')
def test_create(self):
results = self.cc.create('Contact',
contact_type='individual',
display_name='bar, foo')
self.cc.delete('Contact', results[0]['id'], True)
self.assertEquals(results[0]['display_name'], 'bar, foo')
def test_delete(self):
cresults = self.cc.create('Contact',
contact_type='individual',
display_name='bar, foo')
results = self.cc.delete('Contact', cresults[0]['id'], True)
self.assertEquals(results, 1)
def test_update(self):
cresults = self.cc.create('Contact',
contact_type='individual',
display_name='bar, foo')
myid = cresults[0]['id']
results = self.cc.update('Contact', myid, display_name='foo, bar')
self.cc.delete('Contact', myid, True)
self.assertEquals(results[0]['display_name'], 'foo, bar')
def test_setvalue(self):
cresults = self.cc.create('Contact',
contact_type='individual',
display_name='bar, foo')
myid = cresults[0]['id']
results = self.cc.setvalue('Contact', myid, 'display_name', 'foo, bar')
self.cc.delete('Contact', myid, True)
self.assertEquals(results['display_name'], 'foo, bar')
def test_getcount(self):
count = self.cc.getcount('Contact', contact_id=2)
self.assertEquals(count, 1)
def test_getfields(self):
results = self.cc.getfields('Contact')
self.assertIn('id', results)
def test_getoptions(self):
results = self.cc.getoptions('Contact', 'contact_type')
self.assertIn('Organization', results)
def test_getoptions_raises_error(self):
self.assertRaises(CivicrmError, self.cc.getoptions, 'Contact', 'city')
def test_doaction(self):
results = self.cc.doaction('get', 'Contact')
self.assertGreater(len(results), 1)
def test_add_contact(self):
results = self.cc.add_contact(contact_type='Individual',
display_name='test')
self.cc.delete('Contact', results['id'], True)
self.assertEquals(results['display_name'], 'test')
def test_add_contact_required_field_missing(self):
self.assertRaisesRegexp(CivicrmError,
'fields must exist',
self.cc.add_contact,
contact_type='Individual')
def test_add_contact_wrong_type(self):
self.assertRaisesRegexp(CivicrmError,
' not a valid option',
self.cc.add_contact,
'not a contact type',
display_name='test')
def test_add_relationship_by_id(self):
result = self.cc.add_relationship(101, 102, 1)
self.cc.delete('Relationship', result['id'], True)
self.assertEquals(result['relationship_type_id'], '1')
def test_add_relationship_by_type(self):
result = self.cc.add_relationship(101, 102, 'Partner of')
self.cc.delete('Relationship', result['id'], True)
self.assertEquals(result['relationship_type_id'], '3')
def test_add_relationship_type_not_found(self):
self.assertRaises(CivicrmError, self.cc.add_relationship, 101, 102,
'Aunt of')
def test_add_activity_type(self):
result = self.cc.add_activity_type('test_activity_type', is_active=1)
atypes = self.cc.get('ActivityType')
self.cc.delete('ActivityType', result['id'], True)
self.assertIn('test_activity_type', atypes)
def test_add_activity_by_status_id(self):
result = self.cc.add_activity(1,
self.contact_id,
subject="test",
status=2,
is_test=1)
self.cc.delete('Activity', result['id'], True)
self.assertEquals(result['activity_type_id'], '1')
def test_add_activity_by_status_type(self):
result = self.cc.add_activity("Meeting",
self.contact_id,
subject="test",
activity_status="Completed",
status="Cancelled",
is_test=1)
self.cc.delete('Activity', result['id'], True)
self.assertEquals(result['activity_type_id'], '1')
def test_add_activity_invalid_label(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Not A Meeting",
self.contact_id, "test", "0000", 2)
def test_add_activity_invalid_status_id(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting",
self.contact_id, "test", "0000", 10)
def test_add_activity_invalid_status_type(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting",
self.contact_id, "test", "0000", "test")
def test_add_contribution_by_id(self):
result = self.cc.add_contribution(self.contact_id, 100, 1, is_test=1)
self.cc.delete('Contribution', result['id'], True)
self.assertEquals(result['total_amount'], '100')
def test_add_contribution_by_type(self):
result = self.cc.add_contribution(self.contact_id,
100,
'Donation',
is_test=1)
self.cc.delete('Contribution', result['id'], True)
self.assertEquals(result['total_amount'], '100')
def test_add_contribution_invalid_financial_type(self):
self.assertRaises(CivicrmError,
self.cc.add_contribution,
self.contact_id,
100,
'Not Valid',
is_test=1)
def test_add_email(self):
result = self.cc.add_email(self.contact_id, '*****@*****.**')
self.cc.delete('Email', result['id'], True)
self.assertEquals(result['email'], '*****@*****.**')
def test_add_email_is_not_email_like(self):
self.assertRaises(CivicrmError, self.cc.add_email, self.contact_id,
'invalid.address', True)
def test_add_note(self):
result = self.cc.add_note(self.contact_id, 'test')
self.cc.delete('Note', result['id'], True)
self.assertEquals(result['note'], 'test')
def test_add_tag(self):
result = self.cc.add_tag('test')
self.cc.delete('Tag', result['id'], True)
self.assertEquals(result['name'], 'test')
def test_add_entity_tag(self):
result = self.cc.add_entity_tag(self.contact_id, 1)
self.cc.doaction('delete', 'EntityTag', tag_id=1, entity_id=202)
self.assertEquals(result['added'], 1)
def test_add_group(self):
result = self.cc.add_group(title='test')
self.cc.delete('Group', result['id'], True)
self.assertEquals(result['title'], 'test')
def test_add_group_contact(self):
result = self.cc.add_group_contact(self.contact_id, 5)
self.cc.doaction('delete',
'GroupContact',
group_id=5,
contact_id=self.contact_id)
self.assertEquals(result['added'], 1)
def test_add_phone(self):
result = self.cc.add_phone(self.contact_id, '111-111-1111')
self.cc.delete('Phone', result['id'], True)
self.assertEquals(result['phone'], '111-111-1111')
def test_add_address_by_location_type_id(self):
result = self.cc.add_address(self.contact_id, 1)
self.cc.delete('Address', result['id'], True)
self.assertEquals(result['location_type_id'], '1')
def test_add_address_by_location_type(self):
result = self.cc.add_address(self.contact_id, 'Home')
self.cc.delete('Address', result['id'], True)
self.assertEquals(result['location_type_id'], '1')
def test_matches_required_no_match(self):
required = ['exists']
params = {'does not exist': True}
results = matches_required(required, params)
self.assertEquals(results, ['exists'])
def test_matches_required_matches(self):
required = ['exists']
params = {'exists': True}
results = matches_required(required, params)
self.assertEquals(results, None)
class MyTests(unittest.TestCase):
# pylint: disable=R0904
def setUp(self):
ip = IP_ADDR
url = "%s/drupal7/sites/all/modules/civicrm/" % ip
site_key = SITE_KEY
api_key = API_KEY
self.cc = CiviCRM(url, site_key, api_key, timeout=1, use_ssl=False)
self.contact_id = 202 # id for a valid civicrm user
def tearDown(self):
pass
def test__get(self):
results = self.cc._get("get", "Contact")
self.assertGreater(len(results), 1)
def test__post(self):
results = self.cc._post("get", "Contact")
self.assertGreater(len(results), 1)
def test_get(self):
results = self.cc.get("Contact")
self.assertGreater(len(results), 1)
def test_get_with_params(self):
results = self.cc.get("Contact", contact_id=2)
result = results[0]
self.assertEquals(result["sort_name"], "Terry, Brittney")
def test_get_with__multiple_params(self):
results = self.cc.get("Contact", **{"contact_type": "Individual", "Country": "United States"})
self.assertGreater(len(results), 1)
def test_get_with_limit_offset(self):
results = self.cc.get(
"Contact", **{"contact_type": "Individual", "Country": "United States", "limit": 2, "offset": 0}
)
result = results[0]
self.assertEquals(result["sort_name"], "Terry, Brittney")
self.assertEquals(len(results), 2)
def test_get_null_set(self):
results = self.cc.get("Contact", contact_id=100000)
self.assertEquals(results, [])
def test_get_invalid_option(self):
self.assertRaises(CivicrmError, self.cc.get, "Contact", contact_id="a")
def test_getsingle(self):
results = self.cc.getsingle("Contact", contact_id=2)
self.assertEquals(results["sort_name"], "Terry, Brittney")
def test_getsingle_multiple_results(self):
self.assertRaises(CivicrmError, self.cc.getsingle, "Contact", country="United States")
def test_getvalue(self):
results = self.cc.getvalue("Contact", "sort_name", contact_id=2)
self.assertEquals(type(results), unicode)
self.assertEquals(results, "Terry, Brittney")
def test_getvalue_multiple_results(self):
self.assertRaises(CivicrmError, self.cc.getvalue, "Contact", "sort_name", country="United States")
def test_create(self):
results = self.cc.create("Contact", contact_type="individual", display_name="bar, foo")
self.cc.delete("Contact", results[0]["id"], True)
self.assertEquals(results[0]["display_name"], "bar, foo")
def test_delete(self):
cresults = self.cc.create("Contact", contact_type="individual", display_name="bar, foo")
results = self.cc.delete("Contact", cresults[0]["id"], True)
self.assertEquals(results, 1)
def test_update(self):
cresults = self.cc.create("Contact", contact_type="individual", display_name="bar, foo")
myid = cresults[0]["id"]
results = self.cc.update("Contact", myid, display_name="foo, bar")
self.cc.delete("Contact", myid, True)
self.assertEquals(results[0]["display_name"], "foo, bar")
def test_setvalue(self):
cresults = self.cc.create("Contact", contact_type="individual", display_name="bar, foo")
myid = cresults[0]["id"]
results = self.cc.setvalue("Contact", myid, "display_name", "foo, bar")
self.cc.delete("Contact", myid, True)
self.assertEquals(results["display_name"], "foo, bar")
def test_getcount(self):
count = self.cc.getcount("Contact", contact_id=2)
self.assertEquals(count, 1)
def test_getfields(self):
results = self.cc.getfields("Contact")
self.assertIn("id", results)
def test_getoptions(self):
results = self.cc.getoptions("Contact", "contact_type")
self.assertIn("Organization", results)
def test_getoptions_raises_error(self):
self.assertRaises(CivicrmError, self.cc.getoptions, "Contact", "city")
def test_doaction(self):
results = self.cc.doaction("get", "Contact")
self.assertGreater(len(results), 1)
def test_add_contact(self):
results = self.cc.add_contact(contact_type="Individual", display_name="test")
self.cc.delete("Contact", results["id"], True)
self.assertEquals(results["display_name"], "test")
def test_add_contact_required_field_missing(self):
self.assertRaisesRegexp(CivicrmError, "fields must exist", self.cc.add_contact, contact_type="Individual")
def test_add_contact_wrong_type(self):
self.assertRaisesRegexp(
CivicrmError, " not a valid option", self.cc.add_contact, "not a contact type", display_name="test"
)
def test_add_relationship_by_id(self):
result = self.cc.add_relationship(101, 102, 1)
self.cc.delete("Relationship", result["id"], True)
self.assertEquals(result["relationship_type_id"], "1")
def test_add_relationship_by_type(self):
result = self.cc.add_relationship(101, 102, "Partner of")
self.cc.delete("Relationship", result["id"], True)
self.assertEquals(result["relationship_type_id"], "3")
def test_add_relationship_type_not_found(self):
self.assertRaises(CivicrmError, self.cc.add_relationship, 101, 102, "Aunt of")
def test_add_activity_type(self):
result = self.cc.add_activity_type("test_activity_type", is_active=1)
atypes = self.cc.get("ActivityType")
self.cc.delete("ActivityType", result["id"], True)
self.assertIn("test_activity_type", atypes)
def test_add_activity_by_status_id(self):
result = self.cc.add_activity(1, self.contact_id, subject="test", status=2, is_test=1)
self.cc.delete("Activity", result["id"], True)
self.assertEquals(result["activity_type_id"], "1")
def test_add_activity_by_status_type(self):
result = self.cc.add_activity(
"Meeting", self.contact_id, subject="test", activity_status="Completed", status="Cancelled", is_test=1
)
self.cc.delete("Activity", result["id"], True)
self.assertEquals(result["activity_type_id"], "1")
def test_add_activity_invalid_label(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Not A Meeting", self.contact_id, "test", "0000", 2)
def test_add_activity_invalid_status_id(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting", self.contact_id, "test", "0000", 10)
def test_add_activity_invalid_status_type(self):
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting", self.contact_id, "test", "0000", "test")
def test_add_contribution_by_id(self):
result = self.cc.add_contribution(self.contact_id, 100, 1, is_test=1)
self.cc.delete("Contribution", result["id"], True)
self.assertEquals(result["total_amount"], "100")
def test_add_contribution_by_type(self):
result = self.cc.add_contribution(self.contact_id, 100, "Donation", is_test=1)
self.cc.delete("Contribution", result["id"], True)
self.assertEquals(result["total_amount"], "100")
def test_add_contribution_invalid_financial_type(self):
self.assertRaises(CivicrmError, self.cc.add_contribution, self.contact_id, 100, "Not Valid", is_test=1)
def test_add_email(self):
result = self.cc.add_email(self.contact_id, "*****@*****.**")
self.cc.delete("Email", result["id"], True)
self.assertEquals(result["email"], "*****@*****.**")
def test_add_email_is_not_email_like(self):
self.assertRaises(CivicrmError, self.cc.add_email, self.contact_id, "invalid.address", True)
def test_add_note(self):
result = self.cc.add_note(self.contact_id, "test")
self.cc.delete("Note", result["id"], True)
self.assertEquals(result["note"], "test")
def test_add_tag(self):
result = self.cc.add_tag("test")
self.cc.delete("Tag", result["id"], True)
self.assertEquals(result["name"], "test")
def test_add_entity_tag(self):
result = self.cc.add_entity_tag(self.contact_id, 1)
self.cc.doaction("delete", "EntityTag", tag_id=1, entity_id=202)
self.assertEquals(result["added"], 1)
def test_add_group(self):
result = self.cc.add_group(title="test")
self.cc.delete("Group", result["id"], True)
self.assertEquals(result["title"], "test")
def test_add_group_contact(self):
result = self.cc.add_group_contact(self.contact_id, 5)
self.cc.doaction("delete", "GroupContact", group_id=5, contact_id=self.contact_id)
self.assertEquals(result["added"], 1)
def test_add_phone(self):
result = self.cc.add_phone(self.contact_id, "111-111-1111")
self.cc.delete("Phone", result["id"], True)
self.assertEquals(result["phone"], "111-111-1111")
def test_add_address_by_location_type_id(self):
result = self.cc.add_address(self.contact_id, 1)
self.cc.delete("Address", result["id"], True)
self.assertEquals(result["location_type_id"], "1")
def test_add_address_by_location_type(self):
result = self.cc.add_address(self.contact_id, "Home")
self.cc.delete("Address", result["id"], True)
self.assertEquals(result["location_type_id"], "1")
def test_matches_required_no_match(self):
required = ["exists"]
params = {"does not exist": True}
results = matches_required(required, params)
self.assertEquals(results, ["exists"])
def test_matches_required_matches(self):
required = ["exists"]
params = {"exists": True}
results = matches_required(required, params)
self.assertEquals(results, None)
class CiviCRMTests(unittest.TestCase):
# pylint: disable=R0904
def setUp(self):
#ip = '192.168.56.101' # was '192.168.1.124'
ip = '192.168.1.107'
url = "%s/drupal7/sites/all/modules/civicrm/" % ip
site_key = '371cfadc834d2784a35e4f4ab20c1316'
api_key = 'b734df56706432bb514ed737465424c3'
self.cc = CiviCRM(url, site_key, api_key, timeout=1, use_ssl=False)
self.contact_id = 202 # id for a valid civicrm user
self.contact_json = '''{
"address_id": "1",
"country_id": "1228",
"contact_id": "1",
"id": "1",
"world_region": "America South, Central, North and Caribbean",
"city": "Portland",
"preferred_mail_format": "Both",
"display_name": "Test Test",
"do_not_sms": "0",
"email_id": "1",
"organization_name": "org.org",
"is_opt_out": "0",
"do_not_email": "0",
"do_not_mail": "0",
"state_province_id": "1036",
"email": "*****@*****.**",
"worldregion_id": "2",
"do_not_phone": "0",
"is_deceased": "0", "state_province": "OR",
"contact_type": "Individual",
"contact_is_deleted": "0",
"street_address": "PO Box 28228"
}'''
self.contacts = '{"values":[' + self.contact_json + ']}'
self.results = """
{
"is_error":0,
"version":3,
"count":1,"id":2,
"values":[
{"id":"2",
"contact_type":"Individual",
"contact_sub_type":"",
"do_not_email":"0",
"do_not_phone":"0",
"do_not_mail":"0",
"do_not_sms":"0",
"do_not_trade":"0",
"is_opt_out":"0",
"display_name":"bar, foo",
"created_date":"2014-10-05 13:05:13",
"modified_date":"2014-10-05 13:05:13"}
]
}
"""
def tearDown(self):
pass
# methods and fuctions without network calls
def test_add_options(self):
results = self.cc._add_options({}, limit=1, offset=0)
expected = {'options[limit]': 1, 'options[offset]': 0}
self.assertEqual(expected['options[limit]'], 1)
def test_add_single_option(self):
results = self.cc._add_options({}, limit=1)
self.assertEqual(len(results), 1)
def test__construct_payload_get(self):
payload = self.cc._construct_payload('get', 'get', 'Contact', {
'json': 0,
'contact_id': 2
})
self.assertEqual(payload['json'], 1)
self.assertEqual(payload['contact_id'], 2)
def test__construct_payload_post(self):
payload = self.cc._construct_payload('post', 'create', 'Contact', {
'json': 0,
'contact_id': 2
})
self.assertEqual(payload['json'], 1)
self.assertEqual(payload['contact_id'], 2)
def test__check_results(self):
results = self.cc._check_results({'is_error': 0, 'result': 1})
self.assertEqual(results, 1)
def test__check_results_raises_exception(self):
self.assertRaises(CivicrmError, self.cc._check_results, {
'is_error': 1,
'error_message': 'test',
'result': 1
})
def test_is_valid_option_id_is_valid(self):
result = self.cc.is_valid_option('Activity', 'activity_is_test', 0)
self.assertEqual(result, 0)
def test_is_valid_option_id_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option, 'Activity',
'activity_is_test', 2)
def test_is_valid_option_label_is_valid(self):
result = self.cc.is_valid_option('Activity', 'activity_is_test', 'Yes')
self.assertEqual(result, '1')
def test_is_valid_option_label_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option, 'Activity',
'activity_is_test', 'Not Valid')
def test_is_valid_option_label_is_none(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option, 'Activity',
'activity_is_test', None)
def test_matches_required_no_match(self):
required = ['exists']
params = {'does not exist': True}
results = matches_required(required, params)
self.assertEqual(results, ['exists'])
def test_matches_required_matches(self):
required = ['exists']
params = {'exists': True}
results = matches_required(required, params)
self.assertEqual(results, None)
# Methods calling requests
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test__get(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contacts
results = self.cc._get('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test__post(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.contacts
results = self.cc._post('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_get(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contacts
results = self.cc.get('Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_get_invalid_option(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error": 1,
"error_code": 2001,
"error_message": "id is not a valid integer",
"entity": "Contact",
"action": "get",
"error_field": "id",
"type": "integer"
}
"""
self.assertRaises(CivicrmError, self.cc.get, "Contact", contact_id="a")
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getsingle(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contact_json
results = self.cc.getsingle('Contact', contact_id=1)
self.assertEqual(results['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getsingle_multiple_results(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"count":25,
"is_error":1,
"error_message":"Expected one Contact but found 25"
}"""
self.assertRaises(CivicrmError,
self.cc.getsingle,
'Contact',
country='United States')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getvalue(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = \
"""{"is_error":0,"result":"Test, Test"}"""
results = self.cc.getvalue('Contact', 'sort_name', contact_id=1)
self.assertEqual(type(results), str)
self.assertEqual(results, 'Test, Test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getvalue_multiple_results(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"count":25,
"is_error":1,
"error_message":"Expected one Contact but found 25"
}"""
self.assertRaises(CivicrmError,
self.cc.getvalue,
'Contact',
'sort_name',
country='United States')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_create(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.create('Contact',
contact_type='individual',
display_name='bar, foo')
self.assertEqual(results[0]['display_name'], 'bar, foo')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_delete(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"version":3,"count":1,"values":1}"""
results = self.cc.delete('Contact', 2, True)
self.assertEqual(results, 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_update(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.update('Contact', 2, display_name='bar, foo')
self.assertEqual(results[0]['display_name'], 'bar, foo')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_setvalue(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":2,
"values":{"id":"2","display_name":"foo,bar"}
}"""
results = self.cc.setvalue('Contact', 2, 'display_name', 'foo, bar')
self.assertEqual(results['display_name'], 'foo,bar')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getcount(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content =\
"""{"is_error":0,"result":1}"""
count = self.cc.getcount('Contact', contact_id=1)
self.assertEqual(count, 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getoptions(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":3,
"values":{
"Household":"Household",
"Individual":"Individual",
"Organization":"Organization"
}
}"""
results = self.cc.getoptions('Contact', 'contact_type')
self.assertIn('Organization', results)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getoptions_raises_error(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{"is_error":1,"error_message":"The field 'city' doesn't exist."}
"""
self.assertRaises(CivicrmError, self.cc.getoptions, 'Contact', 'city')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_doaction(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.contacts
results = self.cc.doaction('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contact(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.add_contact(contact_type='Individual',
display_name='bar, foo')
self.assertEqual(results['display_name'], 'bar, foo')
def test_add_contact_required_field_missing(self):
self.assertRaisesRegex(CivicrmError,
'fields must exist',
self.cc.add_contact,
contact_type='Individual')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contact_wrong_type(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"error_field":"contact_type",
"error_code":2001,
"entity":"Contact",
"action":"create",
"is_error":1,
"error_message":"'not a contact type' is not a valid option for field contact_type"
}"""
self.assertRaisesRegex(CivicrmError,
' not a valid option',
self.cc.add_contact,
'not a contact type',
display_name='test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_by_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":382,
"values":[{
"id":"382",
"contact_id_a":"101",
"contact_id_b":"102",
"relationship_type_id":"1",
"start_date":"NULL",
"end_date":"NULL",
"is_active":"1",
"description":"",
"is_permission_a_b":"0",
"is_permission_b_a":"0",
"case_id":""}]
}"""
result = self.cc.add_relationship(101, 102, 1)
self.assertEqual(result['relationship_type_id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_by_type(self, mock_requests):
result1 = """{
"is_error":0,"version":3,"count":1,"id":3,
"values":[{"id":"3","name_a_b":"Partnerof"}]
}"""
result2 = """
{
"is_error":0,
"version":3,
"count":1,
"id":382,
"values":[{
"id":"382",
"contact_id_a":"101",
"contact_id_b":"102",
"relationship_type_id":"3",
"start_date":"NULL",
"end_date":"NULL",
"is_active":"1",
"description":"",
"is_permission_a_b":"0",
"is_permission_b_a":"0",
"case_id":""}]
}"""
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = result1
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = result2
result = self.cc.add_relationship(101, 102, 'Partner of')
call = mock_requests.post.call_args[1]['data']['relationship_type_id']
self.assertEqual(call, '3')
self.assertEqual(result['relationship_type_id'], '3')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_type_not_found(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content =\
"""{"is_error":0,"version":3,"count":0,"values":[]}"""
self.assertRaises(CivicrmError, self.cc.add_relationship, 101, 102,
'Aunt of')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_type(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":772,
"values":[{
"id":"772",
"option_group_id":"2",
"label":"test_activity_type",
"value":"64",
"name":"test_activity_type",
"is_active":"1"}]
}"""
result = self.cc.add_activity_type('test_activity_type', is_active=1)
self.assertEqual(result['name'], 'test_activity_type')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_by_status_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":3,
"values":[{
"id":"3",
"activity_type_id":"1",
"subject":"test",
"status_id":"2",
"priority_id":"2"}]
}"""
result = self.cc.add_activity(1,
self.contact_id,
subject="test",
status=2,
is_test=1)
self.assertEqual(result['activity_type_id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_by_status_type(self, mock_is_valid, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":3,
"values":[{
"id":"3",
"activity_type_id":"1",
"subject":"test",
"status_id":"2",
"priority_id":"2"}]
}"""
results = [1, 2]
def side_effect(*args, **kwargs):
return results.pop(0)
mock_is_valid.side_effect = side_effect
result = self.cc.add_activity("Meeting",
self.contact_id,
subject="test",
activity_status="Completed",
status="Cancelled",
is_test=1)
self.assertEqual(result['activity_type_id'], '1')
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_invalid_label(self, mock_is_valid):
def side_effect(*args, **kwargs):
raise CivicrmError
mock_is_valid.side_effect = side_effect
self.assertRaises(CivicrmError, self.cc.add_activity, "Not A Meeting",
self.contact_id, "test", "0000", 2)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_invalid_status_id(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":3,
"values":{"1":"Meeting","2":"Phone Call","3":"Email"}
}
"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"error_field":"status_id",
"error_code":2001,
"entity":"Activity",
"action":"create",
"is_error":1,
"error_message":"'10'is not a valid option for field status_id"
}"""
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting",
self.contact_id, "test", "0000", 10)
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_invalid_status_type(self, mock_valid):
returns = [1, CivicrmError('error')]
def side_effect(*args, **kwargs):
result = returns.pop(0)
if isinstance(result, Exception):
raise result
return result
mock_valid.side_effect = side_effect
self.assertRaises(CivicrmError, self.cc.add_activity, "Meeting",
self.contact_id, "test", "0000", "test")
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_by_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":130,
"values":[
{"id":"130",
"contact_id":"202",
"financial_type_id":"1",
"payment_instrument_id":"4",
"total_amount":"100",
"currency":"USD",
"contribution_status_id":"1",
"contribution_type_id":"1"}
]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_contribution(self.contact_id, 100, 1, is_test=1)
self.assertEqual(result['total_amount'], '100')
assert not self.cc.is_valid_option.called
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_by_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":4,
"values":{
"3":"Campaign Contribution",
"1":"Donation",
"4":"Event Fee",
"2":"Member Dues"}
}"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":130,
"values":[
{"id":"130",
"contact_id":"202",
"financial_type_id":"1",
"payment_instrument_id":"4",
"total_amount":"100",
"currency":"USD",
"contribution_status_id":"1",
"contribution_type_id":"1"}
]
}"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_contribution(self.contact_id,
100,
'Donation',
is_test=1)
self.assertEqual(result['total_amount'], '100')
self.cc.is_valid_option.assert_called_with('Contribution',
'financial_type_id',
'Donation')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_invalid_financial_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":4,
"values":{
"3":"Campaign Contribution",
"1":"Donation",
"4":"Event Fee",
"2":"Member Dues"}
}"""
self.assertRaises(CivicrmError,
self.cc.add_contribution,
self.contact_id,
100,
'Not Valid',
is_test=1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_email(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,"count":1,
"id":220,
"values":[{
"id":"220",
"contact_id":"202",
"email":"*****@*****.**",
"is_primary":"0"
}]
}
"""
result = self.cc.add_email(self.contact_id, '*****@*****.**')
self.assertEqual(result['email'], '*****@*****.**')
def test_add_email_is_not_email_like(self):
self.assertRaises(CivicrmError, self.cc.add_email, self.contact_id,
'invalid.address', True)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_note(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":41,
"values":[{
"id":"41",
"entity_table":"civicrm_contact",
"entity_id":"202",
"note":"test",
"contact_id":"202",
"privacy":"0"}]
}
"""
result = self.cc.add_note(self.contact_id, 'test')
self.assertEqual(result['note'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_tag(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":22,
"values":[{
"id":"22",
"name":"test",
"description":"",
"used_for":"civicrm_contact"
}]
}
"""
result = self.cc.add_tag('test')
self.assertEqual(result['name'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_entity_tag(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"not_added":0,"added":1,"total_count":1}"""
result = self.cc.add_entity_tag(self.contact_id, 1)
self.assertEqual(result['added'], 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_group(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":22,
"values":[{
"id":"22",
"name":"test_22",
"title":"test"
}]
}
"""
result = self.cc.add_group(title='test')
self.assertEqual(result['title'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_group_contact(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"not_added":0,"added":1,"total_count":1}"""
result = self.cc.add_group_contact(self.contact_id, 5)
self.assertEqual(result['added'], 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_phone(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":179,
"values":[{
"id":"179",
"contact_id":"202",
"is_primary":"0",
"mobile_provider_id":"",
"phone":"111-111-1111",
"phone_ext":"",
"phone_numeric":"",
"phone_type_id":""
}]
}
"""
result = self.cc.add_phone(self.contact_id, '111-111-1111')
self.assertEqual(result['phone'], '111-111-1111')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_address_by_location_type_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":214,
"values":[{
"id":"214",
"contact_id":"202",
"location_type_id":"1",
"is_primary":"0",
"is_billing":"0",
"manual_geo_code":"0"
}]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_address(self.contact_id, 1)
self.assertEqual(result['location_type_id'], '1')
assert not self.cc.is_valid_option.called
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_address_by_location_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":5,
"values":{
"5":"Billing",
"1":"Home",
"3":"Main",
"4":"Other",
"2":"Work"
}
}
"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":214,
"values":[{
"id":"214",
"contact_id":"202",
"location_type_id":"1",
"is_primary":"0",
"is_billing":"0",
"manual_geo_code":"0"
}]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_address(self.contact_id, 'Home')
self.assertEqual(result['location_type_id'], '1')
self.cc.is_valid_option.assert_called_with('Address',
'location_type_id', 'Home')
class CiviCRMTests(unittest.TestCase):
# pylint: disable=R0904
def setUp(self):
#ip = '192.168.56.101' # was '192.168.1.124'
ip = '192.168.1.107'
url = "%s/drupal7/sites/all/modules/civicrm/" % ip
site_key = '371cfadc834d2784a35e4f4ab20c1316'
api_key = 'b734df56706432bb514ed737465424c3'
self.cc = CiviCRM(url, site_key, api_key, timeout=1, use_ssl=False)
self.contact_id = 202 # id for a valid civicrm user
self.contact_json = '''{
"address_id": "1",
"country_id": "1228",
"contact_id": "1",
"id": "1",
"world_region": "America South, Central, North and Caribbean",
"city": "Portland",
"preferred_mail_format": "Both",
"display_name": "Test Test",
"do_not_sms": "0",
"email_id": "1",
"organization_name": "org.org",
"is_opt_out": "0",
"do_not_email": "0",
"do_not_mail": "0",
"state_province_id": "1036",
"email": "*****@*****.**",
"worldregion_id": "2",
"do_not_phone": "0",
"is_deceased": "0", "state_province": "OR",
"contact_type": "Individual",
"contact_is_deleted": "0",
"street_address": "PO Box 28228"
}'''
self.contacts = '{"values":[' + self.contact_json + ']}'
self.results = """
{
"is_error":0,
"version":3,
"count":1,"id":2,
"values":[
{"id":"2",
"contact_type":"Individual",
"contact_sub_type":"",
"do_not_email":"0",
"do_not_phone":"0",
"do_not_mail":"0",
"do_not_sms":"0",
"do_not_trade":"0",
"is_opt_out":"0",
"display_name":"bar, foo",
"created_date":"2014-10-05 13:05:13",
"modified_date":"2014-10-05 13:05:13"}
]
}
"""
def tearDown(self):
pass
# methods and fuctions without network calls
def test_add_options(self):
results = self.cc._add_options({}, limit=1,offset=0)
expected = {u'options[limit]' : 1, u'options[offset]' : 0}
self.assertEquals(expected['options[limit]'], 1)
def test_add_single_option(self):
results = self.cc._add_options({}, limit=1)
self.assertEquals(len(results), 1)
def test__construct_payload_get(self):
payload = self.cc._construct_payload('get', 'get', 'Contact',
{'json' : 0, 'contact_id': 2})
self.assertEquals(payload['json'], 1)
self.assertEquals(payload['contact_id'], 2)
def test__construct_payload_post(self):
payload = self.cc._construct_payload('post', 'create', 'Contact',
{'json' : 0, 'contact_id': 2})
self.assertEquals(payload['json'], 1)
self.assertEquals(payload['contact_id'], 2)
def test__check_results(self):
results = self.cc._check_results({'is_error' : 0, 'result' : 1})
self.assertEquals(results, 1)
def test__check_results_raises_exception(self):
self.assertRaises(CivicrmError, self.cc._check_results,
{'is_error' : 1, 'error_message' : 'test', 'result' : 1})
def test_is_valid_option_id_is_valid(self):
result = self.cc.is_valid_option(
'Activity', 'activity_is_test', 0)
self.assertEquals(result, 0)
def test_is_valid_option_id_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', 2)
def test_is_valid_option_label_is_valid(self):
result = self.cc.is_valid_option(
'Activity', 'activity_is_test', 'Yes')
self.assertEquals(result, '1')
def test_is_valid_option_label_is_not_valid(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', 'Not Valid')
def test_is_valid_option_label_is_none(self):
self.assertRaises(CivicrmError, self.cc.is_valid_option,
'Activity', 'activity_is_test', None)
def test_matches_required_no_match(self):
required = ['exists']
params = {'does not exist' : True}
results = matches_required(required, params)
self.assertEquals(results, ['exists'])
def test_matches_required_matches(self):
required = ['exists']
params = {'exists' : True}
results = matches_required(required, params)
self.assertEquals(results, None)
# Methods calling requests
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test__get(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contacts
results = self.cc._get('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test__post(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.contacts
results = self.cc._post('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_get(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contacts
results = self.cc.get('Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_get_invalid_option(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error": 1,
"error_code": 2001,
"error_message": "id is not a valid integer",
"entity": "Contact",
"action": "get",
"error_field": "id",
"type": "integer"
}
"""
self.assertRaises(CivicrmError,self.cc.get,
"Contact", contact_id="a")
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getsingle(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = self.contact_json
results = self.cc.getsingle('Contact',contact_id=1)
self.assertEqual(results['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getsingle_multiple_results(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"count":25,
"is_error":1,
"error_message":"Expected one Contact but found 25"
}"""
self.assertRaises(CivicrmError, self.cc.getsingle,
'Contact', country='United States')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getvalue(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = \
"""{"is_error":0,"result":"Test, Test"}"""
results = self.cc.getvalue('Contact', 'sort_name', contact_id=1)
self.assertEquals(type(results), unicode)
self.assertEquals(results, 'Test, Test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getvalue_multiple_results(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"count":25,
"is_error":1,
"error_message":"Expected one Contact but found 25"
}"""
self.assertRaises(CivicrmError, self.cc.getvalue,
'Contact', 'sort_name', country='United States')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_create(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.create('Contact',
contact_type='individual', display_name='bar, foo')
self.assertEquals(results[0]['display_name'], 'bar, foo')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_delete(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"version":3,"count":1,"values":1}"""
results = self.cc.delete('Contact', 2, True)
self.assertEquals(results, 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_update(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.update('Contact', 2, display_name='bar, foo')
self.assertEquals(results[0]['display_name'], 'bar, foo')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_setvalue(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":2,
"values":{"id":"2","display_name":"foo,bar"}
}"""
results = self.cc.setvalue('Contact', 2, 'display_name', 'foo, bar')
self.assertEquals(results['display_name'], 'foo,bar')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getcount(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content =\
"""{"is_error":0,"result":1}"""
count = self.cc.getcount('Contact', contact_id=1)
self.assertEquals(count, 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getoptions(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":3,
"values":{
"Household":"Household",
"Individual":"Individual",
"Organization":"Organization"
}
}"""
results = self.cc.getoptions('Contact', 'contact_type')
self.assertIn('Organization', results)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_getoptions_raises_error(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{"is_error":1,"error_message":"The field 'city' doesn't exist."}
"""
self.assertRaises(CivicrmError, self.cc.getoptions, 'Contact', 'city')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_doaction(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.contacts
results = self.cc.doaction('get', 'Contact')
self.assertEqual(results[0]['id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contact(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = self.results
results = self.cc.add_contact(
contact_type='Individual', display_name='bar, foo')
self.assertEquals(results['display_name'], 'bar, foo')
def test_add_contact_required_field_missing(self):
self.assertRaisesRegexp(CivicrmError, 'fields must exist',
self.cc.add_contact, contact_type='Individual')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contact_wrong_type(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"error_field":"contact_type",
"error_code":2001,
"entity":"Contact",
"action":"create",
"is_error":1,
"error_message":"'not a contact type' is not a valid option for field contact_type"
}"""
self.assertRaisesRegexp(CivicrmError,' not a valid option',
self.cc.add_contact, 'not a contact type',
display_name='test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_by_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":382,
"values":[{
"id":"382",
"contact_id_a":"101",
"contact_id_b":"102",
"relationship_type_id":"1",
"start_date":"NULL",
"end_date":"NULL",
"is_active":"1",
"description":"",
"is_permission_a_b":"0",
"is_permission_b_a":"0",
"case_id":""}]
}"""
result = self.cc.add_relationship(101, 102, 1)
self.assertEquals(result['relationship_type_id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_by_type(self, mock_requests):
result1 = """{
"is_error":0,"version":3,"count":1,"id":3,
"values":[{"id":"3","name_a_b":"Partnerof"}]
}"""
result2 = """
{
"is_error":0,
"version":3,
"count":1,
"id":382,
"values":[{
"id":"382",
"contact_id_a":"101",
"contact_id_b":"102",
"relationship_type_id":"3",
"start_date":"NULL",
"end_date":"NULL",
"is_active":"1",
"description":"",
"is_permission_a_b":"0",
"is_permission_b_a":"0",
"case_id":""}]
}"""
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = result1
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = result2
result = self.cc.add_relationship(101, 102, 'Partner of')
call = mock_requests.post.call_args[1]['data']['relationship_type_id']
self.assertEquals(call, '3')
self.assertEquals(result['relationship_type_id'], '3')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_relationship_type_not_found(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content =\
"""{"is_error":0,"version":3,"count":0,"values":[]}"""
self.assertRaises(CivicrmError,
self.cc.add_relationship, 101, 102, 'Aunt of')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_type(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":772,
"values":[{
"id":"772",
"option_group_id":"2",
"label":"test_activity_type",
"value":"64",
"name":"test_activity_type",
"is_active":"1"}]
}"""
result = self.cc.add_activity_type('test_activity_type', is_active=1)
self.assertEqual(result['name'], 'test_activity_type')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_by_status_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,
"count":1,
"id":3,
"values":[{
"id":"3",
"activity_type_id":"1",
"subject":"test",
"status_id":"2",
"priority_id":"2"}]
}"""
result = self.cc.add_activity(1, self.contact_id,
subject = "test", status = 2, is_test=1)
self.assertEquals(result['activity_type_id'], '1')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_by_status_type(self, mock_is_valid, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,
"count":1,
"id":3,
"values":[{
"id":"3",
"activity_type_id":"1",
"subject":"test",
"status_id":"2",
"priority_id":"2"}]
}"""
results = [1, 2]
def side_effect(*args, **kwargs):
return results.pop(0)
mock_is_valid.side_effect = side_effect
result = self.cc.add_activity("Meeting", self.contact_id,
subject = "test", activity_status = "Completed",
status = "Cancelled", is_test=1)
self.assertEquals(result['activity_type_id'], '1')
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_invalid_label(self, mock_is_valid):
def side_effect(*args, **kwargs):
raise CivicrmError
mock_is_valid.side_effect = side_effect
self.assertRaises(CivicrmError,
self.cc.add_activity,"Not A Meeting", self.contact_id,
"test", "0000", 2)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_activity_invalid_status_id(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":3,
"values":{"1":"Meeting","2":"Phone Call","3":"Email"}
}
"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"error_field":"status_id",
"error_code":2001,
"entity":"Activity",
"action":"create",
"is_error":1,
"error_message":"'10'is not a valid option for field status_id"
}"""
self.assertRaises(CivicrmError,
self.cc.add_activity,"Meeting", self.contact_id,
"test", "0000", 10)
@mock.patch.object(CiviCRM, "is_valid_option")
def test_add_activity_invalid_status_type(self, mock_valid):
returns = [1, CivicrmError('error')]
def side_effect(*args, **kwargs):
result = returns.pop(0)
if isinstance(result, Exception):
raise result
return result
mock_valid.side_effect = side_effect
self.assertRaises(CivicrmError,
self.cc.add_activity,"Meeting", self.contact_id,
"test", "0000", "test")
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_by_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":130,
"values":[
{"id":"130",
"contact_id":"202",
"financial_type_id":"1",
"payment_instrument_id":"4",
"total_amount":"100",
"currency":"USD",
"contribution_status_id":"1",
"contribution_type_id":"1"}
]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_contribution(self.contact_id, 100, 1, is_test=1)
self.assertEquals(result['total_amount'], '100')
assert not self.cc.is_valid_option.called
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_by_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content ="""
{
"is_error":0,
"version":3,
"count":4,
"values":{
"3":"Campaign Contribution",
"1":"Donation",
"4":"Event Fee",
"2":"Member Dues"}
}"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,
"count":1,
"id":130,
"values":[
{"id":"130",
"contact_id":"202",
"financial_type_id":"1",
"payment_instrument_id":"4",
"total_amount":"100",
"currency":"USD",
"contribution_status_id":"1",
"contribution_type_id":"1"}
]
}"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_contribution(self.contact_id,
100, 'Donation', is_test=1)
self.assertEquals(result['total_amount'], '100')
self.cc.is_valid_option.assert_called_with(
'Contribution', 'financial_type_id', 'Donation')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_contribution_invalid_financial_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content ="""
{
"is_error":0,
"version":3,
"count":4,
"values":{
"3":"Campaign Contribution",
"1":"Donation",
"4":"Event Fee",
"2":"Member Dues"}
}"""
self.assertRaises(CivicrmError,
self.cc.add_contribution,self.contact_id,
100, 'Not Valid', is_test=1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_email(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,"count":1,
"id":220,
"values":[{
"id":"220",
"contact_id":"202",
"email":"*****@*****.**",
"is_primary":"0"
}]
}
"""
result = self.cc.add_email(self.contact_id, '*****@*****.**')
self.assertEquals(result['email'], '*****@*****.**')
def test_add_email_is_not_email_like(self):
self.assertRaises(CivicrmError, self.cc.add_email,
self.contact_id, 'invalid.address', True)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_note(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,
"count":1,
"id":41,
"values":[{
"id":"41",
"entity_table":"civicrm_contact",
"entity_id":"202",
"note":"test",
"contact_id":"202",
"privacy":"0"}]
}
"""
result = self.cc.add_note(self.contact_id, 'test')
self.assertEquals(result['note'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_tag(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content ="""
{
"is_error":0,
"version":3,
"count":1,
"id":22,
"values":[{
"id":"22",
"name":"test",
"description":"",
"used_for":"civicrm_contact"
}]
}
"""
result = self.cc.add_tag('test')
self.assertEquals(result['name'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_entity_tag(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"not_added":0,"added":1,"total_count":1}"""
result = self.cc.add_entity_tag(self.contact_id, 1)
self.assertEquals(result['added'], 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_group(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":22,
"values":[{
"id":"22",
"name":"test_22",
"title":"test"
}]
}
"""
result = self.cc.add_group(title='test')
self.assertEquals(result['title'], 'test')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_group_contact(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content =\
"""{"is_error":0,"not_added":0,"added":1,"total_count":1}"""
result = self.cc.add_group_contact(self.contact_id, 5)
self.assertEquals(result['added'], 1)
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_phone(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":179,
"values":[{
"id":"179",
"contact_id":"202",
"is_primary":"0",
"mobile_provider_id":"",
"phone":"111-111-1111",
"phone_ext":"",
"phone_numeric":"",
"phone_type_id":""
}]
}
"""
result = self.cc.add_phone(self.contact_id, '111-111-1111')
self.assertEquals(result['phone'], '111-111-1111')
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_address_by_location_type_id(self, mock_requests):
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":214,
"values":[{
"id":"214",
"contact_id":"202",
"location_type_id":"1",
"is_primary":"0",
"is_billing":"0",
"manual_geo_code":"0"
}]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_address(self.contact_id, 1)
self.assertEquals(result['location_type_id'], '1')
assert not self.cc.is_valid_option.called
@mock.patch("pythoncivicrm.pythoncivicrm.requests")
def test_add_address_by_location_type(self, mock_requests):
mock_requests.get.return_value.status_code = 200
mock_requests.get.return_value.content = """
{
"is_error":0,
"version":3,
"count":5,
"values":{
"5":"Billing",
"1":"Home",
"3":"Main",
"4":"Other",
"2":"Work"
}
}
"""
mock_requests.post.return_value.status_code = 200
mock_requests.post.return_value.content = """
{
"is_error":0,
"version":3,
"count":1,
"id":214,
"values":[{
"id":"214",
"contact_id":"202",
"location_type_id":"1",
"is_primary":"0",
"is_billing":"0",
"manual_geo_code":"0"
}]
}
"""
self.cc.is_valid_option = mock.MagicMock()
result = self.cc.add_address(self.contact_id, 'Home')
self.assertEquals(result['location_type_id'], '1')
self.cc.is_valid_option.assert_called_with(
'Address', 'location_type_id', 'Home')