From e2766af35336c93bba89ad8deb7f71a2f02b6b42 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Fri, 17 Apr 2020 23:05:55 -0400 Subject: [PATCH 01/12] added metric component and some tests --- tests/zoomus/components/metric/__init__.py | 0 tests/zoomus/components/metric/test_get.py | 37 ++++++++++++++++ tests/zoomus/components/metric/test_list.py | 37 ++++++++++++++++ .../components/past_meeting/test_list.py | 2 +- zoomus/components/__init__.py | 2 +- zoomus/components/metric.py | 44 +++++++++++++++++++ 6 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 tests/zoomus/components/metric/__init__.py create mode 100644 tests/zoomus/components/metric/test_get.py create mode 100644 tests/zoomus/components/metric/test_list.py create mode 100644 zoomus/components/metric.py diff --git a/tests/zoomus/components/metric/__init__.py b/tests/zoomus/components/metric/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/zoomus/components/metric/test_get.py b/tests/zoomus/components/metric/test_get.py new file mode 100644 index 0000000..c126149 --- /dev/null +++ b/tests/zoomus/components/metric/test_get.py @@ -0,0 +1,37 @@ +import unittest + +try: + from unittest.mock import patch +except ImportError: + from mock import patch + +from zoomus import components + + +def suite(): + """Define all the tests of the module.""" + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(GetMetricV2TestCase)) + return suite + + +class GetMetricV2TestCase(unittest.TestCase): + def setUp(self): + self.component = components.metric.MetricComponentV2( + base_uri="http://foo.com", config={"api_key": "KEY", "api_secret": "SECRET"} + ) + + @patch.object(components.base.BaseComponent, "get_request", return_value=True) + def test_can_get_meeting(self, mock_get_request): + self.component.get_meeting(meeting_id="ID") + mock_get_request.assert_called_with( + "/metrics/meetings/ID", params={"meeting_id": "ID"} + ) + + def test_requires_id(self): + with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): + self.component.get_meeting() + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/zoomus/components/metric/test_list.py b/tests/zoomus/components/metric/test_list.py new file mode 100644 index 0000000..606607a --- /dev/null +++ b/tests/zoomus/components/metric/test_list.py @@ -0,0 +1,37 @@ +import datetime +import unittest + +try: + from unittest.mock import patch +except ImportError: + from mock import patch + +from zoomus import components, util + + +def suite(): + """Define all the tests of the module.""" + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(ListV2TestCase)) + return suite + + +class ListV2TestCase(unittest.TestCase): + def setUp(self): + self.component = components.metric.MetricComponentV2( + base_uri="http://foo.com", config={"api_key": "KEY", "api_secret": "SECRET"} + ) + + @patch.object(components.base.BaseComponent, "get_request", return_value=True) + def test_can_list(self, mock_get_request): + self.component.list_meetings() + + mock_get_request.assert_called_with("/metrics/meetings", params={}) + + def test_list_participants_requires_meeting_id(self): + with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): + self.component.list_participants() + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/zoomus/components/past_meeting/test_list.py b/tests/zoomus/components/past_meeting/test_list.py index e72d2dd..f810b70 100644 --- a/tests/zoomus/components/past_meeting/test_list.py +++ b/tests/zoomus/components/past_meeting/test_list.py @@ -30,7 +30,7 @@ def test_can_list(self, mock_get_request): "/past_meetings/ID/instances", params={"meeting_id": "ID"} ) - def test_requires_user_id(self): + def test_requires_meeting_id(self): with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): self.component.list() diff --git a/zoomus/components/__init__.py b/zoomus/components/__init__.py index 093c7b8..66726a0 100644 --- a/zoomus/components/__init__.py +++ b/zoomus/components/__init__.py @@ -2,4 +2,4 @@ from __future__ import absolute_import -from . import meeting, past_meeting, recording, report, user, webinar +from . import meeting, metric, past_meeting, recording, report, user, webinar diff --git a/zoomus/components/metric.py b/zoomus/components/metric.py new file mode 100644 index 0000000..433f656 --- /dev/null +++ b/zoomus/components/metric.py @@ -0,0 +1,44 @@ +"""Zoom.us REST API Python Client""" + +from __future__ import absolute_import + +from zoomus import util +from zoomus.components import base + + +class MetricComponentV2(base.BaseComponent): + def list_meetings(self, **kwargs): + return self.get_request("/metrics/meetings", params=kwargs,) + + def get_meeting(self, **kwargs): + util.require_keys(kwargs, "meeting_id") + kwargs["meeting_id"] = util.encode_uuid(kwargs.get("meeting_id")) + return self.get_request( + "/metrics/meetings/{}".format(kwargs.get("meeting_id")), params=kwargs + ) + + def list_participants(self, **kwargs): + util.require_keys(kwargs, "meeting_id") + kwargs["meeting_id"] = util.encode_uuid(kwargs.get("meeting_id")) + return self.get_request( + "/metrics/meetings/{}/participants".format(kwargs.get("meeting_id")), + params=kwargs, + ) + + def get_participant_qos(self, **kwargs): + util.require_keys(kwargs, ("meeting_id", "participant_id")) + kwargs["meeting_id"] = util.encode_uuid(kwargs.get("meeting_id")) + return self.get_request( + "/metrics/meetings/{}/participants/{}/qos".format( + kwargs.get("meeting_id"), kwargs.get("participant_id") + ), + params=kwargs, + ) + + def list_participant_qos(self, **kwargs): + util.require_keys(kwargs, "meeting_id") + kwargs["meeting_id"] = util.encode_uuid(kwargs.get("meeting_id")) + return self.get_request( + "/metrics/meetings/{}/participants/qos".format(kwargs.get("meeting_id")), + params=kwargs, + ) From c004f4a7ca28b955a2fc41d513ff7f119480d14d Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Sat, 18 Apr 2020 09:51:58 -0400 Subject: [PATCH 02/12] added more tests for metric component --- .gitignore | 3 +++ tests/zoomus/components/metric/test_get.py | 16 ++++++++++++++++ tests/zoomus/components/metric/test_list.py | 20 ++++++++++++++++++++ zoomus/components/metric.py | 2 +- 4 files changed, 40 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 1264703..5c4decc 100644 --- a/.gitignore +++ b/.gitignore @@ -55,3 +55,6 @@ ENV/ .project .pydevproject .settings/ +.python-version +Pipfile +Pipfile.lock diff --git a/tests/zoomus/components/metric/test_get.py b/tests/zoomus/components/metric/test_get.py index c126149..56ccf95 100644 --- a/tests/zoomus/components/metric/test_get.py +++ b/tests/zoomus/components/metric/test_get.py @@ -28,10 +28,26 @@ def test_can_get_meeting(self, mock_get_request): "/metrics/meetings/ID", params={"meeting_id": "ID"} ) + @patch.object(components.base.BaseComponent, "get_request", return_value=True) + def test_can_get_participant_qos(self, mock_get_request): + self.component.get_participant_qos(meeting_id="ID", participant_id="PID") + mock_get_request.assert_called_with( + "/metrics/meetings/ID/participants/PID/qos", + params={"meeting_id": "ID", "participant_id": "PID"}, + ) + def test_requires_id(self): with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): self.component.get_meeting() + def test_get_participant_qos_requires_meeting_id(self): + with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): + self.component.get_participant_qos(participant_id="PID") + + def test_get_participant_qos_requires_participant_id(self): + with self.assertRaisesRegexp(ValueError, "'participant_id' must be set"): + self.component.get_participant_qos(meeting_id="PID") + if __name__ == "__main__": unittest.main() diff --git a/tests/zoomus/components/metric/test_list.py b/tests/zoomus/components/metric/test_list.py index 606607a..5299078 100644 --- a/tests/zoomus/components/metric/test_list.py +++ b/tests/zoomus/components/metric/test_list.py @@ -28,10 +28,30 @@ def test_can_list(self, mock_get_request): mock_get_request.assert_called_with("/metrics/meetings", params={}) + @patch.object(components.base.BaseComponent, "get_request", return_value=True) + def test_can_list_participants(self, mock_get_request): + self.component.list_participants(meeting_id="ID") + + mock_get_request.assert_called_with( + "/metrics/meetings/ID/participants", params={"meeting_id": "ID"} + ) + + @patch.object(components.base.BaseComponent, "get_request", return_value=True) + def test_can_list_participants_qos(self, mock_get_request): + self.component.list_participants_qos(meeting_id="ID") + + mock_get_request.assert_called_with( + "/metrics/meetings/ID/participants/qos", params={"meeting_id": "ID"} + ) + def test_list_participants_requires_meeting_id(self): with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): self.component.list_participants() + def test_list_participants_qos_requires_meeting_id(self): + with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): + self.component.list_participants_qos() + if __name__ == "__main__": unittest.main() diff --git a/zoomus/components/metric.py b/zoomus/components/metric.py index 433f656..9dcaca9 100644 --- a/zoomus/components/metric.py +++ b/zoomus/components/metric.py @@ -35,7 +35,7 @@ def get_participant_qos(self, **kwargs): params=kwargs, ) - def list_participant_qos(self, **kwargs): + def list_participants_qos(self, **kwargs): util.require_keys(kwargs, "meeting_id") kwargs["meeting_id"] = util.encode_uuid(kwargs.get("meeting_id")) return self.get_request( From dbe3219973f649478100e455e81d0e77819687e5 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Sat, 18 Apr 2020 09:53:37 -0400 Subject: [PATCH 03/12] rollback .gitignore commit --- .gitignore | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 5c4decc..c6f210e 100644 --- a/.gitignore +++ b/.gitignore @@ -55,6 +55,4 @@ ENV/ .project .pydevproject .settings/ -.python-version -Pipfile -Pipfile.lock + From 5ea04a303b1abda73de0c9ae03c411bbcf5ac6d3 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Sat, 18 Apr 2020 10:05:00 -0400 Subject: [PATCH 04/12] added metric component to client --- zoomus/client.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/zoomus/client.py b/zoomus/client.py index 848c482..562ecf5 100644 --- a/zoomus/client.py +++ b/zoomus/client.py @@ -22,6 +22,7 @@ API_VERSION_2: { "user": components.user.UserComponentV2, "meeting": components.meeting.MeetingComponentV2, + "metric": components.metric.MetricComponentV2, "past_meeting": components.past_meeting.PastMeetingComponentV2, "report": components.report.ReportComponentV2, "webinar": components.webinar.WebinarComponentV2, @@ -106,6 +107,11 @@ def meeting(self): """Get the meeting component""" return self.components.get("meeting") + @property + def metric(self): + """Get the metric component""" + return self.components.get("metric") + @property def report(self): """Get the report component""" From 24b865ba081a758cb983d0bcafe0bb47c15c409f Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Sat, 18 Apr 2020 22:59:57 -0400 Subject: [PATCH 05/12] corrected client tests for new component --- tests/zoomus/test_client.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/tests/zoomus/test_client.py b/tests/zoomus/test_client.py index 18eb811..927448f 100644 --- a/tests/zoomus/test_client.py +++ b/tests/zoomus/test_client.py @@ -47,12 +47,25 @@ def test_cannot_init_with_non_int_timeout(self): def test_init_creates_all_components(self): client = ZoomClient("KEY", "SECRET") self.assertEqual( - set(["meeting", "past_meeting", "report", "user", "webinar", "recording"]), + set( + [ + "meeting", + "metric", + "past_meeting", + "report", + "user", + "webinar", + "recording", + ] + ), set(client.components.keys()), ) self.assertIsInstance( client.components["meeting"], components.meeting.MeetingComponentV2 ) + self.assertIsInstance( + client.components["metric"], components.metric.MetricComponentV2 + ) self.assertIsInstance( client.components["past_meeting"], components.past_meeting.PastMeetingComponentV2, From f5fc052b32c053cb7022306751026e4109fc6500 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Sat, 18 Apr 2020 23:42:29 -0400 Subject: [PATCH 06/12] added requests session to ApiClient --- tests/zoomus/test_util.py | 42 +++++++++++++++++++-------------------- zoomus/util.py | 11 +++++----- 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/tests/zoomus/test_util.py b/tests/zoomus/test_util.py index 3efd928..1d434fc 100644 --- a/tests/zoomus/test_util.py +++ b/tests/zoomus/test_util.py @@ -81,7 +81,7 @@ def test_url_for_ignores_trailing_slash(self): client = util.ApiClient(base_uri="http://www.foo.com") self.assertEqual(client.url_for("bar/"), "http://www.foo.com/bar") - @patch("requests.get") + @patch.object(util.requests.Session, "get") def test_can_get_request(self, mocked_get): mocked_get.side_effect = lambda *args, **kwargs: True @@ -98,7 +98,7 @@ def test_can_get_request(self, mocked_get): timeout=client.timeout, ) - @patch("requests.get") + @patch.object(util.requests.Session, "get") def test_can_get_request_with_params(self, mocked_get): mocked_get.side_effect = lambda *args, **kwargs: True @@ -115,7 +115,7 @@ def test_can_get_request_with_params(self, mocked_get): timeout=client.timeout, ) - @patch("requests.get") + @patch.object(util.requests.Session, "get") def test_can_get_request_with_headers(self, mocked_get): mocked_get.side_effect = lambda *args, **kwargs: True @@ -132,7 +132,7 @@ def test_can_get_request_with_headers(self, mocked_get): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -151,7 +151,7 @@ def test_can_post_request(self, mocked_post): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request_with_params(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -170,7 +170,7 @@ def test_can_post_request_with_params(self, mocked_post): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request_with_dict_data(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -189,7 +189,7 @@ def test_can_post_request_with_dict_data(self, mocked_post): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request_with_json_data(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -208,7 +208,7 @@ def test_can_post_request_with_json_data(self, mocked_post): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request_with_headers(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -227,7 +227,7 @@ def test_can_post_request_with_headers(self, mocked_post): timeout=client.timeout, ) - @patch("requests.post") + @patch.object(util.requests.Session, "post") def test_can_post_request_with_cookies(self, mocked_post): mocked_post.side_effect = lambda *args, **kwargs: True @@ -246,7 +246,7 @@ def test_can_post_request_with_cookies(self, mocked_post): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -265,7 +265,7 @@ def test_can_patch_request(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request_with_params(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -284,7 +284,7 @@ def test_can_patch_request_with_params(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request_with_dict_data(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -303,7 +303,7 @@ def test_can_patch_request_with_dict_data(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request_with_json_data(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -322,7 +322,7 @@ def test_can_patch_request_with_json_data(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request_with_headers(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -341,7 +341,7 @@ def test_can_patch_request_with_headers(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.patch") + @patch.object(util.requests.Session, "patch") def test_can_patch_request_with_cookies(self, mocked_patch): mocked_patch.side_effect = lambda *args, **kwargs: True @@ -360,7 +360,7 @@ def test_can_patch_request_with_cookies(self, mocked_patch): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True @@ -379,7 +379,7 @@ def test_can_delete_request(self, mocked_delete): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request_with_params(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True @@ -398,7 +398,7 @@ def test_can_delete_request_with_params(self, mocked_delete): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request_with_dict_data(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True @@ -417,7 +417,7 @@ def test_can_delete_request_with_dict_data(self, mocked_delete): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request_with_json_data(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True @@ -436,7 +436,7 @@ def test_can_delete_request_with_json_data(self, mocked_delete): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request_with_headers(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True @@ -455,7 +455,7 @@ def test_can_delete_request_with_headers(self, mocked_delete): timeout=client.timeout, ) - @patch("requests.delete") + @patch.object(util.requests.Session, "delete") def test_can_delete_request_with_cookies(self, mocked_delete): mocked_delete.side_effect = lambda *args, **kwargs: True diff --git a/zoomus/util.py b/zoomus/util.py index 6cf791b..8835864 100644 --- a/zoomus/util.py +++ b/zoomus/util.py @@ -30,6 +30,7 @@ def __init__(self, base_uri=None, timeout=15, **kwargs): self.timeout = timeout for k, v in kwargs.items(): setattr(self, k, v) + self.session = requests.Session() @property def timeout(self): @@ -80,7 +81,7 @@ def get_request(self, endpoint, params=None, headers=None): """ if headers is None and self.config.get("version") == API_VERSION_2: headers = {"Authorization": "Bearer {}".format(self.config.get("token"))} - return requests.get( + return self.session.get( self.url_for(endpoint), params=params, headers=headers, timeout=self.timeout ) @@ -104,7 +105,7 @@ def post_request( "Authorization": "Bearer {}".format(self.config.get("token")), "Content-Type": "application/json", } - return requests.post( + return self.session.post( self.url_for(endpoint), params=params, data=data, @@ -133,7 +134,7 @@ def patch_request( "Authorization": "Bearer {}".format(self.config.get("token")), "Content-Type": "application/json", } - return requests.patch( + return self.session.patch( self.url_for(endpoint), params=params, data=data, @@ -159,7 +160,7 @@ def delete_request( data = json.dumps(data) if headers is None and self.config.get("version") == API_VERSION_2: headers = {"Authorization": "Bearer {}".format(self.config.get("token"))} - return requests.delete( + return self.session.delete( self.url_for(endpoint), params=params, data=data, @@ -183,7 +184,7 @@ def put_request(self, endpoint, params=None, data=None, headers=None, cookies=No data = json.dumps(data) if headers is None and self.config.get("version") == API_VERSION_2: headers = {"Authorization": "Bearer {}".format(self.config.get("token"))} - return requests.put( + return self.session.put( self.url_for(endpoint), params=params, data=data, From 51ebe867201602decbc7b39654bd6d6c06b02fa3 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Fri, 24 Apr 2020 15:16:19 -0400 Subject: [PATCH 07/12] updated tests to use responses library --- tests/zoomus/components/metric/test_get.py | 26 ++++++--------- tests/zoomus/components/metric/test_list.py | 35 +++++++++------------ 2 files changed, 25 insertions(+), 36 deletions(-) diff --git a/tests/zoomus/components/metric/test_get.py b/tests/zoomus/components/metric/test_get.py index 56ccf95..617f67b 100644 --- a/tests/zoomus/components/metric/test_get.py +++ b/tests/zoomus/components/metric/test_get.py @@ -1,11 +1,7 @@ import unittest -try: - from unittest.mock import patch -except ImportError: - from mock import patch - from zoomus import components +import responses def suite(): @@ -21,20 +17,18 @@ def setUp(self): base_uri="http://foo.com", config={"api_key": "KEY", "api_secret": "SECRET"} ) - @patch.object(components.base.BaseComponent, "get_request", return_value=True) - def test_can_get_meeting(self, mock_get_request): + @responses.activate + def test_can_get_meeting(self): + responses.add(responses.GET, "http://foo.com/metrics/meetings/ID?meeting_id=ID") self.component.get_meeting(meeting_id="ID") - mock_get_request.assert_called_with( - "/metrics/meetings/ID", params={"meeting_id": "ID"} - ) - @patch.object(components.base.BaseComponent, "get_request", return_value=True) - def test_can_get_participant_qos(self, mock_get_request): - self.component.get_participant_qos(meeting_id="ID", participant_id="PID") - mock_get_request.assert_called_with( - "/metrics/meetings/ID/participants/PID/qos", - params={"meeting_id": "ID", "participant_id": "PID"}, + @responses.activate + def test_can_get_participant_qos(self): + responses.add( + responses.GET, + "http://foo.com/metrics/meetings/ID/participants/PID/qos?meeting_id=ID&participant_id=PID", ) + self.component.get_participant_qos(meeting_id="ID", participant_id="PID") def test_requires_id(self): with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): diff --git a/tests/zoomus/components/metric/test_list.py b/tests/zoomus/components/metric/test_list.py index 5299078..e72b8d0 100644 --- a/tests/zoomus/components/metric/test_list.py +++ b/tests/zoomus/components/metric/test_list.py @@ -1,12 +1,8 @@ import datetime import unittest -try: - from unittest.mock import patch -except ImportError: - from mock import patch - from zoomus import components, util +import responses def suite(): @@ -22,28 +18,27 @@ def setUp(self): base_uri="http://foo.com", config={"api_key": "KEY", "api_secret": "SECRET"} ) - @patch.object(components.base.BaseComponent, "get_request", return_value=True) - def test_can_list(self, mock_get_request): + @responses.activate + def test_can_list(self): + responses.add(responses.GET, "http://foo.com/metrics/meetings") self.component.list_meetings() - mock_get_request.assert_called_with("/metrics/meetings", params={}) - - @patch.object(components.base.BaseComponent, "get_request", return_value=True) - def test_can_list_participants(self, mock_get_request): + @responses.activate + def test_can_list_participants(self): + responses.add( + responses.GET, + "http://foo.com/metrics/meetings/ID/participants?meeting_id=ID", + ) self.component.list_participants(meeting_id="ID") - mock_get_request.assert_called_with( - "/metrics/meetings/ID/participants", params={"meeting_id": "ID"} + @responses.activate + def test_can_list_participants_qos(self): + responses.add( + responses.GET, + "http://foo.com/metrics/meetings/ID/participants/qos?meeting_id=ID", ) - - @patch.object(components.base.BaseComponent, "get_request", return_value=True) - def test_can_list_participants_qos(self, mock_get_request): self.component.list_participants_qos(meeting_id="ID") - mock_get_request.assert_called_with( - "/metrics/meetings/ID/participants/qos", params={"meeting_id": "ID"} - ) - def test_list_participants_requires_meeting_id(self): with self.assertRaisesRegexp(ValueError, "'meeting_id' must be set"): self.component.list_participants() From 302ae7676b14a29eae960f89ebd9f1024d8ed521 Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Fri, 8 May 2020 15:09:17 -0400 Subject: [PATCH 08/12] added context manager to ApiClient and tests --- tests/zoomus/test_util.py | 218 ++++++++++++++++++++++++++++++++++++++ zoomus/util.py | 10 +- 2 files changed, 227 insertions(+), 1 deletion(-) diff --git a/tests/zoomus/test_util.py b/tests/zoomus/test_util.py index aa0c7d1..cf4bae5 100644 --- a/tests/zoomus/test_util.py +++ b/tests/zoomus/test_util.py @@ -77,6 +77,20 @@ def test_url_for_ignores_trailing_slash(self): client = util.ApiClient(base_uri="http://www.foo.com") self.assertEqual(client.url_for("bar/"), "http://www.foo.com/bar") + @responses.activate + def test_can_multiple_request_with_session(self): + responses.add(responses.GET, "http://www.foo.com/endpoint") + responses.add(responses.POST, "http://www.foo.com/endpoint") + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + responses.add(responses.DELETE, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.get_request("endpoint") + client.post_request("endpoint") + client.patch_request("endpoint") + client.delete_request("endpoint") + @responses.activate def test_can_get_request(self): responses.add(responses.GET, "http://www.foo.com/endpoint") @@ -85,6 +99,14 @@ def test_can_get_request(self): ) client.get_request("endpoint") + @responses.activate + def test_can_get_request_with_session(self): + responses.add(responses.GET, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.get_request("endpoint") + @responses.activate def test_can_get_request_with_params(self): responses.add(responses.GET, "http://www.foo.com/endpoint?foo=bar") @@ -93,6 +115,14 @@ def test_can_get_request_with_params(self): ) client.get_request("endpoint", params={"foo": "bar"}) + @responses.activate + def test_can_get_request_with_params_and_session(self): + responses.add(responses.GET, "http://www.foo.com/endpoint?foo=bar") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.get_request("endpoint", params={"foo": "bar"}) + @responses.activate def test_can_get_request_with_headers(self): responses.add( @@ -103,6 +133,16 @@ def test_can_get_request_with_headers(self): ) client.get_request("endpoint", headers={"foo": "bar"}) + @responses.activate + def test_can_get_request_with_headers_and_session(self): + responses.add( + responses.GET, "http://www.foo.com/endpoint", headers={"foo": "bar"} + ) + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.get_request("endpoint", headers={"foo": "bar"}) + @responses.activate def test_can_post_request(self): responses.add(responses.POST, "http://www.foo.com/endpoint") @@ -112,6 +152,15 @@ def test_can_post_request(self): ) client.post_request("endpoint") + @responses.activate + def test_can_post_request(self): + responses.add(responses.POST, "http://www.foo.com/endpoint") + + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint") + @responses.activate def test_can_post_request_with_params(self): responses.add(responses.POST, "http://www.foo.com/endpoint?foo=bar") @@ -120,6 +169,14 @@ def test_can_post_request_with_params(self): ) client.post_request("endpoint", params={"foo": "bar"}) + @responses.activate + def test_can_post_request_with_params_and_session(self): + responses.add(responses.POST, "http://www.foo.com/endpoint?foo=bar") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint", params={"foo": "bar"}) + @responses.activate def test_can_post_request_with_dict_data(self): responses.add(responses.POST, "http://www.foo.com/endpoint") @@ -129,6 +186,15 @@ def test_can_post_request_with_dict_data(self): client.post_request("endpoint", data={"foo": "bar"}) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_post_request_with_dict_data_and_session(self): + responses.add(responses.POST, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint", data={"foo": "bar"}) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_post_request_with_json_data(self): responses.add(responses.POST, "http://www.foo.com/endpoint") @@ -138,6 +204,15 @@ def test_can_post_request_with_json_data(self): client.post_request("endpoint", data=json.dumps({"foo": "bar"})) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_post_request_with_json_data_and_session(self): + responses.add(responses.POST, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint", data=json.dumps({"foo": "bar"})) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_post_request_with_headers(self): responses.add(responses.POST, "http://www.foo.com/endpoint") @@ -151,6 +226,19 @@ def test_can_post_request_with_headers(self): set(expected_headers.items()).issubset(set(actual_headers.items())) ) + @responses.activate + def test_can_post_request_with_headers_and_session(self): + responses.add(responses.POST, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint", headers={"foo": "bar"}) + expected_headers = {"foo": "bar"} + actual_headers = responses.calls[0].request.headers + self.assertTrue( + set(expected_headers.items()).issubset(set(actual_headers.items())) + ) + @responses.activate def test_can_post_request_with_cookies(self): responses.add(responses.POST, "http://www.foo.com/endpoint") @@ -164,6 +252,19 @@ def test_can_post_request_with_cookies(self): set(expected_headers.items()).issubset(set(actual_headers.items())) ) + @responses.activate + def test_can_post_request_with_cookies_and_session(self): + responses.add(responses.POST, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.post_request("endpoint", cookies={"foo": "bar"}) + expected_headers = {"Cookie": "foo=bar"} + actual_headers = responses.calls[0].request.headers + self.assertTrue( + set(expected_headers.items()).issubset(set(actual_headers.items())) + ) + @responses.activate def test_can_patch_request(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint") @@ -172,6 +273,14 @@ def test_can_patch_request(self): ) client.patch_request("endpoint") + @responses.activate + def test_can_patch_request_with_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint") + @responses.activate def test_can_patch_request_with_params(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint?foo=bar") @@ -180,6 +289,14 @@ def test_can_patch_request_with_params(self): ) client.patch_request("endpoint", params={"foo": "bar"}) + @responses.activate + def test_can_patch_request_with_params_and_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint?foo=bar") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint", params={"foo": "bar"}) + @responses.activate def test_can_patch_request_with_dict_data(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint") @@ -189,6 +306,15 @@ def test_can_patch_request_with_dict_data(self): client.patch_request("endpoint", data={"foo": "bar"}) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_patch_request_with_dict_data_and_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint", data={"foo": "bar"}) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_patch_request_with_json_data(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint") @@ -198,6 +324,15 @@ def test_can_patch_request_with_json_data(self): client.patch_request("endpoint", data=json.dumps({"foo": "bar"})) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_patch_request_with_json_data_and_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint", data=json.dumps({"foo": "bar"})) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_patch_request_with_headers(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint") @@ -211,6 +346,19 @@ def test_can_patch_request_with_headers(self): set(expected_headers.items()).issubset(set(actual_headers.items())) ) + @responses.activate + def test_can_patch_request_with_headers_and_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint", headers={"foo": "bar"}) + expected_headers = {"foo": "bar"} + actual_headers = responses.calls[0].request.headers + self.assertTrue( + set(expected_headers.items()).issubset(set(actual_headers.items())) + ) + @responses.activate def test_can_patch_request_with_cookies(self): responses.add(responses.PATCH, "http://www.foo.com/endpoint") @@ -224,6 +372,19 @@ def test_can_patch_request_with_cookies(self): set(expected_headers.items()).issubset(set(actual_headers.items())) ) + @responses.activate + def test_can_patch_request_with_cookies_and_session(self): + responses.add(responses.PATCH, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.patch_request("endpoint", cookies={"foo": "bar"}) + expected_headers = {"Cookie": "foo=bar"} + actual_headers = responses.calls[0].request.headers + self.assertTrue( + set(expected_headers.items()).issubset(set(actual_headers.items())) + ) + @responses.activate def test_can_delete_request(self): responses.add(responses.DELETE, "http://www.foo.com/endpoint") @@ -232,6 +393,14 @@ def test_can_delete_request(self): ) client.delete_request("endpoint") + @responses.activate + def test_can_delete_request_with_session(self): + responses.add(responses.DELETE, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint") + @responses.activate def test_can_delete_request_with_params(self): responses.add(responses.DELETE, "http://www.foo.com/endpoint?foo=bar") @@ -240,6 +409,14 @@ def test_can_delete_request_with_params(self): ) client.delete_request("endpoint", params={"foo": "bar"}) + @responses.activate + def test_can_delete_request_with_params_and_session(self): + responses.add(responses.DELETE, "http://www.foo.com/endpoint?foo=bar") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint", params={"foo": "bar"}) + @responses.activate def test_can_delete_request_with_dict_data(self): responses.add(responses.DELETE, "http://www.foo.com/endpoint") @@ -249,6 +426,15 @@ def test_can_delete_request_with_dict_data(self): client.delete_request("endpoint", data={"foo": "bar"}) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_delete_request_with_dict_data_and_session(self): + responses.add(responses.DELETE, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint", data={"foo": "bar"}) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_delete_request_with_json_data(self): responses.add(responses.DELETE, "http://www.foo.com/endpoint") @@ -258,6 +444,15 @@ def test_can_delete_request_with_json_data(self): client.delete_request("endpoint", data=json.dumps({"foo": "bar"})) self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate + def test_can_delete_request_with_json_data_and_session(self): + responses.add(responses.DELETE, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint", data=json.dumps({"foo": "bar"})) + self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}') + @responses.activate def test_can_delete_request_with_headers(self): responses.add( @@ -268,6 +463,16 @@ def test_can_delete_request_with_headers(self): ) client.delete_request("endpoint", headers={"foo": "bar"}) + @responses.activate + def test_can_delete_request_with_headers_and_session(self): + responses.add( + responses.DELETE, "http://www.foo.com/endpoint", headers={"foo": "bar"} + ) + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint", headers={"foo": "bar"}) + @responses.activate def test_can_delete_request_with_cookies(self): responses.add(responses.DELETE, "http://www.foo.com/endpoint") @@ -281,6 +486,19 @@ def test_can_delete_request_with_cookies(self): set(expected_headers.items()).issubset(set(actual_headers.items())) ) + @responses.activate + def test_can_delete_request_with_cookies_and_session(self): + responses.add(responses.DELETE, "http://www.foo.com/endpoint") + with util.ApiClient( + base_uri="http://www.foo.com", config={"version": util.API_VERSION_1} + ) as client: + client.delete_request("endpoint", cookies={"foo": "bar"}) + expected_headers = {"Cookie": "foo=bar"} + actual_headers = responses.calls[0].request.headers + self.assertTrue( + set(expected_headers.items()).issubset(set(actual_headers.items())) + ) + class RequireKeysTestCase(unittest.TestCase): def test_can_require_keys_with_single_string_key(self): diff --git a/zoomus/util.py b/zoomus/util.py index 8835864..4127217 100644 --- a/zoomus/util.py +++ b/zoomus/util.py @@ -30,7 +30,7 @@ def __init__(self, base_uri=None, timeout=15, **kwargs): self.timeout = timeout for k, v in kwargs.items(): setattr(self, k, v) - self.session = requests.Session() + self.session = requests @property def timeout(self): @@ -59,6 +59,14 @@ def base_uri(self, value): value = value[:-1] self._base_uri = value + def __enter__(self): + self.session = requests.Session() + return self + + def __exit__(self, *args): + self.session.close() + self.session = None + def url_for(self, endpoint): """Get the URL for the given endpoint From 87a67a0f3e0a6d70093f392fe63778fbe2ed4c0b Mon Sep 17 00:00:00 2001 From: Sean Tibor <40579452+seantibor@users.noreply.github.com> Date: Fri, 8 May 2020 16:49:49 -0400 Subject: [PATCH 09/12] added session getter, setter property methods --- zoomus/util.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/zoomus/util.py b/zoomus/util.py index 4127217..c1a4fc3 100644 --- a/zoomus/util.py +++ b/zoomus/util.py @@ -30,7 +30,7 @@ def __init__(self, base_uri=None, timeout=15, **kwargs): self.timeout = timeout for k, v in kwargs.items(): setattr(self, k, v) - self.session = requests + self._session = None @property def timeout(self): @@ -59,6 +59,21 @@ def base_uri(self, value): value = value[:-1] self._base_uri = value + @property + def session(self): + """Provide a session if one is in use; otherwise, provide the requests module directly.""" + if self._session is not None: + return self._session + return requests + + @session.setter + def session(self, val): + self._session = val + + @session.deleter + def session(self): + self._session = None + def __enter__(self): self.session = requests.Session() return self From c28e1503a4956c1f57b85987fa3eb014733ed5cf Mon Sep 17 00:00:00 2001 From: Sean Tibor Date: Wed, 5 May 2021 18:02:03 -0400 Subject: [PATCH 10/12] updated to black 21.4 --- .pre-commit-config.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4275ae1..adacbb5 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,4 +3,5 @@ repos: rev: stable hooks: - id: black + args: [-v] # language_version: python3.6 From 3e191181309dd9c62a972c3f267e953d2bfca7ea Mon Sep 17 00:00:00 2001 From: Sean Tibor Date: Wed, 5 May 2021 18:08:57 -0400 Subject: [PATCH 11/12] again and again --- .pre-commit-config.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index adacbb5..4275ae1 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,5 +3,4 @@ repos: rev: stable hooks: - id: black - args: [-v] # language_version: python3.6 From d0a45386817a226693ce7a406695f3ffdc4a1893 Mon Sep 17 00:00:00 2001 From: Sean Tibor Date: Wed, 5 May 2021 18:16:12 -0400 Subject: [PATCH 12/12] ignoring pre-commit hooks --- tests/zoomus/test_util.py | 42 ++++++++++++++++++++++++++------------- 1 file changed, 28 insertions(+), 14 deletions(-) diff --git a/tests/zoomus/test_util.py b/tests/zoomus/test_util.py index 6263182..031d18f 100644 --- a/tests/zoomus/test_util.py +++ b/tests/zoomus/test_util.py @@ -119,7 +119,8 @@ def test_can_get_request_with_session(self): @responses.activate def test_can_get_request_v2(self): responses.add( - responses.GET, "http://www.foo.com/endpoint", + responses.GET, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -151,7 +152,8 @@ def test_can_get_request_with_params_and_session(self): @responses.activate def test_can_get_request_with_params_v2(self): responses.add( - responses.GET, "http://www.foo.com/endpoint?foo=bar", + responses.GET, + "http://www.foo.com/endpoint?foo=bar", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -217,7 +219,8 @@ def test_can_post_request(self): @responses.activate def test_can_post_request_v2(self): responses.add( - responses.POST, "http://www.foo.com/endpoint", + responses.POST, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -252,7 +255,8 @@ def test_can_post_request_with_params_and_session(self): @responses.activate def test_can_post_request_with_params_v2(self): responses.add( - responses.POST, "http://www.foo.com/endpoint?foo=bar", + responses.POST, + "http://www.foo.com/endpoint?foo=bar", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -286,7 +290,8 @@ def test_can_post_request_with_dict_data_and_session(self): @responses.activate def test_can_post_request_with_dict_data_v2(self): responses.add( - responses.POST, "http://www.foo.com/endpoint", + responses.POST, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -324,7 +329,8 @@ def test_can_post_request_with_json_data_and_session(self): @responses.activate def test_can_post_request_with_json_data_v2(self): responses.add( - responses.POST, "http://www.foo.com/endpoint", + responses.POST, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -370,7 +376,8 @@ def test_can_post_request_with_headers_and_session(self): @responses.activate def test_can_post_request_with_headers_v2(self): responses.add( - responses.POST, "http://www.foo.com/endpoint", + responses.POST, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -442,7 +449,8 @@ def test_can_patch_request_with_session(self): @responses.activate def test_can_patch_request_v2(self): responses.add( - responses.PATCH, "http://www.foo.com/endpoint", + responses.PATCH, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -476,7 +484,8 @@ def test_can_patch_request_with_params_and_session(self): @responses.activate def test_can_patch_request_with_params_v2(self): responses.add( - responses.PATCH, "http://www.foo.com/endpoint?foo=bar", + responses.PATCH, + "http://www.foo.com/endpoint?foo=bar", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -512,7 +521,8 @@ def test_can_patch_request_with_dict_data_and_session(self): @responses.activate def test_can_patch_request_with_dict_data_v2(self): responses.add( - responses.PATCH, "http://www.foo.com/endpoint", + responses.PATCH, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -549,7 +559,8 @@ def test_can_patch_request_with_json_data_and_session(self): @responses.activate def test_can_patch_request_with_json_data_v2(self): responses.add( - responses.PATCH, "http://www.foo.com/endpoint", + responses.PATCH, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -664,7 +675,8 @@ def test_can_delete_request_with_session(self): @responses.activate def test_can_delete_request_v2(self): responses.add( - responses.DELETE, "http://www.foo.com/endpoint", + responses.DELETE, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -733,7 +745,8 @@ def test_can_delete_request_with_dict_data_and_session(self): @responses.activate def test_can_delete_request_with_dict_data_v2(self): responses.add( - responses.DELETE, "http://www.foo.com/endpoint", + responses.DELETE, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com", @@ -770,7 +783,8 @@ def test_can_delete_request_with_json_data_and_session(self): @responses.activate def test_can_delete_request_with_json_data_v2(self): responses.add( - responses.DELETE, "http://www.foo.com/endpoint", + responses.DELETE, + "http://www.foo.com/endpoint", ) client = util.ApiClient( base_uri="http://www.foo.com",