@classmethod

def setUpClass(cls):

cls.host = host

cls.path = '{0}{1}'.format(

os.path.abspath(

os.path.dirname(__file__)), '/..')

cls.sg = sendgrid.SendGridAPIClient(

host=host, path=cls.path,

api_key=os.environ.get('SENDGRID_API_KEY'))

cls.devnull = open(os.devnull, 'w')

prism_cmd = None

try:

# check for prism in the PATH

if subprocess.call('prism version'.split(), stdout=cls.devnull) == 0:

prism_cmd = 'prism'

except OSError:

prism_cmd = None

if not prism_cmd:

# check for known prism locations

for path in ('/usr/local/bin/prism', os.path.expanduser(os.path.join('~', 'bin', 'prism')),

os.path.abspath(os.path.join(os.getcwd(), 'prism', 'bin', 'prism'))):

prism_cmd = path if os.path.isfile(path) else None

if prism_cmd:

break

if not prism_cmd:

if sys.platform != 'win32':

# try to install with prism.sh

try:

print("Warning: no prism detected, I will try to install it locally")

prism_sh = os.path.abspath(os.path.join(cls.path, 'test', 'prism.sh'))

if subprocess.call(prism_sh) == 0:

prism_cmd = os.path.expanduser(os.path.join('~', 'bin', 'prism'))

else:

raise RuntimeError()

except Exception as e:

print(

"Error installing the prism binary, you can try "

"downloading directly here "

"(https://github.com/stoplightio/prism/releases) "

"and place in your $PATH", e)

sys.exit()

else:

print("Please download the Windows binary "

"(https://github.com/stoplightio/prism/releases) "

"and place it in your %PATH% ")

sys.exit()

print("Activating Prism (~20 seconds)")

cls.p = subprocess.Popen([

prism_cmd, "run", "-s",

"https://raw.githubusercontent.com/sendgrid/sendgrid-oai/master/"

"oai_stoplight.json"], stdout=cls.devnull, stderr=subprocess.STDOUT)

time.sleep(15)

print("Prism Started")

def test_apikey_init(self):

self.assertEqual(self.sg.apikey, os.environ.get('SENDGRID_API_KEY'))

# Support the previous naming convention for API keys

self.assertEqual(self.sg.api_key, self.sg.apikey)

my_sendgrid = sendgrid.SendGridAPIClient(apikey="THISISMYKEY")

self.assertEqual(my_sendgrid.apikey, "THISISMYKEY")

def test_impersonate_subuser_init(self):

temp_subuser = 'abcxyz@this.is.a.test.subuser'

sg_impersonate = sendgrid.SendGridAPIClient(

host=host, path=self.path,

api_key=os.environ.get('SENDGRID_API_KEY'),

impersonate_subuser=temp_subuser)

self.assertEqual(sg_impersonate.impersonate_subuser, temp_subuser)

def test_useragent(self):

useragent = '{0}{1}{2}'.format('sendgrid/', __version__, ';python')

self.assertEqual(self.sg.useragent, useragent)

def test_host(self):

self.assertEqual(self.sg.host, self.host)

def test_get_default_headers(self):

headers = self.sg._get_default_headers()

self.assertIn('Authorization', headers)

self.assertIn('User-agent', headers)

self.assertIn('Accept', headers)

self.assertNotIn('On-Behalf-Of', headers)

self.sg._impersonate_subuser = 'ladida@testsubuser.sendgrid'

headers = self.sg._get_default_headers()

self.assertIn('Authorization', headers)

self.assertIn('User-agent', headers)

self.assertIn('Accept', headers)

self.assertIn('On-Behalf-Of', headers)

def test_reset_request_headers(self):

addl_headers = {

'blah': 'test value',

'blah2x': 'another test value',

}

self.sg.client.request_headers.update(addl_headers)

self.assertIn('blah', self.sg.client.request_headers)

self.assertIn('blah2x', self.sg.client.request_headers)

self.sg.reset_request_headers()

self.assertNotIn('blah', self.sg.client.request_headers)

self.assertNotIn('blah2x', self.sg.client.request_headers)

for k,v in self.sg._get_default_headers().items():

self.assertEqual(v, self.sg.client.request_headers[k])

def test_hello_world(self):

from_email = Email("test@example.com")

to_email = Email("test@example.com")

subject = "Sending with SendGrid is Fun"

content = Content("text/plain", "and easy to do anywhere, even with Python")

mail = Mail(from_email, subject, to_email, content)

self.assertTrue(mail.get() == {'content': [{'type': 'text/plain', 'value': 'and easy to do anywhere, even with Python'}], 'personalizations': [{'to': [{'email': 'test@example.com'}]}], 'from': {'email': 'test@example.com'}, 'subject': 'Sending with SendGrid is Fun'})

def test_access_settings_activity_get(self):

params = {'limit': 1}

headers = {'X-Mock': 200}

response = self.sg.client.access_settings.activity.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_access_settings_whitelist_post(self):

data = {

"ips": [

{

"ip": "192.168.1.1"

},

{

"ip": "192.*.*.*"

},

{

"ip": "192.168.1.3/32"

}

]

}

headers = {'X-Mock': 201}

response = self.sg.client.access_settings.whitelist.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_access_settings_whitelist_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.access_settings.whitelist.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_access_settings_whitelist_delete(self):

data = {

"ids": [

1,

2,

3

]

}

headers = {'X-Mock': 204}

response = self.sg.client.access_settings.whitelist.delete(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_access_settings_whitelist__rule_id__get(self):

rule_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.access_settings.whitelist._(rule_id).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_access_settings_whitelist__rule_id__delete(self):

rule_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.access_settings.whitelist._(rule_id).delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_alerts_post(self):

data = {

"email_to": "example@example.com",

"frequency": "daily",

"type": "stats_notification"

}

headers = {'X-Mock': 201}

response = self.sg.client.alerts.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_alerts_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.alerts.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_alerts__alert_id__patch(self):

data = {

"email_to": "example@example.com"

}

alert_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.alerts._(alert_id).patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_alerts__alert_id__get(self):

alert_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.alerts._(alert_id).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_alerts__alert_id__delete(self):

alert_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.alerts._(alert_id).delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_api_keys_post(self):

data = {

"name": "My API Key",

"sample": "data",

"scopes": [

"mail.send",

"alerts.create",

"alerts.read"

]

}

headers = {'X-Mock': 201}

response = self.sg.client.api_keys.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_api_keys_get(self):

params = {'limit': 1}

headers = {'X-Mock': 200}

response = self.sg.client.api_keys.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_api_keys__api_key_id__put(self):

data = {

"name": "A New Hope",

"scopes": [

"user.profile.read",

"user.profile.update"

]

}

api_key_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.api_keys._(api_key_id).put(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_api_keys__api_key_id__patch(self):

data = {

"name": "A New Hope"

}

api_key_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.api_keys._(api_key_id).patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_api_keys__api_key_id__get(self):

api_key_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.api_keys._(api_key_id).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_api_keys__api_key_id__delete(self):

api_key_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.api_keys._(api_key_id).delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_asm_groups_post(self):

data = {

"description": "Suggestions for products our users might like.",

"is_default": True,

"name": "Product Suggestions"

}

headers = {'X-Mock': 201}

response = self.sg.client.asm.groups.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_asm_groups_get(self):

params = {'id': 1}

headers = {'X-Mock': 200}

response = self.sg.client.asm.groups.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_groups__group_id__patch(self):

data = {

"description": "Suggestions for items our users might like.",

"id": 103,

"name": "Item Suggestions"

}

group_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.asm.groups._(group_id).patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_asm_groups__group_id__get(self):

group_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.asm.groups._(group_id).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_groups__group_id__delete(self):

group_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.asm.groups._(group_id).delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_asm_groups__group_id__suppressions_post(self):

data = {

"recipient_emails": [

"test1@example.com",

"test2@example.com"

]

}

group_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.asm.groups._(group_id).suppressions.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_asm_groups__group_id__suppressions_get(self):

group_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.asm.groups._(group_id).suppressions.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_groups__group_id__suppressions_search_post(self):

data = {

"recipient_emails": [

"exists1@example.com",

"exists2@example.com",

"doesnotexists@example.com"

]

}

group_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.asm.groups._(

group_id).suppressions.search.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_groups__group_id__suppressions__email__delete(self):

group_id = "test_url_param"

email = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.asm.groups._(group_id).suppressions._(

email).delete(request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_asm_suppressions_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.asm.suppressions.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_suppressions_global_post(self):

data = {

"recipient_emails": [

"test1@example.com",

"test2@example.com"

]

}

headers = {'X-Mock': 201}

response = self.sg.client.asm.suppressions._("global").post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_asm_suppressions_global__email__get(self):

email = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.asm.suppressions._("global")._(

email).get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_asm_suppressions_global__email__delete(self):

email = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.asm.suppressions._("global")._(

email).delete(request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_asm_suppressions__email__get(self):

email = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.asm.suppressions._(email).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_browsers_stats_get(self):

params = {'end_date': '2016-04-01', 'aggregated_by': 'day',

'browsers': 'test_string', 'limit': 'test_string',

'offset': 'test_string', 'start_date': '2016-01-01'}

headers = {'X-Mock': 200}

response = self.sg.client.browsers.stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns_post(self):

data = {

"categories": [

"spring line"

],

"custom_unsubscribe_url": "",

"html_content": "<html><head><title></title></head><body>"

"<p>Check out our spring line!</p></body></html>",

"ip_pool": "marketing",

"list_ids": [

110,

124

],

"plain_content": "Check out our spring line!",

"segment_ids": [

110

],

"sender_id": 124451,

"subject": "New Products for Spring!",

"suppression_group_id": 42,

"title": "March Newsletter"

}

headers = {'X-Mock': 201}

response = self.sg.client.campaigns.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_campaigns_get(self):

params = {'limit': 1, 'offset': 1}

headers = {'X-Mock': 200}

response = self.sg.client.campaigns.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns__campaign_id__patch(self):

data = {

"categories": [

"summer line"

],

"html_content": "<html><head><title></title></head><body><p>"

"Check out our summer line!</p></body></html>",

"plain_content": "Check out our summer line!",

"subject": "New Products for Summer!",

"title": "May Newsletter"

}

campaign_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.campaigns._(campaign_id).patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns__campaign_id__get(self):

campaign_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.campaigns._(campaign_id).get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns__campaign_id__delete(self):

campaign_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.campaigns._(campaign_id).delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_campaigns__campaign_id__schedules_patch(self):

data = {

"send_at": 1489451436

}

campaign_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.campaigns._(campaign_id).schedules.patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns__campaign_id__schedules_post(self):

data = {

"send_at": 1489771528

}

campaign_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.campaigns._(campaign_id).schedules.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_campaigns__campaign_id__schedules_get(self):

campaign_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.campaigns._(campaign_id).schedules.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_campaigns__campaign_id__schedules_delete(self):

campaign_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.campaigns._(campaign_id).schedules.delete(

request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_campaigns__campaign_id__schedules_now_post(self):

campaign_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.campaigns._(campaign_id).schedules.now.post(

request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_campaigns__campaign_id__schedules_test_post(self):

data = {

"to": "your.email@example.com"

}

campaign_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.campaigns._(campaign_id).schedules.test.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_categories_get(self):

params = {'category': 'test_string', 'limit': 1, 'offset': 1}

headers = {'X-Mock': 200}

response = self.sg.client.categories.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_categories_stats_get(self):

params = {'end_date': '2016-04-01', 'aggregated_by': 'day',

'limit': 1, 'offset': 1, 'start_date': '2016-01-01',

'categories': 'test_string'}

headers = {'X-Mock': 200}

response = self.sg.client.categories.stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_categories_stats_sums_get(self):

params = {'end_date': '2016-04-01', 'aggregated_by': 'day',

'limit': 1, 'sort_by_metric': 'test_string', 'offset': 1,

'start_date': '2016-01-01', 'sort_by_direction': 'asc'}

headers = {'X-Mock': 200}

response = self.sg.client.categories.stats.sums.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_clients_stats_get(self):

params = {'aggregated_by': 'day', 'start_date': '2016-01-01',

'end_date': '2016-04-01'}

headers = {'X-Mock': 200}

response = self.sg.client.clients.stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_clients__client_type__stats_get(self):

params = {'aggregated_by': 'day', 'start_date': '2016-01-01',

'end_date': '2016-04-01'}

client_type = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.clients._(client_type).stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_custom_fields_post(self):

data = {

"name": "pet",

"type": "text"

}

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.custom_fields.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_custom_fields_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.custom_fields.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_custom_fields__custom_field_id__get(self):

custom_field_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.custom_fields._(

custom_field_id).get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_custom_fields__custom_field_id__delete(self):

custom_field_id = "test_url_param"

headers = {'X-Mock': 202}

response = self.sg.client.contactdb.custom_fields._(

custom_field_id).delete(request_headers=headers)

self.assertEqual(response.status_code, 202)

def test_contactdb_lists_post(self):

data = {

"name": "your list name"

}

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.lists.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_lists_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.lists.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_lists_delete(self):

data = [

1,

2,

3,

4

]

headers = {'X-Mock': 204}

response = self.sg.client.contactdb.lists.delete(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_contactdb_lists__list_id__patch(self):

data = {

"name": "newlistname"

}

params = {'list_id': 1}

list_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.lists._(list_id).patch(

request_body=data, query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_lists__list_id__get(self):

params = {'list_id': 1}

list_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.lists._(list_id).get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_lists__list_id__delete(self):

params = {'delete_contacts': 'true'}

list_id = "test_url_param"

headers = {'X-Mock': 202}

response = self.sg.client.contactdb.lists._(list_id).delete(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 202)

def test_contactdb_lists__list_id__recipients_post(self):

data = [

"recipient_id1",

"recipient_id2"

]

list_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.lists._(list_id).recipients.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_lists__list_id__recipients_get(self):

params = {'page': 1, 'page_size': 1}

list_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.lists._(list_id).recipients.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_lists__list_id__recipients__recipient_id__post(self):

list_id = "test_url_param"

recipient_id = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.lists._(list_id).recipients._(

recipient_id).post(request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_lists__list_id__recipients__recipient_id__delete(self):

params = {'recipient_id': 1, 'list_id': 1}

list_id = "test_url_param"

recipient_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.contactdb.lists._(list_id).recipients._(

recipient_id).delete(query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_contactdb_recipients_patch(self):

data = [

{

"email": "jones@example.com",

"first_name": "Guy",

"last_name": "Jones"

}

]

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.recipients.patch(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_recipients_post(self):

data = [

{

"age": 25,

"email": "example@example.com",

"first_name": "",

"last_name": "User"

},

{

"age": 25,

"email": "example2@example.com",

"first_name": "Example",

"last_name": "User"

}

]

headers = {'X-Mock': 201}

response = self.sg.client.contactdb.recipients.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_contactdb_recipients_get(self):

params = {'page': 1, 'page_size': 1}

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients_delete(self):

data = [

"recipient_id1",

"recipient_id2"

]

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients.delete(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients_billable_count_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients.billable_count.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients_count_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients.count.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients_search_get(self):

params = {'{field_name}': 'test_string'}

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients.search.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients__recipient_id__get(self):

recipient_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients._(

recipient_id).get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_recipients__recipient_id__delete(self):

recipient_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.contactdb.recipients._(

recipient_id).delete(request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_contactdb_recipients__recipient_id__lists_get(self):

recipient_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.recipients._(

recipient_id).lists.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_reserved_fields_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.reserved_fields.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_segments_post(self):

data = {

"conditions": [

{

"and_or": "",

"field": "last_name",

"operator": "eq",

"value": "Miller"

},

{

"and_or": "and",

"field": "last_clicked",

"operator": "gt",

"value": "01/02/2015"

},

{

"and_or": "or",

"field": "clicks.campaign_identifier",

"operator": "eq",

"value": "513"

}

],

"list_id": 4,

"name": "Last Name Miller"

}

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.segments.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_segments_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.segments.get(

request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_segments__segment_id__patch(self):

data = {

"conditions": [

{

"and_or": "",

"field": "last_name",

"operator": "eq",

"value": "Miller"

}

],

"list_id": 5,

"name": "The Millers"

}

params = {'segment_id': 'test_string'}

segment_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.segments._(segment_id).patch(

request_body=data, query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_segments__segment_id__get(self):

params = {'segment_id': 1}

segment_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.segments._(segment_id).get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_contactdb_segments__segment_id__delete(self):

params = {'delete_contacts': 'true'}

segment_id = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.contactdb.segments._(segment_id).delete(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_contactdb_segments__segment_id__recipients_get(self):

params = {'page': 1, 'page_size': 1}

segment_id = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.contactdb.segments._(

segment_id).recipients.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_devices_stats_get(self):

params = {

'aggregated_by': 'day',

'limit': 1,

'start_date': '2016-01-01',

'end_date': '2016-04-01',

'offset': 1}

headers = {'X-Mock': 200}

response = self.sg.client.devices.stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_geo_stats_get(self):

params = {

'end_date': '2016-04-01',

'country': 'US',

'aggregated_by': 'day',

'limit': 1,

'offset': 1,

'start_date': '2016-01-01'}

headers = {'X-Mock': 200}

response = self.sg.client.geo.stats.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_get(self):

params = {

'subuser': 'test_string',

'ip': 'test_string',

'limit': 1,

'exclude_whitelabels': 'true',

'offset': 1}

headers = {'X-Mock': 200}

response = self.sg.client.ips.get(

query_params=params, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_assigned_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.ips.assigned.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_pools_post(self):

data = {

"name": "marketing"

}

headers = {'X-Mock': 200}

response = self.sg.client.ips.pools.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_pools_get(self):

headers = {'X-Mock': 200}

response = self.sg.client.ips.pools.get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_pools__pool_name__put(self):

data = {

"name": "new_pool_name"

}

pool_name = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.ips.pools._(pool_name).put(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_pools__pool_name__get(self):

pool_name = "test_url_param"

headers = {'X-Mock': 200}

response = self.sg.client.ips.pools._(

pool_name).get(request_headers=headers)

self.assertEqual(response.status_code, 200)

def test_ips_pools__pool_name__delete(self):

pool_name = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.ips.pools._(

pool_name).delete(request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_ips_pools__pool_name__ips_post(self):

data = {

"ip": "0.0.0.0"

}

pool_name = "test_url_param"

headers = {'X-Mock': 201}

response = self.sg.client.ips.pools._(pool_name).ips.post(

request_body=data, request_headers=headers)

self.assertEqual(response.status_code, 201)

def test_ips_pools__pool_name__ips__ip__delete(self):

pool_name = "test_url_param"

ip = "test_url_param"

headers = {'X-Mock': 204}

response = self.sg.client.ips.pools._(pool_name).ips._(

ip).delete(request_headers=headers)

self.assertEqual(response.status_code, 204)

def test_ips_warmup_post(self):

data = {

"ip": "0.0.0.0"