From 031c33ee46e3a20748fa0965ad0253a99eb2b6df Mon Sep 17 00:00:00 2001 From: Humberto Morales Date: Thu, 13 Feb 2014 10:41:44 -0800 Subject: [PATCH] Added proxy support by migrating to the requests module. --- setup.py | 2 +- telesign/api.py | 67 ++++++++------ telesign/exceptions.py | 6 +- test/test_exceptions.py | 6 +- test/test_phoneid.py | 142 ++++++++++++++++++++++-------- test/test_verify.py | 188 ++++++++++++++++++++++++++++------------ 6 files changed, 283 insertions(+), 128 deletions(-) diff --git a/setup.py b/setup.py index 1423915..7ecc423 100644 --- a/setup.py +++ b/setup.py @@ -75,7 +75,7 @@ def run(self): author = 'TeleSign Corp.', author_email='support@telesign.com', url="http://github.com/telesign/python_telesign", - install_requires=['urllib3', + install_requires=['requests', ], packages=find_packages(), diff --git a/telesign/api.py b/telesign/api.py index 23ea873..4310b0c 100644 --- a/telesign/api.py +++ b/telesign/api.py @@ -4,9 +4,9 @@ :synopsis: The **api** module contains Python classes and methods that allow you to use the Python programming language to programmatically access the **Verify** and **PhoneId** TeleSign web services. """ -import urllib3 import json from random import randint +import requests from telesign.auth import generate_auth_headers from telesign.exceptions import TelesignError, AuthorizationError @@ -30,27 +30,27 @@ class Response(object): def __init__(self, data, http_response, verify_code=None): self.data = data self.headers = http_response.headers - self.status = http_response.status - self.raw_data = http_response.data + self.status = http_response.status_code + self.raw_data = http_response.text self.verify_code = verify_code class ServiceBase(object): - def __init__(self, api_host, customer_id, secret_key, ssl=True): + def __init__(self, api_host, customer_id, secret_key, ssl=True, proxy_host=None): self._customer_id = customer_id self._secret_key = secret_key self._api_host = api_host - http_root = "https://" if ssl else "http://" - self._pool = urllib3.connection_from_url(http_root + api_host) + http_root = "https" if ssl else "http" + self._proxy = {"{}".format(http_root): "{}{}{}".format(http_root, '://', proxy_host)} if proxy_host else None + self._url = "{}{}{}".format(http_root, '://', api_host) def _validate_response(self, response): - resp_obj = json.loads(response.data) - if(response.status != 200): - if(response.status == 401): + resp_obj = json.loads(response.text) + if(response.status_code != 200): + if(response.status_code == 401): raise AuthorizationError(resp_obj, response) else: - print "%s|%s" % (response.status, response.data) raise TelesignError(resp_obj, response) return resp_obj @@ -74,13 +74,15 @@ class PhoneId(ServiceBase): - Specifies whether to use a secure connection with the TeleSign server. Defaults to *True*. * - `api_host` - The Internet host used in the base URI for REST web services. The default is *rest.telesign.com* (and the base URI is https://rest.telesign.com/). + * - `proxy_host` + - The host and port when going through a proxy server. ex: "localhost:8080. The default to no proxy. .. note:: You can obtain both your Customer ID and Secret Key from the `TeleSign Customer Portal `_. """ - def __init__(self, customer_id, secret_key, ssl=True, api_host="rest.telesign.com"): - super(PhoneId, self).__init__(api_host, customer_id, secret_key, ssl) + def __init__(self, customer_id, secret_key, ssl=True, api_host="rest.telesign.com", proxy_host=None): + super(PhoneId, self).__init__(api_host, customer_id, secret_key, ssl, proxy_host) def standard(self, phone_number): """ @@ -120,13 +122,15 @@ def standard(self, phone_number): """ resource = "/v1/phoneid/standard/%s" % phone_number + method = "GET" + headers = generate_auth_headers( self._customer_id, self._secret_key, resource, - "GET") + method) - req = self._pool.request('GET', resource, headers=headers) + req = requests.get(url="{}{}".format(self._url, resource), headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req) @@ -187,12 +191,15 @@ def score(self, phone_number, use_case_code): """ resource = "/v1/phoneid/score/%s" % phone_number + method = "GET" + headers = generate_auth_headers( self._customer_id, self._secret_key, resource, - "GET") - req = self._pool.request('GET', resource, headers=headers, fields={'ucid': use_case_code}) + method) + + req = requests.get(url="{}{}".format(self._url, resource), params={'ucid': use_case_code}, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req) @@ -256,13 +263,15 @@ def contact(self, phone_number, use_case_code): """ resource = "/v1/phoneid/contact/%s" % phone_number + method = "GET" + headers = generate_auth_headers( self._customer_id, self._secret_key, resource, - "GET") + method) - req = self._pool.request('GET', resource, headers=headers, fields={'ucid': use_case_code}) + req = requests.get(url="{}{}".format(self._url, resource), params={'ucid': use_case_code}, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req) @@ -326,13 +335,15 @@ def live(self, phone_number, use_case_code): """ resource = "/v1/phoneid/live/%s" % phone_number + method = "GET" + headers = generate_auth_headers( self._customer_id, self._secret_key, resource, - "GET") + method) - req = self._pool.request('GET', resource, headers=headers, fields={'ucid': use_case_code}) + req = requests.get(url="{}{}".format(self._url, resource), params={'ucid': use_case_code}, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req) @@ -359,14 +370,16 @@ class Verify(ServiceBase): - Specifies whether to use a secure connection with the TeleSign server. Defaults to *True*. * - `api_host` - The Internet host used in the base URI for REST web services. The default is *rest.telesign.com* (and the base URI is https://rest.telesign.com/). + * - `proxy_host` + - The host and port when going through a proxy server. ex: "localhost:8080. The default to no proxy. .. note:: You can obtain both your Customer ID and Secret Key from the `TeleSign Customer Portal `_. """ - def __init__(self, customer_id, secret_key, ssl=True, api_host="rest.telesign.com"): - super(Verify, self).__init__(api_host, customer_id, secret_key, ssl) + def __init__(self, customer_id, secret_key, ssl=True, api_host="rest.telesign.com", proxy_host=None): + super(Verify, self).__init__(api_host, customer_id, secret_key, ssl, proxy_host) def sms(self, phone_number, verify_code=None, language="en", template=""): """ @@ -437,7 +450,7 @@ def sms(self, phone_number, verify_code=None, language="en", template=""): method, fields=fields) - req = self._pool.request_encode_body(method, resource, headers=headers, fields=fields, encode_multipart=False) + req = requests.post(url="{}{}".format(self._url, resource), data=fields, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req, verify_code=verify_code) @@ -508,7 +521,7 @@ def call(self, phone_number, verify_code=None, language="en"): method, fields=fields) - req = self._pool.request_encode_body(method, resource, headers=headers, fields=fields, encode_multipart=False) + req = requests.post(url="{}{}".format(self._url, resource), data=fields, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req, verify_code=verify_code) @@ -552,15 +565,17 @@ def status(self, ref_id, verify_code=None): """ resource = "/v1/verify/%s" % ref_id + method = "GET" + headers = generate_auth_headers( self._customer_id, self._secret_key, resource, - "GET") + method) fields = None if(verify_code != None): fields = {"verify_code": verify_code} - req = self._pool.request('GET', resource, headers=headers, fields=fields) + req = requests.get(url="{}{}".format(self._url, resource), params=fields, headers=headers, proxies=self._proxy) return Response(self._validate_response(req), req) diff --git a/telesign/exceptions.py b/telesign/exceptions.py index d5f7b93..3fa55c2 100644 --- a/telesign/exceptions.py +++ b/telesign/exceptions.py @@ -34,9 +34,9 @@ class TelesignError(Exception): def __init__(self, data, http_response): self.errors = data["errors"] self.headers = http_response.headers - self.status = http_response.status - self.data = http_response.data - self.raw_data = http_response.data + self.status = http_response.status_code + self.data = http_response.text + self.raw_data = http_response.text def __str__(self): result = "" diff --git a/test/test_exceptions.py b/test/test_exceptions.py index 9548758..b1e2039 100644 --- a/test/test_exceptions.py +++ b/test/test_exceptions.py @@ -13,9 +13,9 @@ def setUp(self): self.expected_status = "200" self.expected_data = "abcdefg" self.expected_http_response = mock.Mock() - self.expected_http_response .headers = self.expected_headers - self.expected_http_response .status = self.expected_status - self.expected_http_response .data = self.expected_data + self.expected_http_response.headers = self.expected_headers + self.expected_http_response.status_code = self.expected_status + self.expected_http_response.text = self.expected_data def tearDown(self): pass diff --git a/test/test_phoneid.py b/test/test_phoneid.py index b000464..232a6c2 100644 --- a/test/test_phoneid.py +++ b/test/test_phoneid.py @@ -1,7 +1,7 @@ import unittest import mock import telesign.api -import urllib3 +import requests class PhoneIdTest(unittest.TestCase): @@ -12,33 +12,35 @@ def setUp(self): self.expected_secret_key = "8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M==" self.expected_phone_no = "12343455678" self.expected_data = "{ \"a\": \"AA\", \"b\":\"BB\" }" - self.expected_resource = "/v1/phoneid/%s/%s" + self.expected_resource = "https://rest.telesign.com/v1/phoneid/%s/%s" + self.proxy = "localhost:8080" + self.expected_proxy = "https://localhost:8080" def tearDown(self): pass - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_standard_phoneid(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) p.standard(self.expected_phone_no) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_standard_phoneid_unauthorized(self, req_mock): response = mock.Mock() response.reason = "Unauthorized" - response.status = 401 - response.data = "{ \"a\": \"AA\", \"b\":\"BB\", \"errors\": { \"code\": \"401\", \"description\":\"Unauthorized\" } }" + response.status_code = 401 + response.text = "{ \"a\": \"AA\", \"b\":\"BB\", \"errors\": { \"code\": \"401\", \"description\":\"Unauthorized\" } }" req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) @@ -47,16 +49,16 @@ def test_standard_phoneid_unauthorized(self, req_mock): p.standard(self.expected_phone_no) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_standard_phoneid_other_error(self, req_mock): response = mock.Mock() response.reason = "Bad Gateway" - response.status = 502 - response.data = "{ \"a\": \"AA\", \"b\":\"BB\", \"errors\": { \"code\": \"502\", \"description\":\"Bad Gateway\" } }" + response.status_code = 502 + response.text = "{ \"a\": \"AA\", \"b\":\"BB\", \"errors\": { \"code\": \"502\", \"description\":\"Bad Gateway\" } }" req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) @@ -65,54 +67,118 @@ def test_standard_phoneid_other_error(self, req_mock): p.standard(self.expected_phone_no) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_score_phoneid(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) p.score(self.expected_phone_no, 'OTHR') self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('score', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('score', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_contact_phoneid(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) p.contact(self.expected_phone_no, 'OTHR') self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('contact', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('contact', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_live_phoneid(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key) p.live(self.expected_phone_no, 'OTHR') self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_resource % ('live', self.expected_phone_no), "Phone ID resource name is incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('live', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "get") + def test_standard_phoneid_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.standard(self.expected_phone_no) + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('standard', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "get") + def test_score_phoneid_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.score(self.expected_phone_no, 'OTHR') + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('score', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "get") + def test_contact_phoneid_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.contact(self.expected_phone_no, 'OTHR') + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('contact', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "get") + def test_live_phoneid_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.PhoneId(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.live(self.expected_phone_no, 'OTHR') + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_resource % ('live', self.expected_phone_no), "Phone ID resource name is incorrect") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") diff --git a/test/test_verify.py b/test/test_verify.py index 506d48a..555b991 100644 --- a/test/test_verify.py +++ b/test/test_verify.py @@ -1,7 +1,7 @@ import unittest import mock import telesign.api -import urllib3 +import requests class VerifyTest(unittest.TestCase): @@ -15,118 +15,192 @@ def setUp(self): self.expected_verify_code = 54321 self.expected_ref_id = "99999999999999999" self.expected_data = "{ \"a\": \"AA\", \"b\":\"BB\" }" - self.expected_sms_resource = "/v1/verify/sms" - self.expected_call_resource = "/v1/verify/call" - self.expected_status_resource = "/v1/verify/%s" % self.expected_ref_id + self.expected_sms_resource = "https://rest.telesign.com/v1/verify/sms" + self.expected_call_resource = "https://rest.telesign.com/v1/verify/call" + self.expected_status_resource = "https://rest.telesign.com/v1/verify/%s" % self.expected_ref_id + self.proxy = "localhost:8080" + self.expected_proxy = "https://localhost:8080" def tearDown(self): pass - @mock.patch.object(urllib3.HTTPConnectionPool, "request_encode_body") + @mock.patch.object(requests, "post") def test_verify_sms(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.sms(self.expected_phone_no, self.expected_verify_code, self.expected_language) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "POST", "Expected POST") - self.assertEqual(args[0][1], self.expected_sms_resource, "Sms verify resource was incorrect") - self.assertEqual(args[1]["fields"]["phone_number"], self.expected_phone_no, "Phone number field did not match") - self.assertEqual(args[1]["fields"]["language"], self.expected_language, "Language field did not match") - self.assertEqual(args[1]["fields"]["verify_code"], self.expected_verify_code, "Verify code field did not match") - - @mock.patch.object(urllib3.HTTPConnectionPool, "request_encode_body") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs['url'], self.expected_sms_resource, "Sms verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(kwargs["data"]["verify_code"], self.expected_verify_code, "Verify code field did not match") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "post") def test_verify_call(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.call(self.expected_phone_no, self.expected_verify_code, self.expected_language) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "POST", "Expected POST") - self.assertEqual(args[0][1], self.expected_call_resource, "Call verify resource was incorrect") - self.assertEqual(args[1]["fields"]["phone_number"], self.expected_phone_no, "Phone number field did not match") - self.assertEqual(args[1]["fields"]["language"], self.expected_language, "Language field did not match") - self.assertEqual(args[1]["fields"]["verify_code"], self.expected_verify_code, "Verify code field did not match") - - @mock.patch.object(urllib3.HTTPConnectionPool, "request_encode_body") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs['url'], self.expected_call_resource, "Call verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(kwargs["data"]["verify_code"], self.expected_verify_code, "Verify code field did not match") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "post") def test_verify_sms_default_code(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.sms(self.expected_phone_no, language=self.expected_language) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "POST", "Expected POST") - self.assertEqual(args[0][1], self.expected_sms_resource, "Sms verify resource was incorrect") - self.assertEqual(args[1]["fields"]["phone_number"], self.expected_phone_no, "Phone number field did not match") - self.assertEqual(args[1]["fields"]["language"], self.expected_language, "Language field did not match") - self.assertEqual(len("%s" % args[1]["fields"]["verify_code"]), 5, "Expected default verify code to be 5 digits") - - @mock.patch.object(urllib3.HTTPConnectionPool, "request_encode_body") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_sms_resource, "Sms verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(len("%s" % kwargs["data"]["verify_code"]), 5, "Expected default verify code to be 5 digits") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "post") def test_verify_call_default_code(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.call(self.expected_phone_no, language=self.expected_language) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "POST", "Expected POST") - self.assertEqual(args[0][1], self.expected_call_resource, "Call verify resource was incorrect") - self.assertEqual(args[1]["fields"]["phone_number"], self.expected_phone_no, "Phone number field did not match") - self.assertEqual(args[1]["fields"]["language"], self.expected_language, "Language field did not match") - self.assertEqual(len("%s" % args[1]["fields"]["verify_code"]), 5, "Expected default verify code to be 5 digits") - - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_call_resource, "Call verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(len("%s" % kwargs["data"]["verify_code"]), 5, "Expected default verify code to be 5 digits") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "get") def test_status_check(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.status(self.expected_ref_id) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_status_resource, "Status resource was incorrect") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_status_resource, "Status resource was incorrect") + self.assertFalse(kwargs['proxies']) - @mock.patch.object(urllib3.HTTPConnectionPool, "request") + @mock.patch.object(requests, "get") def test_report_code(self, req_mock): response = mock.Mock() response.reason = "" - response.status = 200 - response.data = self.expected_data + response.status_code = 200 + response.text = self.expected_data req_mock.return_value = response p = telesign.api.Verify(self.expected_cid, self.expected_secret_key) p.status(self.expected_ref_id, self.expected_verify_code) self.assertTrue(req_mock.called) - args = req_mock.call_args - self.assertEqual(args[0][0], "GET", "Expected GET") - self.assertEqual(args[0][1], self.expected_status_resource, "Status resource was incorrect") - self.assertEqual(args[1]["fields"]["verify_code"], self.expected_verify_code, "Verify code did not match") + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_status_resource, "Status resource was incorrect") + self.assertEqual(kwargs["params"]["verify_code"], self.expected_verify_code, "Verify code did not match") + self.assertFalse(kwargs['proxies']) + + @mock.patch.object(requests, "post") + def test_verify_sms_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.Verify(self.expected_cid, self.expected_secret_key, proxy_host="localhost:8080") + p.sms(self.expected_phone_no, self.expected_verify_code, self.expected_language) + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs['url'], self.expected_sms_resource, "Sms verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(kwargs["data"]["verify_code"], self.expected_verify_code, "Verify code field did not match") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "post") + def test_verify_call_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.Verify(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.call(self.expected_phone_no, self.expected_verify_code, self.expected_language) + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs['url'], self.expected_call_resource, "Call verify resource was incorrect") + self.assertEqual(kwargs["data"]["phone_number"], self.expected_phone_no, "Phone number field did not match") + self.assertEqual(kwargs["data"]["language"], self.expected_language, "Language field did not match") + self.assertEqual(kwargs["data"]["verify_code"], self.expected_verify_code, "Verify code field did not match") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "get") + def test_status_check_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.Verify(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.status(self.expected_ref_id) + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_status_resource, "Status resource was incorrect") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") + + @mock.patch.object(requests, "get") + def test_report_code_with_proxy(self, req_mock): + response = mock.Mock() + response.reason = "" + response.status_code = 200 + response.text = self.expected_data + req_mock.return_value = response + + p = telesign.api.Verify(self.expected_cid, self.expected_secret_key, proxy_host=self.proxy) + p.status(self.expected_ref_id, self.expected_verify_code) + + self.assertTrue(req_mock.called) + _, kwargs = req_mock.call_args + self.assertEqual(kwargs["url"], self.expected_status_resource, "Status resource was incorrect") + self.assertEqual(kwargs["params"]["verify_code"], self.expected_verify_code, "Verify code did not match") + self.assertEqual(kwargs["proxies"]["https"], self.expected_proxy, "Proxy did not match") +