diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/test/integ')
| -rw-r--r-- | .venv/lib/python3.12/site-packages/test/integ/__init__.py | 0 | ||||
| -rw-r--r-- | .venv/lib/python3.12/site-packages/test/integ/test_sendgrid.py | 2309 |
2 files changed, 2309 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/test/integ/__init__.py b/.venv/lib/python3.12/site-packages/test/integ/__init__.py new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/integ/__init__.py diff --git a/.venv/lib/python3.12/site-packages/test/integ/test_sendgrid.py b/.venv/lib/python3.12/site-packages/test/integ/test_sendgrid.py new file mode 100644 index 00000000..0c63851e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/integ/test_sendgrid.py @@ -0,0 +1,2309 @@ +import datetime +import os +import unittest + +import sendgrid +from sendgrid.helpers.endpoints.ip.unassigned import unassigned + + +class UnitTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.path = '{}{}'.format( + os.path.abspath( + os.path.dirname(__file__)), '/..') + cls.sg = sendgrid.SendGridAPIClient() + cls.devnull = open(os.devnull, 'w') + + def test_api_key_init(self): + self.assertEqual(self.sg.api_key, os.environ.get('SENDGRID_API_KEY')) + my_sendgrid = sendgrid.SendGridAPIClient(api_key="THISISMYKEY") + self.assertEqual(my_sendgrid.api_key, "THISISMYKEY") + + def test_api_key_setter(self): + sg_api_key_setter = sendgrid.SendGridAPIClient(api_key="THISISMYKEY") + self.assertEqual(sg_api_key_setter.api_key, "THISISMYKEY") + # Use api_key setter to change api key + sg_api_key_setter.api_key = "THISISMYNEWAPIKEY" + self.assertEqual(sg_api_key_setter.api_key, "THISISMYNEWAPIKEY") + + def test_impersonate_subuser_init(self): + temp_subuser = 'abcxyz@this.is.a.test.subuser' + sg_impersonate = sendgrid.SendGridAPIClient( + impersonate_subuser=temp_subuser) + self.assertEqual(sg_impersonate.impersonate_subuser, temp_subuser) + + def test_useragent(self): + useragent = '{}{}{}'.format('sendgrid/', sendgrid.__version__, ';python') + self.assertEqual(self.sg.useragent, useragent) + + def test_host(self): + self.assertEqual(self.sg.host, 'https://api.sendgrid.com') + + def test_get_default_headers(self): + headers = self.sg._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._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._default_headers.items(): + self.assertEqual(v, self.sg.client.request_headers[k]) + + 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) + data = response.body + unused = unassigned(data) + self.assertEqual(type(unused), list) + 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" + } + headers = {'X-Mock': 200} + response = self.sg.client.ips.warmup.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_ips_warmup_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.ips.warmup.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_ips_warmup__ip_address__get(self): + ip_address = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.ips.warmup._( + ip_address).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_ips_warmup__ip_address__delete(self): + ip_address = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.ips.warmup._( + ip_address).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_ips__ip_address__get(self): + ip_address = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.ips._( + ip_address).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_batch_post(self): + headers = {'X-Mock': 201} + response = self.sg.client.mail.batch.post(request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_mail_batch__batch_id__get(self): + batch_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.mail.batch._( + batch_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_send_post(self): + data = { + "asm": { + "group_id": 1, + "groups_to_display": [ + 1, + 2, + 3 + ] + }, + "attachments": [ + { + "content": "[BASE64 encoded content block here]", + "content_id": "ii_139db99fdb5c3704", + "disposition": "inline", + "filename": "file1.jpg", + "name": "file1", + "type": "jpg" + } + ], + "batch_id": "[YOUR BATCH ID GOES HERE]", + "categories": [ + "category1", + "category2" + ], + "content": [ + { + "type": "text/html", + "value": "<html><p>Hello, world!</p><img " + "src=[CID GOES HERE]></img></html>" + } + ], + "custom_args": { + "New Argument 1": "New Value 1", + "activationAttempt": "1", + "customerAccountNumber": "[CUSTOMER ACCOUNT NUMBER GOES HERE]" + }, + "from": { + "email": "sam.smith@example.com", + "name": "Sam Smith" + }, + "headers": {}, + "ip_pool_name": "[YOUR POOL NAME GOES HERE]", + "mail_settings": { + "bcc": { + "email": "ben.doe@example.com", + "enable": True + }, + "bypass_list_management": { + "enable": True + }, + "footer": { + "enable": True, + "html": "<p>Thanks</br>The SendGrid Team</p>", + "text": "Thanks,/n The SendGrid Team" + }, + "sandbox_mode": { + "enable": False + }, + "spam_check": { + "enable": True, + "post_to_url": "http://example.com/compliance", + "threshold": 3 + } + }, + "personalizations": [ + { + "bcc": [ + { + "email": "sam.doe@example.com", + "name": "Sam Doe" + } + ], + "cc": [ + { + "email": "jane.doe@example.com", + "name": "Jane Doe" + } + ], + "custom_args": { + "New Argument 1": "New Value 1", + "activationAttempt": "1", + "customerAccountNumber": + "[CUSTOMER ACCOUNT NUMBER GOES HERE]" + }, + "headers": { + "X-Accept-Language": "en", + "X-Mailer": "MyApp" + }, + "send_at": 1409348513, + "subject": "Hello, World!", + "substitutions": { + "id": "substitutions", + "type": "object" + }, + "to": [ + { + "email": "john.doe@example.com", + "name": "John Doe" + } + ] + } + ], + "reply_to": { + "email": "sam.smith@example.com", + "name": "Sam Smith" + }, + "sections": { + "section": { + ":sectionName1": "section 1 text", + ":sectionName2": "section 2 text" + } + }, + "send_at": 1409348513, + "subject": "Hello, World!", + "template_id": "[YOUR TEMPLATE ID GOES HERE]", + "tracking_settings": { + "click_tracking": { + "enable": True, + "enable_text": True + }, + "ganalytics": { + "enable": True, + "utm_campaign": "[NAME OF YOUR REFERRER SOURCE]", + "utm_content": "[USE THIS SPACE TO DIFFERENTIATE " + "YOUR EMAIL FROM ADS]", + "utm_medium": "[NAME OF YOUR MARKETING MEDIUM e.g. email]", + "utm_name": "[NAME OF YOUR CAMPAIGN]", + "utm_term": "[IDENTIFY PAID KEYWORDS HERE]" + }, + "open_tracking": { + "enable": True, + "substitution_tag": "%opentrack" + }, + "subscription_tracking": { + "enable": True, + "html": "If you would like to unsubscribe and stop " + "receiving these emails <% clickhere %>.", + "substitution_tag": "<%click here%>", + "text": "If you would like to unsubscribe and stop " + "receiving these emails <% click here %>." + } + } + } + headers = {'X-Mock': 202} + response = self.sg.client.mail.send.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 202) + + def test_mail_settings_get(self): + params = {'limit': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_address_whitelist_patch(self): + data = { + "enabled": True, + "list": [ + "email1@example.com", + "example.com" + ] + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.address_whitelist.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_address_whitelist_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.address_whitelist.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_bcc_patch(self): + data = { + "email": "email@example.com", + "enabled": False + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.bcc.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_bcc_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.bcc.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_bounce_purge_patch(self): + data = { + "enabled": True, + "hard_bounces": 5, + "soft_bounces": 5 + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.bounce_purge.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_bounce_purge_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.bounce_purge.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_footer_patch(self): + data = { + "enabled": True, + "html_content": "...", + "plain_content": "..." + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.footer.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_footer_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.footer.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_forward_bounce_patch(self): + data = { + "email": "example@example.com", + "enabled": True + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.forward_bounce.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_forward_bounce_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.forward_bounce.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_forward_spam_patch(self): + data = { + "email": "", + "enabled": False + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.forward_spam.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_forward_spam_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.forward_spam.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_plain_content_patch(self): + data = { + "enabled": False + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.plain_content.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_plain_content_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.plain_content.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_spam_check_patch(self): + data = { + "enabled": True, + "max_score": 5, + "url": "url" + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.spam_check.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_spam_check_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.spam_check.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_template_patch(self): + data = { + "enabled": True, + "html_content": "<% body %>" + } + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.template.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mail_settings_template_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.mail_settings.template.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_mailbox_providers_stats_get(self): + params = { + 'end_date': '2016-04-01', + 'mailbox_providers': 'test_string', + 'aggregated_by': 'day', + 'limit': 1, + 'offset': 1, + 'start_date': '2016-01-01'} + headers = {'X-Mock': 200} + response = self.sg.client.mailbox_providers.stats.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_partner_settings_get(self): + params = {'limit': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.partner_settings.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_partner_settings_new_relic_patch(self): + data = { + "enable_subuser_statistics": True, + "enabled": True, + "license_key": "" + } + headers = {'X-Mock': 200} + response = self.sg.client.partner_settings.new_relic.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_partner_settings_new_relic_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.partner_settings.new_relic.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_scopes_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.scopes.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_senders_post(self): + data = { + "address": "123 Elm St.", + "address_2": "Apt. 456", + "city": "Denver", + "country": "United States", + "from": { + "email": "from@example.com", + "name": "Example INC" + }, + "nickname": "My Sender ID", + "reply_to": { + "email": "replyto@example.com", + "name": "Example INC" + }, + "state": "Colorado", + "zip": "80202" + } + headers = {'X-Mock': 201} + response = self.sg.client.senders.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_senders_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.senders.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_senders__sender_id__patch(self): + data = { + "address": "123 Elm St.", + "address_2": "Apt. 456", + "city": "Denver", + "country": "United States", + "from": { + "email": "from@example.com", + "name": "Example INC" + }, + "nickname": "My Sender ID", + "reply_to": { + "email": "replyto@example.com", + "name": "Example INC" + }, + "state": "Colorado", + "zip": "80202" + } + sender_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.senders._(sender_id).patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_senders__sender_id__get(self): + sender_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.senders._( + sender_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_senders__sender_id__delete(self): + sender_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.senders._( + sender_id).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_senders__sender_id__resend_verification_post(self): + sender_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.senders._( + sender_id).resend_verification.post(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_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.stats.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_post(self): + data = { + "email": "John@example.com", + "ips": [ + "1.1.1.1", + "2.2.2.2" + ], + "password": "johns_password", + "username": "John@example.com" + } + headers = {'X-Mock': 200} + response = self.sg.client.subusers.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_get(self): + params = {'username': 'test_string', 'limit': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.subusers.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_reputations_get(self): + params = {'usernames': 'test_string'} + headers = {'X-Mock': 200} + response = self.sg.client.subusers.reputations.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_stats_get(self): + params = { + 'end_date': '2016-04-01', + 'aggregated_by': 'day', + 'limit': 1, + 'offset': 1, + 'start_date': '2016-01-01', + 'subusers': 'test_string'} + headers = {'X-Mock': 200} + response = self.sg.client.subusers.stats.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_stats_monthly_get(self): + params = { + 'subuser': 'test_string', + 'limit': 1, + 'sort_by_metric': 'test_string', + 'offset': 1, + 'date': 'test_string', + 'sort_by_direction': 'asc'} + headers = {'X-Mock': 200} + response = self.sg.client.subusers.stats.monthly.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers_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.subusers.stats.sums.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers__subuser_name__patch(self): + data = { + "disabled": False + } + subuser_name = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.subusers._(subuser_name).patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_subusers__subuser_name__delete(self): + subuser_name = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.subusers._( + subuser_name).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_subusers__subuser_name__ips_put(self): + data = [ + "127.0.0.1" + ] + subuser_name = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.subusers._(subuser_name).ips.put( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers__subuser_name__monitor_put(self): + data = { + "email": "example@example.com", + "frequency": 500 + } + subuser_name = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.subusers._(subuser_name).monitor.put( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers__subuser_name__monitor_post(self): + data = { + "email": "example@example.com", + "frequency": 50000 + } + subuser_name = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.subusers._(subuser_name).monitor.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers__subuser_name__monitor_get(self): + subuser_name = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.subusers._( + subuser_name).monitor.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_subusers__subuser_name__monitor_delete(self): + subuser_name = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.subusers._( + subuser_name).monitor.delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_subusers__subuser_name__stats_monthly_get(self): + params = { + 'date': 'test_string', + 'sort_by_direction': 'asc', + 'limit': 1, + 'sort_by_metric': 'test_string', + 'offset': 1} + subuser_name = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.subusers._(subuser_name).stats.monthly.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_blocks_get(self): + params = {'start_time': 1, 'limit': 1, 'end_time': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.suppression.blocks.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_blocks_delete(self): + data = { + "delete_all": False, + "emails": [ + "example1@example.com", + "example2@example.com" + ] + } + headers = {'X-Mock': 204} + response = self.sg.client.suppression.blocks.delete( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_blocks__email__get(self): + email = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.suppression.blocks._( + email).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_blocks__email__delete(self): + email = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.suppression.blocks._( + email).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_bounces_get(self): + params = {'start_time': 1, 'end_time': 1} + headers = {'X-Mock': 200} + response = self.sg.client.suppression.bounces.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_bounces_delete(self): + data = { + "delete_all": True, + "emails": [ + "example@example.com", + "example2@example.com" + ] + } + headers = {'X-Mock': 204} + response = self.sg.client.suppression.bounces.delete( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_bounces__email__get(self): + email = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.suppression.bounces._( + email).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_bounces__email__delete(self): + params = {'email_address': 'example@example.com'} + email = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.suppression.bounces._(email).delete( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_invalid_emails_get(self): + params = {'start_time': 1, 'limit': 1, 'end_time': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.suppression.invalid_emails.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_invalid_emails_delete(self): + data = { + "delete_all": False, + "emails": [ + "example1@example.com", + "example2@example.com" + ] + } + headers = {'X-Mock': 204} + response = self.sg.client.suppression.invalid_emails.delete( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_invalid_emails__email__get(self): + email = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.suppression.invalid_emails._( + email).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_invalid_emails__email__delete(self): + email = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.suppression.invalid_emails._( + email).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_spam_report__email__get(self): + email = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.suppression.spam_reports._( + email).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_spam_report__email__delete(self): + email = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.suppression.spam_reports._( + email).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_spam_reports_get(self): + params = {'start_time': 1, 'limit': 1, 'end_time': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.suppression.spam_reports.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_suppression_spam_reports_delete(self): + data = { + "delete_all": False, + "emails": [ + "example1@example.com", + "example2@example.com" + ] + } + headers = {'X-Mock': 204} + response = self.sg.client.suppression.spam_reports.delete( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_suppression_unsubscribes_get(self): + params = {'start_time': 1, 'limit': 1, 'end_time': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.suppression.unsubscribes.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates_post(self): + data = { + "name": "example_name" + } + headers = {'X-Mock': 201} + response = self.sg.client.templates.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_templates_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.templates.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates__template_id__patch(self): + data = { + "name": "new_example_name" + } + template_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.templates._(template_id).patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates__template_id__get(self): + template_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.templates._( + template_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates__template_id__delete(self): + template_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.templates._( + template_id).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_templates__template_id__versions_post(self): + data = { + "active": 1, + "html_content": "<%body%>", + "name": "example_version_name", + "plain_content": "<%body%>", + "subject": "<%subject%>", + "template_id": "ddb96bbc-9b92-425e-8979-99464621b543" + } + template_id = "test_url_param" + headers = {'X-Mock': 201} + response = self.sg.client.templates._(template_id).versions.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_templates__template_id__versions__version_id__patch(self): + data = { + "active": 1, + "html_content": "<%body%>", + "name": "updated_example_name", + "plain_content": "<%body%>", + "subject": "<%subject%>" + } + template_id = "test_url_param" + version_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.templates._(template_id).versions._( + version_id).patch(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates__template_id__versions__version_id__get(self): + template_id = "test_url_param" + version_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.templates._(template_id).versions._( + version_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_templates__template_id__versions__version_id__delete(self): + template_id = "test_url_param" + version_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.templates._(template_id).versions._( + version_id).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_templates__template_id__versions__version_id__activate_post(self): + template_id = "test_url_param" + version_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.templates._(template_id).versions._( + version_id).activate.post(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_get(self): + params = {'limit': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_click_patch(self): + data = { + "enabled": True + } + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.click.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_click_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.click.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_google_analytics_patch(self): + data = { + "enabled": True, + "utm_campaign": "website", + "utm_content": "", + "utm_medium": "email", + "utm_source": "sendgrid.com", + "utm_term": "" + } + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.google_analytics.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_google_analytics_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.google_analytics.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_open_patch(self): + data = { + "enabled": True + } + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.open.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_open_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.open.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_subscription_patch(self): + data = { + "enabled": True, + "html_content": "html content", + "landing": "landing page html", + "plain_content": "text content", + "replace": "replacement tag", + "url": "url" + } + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.subscription.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_tracking_settings_subscription_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.tracking_settings.subscription.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_account_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.account.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_credits_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.credits.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_email_put(self): + data = { + "email": "example@example.com" + } + headers = {'X-Mock': 200} + response = self.sg.client.user.email.put( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_email_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.email.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_password_put(self): + data = { + "new_password": "new_password", + "old_password": "old_password" + } + headers = {'X-Mock': 200} + response = self.sg.client.user.password.put( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_profile_patch(self): + data = { + "city": "Orange", + "first_name": "Example", + "last_name": "User" + } + headers = {'X-Mock': 200} + response = self.sg.client.user.profile.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_profile_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.profile.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_scheduled_sends_post(self): + data = { + "batch_id": "YOUR_BATCH_ID", + "status": "pause" + } + headers = {'X-Mock': 201} + response = self.sg.client.user.scheduled_sends.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_user_scheduled_sends_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.scheduled_sends.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_scheduled_sends__batch_id__patch(self): + data = { + "status": "pause" + } + batch_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.user.scheduled_sends._( + batch_id).patch(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_user_scheduled_sends__batch_id__get(self): + batch_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.user.scheduled_sends._( + batch_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_scheduled_sends__batch_id__delete(self): + batch_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.user.scheduled_sends._( + batch_id).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_user_settings_enforced_tls_patch(self): + data = { + "require_tls": True, + "require_valid_cert": False + } + headers = {'X-Mock': 200} + response = self.sg.client.user.settings.enforced_tls.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_settings_enforced_tls_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.settings.enforced_tls.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_username_put(self): + data = { + "username": "test_username" + } + headers = {'X-Mock': 200} + response = self.sg.client.user.username.put( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_username_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.username.get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_event_settings_patch(self): + data = { + "bounce": True, + "click": True, + "deferred": True, + "delivered": True, + "dropped": True, + "enabled": True, + "group_resubscribe": True, + "group_unsubscribe": True, + "open": True, + "processed": True, + "spam_report": True, + "unsubscribe": True, + "url": "url" + } + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.event.settings.patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_event_settings_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.event.settings.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_event_test_post(self): + data = { + "url": "url" + } + headers = {'X-Mock': 204} + response = self.sg.client.user.webhooks.event.test.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_user_webhooks_parse_settings_post(self): + data = { + "hostname": "myhostname.com", + "send_raw": False, + "spam_check": True, + "url": "http://email.myhosthame.com" + } + headers = {'X-Mock': 201} + response = self.sg.client.user.webhooks.parse.settings.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_user_webhooks_parse_settings_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.parse.settings.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_parse_settings__hostname__patch(self): + data = { + "send_raw": True, + "spam_check": False, + "url": "http://newdomain.com/parse" + } + hostname = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.parse.settings._( + hostname).patch(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_parse_settings__hostname__get(self): + hostname = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.parse.settings._( + hostname).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_user_webhooks_parse_settings__hostname__delete(self): + hostname = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.user.webhooks.parse.settings._( + hostname).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_user_webhooks_parse_stats_get(self): + params = { + 'aggregated_by': 'day', + 'limit': 'test_string', + 'start_date': '2016-01-01', + 'end_date': '2016-04-01', + 'offset': 'test_string'} + headers = {'X-Mock': 200} + response = self.sg.client.user.webhooks.parse.stats.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains_post(self): + data = { + "automatic_security": False, + "custom_spf": True, + "default": True, + "domain": "example.com", + "ips": [ + "192.168.1.1", + "192.168.1.2" + ], + "subdomain": "news", + "username": "john@example.com" + } + headers = {'X-Mock': 201} + response = self.sg.client.whitelabel.domains.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_whitelabel_domains_get(self): + params = { + 'username': 'test_string', + 'domain': 'test_string', + 'exclude_subusers': 'true', + 'limit': 1, + 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains_default_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains.default.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains_subuser_get(self): + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains.subuser.get( + request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains_subuser_delete(self): + headers = {'X-Mock': 204} + response = self.sg.client.whitelabel.domains.subuser.delete( + request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_whitelabel_domains__domain_id__patch(self): + data = { + "custom_spf": True, + "default": False + } + domain_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains._( + domain_id).patch(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains__domain_id__get(self): + domain_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains._( + domain_id).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains__domain_id__delete(self): + domain_id = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.whitelabel.domains._( + domain_id).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_whitelabel_domains__domain_id__subuser_post(self): + data = { + "username": "jane@example.com" + } + domain_id = "test_url_param" + headers = {'X-Mock': 201} + response = self.sg.client.whitelabel.domains._( + domain_id).subuser.post(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_whitelabel_domains__id__ips_post(self): + data = { + "ip": "192.168.0.1" + } + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains._( + id_).ips.post(request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains__id__ips__ip__delete(self): + id_ = "test_url_param" + ip = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains._( + id_).ips._(ip).delete(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_domains__id__validate_post(self): + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.domains._( + id_).validate.post(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_ips_post(self): + data = { + "domain": "example.com", + "ip": "192.168.1.1", + "subdomain": "email" + } + headers = {'X-Mock': 201} + response = self.sg.client.whitelabel.ips.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_whitelabel_ips_get(self): + params = {'ip': 'test_string', 'limit': 1, 'offset': 1} + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.ips.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_ips__id__get(self): + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.ips._( + id_).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_ips__id__delete(self): + id_ = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.whitelabel.ips._( + id_).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_whitelabel_ips__id__validate_post(self): + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.ips._( + id_).validate.post(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links_post(self): + data = { + "default": True, + "domain": "example.com", + "subdomain": "mail" + } + params = {'limit': 1, 'offset': 1} + headers = {'X-Mock': 201} + response = self.sg.client.whitelabel.links.post( + request_body=data, query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 201) + + def test_whitelabel_links_get(self): + params = {'limit': 1} + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links_default_get(self): + params = {'domain': 'test_string'} + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links.default.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links_subuser_get(self): + params = {'username': 'test_string'} + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links.subuser.get( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links_subuser_delete(self): + params = {'username': 'test_string'} + headers = {'X-Mock': 204} + response = self.sg.client.whitelabel.links.subuser.delete( + query_params=params, request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_whitelabel_links__id__patch(self): + data = { + "default": True + } + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links._(id_).patch( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links__id__get(self): + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links._( + id_).get(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links__id__delete(self): + id_ = "test_url_param" + headers = {'X-Mock': 204} + response = self.sg.client.whitelabel.links._( + id_).delete(request_headers=headers) + self.assertEqual(response.status_code, 204) + + def test_whitelabel_links__id__validate_post(self): + id_ = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links._( + id_).validate.post(request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_whitelabel_links__link_id__subuser_post(self): + data = { + "username": "jane@example.com" + } + link_id = "test_url_param" + headers = {'X-Mock': 200} + response = self.sg.client.whitelabel.links._(link_id).subuser.post( + request_body=data, request_headers=headers) + self.assertEqual(response.status_code, 200) + + def test_license_year(self): + LICENSE_FILE = 'LICENSE' + copyright_line = '' + with open(LICENSE_FILE, 'r') as f: + for line in f: + if line.startswith('Copyright'): + copyright_line = line.strip() + break + self.assertEqual( + 'Copyright (C) %s, Twilio SendGrid, Inc. <help@twilio.com>' % datetime.datetime.now().year, + copyright_line) |