praekelt / go-http-api / 184

Committed 11 Nov 2015 - 8:43 coverage: 99.37% (-0.3%) from 99.705%

Build # 184

Build Type

Pull #20

travis-ci

Committed by

hodgestar

Commit Message

Add test for non-JSON error responses.

Pull Request Pull Request #20: Add support for optout API

Run Details

115 of 118 new or added lines in 3 files covered. (97.46%)

789 of 794 relevant lines covered (99.37%)

1.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.65

/go_http/tests/test_optouts.py

""" Tests for go_http.optouts.
"""

import json
from unittest import TestCase

from requests import HTTPError

from requests_testadapter import TestAdapter, TestSession

from go_http.optouts import OptOutsApiClient


class RecordingAdapter(TestAdapter):
    """ Record the request that was handled by the adapter.
    """
    request = None

    def send(self, request, *args, **kw):
        self.request = request
        return super(RecordingAdapter, self).send(request, *args, **kw)


class TestOptOutsApiClient(TestCase):

    def setUp(self):
        self.session = TestSession()
        self.client = OptOutsApiClient(
            auth_token="auth-token",
            api_url="http://example.com/api/v1/go",
            session=self.session)

    def response_ok(self, data):
        data.update({
            u'status': {
                u'reason': u'OK',
                u'code': 200,
            },
        })
        return data

    def test_default_session(self):
        import requests
        client = OptOutsApiClient(
            auth_token="auth-token")
        self.assertTrue(isinstance(client.session, requests.Session))

    def test_default_api_url(self):
        client = OptOutsApiClient(
            auth_token="auth-token")
        self.assertEqual(client.api_url,
                         "https://go.vumi.org/api/v1/go")

    def check_request(self, request, method, data=None, headers=None):
        self.assertEqual(request.method, method)
        if headers is not None:
            for key, value in headers.items():
                self.assertEqual(request.headers[key], value)
        if data is None:
            self.assertEqual(request.body, None)
        else:
            self.assertEqual(json.loads(request.body), data)

    def test_error_response(self):
        response = {
            u'status': {
                u'reason': u'Opt out not found',
                u'code': 404,
            },
        }
        adapter = RecordingAdapter(json.dumps(response), status=404)
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/msisdn/%2b1234", adapter)

        self.assertRaises(
            HTTPError,
            self.client.get_optout, "msisdn", "+1234")
        self.check_request(
            adapter.request, 'GET',
            headers={"Authorization": u'Bearer auth-token'})

    def test_non_json_error_response(self):
        response = "Not JSON"
        adapter = RecordingAdapter(json.dumps(response), status=503)
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/msisdn/%2b1234", adapter)

        self.assertRaises(
            HTTPError,
            self.client.get_optout, "msisdn", "+1234")

    def test_get_optout(self):
        opt_out = {
            u'created_at': u'2015-11-10 20:33:03.742409',
            u'message': None,
            u'user_account': u'fxxxeee',
        }
        response = self.response_ok({u'opt_out': opt_out})
        adapter = RecordingAdapter(json.dumps(response))
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/msisdn/%2b1234", adapter)

        result = self.client.get_optout("msisdn", "+1234")
        self.assertEqual(result, opt_out)
        self.check_request(
            adapter.request, 'GET',
            headers={"Authorization": u'Bearer auth-token'})

    def test_set_optout(self):
        opt_out = {
            u'created_at': u'2015-11-10 20:33:03.742409',
            u'message': None,
            u'user_account': u'fxxxeee',
        }
        response = self.response_ok({u'opt_out': opt_out})
        adapter = RecordingAdapter(json.dumps(response))
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/msisdn/%2b1234", adapter)

        result = self.client.set_optout("msisdn", "+1234")
        self.assertEqual(result, opt_out)
        self.check_request(
            adapter.request, 'PUT',
            headers={"Authorization": u'Bearer auth-token'})

    def test_delete_optout(self):
        opt_out = {
            u'created_at': u'2015-11-10 20:33:03.742409',
            u'message': None,
            u'user_account': u'fxxxeee',
        }
        response = self.response_ok({u'opt_out': opt_out})
        adapter = RecordingAdapter(json.dumps(response))
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/msisdn/%2b1234", adapter)

        result = self.client.delete_optout("msisdn", "+1234")
        self.assertEqual(result, opt_out)
        self.check_request(
            adapter.request, 'DELETE',
            headers={"Authorization": u'Bearer auth-token'})

    def test_count(self):
        response = self.response_ok({
            u'opt_out_count': 2,
        })
        adapter = RecordingAdapter(json.dumps(response))
        self.session.mount(
            "http://example.com/api/v1/go/"
            "optouts/count", adapter)

        result = self.client.count()
        self.assertEqual(result, 2)
        self.check_request(
            adapter.request, 'GET',
            headers={"Authorization": u'Bearer auth-token'})

1	""" Tests for go_http.optouts.
2	"""
3
4	import json	2×
5	from unittest import TestCase	2×
6
7	from requests import HTTPError	2×
8
9	from requests_testadapter import TestAdapter, TestSession	2×
10
11	from go_http.optouts import OptOutsApiClient	2×
12
13
14	class RecordingAdapter(TestAdapter):	2×
15	""" Record the request that was handled by the adapter.
16	"""
17	request = None	2×
18
19	def send(self, request, args, *kw):	2×
20	self.request = request	2×
21	return super(RecordingAdapter, self).send(request, args, *kw)	2×
22
23
24	class TestOptOutsApiClient(TestCase):	2×
25
26	def setUp(self):	2×
27	self.session = TestSession()	2×
28	self.client = OptOutsApiClient(	2×
29	auth_token="auth-token",
30	api_url="http://example.com/api/v1/go",
31	session=self.session)
32
33	def response_ok(self, data):	2×
34	data.update({	2×
35	u'status': {
36	u'reason': u'OK',
37	u'code': 200,
38	},
39	})
40	return data	2×
41
42	def test_default_session(self):	2×
43	import requests	2×
44	client = OptOutsApiClient(	2×
45	auth_token="auth-token")
46	self.assertTrue(isinstance(client.session, requests.Session))	2×
47
48	def test_default_api_url(self):	2×
49	client = OptOutsApiClient(	2×
50	auth_token="auth-token")
51	self.assertEqual(client.api_url,	2×
52	"https://go.vumi.org/api/v1/go")
53
54	def check_request(self, request, method, data=None, headers=None):	2×
55	self.assertEqual(request.method, method)	2×
56	if headers is not None:	2×
57	for key, value in headers.items():	2×
58	self.assertEqual(request.headers[key], value)	2×
59	if data is None:	2×
60	self.assertEqual(request.body, None)	2×
61	else:
NEW 62	self.assertEqual(json.loads(request.body), data)	!
63
64	def test_error_response(self):	2×
65	response = {	2×
66	u'status': {
67	u'reason': u'Opt out not found',
68	u'code': 404,
69	},
70	}
71	adapter = RecordingAdapter(json.dumps(response), status=404)	2×
72	self.session.mount(	2×
73	"http://example.com/api/v1/go/"
74	"optouts/msisdn/%2b1234", adapter)
75
76	self.assertRaises(	2×
77	HTTPError,
78	self.client.get_optout, "msisdn", "+1234")
79	self.check_request(	2×
80	adapter.request, 'GET',
81	headers={"Authorization": u'Bearer auth-token'})
82
83	def test_non_json_error_response(self):	2×
84	response = "Not JSON"	2×
85	adapter = RecordingAdapter(json.dumps(response), status=503)	2×
86	self.session.mount(	2×
87	"http://example.com/api/v1/go/"
88	"optouts/msisdn/%2b1234", adapter)
89
90	self.assertRaises(	2×
91	HTTPError,
92	self.client.get_optout, "msisdn", "+1234")
93
94	def test_get_optout(self):	2×
95	opt_out = {	2×
96	u'created_at': u'2015-11-10 20:33:03.742409',
97	u'message': None,
98	u'user_account': u'fxxxeee',
99	}
100	response = self.response_ok({u'opt_out': opt_out})	2×
101	adapter = RecordingAdapter(json.dumps(response))	2×
102	self.session.mount(	2×
103	"http://example.com/api/v1/go/"
104	"optouts/msisdn/%2b1234", adapter)
105
106	result = self.client.get_optout("msisdn", "+1234")	2×
107	self.assertEqual(result, opt_out)	2×
108	self.check_request(	2×
109	adapter.request, 'GET',
110	headers={"Authorization": u'Bearer auth-token'})
111
112	def test_set_optout(self):	2×
113	opt_out = {	2×
114	u'created_at': u'2015-11-10 20:33:03.742409',
115	u'message': None,
116	u'user_account': u'fxxxeee',
117	}
118	response = self.response_ok({u'opt_out': opt_out})	2×
119	adapter = RecordingAdapter(json.dumps(response))	2×
120	self.session.mount(	2×
121	"http://example.com/api/v1/go/"
122	"optouts/msisdn/%2b1234", adapter)
123
124	result = self.client.set_optout("msisdn", "+1234")	2×
125	self.assertEqual(result, opt_out)	2×
126	self.check_request(	2×
127	adapter.request, 'PUT',
128	headers={"Authorization": u'Bearer auth-token'})
129
130	def test_delete_optout(self):	2×
131	opt_out = {	2×
132	u'created_at': u'2015-11-10 20:33:03.742409',
133	u'message': None,
134	u'user_account': u'fxxxeee',
135	}
136	response = self.response_ok({u'opt_out': opt_out})	2×
137	adapter = RecordingAdapter(json.dumps(response))	2×
138	self.session.mount(	2×
139	"http://example.com/api/v1/go/"
140	"optouts/msisdn/%2b1234", adapter)
141
142	result = self.client.delete_optout("msisdn", "+1234")	2×
143	self.assertEqual(result, opt_out)	2×
144	self.check_request(	2×
145	adapter.request, 'DELETE',
146	headers={"Authorization": u'Bearer auth-token'})
147
148	def test_count(self):	2×
149	response = self.response_ok({	2×
150	u'opt_out_count': 2,
151	})
152	adapter = RecordingAdapter(json.dumps(response))	2×
153	self.session.mount(	2×
154	"http://example.com/api/v1/go/"
155	"optouts/count", adapter)
156
157	result = self.client.count()	2×
158	self.assertEqual(result, 2)	2×
159	self.check_request(	2×
160	adapter.request, 'GET',
161	headers={"Authorization": u'Bearer auth-token'})

praekelt / go-http-api / 184

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous