test_sendgrid.py

import sendgrid
from sendgrid.helpers.mail import *
from sendgrid.version import __version__
try:
    import unittest2 as unittest
except ImportError:
    import unittest
import os
import subprocess
import sys
import time
import datetime

host = "http://localhost:4010"


class UnitTests(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.host = host
        cls.path = '{0}{1}'.format(
            os.path.abspath(
                os.path.dirname(__file__)), '/..')
        cls.sg = sendgrid.SendGridAPIClient(host=host)
        cls.devnull = open(os.devnull, 'w')
        prism_cmd = None
        
        # try:
        #     # check for prism in the PATH
        #     if subprocess.call('prism version'.split(), stdout=cls.devnull) == 0:
        #         prism_cmd = 'prism'
        # except OSError:
        #     prism_cmd = None

        # if not prism_cmd:
        #     # check for known prism locations
        #     for path in ('/usr/local/bin/prism', os.path.expanduser(os.path.join('~', 'bin', 'prism')),
        #                  os.path.abspath(os.path.join(os.getcwd(), 'prism', 'bin', 'prism'))):
        #         prism_cmd = path if os.path.isfile(path) else None
        #         if prism_cmd:
        #             break

        # if not prism_cmd:
        #     if sys.platform != 'win32':
        #         # try to install with prism.sh
        #         try:
        #             print("Warning: no prism detected, I will try to install it locally")
        #             prism_sh = os.path.abspath(os.path.join(cls.path, 'test', 'prism.sh'))
        #             if subprocess.call(prism_sh) == 0:
        #                 prism_cmd = os.path.expanduser(os.path.join('~', 'bin', 'prism'))
        #             else:
        #                 raise RuntimeError()
        #         except Exception as e:
        #             print(
        #                 "Error installing the prism binary, you can try "
        #                 "downloading directly here "
        #                 "(https://github.com/stoplightio/prism/releases) "
        #                 "and place in your $PATH", e)
        #             sys.exit()
        #     else:
        #         print("Please download the Windows binary "
        #               "(https://github.com/stoplightio/prism/releases) "
        #               "and place it in your %PATH% ")
        #         sys.exit()

        # print("Activating Prism (~20 seconds)")
        # cls.p = subprocess.Popen([
        #     prism_cmd, "run", "-s",
        #     "https://raw.githubusercontent.com/sendgrid/sendgrid-oai/master/"
        #     "oai_stoplight.json"], stdout=cls.devnull, stderr=subprocess.STDOUT)
        # time.sleep(15)
        # print("Prism Started")

    def test_apikey_init(self):
        self.assertEqual(self.sg.apikey, os.environ.get('SENDGRID_API_KEY'))
        # Support the previous naming convention for API keys
        self.assertEqual(self.sg.api_key, self.sg.apikey)
        my_sendgrid = sendgrid.SendGridAPIClient(apikey="THISISMYKEY")
        self.assertEqual(my_sendgrid.apikey, "THISISMYKEY")

    def test_apikey_setter(self):
        sg_apikey_setter = sendgrid.SendGridAPIClient(apikey="THISISMYKEY")
        self.assertEqual(sg_apikey_setter.apikey, "THISISMYKEY")
        # Use apikey setter to change api key
        sg_apikey_setter.apikey = "THISISMYNEWAPIKEY"
        self.assertEqual(sg_apikey_setter.apikey, "THISISMYNEWAPIKEY")

    def test_api_key_setter(self):
        sg_api_key_setter = sendgrid.SendGridAPIClient(apikey="THISISMYKEY")
        self.assertEqual(sg_api_key_setter.apikey, "THISISMYKEY")
        # Use api_key setter to change api key
        sg_api_key_setter.api_key = "THISISMYNEWAPI_KEY"
        self.assertEqual(sg_api_key_setter.apikey, "THISISMYNEWAPI_KEY")

    def test_impersonate_subuser_init(self):
        temp_subuser = 'abcxyz@this.is.a.test.subuser'
        sg_impersonate = sendgrid.SendGridAPIClient(
            host=host,
            impersonate_subuser=temp_subuser)
        self.assertEqual(sg_impersonate.impersonate_subuser, temp_subuser)

    def test_useragent(self):
        useragent = '{0}{1}{2}'.format('sendgrid/', __version__, ';python')
        self.assertEqual(self.sg.useragent, useragent)

    def test_host(self):
        self.assertEqual(self.sg.host, self.host)

    def test_get_default_headers(self):
        headers = self.sg._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_hello_world(self):
        from_email = Email("test@example.com")
        to_email = Email("test@example.com")
        subject = "Sending with SendGrid is Fun"
        content = Content(
            "text/plain", "and easy to do anywhere, even with Python")
        mail = Mail(from_email, subject, to_email, content)
        self.assertTrue(mail.get() == {'content': [{'type': 'text/plain', 'value': 'and easy to do anywhere, even with Python'}], 'personalizations': [
                        {'to': [{'email': 'test@example.com'}]}], 'from': {'email': 'test@example.com'}, 'subject': 'Sending with SendGrid is Fun'})

    def test_access_settings_activity_get(self):
        params = {'limit': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.access_settings.activity.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_access_settings_whitelist_post(self):
        data = {
            "ips": [
                {
                    "ip": "192.168.1.1"
                },
                {
                    "ip": "192.*.*.*"
                },
                {
                    "ip": "192.168.1.3/32"
                }
            ]
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.access_settings.whitelist.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_access_settings_whitelist_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.access_settings.whitelist.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_access_settings_whitelist_delete(self):
        data = {
            "ids": [
                1,
                2,
                3
            ]
        }
        headers = {'X-Mock': 204}
        response = self.sg.client.access_settings.whitelist.delete(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_access_settings_whitelist__rule_id__get(self):
        rule_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.access_settings.whitelist._(rule_id).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_access_settings_whitelist__rule_id__delete(self):
        rule_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.access_settings.whitelist._(rule_id).delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_alerts_post(self):
        data = {
            "email_to": "example@example.com",
            "frequency": "daily",
            "type": "stats_notification"
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.alerts.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_alerts_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.alerts.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_alerts__alert_id__patch(self):
        data = {
            "email_to": "example@example.com"
        }
        alert_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.alerts._(alert_id).patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_alerts__alert_id__get(self):
        alert_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.alerts._(alert_id).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_alerts__alert_id__delete(self):
        alert_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.alerts._(alert_id).delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_api_keys_post(self):
        data = {
            "name": "My API Key",
            "sample": "data",
            "scopes": [
                "mail.send",
                "alerts.create",
                "alerts.read"
            ]
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.api_keys.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_api_keys_get(self):
        params = {'limit': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.api_keys.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_api_keys__api_key_id__put(self):
        data = {
            "name": "A New Hope",
            "scopes": [
                "user.profile.read",
                "user.profile.update"
            ]
        }
        api_key_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.api_keys._(api_key_id).put(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_api_keys__api_key_id__patch(self):
        data = {
            "name": "A New Hope"
        }
        api_key_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.api_keys._(api_key_id).patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_api_keys__api_key_id__get(self):
        api_key_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.api_keys._(api_key_id).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_api_keys__api_key_id__delete(self):
        api_key_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.api_keys._(api_key_id).delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_asm_groups_post(self):
        data = {
            "description": "Suggestions for products our users might like.",
            "is_default": True,
            "name": "Product Suggestions"
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.asm.groups.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_asm_groups_get(self):
        params = {'id': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.groups.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_groups__group_id__patch(self):
        data = {
            "description": "Suggestions for items our users might like.",
            "id": 103,
            "name": "Item Suggestions"
        }
        group_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.asm.groups._(group_id).patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_asm_groups__group_id__get(self):
        group_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.groups._(group_id).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_groups__group_id__delete(self):
        group_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.asm.groups._(group_id).delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_asm_groups__group_id__suppressions_post(self):
        data = {
            "recipient_emails": [
                "test1@example.com",
                "test2@example.com"
            ]
        }
        group_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.asm.groups._(group_id).suppressions.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_asm_groups__group_id__suppressions_get(self):
        group_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.groups._(group_id).suppressions.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_groups__group_id__suppressions_search_post(self):
        data = {
            "recipient_emails": [
                "exists1@example.com",
                "exists2@example.com",
                "doesnotexists@example.com"
            ]
        }
        group_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.groups._(
            group_id).suppressions.search.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_groups__group_id__suppressions__email__delete(self):
        group_id = "test_url_param"
        email = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.asm.groups._(group_id).suppressions._(
            email).delete(request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_asm_suppressions_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.suppressions.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_suppressions_global_post(self):
        data = {
            "recipient_emails": [
                "test1@example.com",
                "test2@example.com"
            ]
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.asm.suppressions._("global").post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_asm_suppressions_global__email__get(self):
        email = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.suppressions._("global")._(
            email).get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_asm_suppressions_global__email__delete(self):
        email = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.asm.suppressions._("global")._(
            email).delete(request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_asm_suppressions__email__get(self):
        email = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.asm.suppressions._(email).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_browsers_stats_get(self):
        params = {'end_date': '2016-04-01', 'aggregated_by': 'day',
                  'browsers': 'test_string', 'limit': 'test_string',
                  'offset': 'test_string', 'start_date': '2016-01-01'}
        headers = {'X-Mock': 200}
        response = self.sg.client.browsers.stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns_post(self):
        data = {
            "categories": [
                "spring line"
            ],
            "custom_unsubscribe_url": "",
            "html_content": "<html><head><title></title></head><body>"
                            "<p>Check out our spring line!</p></body></html>",
            "ip_pool": "marketing",
            "list_ids": [
                110,
                124
            ],
            "plain_content": "Check out our spring line!",
            "segment_ids": [
                110
            ],
            "sender_id": 124451,
            "subject": "New Products for Spring!",
            "suppression_group_id": 42,
            "title": "March Newsletter"
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.campaigns.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_campaigns_get(self):
        params = {'limit': 1, 'offset': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.campaigns.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns__campaign_id__patch(self):
        data = {
            "categories": [
                "summer line"
            ],
            "html_content": "<html><head><title></title></head><body><p>"
                            "Check out our summer line!</p></body></html>",
            "plain_content": "Check out our summer line!",
            "subject": "New Products for Summer!",
            "title": "May Newsletter"
        }
        campaign_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.campaigns._(campaign_id).patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns__campaign_id__get(self):
        campaign_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.campaigns._(campaign_id).get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns__campaign_id__delete(self):
        campaign_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.campaigns._(campaign_id).delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_campaigns__campaign_id__schedules_patch(self):
        data = {
            "send_at": 1489451436
        }
        campaign_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.campaigns._(campaign_id).schedules.patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns__campaign_id__schedules_post(self):
        data = {
            "send_at": 1489771528
        }
        campaign_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.campaigns._(campaign_id).schedules.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_campaigns__campaign_id__schedules_get(self):
        campaign_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.campaigns._(campaign_id).schedules.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_campaigns__campaign_id__schedules_delete(self):
        campaign_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.campaigns._(campaign_id).schedules.delete(
            request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_campaigns__campaign_id__schedules_now_post(self):
        campaign_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.campaigns._(campaign_id).schedules.now.post(
            request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_campaigns__campaign_id__schedules_test_post(self):
        data = {
            "to": "your.email@example.com"
        }
        campaign_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.campaigns._(campaign_id).schedules.test.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_categories_get(self):
        params = {'category': 'test_string', 'limit': 1, 'offset': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.categories.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_categories_stats_get(self):
        params = {'end_date': '2016-04-01', 'aggregated_by': 'day',
                  'limit': 1, 'offset': 1, 'start_date': '2016-01-01',
                  'categories': 'test_string'}
        headers = {'X-Mock': 200}
        response = self.sg.client.categories.stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_categories_stats_sums_get(self):
        params = {'end_date': '2016-04-01', 'aggregated_by': 'day',
                  'limit': 1, 'sort_by_metric': 'test_string', 'offset': 1,
                  'start_date': '2016-01-01', 'sort_by_direction': 'asc'}
        headers = {'X-Mock': 200}
        response = self.sg.client.categories.stats.sums.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_clients_stats_get(self):
        params = {'aggregated_by': 'day', 'start_date': '2016-01-01',
                  'end_date': '2016-04-01'}
        headers = {'X-Mock': 200}
        response = self.sg.client.clients.stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_clients__client_type__stats_get(self):
        params = {'aggregated_by': 'day', 'start_date': '2016-01-01',
                  'end_date': '2016-04-01'}
        client_type = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.clients._(client_type).stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_custom_fields_post(self):
        data = {
            "name": "pet",
            "type": "text"
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.custom_fields.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_custom_fields_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.custom_fields.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_custom_fields__custom_field_id__get(self):
        custom_field_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.custom_fields._(
            custom_field_id).get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_custom_fields__custom_field_id__delete(self):
        custom_field_id = "test_url_param"
        headers = {'X-Mock': 202}
        response = self.sg.client.contactdb.custom_fields._(
            custom_field_id).delete(request_headers=headers)
        self.assertEqual(response.status_code, 202)

    def test_contactdb_lists_post(self):
        data = {
            "name": "your list name"
        }
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.lists.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_lists_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.lists.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_lists_delete(self):
        data = [
            1,
            2,
            3,
            4
        ]
        headers = {'X-Mock': 204}
        response = self.sg.client.contactdb.lists.delete(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_contactdb_lists__list_id__patch(self):
        data = {
            "name": "newlistname"
        }
        params = {'list_id': 1}
        list_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.lists._(list_id).patch(
            request_body=data, query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_lists__list_id__get(self):
        params = {'list_id': 1}
        list_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.lists._(list_id).get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_lists__list_id__delete(self):
        params = {'delete_contacts': 'true'}
        list_id = "test_url_param"
        headers = {'X-Mock': 202}
        response = self.sg.client.contactdb.lists._(list_id).delete(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 202)

    def test_contactdb_lists__list_id__recipients_post(self):
        data = [
            "recipient_id1",
            "recipient_id2"
        ]
        list_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.lists._(list_id).recipients.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_lists__list_id__recipients_get(self):
        params = {'page': 1, 'page_size': 1}
        list_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.lists._(list_id).recipients.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_lists__list_id__recipients__recipient_id__post(self):
        list_id = "test_url_param"
        recipient_id = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.lists._(list_id).recipients._(
            recipient_id).post(request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_lists__list_id__recipients__recipient_id__delete(self):
        params = {'recipient_id': 1, 'list_id': 1}
        list_id = "test_url_param"
        recipient_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.contactdb.lists._(list_id).recipients._(
            recipient_id).delete(query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_contactdb_recipients_patch(self):
        data = [
            {
                "email": "jones@example.com",
                "first_name": "Guy",
                "last_name": "Jones"
            }
        ]
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.recipients.patch(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_recipients_post(self):
        data = [
            {
                "age": 25,
                "email": "example@example.com",
                "first_name": "",
                "last_name": "User"
            },
            {
                "age": 25,
                "email": "example2@example.com",
                "first_name": "Example",
                "last_name": "User"
            }
        ]
        headers = {'X-Mock': 201}
        response = self.sg.client.contactdb.recipients.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_contactdb_recipients_get(self):
        params = {'page': 1, 'page_size': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients_delete(self):
        data = [
            "recipient_id1",
            "recipient_id2"
        ]
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients.delete(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients_billable_count_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients.billable_count.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients_count_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients.count.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients_search_get(self):
        params = {'{field_name}': 'test_string'}
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients.search.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients__recipient_id__get(self):
        recipient_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients._(
            recipient_id).get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_recipients__recipient_id__delete(self):
        recipient_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.contactdb.recipients._(
            recipient_id).delete(request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_contactdb_recipients__recipient_id__lists_get(self):
        recipient_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.recipients._(
            recipient_id).lists.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_reserved_fields_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.reserved_fields.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_segments_post(self):
        data = {
            "conditions": [
                {
                    "and_or": "",
                    "field": "last_name",
                    "operator": "eq",
                    "value": "Miller"
                },
                {
                    "and_or": "and",
                    "field": "last_clicked",
                    "operator": "gt",
                    "value": "01/02/2015"
                },
                {
                    "and_or": "or",
                    "field": "clicks.campaign_identifier",
                    "operator": "eq",
                    "value": "513"
                }
            ],
            "list_id": 4,
            "name": "Last Name Miller"
        }
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.segments.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_segments_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.segments.get(
            request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_segments__segment_id__patch(self):
        data = {
            "conditions": [
                {
                    "and_or": "",
                    "field": "last_name",
                    "operator": "eq",
                    "value": "Miller"
                }
            ],
            "list_id": 5,
            "name": "The Millers"
        }
        params = {'segment_id': 'test_string'}
        segment_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.segments._(segment_id).patch(
            request_body=data, query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_segments__segment_id__get(self):
        params = {'segment_id': 1}
        segment_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.segments._(segment_id).get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_contactdb_segments__segment_id__delete(self):
        params = {'delete_contacts': 'true'}
        segment_id = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.contactdb.segments._(segment_id).delete(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_contactdb_segments__segment_id__recipients_get(self):
        params = {'page': 1, 'page_size': 1}
        segment_id = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.contactdb.segments._(
            segment_id).recipients.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_devices_stats_get(self):
        params = {
            'aggregated_by': 'day',
            'limit': 1,
            'start_date': '2016-01-01',
            'end_date': '2016-04-01',
            'offset': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.devices.stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_geo_stats_get(self):
        params = {
            'end_date': '2016-04-01',
            'country': 'US',
            'aggregated_by': 'day',
            'limit': 1,
            'offset': 1,
            'start_date': '2016-01-01'}
        headers = {'X-Mock': 200}
        response = self.sg.client.geo.stats.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_get(self):
        params = {
            'subuser': 'test_string',
            'ip': 'test_string',
            'limit': 1,
            'exclude_whitelabels': 'true',
            'offset': 1}
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.get(
            query_params=params, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_assigned_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.assigned.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_pools_post(self):
        data = {
            "name": "marketing"
        }
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.pools.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_pools_get(self):
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.pools.get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_pools__pool_name__put(self):
        data = {
            "name": "new_pool_name"
        }
        pool_name = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.pools._(pool_name).put(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_pools__pool_name__get(self):
        pool_name = "test_url_param"
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.pools._(
            pool_name).get(request_headers=headers)
        self.assertEqual(response.status_code, 200)

    def test_ips_pools__pool_name__delete(self):
        pool_name = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.ips.pools._(
            pool_name).delete(request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_ips_pools__pool_name__ips_post(self):
        data = {
            "ip": "0.0.0.0"
        }
        pool_name = "test_url_param"
        headers = {'X-Mock': 201}
        response = self.sg.client.ips.pools._(pool_name).ips.post(
            request_body=data, request_headers=headers)
        self.assertEqual(response.status_code, 201)

    def test_ips_pools__pool_name__ips__ip__delete(self):
        pool_name = "test_url_param"
        ip = "test_url_param"
        headers = {'X-Mock': 204}
        response = self.sg.client.ips.pools._(pool_name).ips._(
            ip).delete(request_headers=headers)
        self.assertEqual(response.status_code, 204)

    def test_ips_warmup_post(self):
        data = {
            "ip": "0.0.0.0"
        }
        headers = {'X-Mock': 200}
        response = self.sg.client.ips.warmup.post(