diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/test')
16 files changed, 4673 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) diff --git a/.venv/lib/python3.12/site-packages/test/unit/__init__.py b/.venv/lib/python3.12/site-packages/test/unit/__init__.py new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/__init__.py diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_app.py b/.venv/lib/python3.12/site-packages/test/unit/test_app.py new file mode 100644 index 00000000..56027d57 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_app.py @@ -0,0 +1,22 @@ +import os +import unittest + +from sendgrid.helpers.inbound.config import Config +from sendgrid.helpers.inbound.app import app + + +class UnitTests(unittest.TestCase): + + def setUp(self): + self.config = Config() + app.testing = True + self.tester = app.test_client(self) + + def test_up_and_running(self): + response = self.tester.get('/') + self.assertEqual(response.status_code, 200) + + def test_used_port_true(self): + if self.config.debug_mode: + port = int(os.environ.get("PORT", self.config.port)) + self.assertEqual(port, self.config.port) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_config.py b/.venv/lib/python3.12/site-packages/test/unit/test_config.py new file mode 100644 index 00000000..f60306a5 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_config.py @@ -0,0 +1,60 @@ +import os +import unittest + +import sendgrid.helpers.inbound.config +from sendgrid.helpers.inbound.config import Config + + +class UnitTests(unittest.TestCase): + + def setUp(self): + self.config = Config() + + def test_initialization(self): + endpoint = '/inbound' + port = 5000 + keys = [ + 'from', + 'attachments', + 'headers', + 'text', + 'envelope', + 'to', + 'html', + 'sender_ip', + 'attachment-info', + 'subject', + 'dkim', + 'SPF', + 'charsets', + 'content-ids', + 'spam_report', + 'spam_score', + 'email', + ] + host = 'http://127.0.0.1:5000/inbound' + + self.assertTrue(self.config.debug_mode) + self.assertEqual(self.config.endpoint, endpoint) + self.assertEqual(self.config.host, host) + self.assertEqual(self.config.port, port) + for key in keys: + self.assertIn(key, self.config.keys) + + def test_init_environment_should_set_env_from_dotenv(self): + config_file = sendgrid.helpers.inbound.config.__file__ + env_file_path = '{0}/.env'.format(os.path.abspath(os.path.dirname(config_file))) + with open(env_file_path, 'w') as f: + f.write('RANDOM_VARIABLE=RANDOM_VALUE') + Config() + os.remove(env_file_path) + self.assertEqual(os.environ['RANDOM_VARIABLE'], 'RANDOM_VALUE') + + def test_init_environment_should_not_set_env_if_format_is_invalid(self): + config_file = sendgrid.helpers.inbound.config.__file__ + env_file_path = os.path.abspath(os.path.dirname(config_file)) + '/.env' + with open(env_file_path, 'w') as f: + f.write('RANDOM_VARIABLE=RANDOM_VALUE=ANOTHER_RANDOM_VALUE') + Config() + os.remove(env_file_path) + self.assertIsNone(os.environ.get('RANDOM_VARIABLE')) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_email.py b/.venv/lib/python3.12/site-packages/test/unit/test_email.py new file mode 100644 index 00000000..9db06070 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_email.py @@ -0,0 +1,68 @@ +# -*- coding: utf-8 -*- +import unittest + +from sendgrid.helpers.mail import (Email) + + +class TestEmailObject(unittest.TestCase): + + def test_add_email_address(self): + address = "test@example.com" + email = Email(address) + + self.assertEqual(email.email, "test@example.com") + + def test_add_name(self): + name = "SomeName" + email = Email(name=name) + + self.assertEqual(email.name, name) + + def test_add_unicode_name(self): + name = u"SomeName" + email = Email(name=name) + + self.assertEqual(email.name, name) + + def test_add_name_email(self): + name = "SomeName" + address = "test@example.com" + email = Email(email=address, name=name) + self.assertEqual(email.name, name) + self.assertEqual(email.email, "test@example.com") + + def test_add_unicode_name_email(self): + name = u"SomeName" + address = u"test@example.com" + email = Email(email=address, name=name) + self.assertEqual(email.name, name) + self.assertEqual(email.email, u"test@example.com") + + def test_add_rfc_function_finds_name_not_email(self): + name = "SomeName" + email = Email(name) + + self.assertEqual(email.name, name) + self.assertIsNone(email.email) + + def test_add_rfc_email(self): + name = "SomeName" + address = "test@example.com" + name_address = "{} <{}>".format(name, address) + email = Email(name_address) + self.assertEqual(email.name, name) + self.assertEqual(email.email, "test@example.com") + + def test_empty_obj_add_name(self): + email = Email() + name = "SomeName" + email.name = name + + self.assertEqual(email.name, name) + + def test_empty_obj_add_email(self): + email = Email() + address = "test@example.com" + email.email = address + + self.assertEqual(email.email, address) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_eventwebhook.py b/.venv/lib/python3.12/site-packages/test/unit/test_eventwebhook.py new file mode 100644 index 00000000..eee1eabf --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_eventwebhook.py @@ -0,0 +1,50 @@ +import json +import unittest + +from sendgrid import EventWebhook + + +class UnitTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.PUBLIC_KEY = 'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE83T4O/n84iotIvIW4mdBgQ/7dAfSmpqIM8kF9mN1flpVKS3GRqe62gw+2fNNRaINXvVpiglSI8eNEc6wEA3F+g==' + cls.SIGNATURE = 'MEUCIGHQVtGj+Y3LkG9fLcxf3qfI10QysgDWmMOVmxG0u6ZUAiEAyBiXDWzM+uOe5W0JuG+luQAbPIqHh89M15TluLtEZtM=' + cls.TIMESTAMP = '1600112502' + cls.PAYLOAD = json.dumps( + [ + { + 'email': 'hello@world.com', + 'event': 'dropped', + 'reason': 'Bounced Address', + 'sg_event_id': 'ZHJvcC0xMDk5NDkxOS1MUnpYbF9OSFN0T0doUTRrb2ZTbV9BLTA', + 'sg_message_id': 'LRzXl_NHStOGhQ4kofSm_A.filterdrecv-p3mdw1-756b745b58-kmzbl-18-5F5FC76C-9.0', + 'smtp-id': '<LRzXl_NHStOGhQ4kofSm_A@ismtpd0039p1iad1.sendgrid.net>', + 'timestamp': 1600112492, + } + ], sort_keys=True, separators=(',', ':') + ) + '\r\n' # Be sure to include the trailing carriage return and newline! + + def test_verify_valid_signature(self): + ew = EventWebhook() + key = ew.convert_public_key_to_ecdsa(self.PUBLIC_KEY) + self.assertTrue(ew.verify_signature(self.PAYLOAD, self.SIGNATURE, self.TIMESTAMP, key)) + + def test_verify_bad_key(self): + ew = EventWebhook('MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqTxd43gyp8IOEto2LdIfjRQrIbsd4SXZkLW6jDutdhXSJCWHw8REntlo7aNDthvj+y7GjUuFDb/R1NGe1OPzpA==') + self.assertFalse(ew.verify_signature(self.PAYLOAD, self.SIGNATURE, self.TIMESTAMP)) + + def test_verify_bad_payload(self): + ew = EventWebhook(self.PUBLIC_KEY) + self.assertFalse(ew.verify_signature('payload', self.SIGNATURE, self.TIMESTAMP)) + + def test_verify_bad_signature(self): + ew = EventWebhook(self.PUBLIC_KEY) + self.assertFalse(ew.verify_signature( + self.PAYLOAD, + 'MEUCIQCtIHJeH93Y+qpYeWrySphQgpNGNr/U+UyUlBkU6n7RAwIgJTz2C+8a8xonZGi6BpSzoQsbVRamr2nlxFDWYNH3j/0=', + self.TIMESTAMP + )) + + def test_verify_bad_timestamp(self): + ew = EventWebhook(self.PUBLIC_KEY) + self.assertFalse(ew.verify_signature(self.PAYLOAD, self.SIGNATURE, 'timestamp')) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_inbound_send.py b/.venv/lib/python3.12/site-packages/test/unit/test_inbound_send.py new file mode 100644 index 00000000..19ee5de1 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_inbound_send.py @@ -0,0 +1,49 @@ +import argparse +import unittest + +from sendgrid.helpers.inbound import send + +try: + import unittest.mock as mock +except ImportError: + import mock + + +class UnitTests(unittest.TestCase): + def setUp(self): + self.client_mock = mock.patch('sendgrid.helpers.inbound.send.Client') + self.open_mock = mock.patch('sendgrid.helpers.inbound.send.open', + mock.mock_open(), create=True) + self.client_mock.start() + self.open_mock.start() + + def tearDown(self): + self.client_mock.stop() + self.open_mock.stop() + + def test_send(self): + + fake_url = 'https://fake_url' + x = send.Send(fake_url) + x.test_payload(fake_url) + + send.Client.assert_called_once_with( + host=fake_url, + request_headers={ + 'User-Agent': 'SendGrid-Test', + 'Content-Type': 'multipart/form-data; boundary=xYzZY' + }) + + def test_main_call(self): + fake_url = 'https://fake_url' + + with mock.patch( + 'argparse.ArgumentParser.parse_args', + return_value=argparse.Namespace( + host=fake_url, data='test_file.txt')): + send.main() + send.Client.assert_called_once_with( + host=fake_url, + request_headers={ + 'User-Agent': 'SendGrid-Test', + 'Content-Type': 'multipart/form-data; boundary=xYzZY'}) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_mail_helpers.py b/.venv/lib/python3.12/site-packages/test/unit/test_mail_helpers.py new file mode 100644 index 00000000..c00307d4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_mail_helpers.py @@ -0,0 +1,1766 @@ +# -*- coding: utf-8 -*- +import json +import unittest + +try: + from email.message import EmailMessage +except ImportError: + # Python2 + from email import message + EmailMessage = message.Message + +from sendgrid.helpers.mail import ( + Asm, Attachment, + ClickTracking, Content, + DynamicTemplateData, Email, From, + Mail, Personalization, + Subject, Substitution, To, Cc, Bcc, TrackingSettings +) + +# The below amp html email content is taken from [Google AMP Hello World Email](https://amp.dev/documentation/examples/introduction/hello_world_email/) +amp_html_content = '''<!doctype html><html amp4email><head><meta charset="utf-8"><script async src="https://cdn.ampproject.org/v0.js"></script><style amp4email-boilerplate>body{visibility:hidden}</style><script async custom-element="amp-carousel" src="https://cdn.ampproject.org/v0/amp-carousel-0.1.js"></script><style amp-custom>.emailbody {padding: 16px;}.helloworld {font-family: Helvetica;color: red;font-size: 24px;padding-bottom: 8px;}.images {max-width: 100%;}</style></head><body><div class="emailbody"><h1 class="helloworld">Hello!</h1><amp-img src="https://amp.dev/static/samples/img/amp.jpg" width="800" height="600" layout="responsive"></amp-img></div></body></html>''' + +response_content_with_all_three_mime_contents = json.dumps({ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/x-amp-html", + "value": amp_html_content + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" +}) + +class UnitTests(unittest.TestCase): + + def test_asm(self): + from sendgrid.helpers.mail import (GroupId, GroupsToDisplay) + asm1 = Asm(GroupId(1), GroupsToDisplay([1, 2, 3])) + asm2 = Asm(1, [1, 2, 3]) + self.assertEqual( + asm1.group_id.get(), asm2.group_id.get()) + self.assertEqual( + asm1.groups_to_display.get(), asm2.groups_to_display.get()) + + def test_attachment(self): + from sendgrid.helpers.mail import (FileContent, FileType, FileName, + Disposition, ContentId) + a1 = Attachment( + FileContent('Base64EncodedString'), + FileName('example.pdf'), + FileType('application/pdf'), + Disposition('attachment'), + ContentId('123') + ) + a2 = Attachment( + 'Base64EncodedString', + 'example.pdf', + 'application/pdf', + 'attachment', + '123' + ) + self.assertEqual(a1.file_content.get(), a2.file_content.get()) + self.assertEqual(a1.file_name.get(), a2.file_name.get()) + self.assertEqual(a1.file_type.get(), a2.file_type.get()) + self.assertEqual(a1.disposition.get(), a2.disposition.get()) + self.assertEqual(a1.content_id.get(), a2.content_id.get()) + + def test_batch_id(self): + from sendgrid.helpers.mail import BatchId + + b1 = BatchId('1') + self.assertEqual('1', b1.get()) + + # Send a Single Email to a Single Recipient + def test_single_email_to_a_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_single_email_to_a_single_recipient_content_reversed(self): + """Tests bug found in Issue-451 with Content ordering causing a crash + """ + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + message = Mail() + message.from_email = From('test+from@example.com', 'Example From Name') + message.to = To('test+to@example.com', 'Example To Name') + message.subject = Subject('Sending with SendGrid is Fun') + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_send_a_single_email_to_multiple_recipients(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + To('test+to0@example.com', 'Example To Name 0'), + To('test+to1@example.com', 'Example To Name 1') + ] + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to0@example.com", + "name": "Example To Name 0" + }, + { + "email": "test+to1@example.com", + "name": "Example To Name 1" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_send_a_single_email_with_multiple_reply_to_addresses(self): + from sendgrid.helpers.mail import (Mail, From, ReplyTo, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to0@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent('and easy to do anywhere, even with Python'), + html_content=HtmlContent('<strong>and easy to do anywhere, even with Python</strong>')) + + message.reply_to_list = [ReplyTo(email = 'test+reply_to_1@example.com'), ReplyTo(email = 'test+reply_to_2@example.com')] + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to0@example.com", + "name": "Example To Name" + } + ] + } + ], + "reply_to_list": [ + { + "email": "test+reply_to_1@example.com" + }, + { + "email": "test+reply_to_2@example.com" + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_multiple_emails_to_multiple_recipients(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, + Substitution) + self.maxDiff = None + + to_emails = [ + To(email='test+to0@example.com', + name='Example Name 0', + substitutions=[ + Substitution('-name-', 'Example Name Substitution 0'), + Substitution('-github-', 'https://example.com/test0'), + ], + subject=Subject('Override Global Subject')), + To(email='test+to1@example.com', + name='Example Name 1', + substitutions=[ + Substitution('-name-', 'Example Name Substitution 1'), + Substitution('-github-', 'https://example.com/test1'), + ]) + ] + global_substitutions = Substitution('-time-', '2019-01-01 00:00:00') + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Hi -name-'), + plain_text_content=PlainTextContent( + 'Hello -name-, your URL is -github-, email sent at -time-'), + html_content=HtmlContent( + '<strong>Hello -name-, your URL is <a href=\"-github-\">here</a></strong> email sent at -time-'), + global_substitutions=global_substitutions, + is_multiple=True) + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "Hello -name-, your URL is -github-, email sent at -time-" + }, + { + "type": "text/html", + "value": "<strong>Hello -name-, your URL is <a href=\"-github-\">here</a></strong> email sent at -time-" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "substitutions": { + "-github-": "https://example.com/test1", + "-name-": "Example Name Substitution 1", + "-time-": "2019-01-01 00:00:00" + }, + "to": [ + { + "email": "test+to1@example.com", + "name": "Example Name 1" + } + ] + }, + { + "subject": "Override Global Subject", + "substitutions": { + "-github-": "https://example.com/test0", + "-name-": "Example Name Substitution 0", + "-time-": "2019-01-01 00:00:00" + }, + "to": [ + { + "email": "test+to0@example.com", + "name": "Example Name 0" + } + ] + } + ], + "subject": "Hi -name-" + }''') + ) + + def test_single_email_with_all_three_email_contents_to_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + amp_html_content=AmpHtmlContent(amp_html_content), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + ) + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_amp_and_html_contents_to_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + amp_html_content=AmpHtmlContent(amp_html_content), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + ) + + response_content = json.dumps({ + "content": [ + { + "type": "text/x-amp-html", + "value": amp_html_content + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }) + self.assertEqual( + message.get(), + json.loads(response_content) + ) + + def test_single_email_with_amp_and_plain_contents_to_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + amp_html_content=AmpHtmlContent(amp_html_content) + ) + + response_content = json.dumps({ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/x-amp-html", + "value": amp_html_content + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }) + self.assertEqual( + message.get(), + json.loads(response_content) + ) + + ## Check ordering of MIME types in different variants - start + def test_single_email_with_all_three_contents_in_collapsed_order_of_plain_amp_html_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + message.content = AmpHtmlContent(amp_html_content) + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_all_three_contents_in_collapsed_order_of_plain_html_amp_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = AmpHtmlContent(amp_html_content) + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_all_three_contents_in_collapsed_order_of_html_plain_amp_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + message.content = AmpHtmlContent(amp_html_content) + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_all_three_contents_in_collapsed_order_of_html_amp_plain_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = AmpHtmlContent(amp_html_content) + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_all_three_contents_in_collapsed_order_of_amp_html_plain_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = AmpHtmlContent(amp_html_content) + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + def test_single_email_with_all_three_contents_in_collapsed_order_of_amp_plain_html_content_single_recipient(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent, AmpHtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun') + ) + message.content = AmpHtmlContent(amp_html_content) + message.content = PlainTextContent( + 'and easy to do anywhere, even with Python') + message.content = HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>') + + self.assertEqual( + message.get(), + json.loads(response_content_with_all_three_mime_contents) + ) + + ## end + + def test_value_error_is_raised_on_to_emails_set_to_list_of_lists(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + ['test+to0@example.com', 'Example To Name 0'], + ['test+to1@example.com', 'Example To Name 1'] + ] + + with self.assertRaises(ValueError): + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_value_error_is_raised_on_to_emails_set_to_reply_to_list_of_strs(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + ('test+to0@example.com', 'Example To Name 0'), + ('test+to1@example.com', 'Example To Name 1') + ] + + mail = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + with self.assertRaises(ValueError): + mail.reply_to_list = ['test+reply_to0@example.com', 'test+reply_to1@example.com'] + + def test_value_error_is_raised_on_to_emails_set_to_reply_to_list_of_tuples(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + ('test+to0@example.com', 'Example To Name 0'), + ('test+to1@example.com', 'Example To Name 1') + ] + + mail = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + with self.assertRaises(ValueError): + mail.reply_to_list = [('test+reply_to@example.com', 'Test Name')] + + def test_error_is_not_raised_on_to_emails_set_to_list_of_tuples(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + ('test+to0@example.com', 'Example To Name 0'), + ('test+to1@example.com', 'Example To Name 1') + ] + + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_error_is_not_raised_on_to_emails_set_to_list_of_strs(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = ['test+to0@example.com', 'test+to1@example.com'] + + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_error_is_not_raised_on_to_emails_set_to_a_str(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = 'test+to0@example.com' + + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_error_is_not_raised_on_to_emails_set_to_a_tuple(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = ('test+to0@example.com', 'Example To Name 0') + + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_error_is_not_raised_on_to_emails_includes_bcc_cc(self): + from sendgrid.helpers.mail import (PlainTextContent, HtmlContent) + self.maxDiff = None + to_emails = [ + To('test+to0@example.com', 'Example To Name 0'), + Bcc('test+bcc@example.com', 'Example Bcc Name 1'), + Cc('test+cc@example.com', 'Example Cc Name 2') + ] + + Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + + def test_personalization_add_email_filters_out_duplicate_to_emails(self): + self.maxDiff = None + + p = Personalization() + to_email = To('test+to0@example.com', 'Example To Name 0') + p.add_email(to_email) + p.add_email(to_email) + + self.assertEqual([to_email.get()], p.tos) + + def test_personalization_add_email_filters_out_duplicate_to_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + to_email = To('test+to0@example.com', 'Example To Name 0') + to_email_with_caps = To('test+TO0@example.com', 'Example To Name 0') + p.add_email(to_email) + p.add_email(to_email_with_caps) + + self.assertEqual([to_email.get()], p.tos) + + def test_personalization_set_from_email(self): + self.maxDiff = None + + p = Personalization() + from_email = From('test+from@example.com', 'Example From') + p.set_from(from_email) + + self.assertEqual(from_email.get(), p.from_email) + + def test_personalization_filters_out_duplicate_cc_emails(self): + self.maxDiff = None + + p = Personalization() + cc_email = Cc('test+cc0@example.com', 'Example Cc Name 0') + p.add_email(cc_email) + p.add_email(cc_email) + + self.assertEqual([cc_email.get()], p.ccs) + + def test_personalization_filters_out_duplicate_cc_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + cc_email = Cc('test+cc0@example.com', 'Example Cc Name 0') + cc_email_with_caps = Cc('test+CC0@example.com', 'Example Cc Name 0') + p.add_email(cc_email) + p.add_email(cc_email_with_caps) + + self.assertEqual([cc_email.get()], p.ccs) + + def test_personalization_filters_out_duplicate_bcc_emails(self): + self.maxDiff = None + + p = Personalization() + bcc_email = Bcc('test+bcc0@example.com', 'Example Bcc Name 0') + p.add_email(bcc_email) + p.add_email(bcc_email) + + self.assertEqual([bcc_email.get()], p.bccs) + + def test_personalization_filters_out_duplicate_bcc_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + bcc_email = Bcc('test+bcc0@example.com', 'Example Bcc Name 0') + bcc_email_with_caps = Bcc('test+BCC0@example.com', 'Example Bcc Name 0') + p.add_email(bcc_email) + p.add_email(bcc_email_with_caps) + + self.assertEqual([bcc_email.get()], p.bccs) + + def test_personalization_tos_setter_filters_out_duplicate_dict_emails(self): + self.maxDiff = None + + p = Personalization() + to_emails = [{ 'email': 'test+to0@example.com', 'name': 'Example To Name 0' }] * 2 + p.tos = to_emails + + self.assertEqual([to_emails[0]], p.tos) + + def test_personalization_tos_setter_filters_out_duplicate_dict_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + to_email = { 'email': 'test+to0@example.com', 'name': 'Example To Name 0' } + to_email_with_caps = { 'email': 'test+TO0@example.com', 'name': 'Example To Name 0' } + to_emails = [to_email, to_email_with_caps] + p.tos = to_emails + + self.assertEqual([to_email], p.tos) + + def test_personalization_tos_setter_filters_out_duplicate_to_emails(self): + self.maxDiff = None + + p = Personalization() + to_emails = [To('test+to0@example.com', 'Example To Name 0')] * 2 + p.tos = to_emails + + self.assertEqual([to_emails[0].get()], p.tos) + + + def test_personalization_tos_setter_filters_out_duplicate_to_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + to_email = To('test+to0@example.com', 'Example To Name 0') + to_email_with_caps = To('test+TO0@example.com', 'Example To Name 0') + to_emails = [to_email, to_email_with_caps] + p.tos = to_emails + + self.assertEqual([to_email.get()], p.tos) + + def test_personalization_ccs_setter_filters_out_duplicate_dict_emails(self): + self.maxDiff = None + + p = Personalization() + cc_emails = [{ 'email': 'test+cc0@example.com', 'name': 'Example Cc Name 0' }] * 2 + p.ccs = cc_emails + + self.assertEqual([cc_emails[0]], p.ccs) + + def test_personalization_ccs_setter_filters_out_duplicate_dict_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + cc_email = { 'email': 'test+cc0@example.com', 'name': 'Example Cc Name 0' } + cc_email_with_caps = { 'email': 'test+CC0@example.com', 'name': 'Example Cc Name 0' } + cc_emails = [cc_email, cc_email_with_caps] + p.ccs = cc_emails + + self.assertEqual([cc_email], p.ccs) + + def test_personalization_ccs_setter_filters_out_duplicate_cc_emails(self): + self.maxDiff = None + + p = Personalization() + cc_emails = [Cc('test+cc0@example.com', 'Example Cc Name 0')] * 2 + p.ccs = cc_emails + + self.assertEqual([cc_emails[0].get()], p.ccs) + + def test_personalization_ccs_setter_filters_out_duplicate_cc_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + cc_email = Cc('test+cc0@example.com', 'Example Cc Name 0') + cc_email_with_caps = Cc('test+CC0@example.com', 'Example Cc Name 0') + p.ccs = [cc_email, cc_email_with_caps] + + self.assertEqual([cc_email.get()], p.ccs) + + def test_personalization_bccs_setter_filters_out_duplicate_dict_emails(self): + self.maxDiff = None + + p = Personalization() + bcc_emails = [{ 'email': 'test+bcc0@example.com', 'name': 'Example Bcc Name 0' }] * 2 + p.bccs = bcc_emails + + self.assertEqual([bcc_emails[0]], p.bccs) + + def test_personalization_bccs_setter_filters_out_duplicate_dict_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + bcc_email = { 'email': 'test+bcc0@example.com', 'name': 'Example Bcc Name 0' } + bcc_email_with_caps = { 'email': 'test+BCC0@example.com', 'name': 'Example Bcc Name 0' } + bcc_emails = [bcc_email, bcc_email_with_caps] + p.bccs = bcc_emails + + self.assertEqual([bcc_email], p.bccs) + + def test_personalization_bccs_setter_filters_out_duplicate_bcc_emails(self): + self.maxDiff = None + + p = Personalization() + bcc_emails = [Bcc('test+bcc0@example.com', 'Example Bcc Name 0')] * 2 + p.bccs = bcc_emails + + self.assertEqual([bcc_emails[0].get()], p.bccs) + + def test_personalization_bccs_setter_filters_out_duplicate_bcc_emails_ignoring_case(self): + self.maxDiff = None + + p = Personalization() + bcc_email = Bcc('test+bcc0@example.com', 'Example Bcc Name 0') + bcc_email_with_caps = Bcc('test+BCC0@example.com', 'Example Bcc Name 0') + p.bccs = [bcc_email, bcc_email_with_caps] + + self.assertEqual([bcc_email.get()], p.bccs) + + def test_personalization_add_to_filters_out_duplicate_to_emails(self): + self.maxDiff = None + + p = Personalization() + to_email = To('test+to0@example.com', 'Example To Name 0') + p.add_to(to_email) + p.add_to(to_email) + + expected = [to_email.get()] + + self.assertEqual(expected, p.tos) + + def test_personalization_add_bcc_filters_out_duplicate_bcc_emails(self): + self.maxDiff = None + + p = Personalization() + bcc_email = Bcc('test+to0@example.com', 'Example To Name 0') + p.add_bcc(bcc_email) + p.add_bcc(bcc_email) + + expected = [bcc_email.get()] + + self.assertEqual(expected, p.bccs) + + def test_personalization_add_cc_filters_out_duplicate_cc_emails(self): + self.maxDiff = None + + p = Personalization() + cc_email = Cc('test+to0@example.com', 'Example To Name 0') + p.add_cc(cc_email) + p.add_cc(cc_email) + + expected = [cc_email.get()] + + self.assertEqual(expected, p.ccs) + + def test_dynamic_template_data(self): + self.maxDiff = None + + to_emails = [ + To(email='test+to+0@example.com', + name='Example To 0 Name', + dynamic_template_data=DynamicTemplateData({'name': 'Example 0 Name'})), + To(email='test+to+1@example.com', + name='Example To 1 Name', + dynamic_template_data={'name': 'Example 1 Name'}) + ] + message = Mail( + from_email=From('test@example.com', 'Example From Name'), + to_emails=to_emails, + subject=Subject('Hi!'), + plain_text_content='Hello!', + html_content='<strong>Hello!</strong>', + is_multiple=True) + + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "Hello!" + }, + { + "type": "text/html", + "value": "<strong>Hello!</strong>" + } + ], + "from": { + "email": "test@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "dynamic_template_data": { + "name": "Example 1 Name" + }, + "to": [ + { + "email": "test+to+1@example.com", + "name": "Example To 1 Name" + } + ] + }, + { + "dynamic_template_data": { + "name": "Example 0 Name" + }, + "to": [ + { + "email": "test+to+0@example.com", + "name": "Example To 0 Name" + } + ] + } + ], + "subject": "Hi!" + }''') + ) + + def test_kitchen_sink(self): + from sendgrid.helpers.mail import ( + Mail, From, To, Cc, Bcc, Subject, Substitution, Header, + CustomArg, SendAt, Content, MimeType, Attachment, FileName, + FileContent, FileType, Disposition, ContentId, TemplateId, + Section, ReplyTo, Category, BatchId, Asm, GroupId, GroupsToDisplay, + IpPoolName, MailSettings, BccSettings, BccSettingsEmail, + BypassBounceManagement, BypassListManagement, BypassSpamManagement, + BypassUnsubscribeManagement, FooterSettings, FooterText, + FooterHtml, SandBoxMode, SpamCheck, SpamThreshold, SpamUrl, + TrackingSettings, ClickTracking, SubscriptionTracking, + SubscriptionText, SubscriptionHtml, SubscriptionSubstitutionTag, + OpenTracking, OpenTrackingSubstitutionTag, Ganalytics, + UtmSource, UtmMedium, UtmTerm, UtmContent, UtmCampaign) + + self.maxDiff = None + + message = Mail() + + # Define Personalizations + + message.to = To('test1@example.com', 'Example User1', p=0) + message.to = [ + To('test2@example.com', 'Example User2', p=0), + To('test3@example.com', 'Example User3', p=0) + ] + + message.cc = Cc('test4@example.com', 'Example User4', p=0) + message.cc = [ + Cc('test5@example.com', 'Example User5', p=0), + Cc('test6@example.com', 'Example User6', p=0) + ] + + message.bcc = Bcc('test7@example.com', 'Example User7', p=0) + message.bcc = [ + Bcc('test8@example.com', 'Example User8', p=0), + Bcc('test9@example.com', 'Example User9', p=0) + ] + + message.subject = Subject('Sending with SendGrid is Fun 0', p=0) + + message.header = Header('X-Test1', 'Test1', p=0) + message.header = Header('X-Test2', 'Test2', p=0) + message.header = [ + Header('X-Test3', 'Test3', p=0), + Header('X-Test4', 'Test4', p=0) + ] + + message.substitution = Substitution('%name1%', 'Example Name 1', p=0) + message.substitution = Substitution('%city1%', 'Example City 1', p=0) + message.substitution = [ + Substitution('%name2%', 'Example Name 2', p=0), + Substitution('%city2%', 'Example City 2', p=0) + ] + + message.custom_arg = CustomArg('marketing1', 'true', p=0) + message.custom_arg = CustomArg('transactional1', 'false', p=0) + message.custom_arg = [ + CustomArg('marketing2', 'false', p=0), + CustomArg('transactional2', 'true', p=0) + ] + + message.send_at = SendAt(1461775051, p=0) + + message.to = To('test10@example.com', 'Example User10', p=1) + message.to = [ + To('test11@example.com', 'Example User11', p=1), + To('test12@example.com', 'Example User12', p=1) + ] + + message.cc = Cc('test13@example.com', 'Example User13', p=1) + message.cc = [ + Cc('test14@example.com', 'Example User14', p=1), + Cc('test15@example.com', 'Example User15', p=1) + ] + + message.bcc = Bcc('test16@example.com', 'Example User16', p=1) + message.bcc = [ + Bcc('test17@example.com', 'Example User17', p=1), + Bcc('test18@example.com', 'Example User18', p=1) + ] + + message.header = Header('X-Test5', 'Test5', p=1) + message.header = Header('X-Test6', 'Test6', p=1) + message.header = [ + Header('X-Test7', 'Test7', p=1), + Header('X-Test8', 'Test8', p=1) + ] + + message.substitution = Substitution('%name3%', 'Example Name 3', p=1) + message.substitution = Substitution('%city3%', 'Example City 3', p=1) + message.substitution = [ + Substitution('%name4%', 'Example Name 4', p=1), + Substitution('%city4%', 'Example City 4', p=1) + ] + + message.custom_arg = CustomArg('marketing3', 'true', p=1) + message.custom_arg = CustomArg('transactional3', 'false', p=1) + message.custom_arg = [ + CustomArg('marketing4', 'false', p=1), + CustomArg('transactional4', 'true', p=1) + ] + + message.send_at = SendAt(1461775052, p=1) + + message.subject = Subject('Sending with SendGrid is Fun 1', p=1) + + # The values below this comment are global to entire message + + message.from_email = From('help@twilio.com', 'Twilio SendGrid') + + message.reply_to = ReplyTo('help_reply@twilio.com', 'Twilio SendGrid Reply') + + message.subject = Subject('Sending with SendGrid is Fun 2') + + message.content = Content( + MimeType.text, + 'and easy to do anywhere, even with Python') + message.content = Content( + MimeType.html, + '<strong>and easy to do anywhere, even with Python</strong>') + message.content = [ + Content('text/calendar', 'Party Time!!'), + Content('text/custom', 'Party Time 2!!') + ] + + message.attachment = Attachment( + FileContent('base64 encoded content 1'), + FileName('balance_001.pdf'), + FileType('application/pdf'), + Disposition('attachment'), + ContentId('Content ID 1')) + message.attachment = [ + Attachment( + FileContent('base64 encoded content 2'), + FileName('banner.png'), + FileType('image/png'), + Disposition('inline'), + ContentId('Content ID 2')), + Attachment( + FileContent('base64 encoded content 3'), + FileName('banner2.png'), + FileType('image/png'), + Disposition('inline'), + ContentId('Content ID 3')) + ] + + message.template_id = TemplateId( + '13b8f94f-bcae-4ec6-b752-70d6cb59f932') + + message.section = Section( + '%section1%', 'Substitution for Section 1 Tag') + message.section = [ + Section('%section2%', 'Substitution for Section 2 Tag'), + Section('%section3%', 'Substitution for Section 3 Tag') + ] + + message.header = Header('X-Test9', 'Test9') + message.header = Header('X-Test10', 'Test10') + message.header = [ + Header('X-Test11', 'Test11'), + Header('X-Test12', 'Test12') + ] + + message.category = Category('Category 1') + message.category = Category('Category 2') + message.category = [ + Category('Category 1'), + Category('Category 2') + ] + + message.custom_arg = CustomArg('marketing5', 'false') + message.custom_arg = CustomArg('transactional5', 'true') + message.custom_arg = [ + CustomArg('marketing6', 'true'), + CustomArg('transactional6', 'false') + ] + + message.send_at = SendAt(1461775053) + + message.batch_id = BatchId("HkJ5yLYULb7Rj8GKSx7u025ouWVlMgAi") + + message.asm = Asm(GroupId(1), GroupsToDisplay([1, 2, 3, 4])) + + message.ip_pool_name = IpPoolName("IP Pool Name") + + mail_settings = MailSettings() + mail_settings.bcc_settings = BccSettings( + False, BccSettingsEmail("bcc@twilio.com")) + mail_settings.bypass_bounce_management = BypassBounceManagement(False) + mail_settings.bypass_list_management = BypassListManagement(False) + mail_settings.bypass_spam_management = BypassSpamManagement(False) + mail_settings.bypass_unsubscribe_management = BypassUnsubscribeManagement(False) + mail_settings.footer_settings = FooterSettings( + True, FooterText("w00t"), FooterHtml("<string>w00t!<strong>")) + mail_settings.sandbox_mode = SandBoxMode(True) + mail_settings.spam_check = SpamCheck( + True, SpamThreshold(5), SpamUrl("https://example.com")) + message.mail_settings = mail_settings + + tracking_settings = TrackingSettings() + tracking_settings.click_tracking = ClickTracking(True, False) + tracking_settings.open_tracking = OpenTracking( + True, OpenTrackingSubstitutionTag("open_tracking")) + tracking_settings.subscription_tracking = SubscriptionTracking( + True, + SubscriptionText("Goodbye"), + SubscriptionHtml("<strong>Goodbye!</strong>"), + SubscriptionSubstitutionTag("unsubscribe")) + tracking_settings.ganalytics = Ganalytics( + True, + UtmSource("utm_source"), + UtmMedium("utm_medium"), + UtmTerm("utm_term"), + UtmContent("utm_content"), + UtmCampaign("utm_campaign")) + message.tracking_settings = tracking_settings + self.assertEqual( + message.get(), + json.loads(r'''{ + "asm": { + "group_id": 1, + "groups_to_display": [ + 1, + 2, + 3, + 4 + ] + }, + "attachments": [ + { + "content": "base64 encoded content 3", + "content_id": "Content ID 3", + "disposition": "inline", + "filename": "banner2.png", + "type": "image/png" + }, + { + "content": "base64 encoded content 2", + "content_id": "Content ID 2", + "disposition": "inline", + "filename": "banner.png", + "type": "image/png" + }, + { + "content": "base64 encoded content 1", + "content_id": "Content ID 1", + "disposition": "attachment", + "filename": "balance_001.pdf", + "type": "application/pdf" + } + ], + "batch_id": "HkJ5yLYULb7Rj8GKSx7u025ouWVlMgAi", + "categories": [ + "Category 2", + "Category 1", + "Category 2", + "Category 1" + ], + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + }, + { + "type": "text/calendar", + "value": "Party Time!!" + }, + { + "type": "text/custom", + "value": "Party Time 2!!" + } + ], + "custom_args": { + "marketing5": "false", + "marketing6": "true", + "transactional5": "true", + "transactional6": "false" + }, + "from": { + "email": "help@twilio.com", + "name": "Twilio SendGrid" + }, + "headers": { + "X-Test10": "Test10", + "X-Test11": "Test11", + "X-Test12": "Test12", + "X-Test9": "Test9" + }, + "ip_pool_name": "IP Pool Name", + "mail_settings": { + "bcc": { + "email": "bcc@twilio.com", + "enable": false + }, + "bypass_bounce_management": { + "enable": false + }, + "bypass_list_management": { + "enable": false + }, + "bypass_spam_management": { + "enable": false + }, + "bypass_unsubscribe_management": { + "enable": false + }, + "footer": { + "enable": true, + "html": "<string>w00t!<strong>", + "text": "w00t" + }, + "sandbox_mode": { + "enable": true + }, + "spam_check": { + "enable": true, + "post_to_url": "https://example.com", + "threshold": 5 + } + }, + "personalizations": [ + { + "bcc": [ + { + "email": "test7@example.com", + "name": "Example User7" + }, + { + "email": "test8@example.com", + "name": "Example User8" + }, + { + "email": "test9@example.com", + "name": "Example User9" + } + ], + "cc": [ + { + "email": "test4@example.com", + "name": "Example User4" + }, + { + "email": "test5@example.com", + "name": "Example User5" + }, + { + "email": "test6@example.com", + "name": "Example User6" + } + ], + "custom_args": { + "marketing1": "true", + "marketing2": "false", + "transactional1": "false", + "transactional2": "true" + }, + "headers": { + "X-Test1": "Test1", + "X-Test2": "Test2", + "X-Test3": "Test3", + "X-Test4": "Test4" + }, + "send_at": 1461775051, + "subject": "Sending with SendGrid is Fun 0", + "substitutions": { + "%city1%": "Example City 1", + "%city2%": "Example City 2", + "%name1%": "Example Name 1", + "%name2%": "Example Name 2" + }, + "to": [ + { + "email": "test1@example.com", + "name": "Example User1" + }, + { + "email": "test2@example.com", + "name": "Example User2" + }, + { + "email": "test3@example.com", + "name": "Example User3" + } + ] + }, + { + "bcc": [ + { + "email": "test16@example.com", + "name": "Example User16" + }, + { + "email": "test17@example.com", + "name": "Example User17" + }, + { + "email": "test18@example.com", + "name": "Example User18" + } + ], + "cc": [ + { + "email": "test13@example.com", + "name": "Example User13" + }, + { + "email": "test14@example.com", + "name": "Example User14" + }, + { + "email": "test15@example.com", + "name": "Example User15" + } + ], + "custom_args": { + "marketing3": "true", + "marketing4": "false", + "transactional3": "false", + "transactional4": "true" + }, + "headers": { + "X-Test5": "Test5", + "X-Test6": "Test6", + "X-Test7": "Test7", + "X-Test8": "Test8" + }, + "send_at": 1461775052, + "subject": "Sending with SendGrid is Fun 1", + "substitutions": { + "%city3%": "Example City 3", + "%city4%": "Example City 4", + "%name3%": "Example Name 3", + "%name4%": "Example Name 4" + }, + "to": [ + { + "email": "test10@example.com", + "name": "Example User10" + }, + { + "email": "test11@example.com", + "name": "Example User11" + }, + { + "email": "test12@example.com", + "name": "Example User12" + } + ] + } + ], + "reply_to": { + "email": "help_reply@twilio.com", + "name": "Twilio SendGrid Reply" + }, + "sections": { + "%section1%": "Substitution for Section 1 Tag", + "%section2%": "Substitution for Section 2 Tag", + "%section3%": "Substitution for Section 3 Tag" + }, + "send_at": 1461775053, + "subject": "Sending with SendGrid is Fun 2", + "template_id": "13b8f94f-bcae-4ec6-b752-70d6cb59f932", + "tracking_settings": { + "click_tracking": { + "enable": true, + "enable_text": false + }, + "ganalytics": { + "enable": true, + "utm_campaign": "utm_campaign", + "utm_content": "utm_content", + "utm_medium": "utm_medium", + "utm_source": "utm_source", + "utm_term": "utm_term" + }, + "open_tracking": { + "enable": true, + "substitution_tag": "open_tracking" + }, + "subscription_tracking": { + "enable": true, + "html": "<strong>Goodbye!</strong>", + "substitution_tag": "unsubscribe", + "text": "Goodbye" + } + } + }''') + ) + + # Send a Single Email to a Single Recipient with a Dynamic Template + def test_single_email_to_a_single_recipient_with_dynamic_templates(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + message.dynamic_template_data = DynamicTemplateData({ + "total": "$ 239.85", + "items": [ + { + "text": "New Line Sneakers", + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png", + "price": "$ 79.95" + }, + { + "text": "Old Line Sneakers", + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png", + "price": "$ 79.95" + }, + { + "text": "Blue Line Sneakers", + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/00731ed18eff0ad5da890d876c456c3124a4e44cb48196533e9b95fb2b959b7194c2dc7637b788341d1ff4f88d1dc88e23f7e3704726d313c57f350911dd2bd0.png", + "price": "$ 79.95" + } + ], + "receipt": True, + "name": "Sample Name", + "address01": "1234 Fake St.", + "address02": "Apt. 123", + "city": "Place", + "state": "CO", + "zip": "80202" + }) + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "dynamic_template_data": { + "address01": "1234 Fake St.", + "address02": "Apt. 123", + "city": "Place", + "items": [ + { + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/8dda1131320a6d978b515cc04ed479df259a458d5d45d58b6b381cae0bf9588113e80ef912f69e8c4cc1ef1a0297e8eefdb7b270064cc046b79a44e21b811802.png", + "price": "$ 79.95", + "text": "New Line Sneakers" + }, + { + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/3629f54390ead663d4eb7c53702e492de63299d7c5f7239efdc693b09b9b28c82c924225dcd8dcb65732d5ca7b7b753c5f17e056405bbd4596e4e63a96ae5018.png", + "price": "$ 79.95", + "text": "Old Line Sneakers" + }, + { + "image": "https://marketing-image-production.s3.amazonaws.com/uploads/00731ed18eff0ad5da890d876c456c3124a4e44cb48196533e9b95fb2b959b7194c2dc7637b788341d1ff4f88d1dc88e23f7e3704726d313c57f350911dd2bd0.png", + "price": "$ 79.95", + "text": "Blue Line Sneakers" + } + ], + "name": "Sample Name", + "receipt": true, + "state": "CO", + "total": "$ 239.85", + "zip": "80202" + }, + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_sendgrid_api_key(self): + """Tests if including SendGrid API will throw an Exception""" + + # Minimum required to send an email + self.max_diff = None + mail = Mail() + + mail.from_email = Email("test@example.com") + + mail.subject = "Hello World from the SendGrid Python Library" + + personalization = Personalization() + personalization.add_to(Email("test@example.com")) + mail.add_personalization(personalization) + + # Try to include SendGrid API key + try: + mail.add_content( + Content( + "text/plain", + "some SG.2123b1B.1212lBaC here")) + mail.add_content( + Content( + "text/html", + "<html><body>some SG.Ba2BlJSDba.232Ln2 here</body></html>")) + + self.assertEqual( + json.dumps( + mail.get(), + sort_keys=True), + '{"content": [{"type": "text/plain", "value": "some text here"}, ' + '{"type": "text/html", ' + '"value": "<html><body>some text here</body></html>"}], ' + '"from": {"email": "test@example.com"}, "personalizations": ' + '[{"to": [{"email": "test@example.com"}]}], ' + '"subject": "Hello World from the SendGrid Python Library"}' + ) + + # Exception should be thrown + except Exception: + pass + + # Exception not thrown + else: + self.fail("Should have failed as SendGrid API key included") + + def test_unicode_values_in_substitutions_helper(self): + from sendgrid.helpers.mail import (Mail, From, To, Subject, + PlainTextContent, HtmlContent) + self.maxDiff = None + message = Mail( + from_email=From('test+from@example.com', 'Example From Name'), + to_emails=To('test+to@example.com', 'Example To Name'), + subject=Subject('Sending with SendGrid is Fun'), + plain_text_content=PlainTextContent( + 'and easy to do anywhere, even with Python'), + html_content=HtmlContent( + '<strong>and easy to do anywhere, even with Python</strong>')) + message.substitution = Substitution('%city%', u'Αθήνα', p=1) + self.assertEqual( + message.get(), + json.loads(r'''{ + "content": [ + { + "type": "text/plain", + "value": "and easy to do anywhere, even with Python" + }, + { + "type": "text/html", + "value": "<strong>and easy to do anywhere, even with Python</strong>" + } + ], + "from": { + "email": "test+from@example.com", + "name": "Example From Name" + }, + "personalizations": [ + { + "to": [ + { + "email": "test+to@example.com", + "name": "Example To Name" + } + ] + }, + { + "substitutions": { + "%city%": "Αθήνα" + } + } + ], + "subject": "Sending with SendGrid is Fun" + }''') + ) + + def test_asm_display_group_limit(self): + self.assertRaises(ValueError, Asm, 1, list(range(26))) + + def test_disable_tracking(self): + tracking_settings = TrackingSettings() + tracking_settings.click_tracking = ClickTracking(False, False) + + self.assertEqual( + tracking_settings.get(), + {'click_tracking': {'enable': False, 'enable_text': False}} + ) + + def test_bypass_list_management(self): + from sendgrid.helpers.mail import (MailSettings, BypassListManagement) + mail_settings = MailSettings() + mail_settings.bypass_list_management = BypassListManagement(True) + + self.assertEqual( + mail_settings.get(), + { + "bypass_list_management": { + "enable": True + }, + }, + ) + + def test_v3_bypass_filters(self): + from sendgrid.helpers.mail import ( + MailSettings, BypassBounceManagement, + BypassSpamManagement, BypassUnsubscribeManagement + ) + mail_settings = MailSettings() + mail_settings.bypass_bounce_management = BypassBounceManagement(True) + mail_settings.bypass_spam_management = BypassSpamManagement(True) + mail_settings.bypass_unsubscribe_management = BypassUnsubscribeManagement(True) + + self.assertEqual( + mail_settings.get(), + { + "bypass_bounce_management": { + "enable": True + }, + "bypass_spam_management": { + "enable": True + }, + "bypass_unsubscribe_management": { + "enable": True + }, + }, + ) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_parse.py b/.venv/lib/python3.12/site-packages/test/unit/test_parse.py new file mode 100644 index 00000000..1c899bbb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_parse.py @@ -0,0 +1,16 @@ +import unittest + +from sendgrid.helpers.inbound.config import Config +from sendgrid.helpers.inbound.app import app + + +class UnitTests(unittest.TestCase): + + def setUp(self): + self.config = Config() + self.tester = app.test_client(self) + + def test_parse(self): + response = self.tester.post(self.config.endpoint, + data='{"Message:", "Success"}') + self.assertEqual(response.status_code, 200) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_project.py b/.venv/lib/python3.12/site-packages/test/unit/test_project.py new file mode 100644 index 00000000..40282bdb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_project.py @@ -0,0 +1,52 @@ +import os +import unittest + + +class ProjectTests(unittest.TestCase): + # ./.env_sample + def test_env(self): + self.assertTrue(os.path.isfile('./.env_sample')) + + # ./.gitignore + def test_gitignore(self): + self.assertTrue(os.path.isfile('./.gitignore')) + + # ./CHANGELOG.md + def test_changelog(self): + self.assertTrue(os.path.isfile('./CHANGELOG.md')) + + # ./CODE_OF_CONDUCT.md + def test_code_of_conduct(self): + self.assertTrue(os.path.isfile('./CODE_OF_CONDUCT.md')) + + # ./CONTRIBUTING.md + def test_contributing(self): + self.assertTrue(os.path.isfile('./CONTRIBUTING.md')) + + # ./LICENSE + def test_license(self): + self.assertTrue(os.path.isfile('./LICENSE')) + + # ./PULL_REQUEST_TEMPLATE.md + def test_pr_template(self): + self.assertTrue(os.path.isfile('./PULL_REQUEST_TEMPLATE.md')) + + # ./README.rst + def test_readme(self): + self.assertTrue(os.path.isfile('./README.rst')) + + # ./TROUBLESHOOTING.md + def test_troubleshooting(self): + self.assertTrue(os.path.isfile('./TROUBLESHOOTING.md')) + + # ./USAGE.md + def test_usage(self): + self.assertTrue(os.path.isfile('./USAGE.md')) + + # ./use-cases/README.md + def test_use_cases(self): + self.assertTrue(os.path.isfile('./use_cases/README.md')) + + +if __name__ == '__main__': + unittest.main() diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_sendgrid.py b/.venv/lib/python3.12/site-packages/test/unit/test_sendgrid.py new file mode 100644 index 00000000..328d978a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_sendgrid.py @@ -0,0 +1,27 @@ +import unittest +import sendgrid + +class UnitTests(unittest.TestCase): + def test_host_with_no_region(self): + sg = sendgrid.SendGridAPIClient(api_key='MY_API_KEY') + self.assertEqual("https://api.sendgrid.com",sg.client.host) + + def test_host_with_eu_region(self): + sg = sendgrid.SendGridAPIClient(api_key='MY_API_KEY') + sg.set_sendgrid_data_residency("eu") + self.assertEqual("https://api.eu.sendgrid.com",sg.client.host) + + def test_host_with_global_region(self): + sg = sendgrid.SendGridAPIClient(api_key='MY_API_KEY') + sg.set_sendgrid_data_residency("global") + self.assertEqual("https://api.sendgrid.com",sg.client.host) + + def test_with_region_is_none(self): + sg = sendgrid.SendGridAPIClient(api_key='MY_API_KEY') + with self.assertRaises(ValueError): + sg.set_sendgrid_data_residency(None) + + def test_with_region_is_invalid(self): + sg = sendgrid.SendGridAPIClient(api_key='MY_API_KEY') + with self.assertRaises(ValueError): + sg.set_sendgrid_data_residency("abc")
\ No newline at end of file diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_spam_check.py b/.venv/lib/python3.12/site-packages/test/unit/test_spam_check.py new file mode 100644 index 00000000..e532573b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_spam_check.py @@ -0,0 +1,38 @@ +from sendgrid.helpers.mail.spam_check import SpamCheck + +try: + import unittest2 as unittest +except ImportError: + import unittest + + +class UnitTests(unittest.TestCase): + + def test_spam_all_values(self): + expected = {'enable': True, 'threshold': 5, 'post_to_url': 'https://www.test.com'} + spam_check = SpamCheck(enable=True, threshold=5, post_to_url='https://www.test.com') + self.assertEqual(spam_check.get(), expected) + + def test_spam_no_url(self): + expected = {'enable': True, 'threshold': 10} + spam_check = SpamCheck(enable=True, threshold=10) + self.assertEqual(spam_check.get(), expected) + + def test_spam_no_threshold(self): + expected = {'enable': True} + spam_check = SpamCheck(enable=True) + self.assertEqual(spam_check.get(), expected) + + def test_has_values_but_not_enabled(self): + expected = {'enable': False, 'threshold': 1, 'post_to_url': 'https://www.test.com'} + spam_check = SpamCheck(enable=False, threshold=1, post_to_url='https://www.test.com') + self.assertEqual(spam_check.get(), expected) + + def test_spam_change_properties(self): + """Tests changing the properties of the spam check class""" + expected = {'enable': False, 'threshold': 10, 'post_to_url': 'https://www.testing.com'} + spam_check = SpamCheck(enable=True, threshold=5, post_to_url='https://www.test.com') + spam_check.enable = False + spam_check.threshold = 10 + spam_check.post_to_url = 'https://www.testing.com' + self.assertEqual(spam_check.get(), expected) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_stats.py b/.venv/lib/python3.12/site-packages/test/unit/test_stats.py new file mode 100644 index 00000000..c7111739 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_stats.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- +import json +from sendgrid.helpers.stats import * + +try: + import unittest2 as unittest +except ImportError: + import unittest + + +class UnitTests(unittest.TestCase): + + def test_basicStats(self): + + """Minimum required for stats""" + global_stats = Stats(start_date='12-09-2017') + + self.assertEqual( + json.dumps( + global_stats.get(), + sort_keys=True), + '{"start_date": "12-09-2017"}' + ) + + self.assertTrue(isinstance(str(global_stats), str)) + + def test_Stats(self): + + all_stats = Stats(start_date='12-09-2017') + all_stats.end_date = '12-10-2017' + all_stats.aggregated_by = 'day' + all_stats._sort_by_direction = 'asc' + all_stats.sort_by_metric = 'clicks' + all_stats._limit = 100 + all_stats._offset = 2 + + self.assertEqual( + json.dumps( + all_stats.get(), + sort_keys=True), + '{"aggregated_by": "day", "end_date": "12-10-2017", ' + '"limit": 100, "offset": 2, "sort_by_direction": "asc", ' + '"sort_by_metric": "clicks", "start_date": "12-09-2017"}' + ) + + def test_categoryStats(self): + + category_stats = CategoryStats(start_date='12-09-2017', categories=['foo', 'bar']) + category_stats.add_category(Category('woo')) + category_stats.end_date = '12-10-2017' + category_stats.aggregated_by = 'day' + category_stats._sort_by_direction = 'asc' + category_stats.sort_by_metric = 'clicks' + category_stats._limit = 100 + category_stats._offset = 2 + + self.assertEqual( + json.dumps( + category_stats.get(), + sort_keys=True), + '{"aggregated_by": "day", "categories": ["foo", "bar", "woo"], ' + '"end_date": "12-10-2017", "limit": 100, "offset": 2, ' + '"sort_by_direction": "asc", "sort_by_metric": "clicks", ' + '"start_date": "12-09-2017"}' + ) + + def test_subuserStats(self): + + subuser_stats = SubuserStats(start_date = '12-09-2017', subusers=['foo', 'bar']) + subuser_stats.add_subuser(Subuser('blah')) + subuser_stats.end_date = '12-10-2017' + subuser_stats.aggregated_by = 'day' + subuser_stats._sort_by_direction = 'asc' + subuser_stats.sort_by_metric = 'clicks' + subuser_stats._limit = 100 + subuser_stats._offset = 2 + + self.assertEqual( + json.dumps( + subuser_stats.get(), + sort_keys=True), + '{"aggregated_by": "day", "end_date": "12-10-2017", ' + '"limit": 100, "offset": 2, "sort_by_direction": "asc", ' + '"sort_by_metric": "clicks", "start_date": "12-09-2017", ' + '"subusers": ["foo", "bar", "blah"]}' + ) diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_twilio_email.py b/.venv/lib/python3.12/site-packages/test/unit/test_twilio_email.py new file mode 100644 index 00000000..92269acf --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_twilio_email.py @@ -0,0 +1,37 @@ +import os +import unittest + +from sendgrid import TwilioEmailAPIClient + + +class UnitTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + os.environ['TWILIO_API_KEY'] = 'api-key' + os.environ['TWILIO_API_SECRET'] = 'api-secret' + os.environ['TWILIO_ACCOUNT_SID'] = 'account-sid' + os.environ['TWILIO_AUTH_TOKEN'] = 'auth-token' + + def test_init_key_over_token(self): + mail_client = TwilioEmailAPIClient() + + self.assertEqual(mail_client.username, 'api-key') + self.assertEqual(mail_client.password, 'api-secret') + self.assertEqual(mail_client.host, 'https://email.twilio.com') + + def test_init_token(self): + del os.environ['TWILIO_API_KEY'] + del os.environ['TWILIO_API_SECRET'] + + mail_client = TwilioEmailAPIClient() + + self.assertEqual(mail_client.username, 'account-sid') + self.assertEqual(mail_client.password, 'auth-token') + + def test_init_args(self): + mail_client = TwilioEmailAPIClient('username', 'password') + + self.assertEqual(mail_client.username, 'username') + self.assertEqual(mail_client.password, 'password') + self.assertEqual(mail_client.auth, 'Basic dXNlcm5hbWU6cGFzc3dvcmQ=') diff --git a/.venv/lib/python3.12/site-packages/test/unit/test_unassigned.py b/.venv/lib/python3.12/site-packages/test/unit/test_unassigned.py new file mode 100644 index 00000000..08ab943b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/test/unit/test_unassigned.py @@ -0,0 +1,93 @@ +import json + +from sendgrid.helpers.endpoints.ip.unassigned import unassigned + +ret_json = '''[ { + "ip": "167.89.21.3", + "pools": [ + "pool1", + "pool2" + ], + "whitelabeled": false, + "start_date": 1409616000, + "subusers": [ + "tim@sendgrid.net" + ], + "warmup": false, + "assigned_at": 1482883200 + }, + { + "ip": "192.168.1.1", + "pools": [ + "pool1", + "pool2" + ], + "whitelabeled": false, + "start_date": 1409616000, + "subusers": [ + "tim@sendgrid.net" + ], + "warmup": false, + "assigned_at": 1482883200 + }, + { + "ip": "208.115.214.22", + "pools": [], + "whitelabeled": true, + "rdns": "o1.email.burgermail.com", + "start_date": 1409616000, + "subusers": [], + "warmup": false, + "assigned_at": 1482883200 + }, + { + "ip": "208.115.214.23", + "pools": [], + "whitelabeled": true, + "rdns": "o1.email.burgermail.com", + "start_date": 1409616000, + "subusers": [], + "warmup": false, + "assigned_at": 1482883200 + + } ] + ''' + + +def get_all_ip(): + ret_val = json.loads(ret_json) + return ret_val + + +def make_data(): + data = set() + data.add("208.115.214.23") + data.add("208.115.214.22") + return data + + +def test_unassigned_ip_json(): + data = make_data() + + as_json = True + calculated = unassigned(get_all_ip(), as_json=as_json) + calculated = json.loads(calculated) + + for item in calculated: + assert item["ip"] in data + + +def test_unassigned_ip_obj(): + data = make_data() + + as_json = False + calculated = unassigned(get_all_ip(), as_json=as_json) + + for item in calculated: + assert item["ip"] in data + + +def test_unassigned_baddata(): + as_json = False + calculated = unassigned(dict(), as_json=as_json) + assert calculated == [] |