python-backlog 0.7.2__tar.gz → 0.7.6__tar.gz

{python_backlog-0.7.2/python_backlog.egg-info → python_backlog-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-backlog
-Version: 0.7.2
+Version: 0.7.6
 Summary: Backlog API v2 wrapper
 Home-page: https://github.com/hassaku63/pbl
 Author: hassaku63
@@ -19,6 +19,19 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests~=2.32.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # pbl
 
@@ -44,6 +57,8 @@ def main():
     """
     Initialize API Object
     """
+    # The API key is sent in the "Backlog-API-Key" request header.
+    # Requests time out after 30 seconds by default (configurable with `timeout=`).
     api = BacklogAPI("your-space", "your-api-key")
 
     """

{python_backlog-0.7.2 → python_backlog-0.7.6}/README.md

@@ -22,6 +22,8 @@ def main():
     """
     Initialize API Object
     """
+    # The API key is sent in the "Backlog-API-Key" request header.
+    # Requests time out after 30 seconds by default (configurable with `timeout=`).
     api = BacklogAPI("your-space", "your-api-key")
 
     """

python_backlog-0.7.6/VERSION

@@ -0,0 +1 @@
+0.7.6

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/attachment.py

@@ -20,10 +20,12 @@ class Attachment(object):
 
         _uri = "space/attachment"
         _method = "POST"
-        _files = {
-            'file': (os.path.basename(filename), open(filename, 'rb'), mimetypes.guess_type(filename))
-        }
+        _content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
 
-        resp = self.api.invoke_method(_method, _uri, files=_files)
+        with open(filename, 'rb') as f:
+            _files = {
+                'file': (os.path.basename(filename), f, _content_type)
+            }
+            resp = self.api.invoke_method(_method, _uri, files=_files)
 
         return resp.json()

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/base.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from urllib.parse import urlencode
+import re
 import requests
 from backlog.wiki import Wiki
 from backlog.attachment import Attachment
@@ -13,6 +13,12 @@ from backlog.custom_field import CustomField
 
 BACKLOG_BASE_URL = "https://{space}.backlog.jp"
 BACKLOG_URI_PREFIX = "/api/v2/"
+BACKLOG_API_KEY_HEADER = "Backlog-API-Key"
+DEFAULT_TIMEOUT = 30
+
+# Space keys consist of alphanumerics and hyphens. Validating it prevents the
+# base URL (and therefore the API key) from being pointed at an arbitrary host.
+_SPACE_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9-]*$")
 
 
 class BacklogError(Exception):
@@ -20,9 +26,18 @@ class BacklogError(Exception):
 
 
 class BaseAPI(object):
-    def __init__(self, space, api_key=None):
+    def __init__(self, space, api_key=None, timeout=DEFAULT_TIMEOUT):
+        """
+        :param space: Backlog space key (the "xxx" of https://xxx.backlog.jp)
+        :param api_key: API key. It is sent in the "Backlog-API-Key" request header.
+        :param timeout: Default timeout (seconds) passed to the HTTP client.
+            Can be overridden per request with the "timeout" keyword argument. None disables it.
+        """
+        if not isinstance(space, str) or not _SPACE_PATTERN.match(space):
+            raise ValueError("Invalid space key: {!r}".format(space))
         self.space = space
         self.api_key = api_key
+        self.timeout = timeout
         self.base_url = BACKLOG_BASE_URL.format(space=space) + BACKLOG_URI_PREFIX
         self.api = None
         self._build_api()
@@ -30,7 +45,18 @@ class BaseAPI(object):
     def _build_api(self):
         self.api = None
 
-    def invoke_method(self, method, uri, query_param={}, request_param={}, headers=None, **kwargs):
+    def _build_headers(self, headers=None):
+        """
+        Merge authentication headers into the given headers without mutating it.
+        """
+        _headers = {}
+        if self.api_key is not None:
+            _headers[BACKLOG_API_KEY_HEADER] = self.api_key
+        if headers:
+            _headers.update(headers)
+        return _headers
+
+    def invoke_method(self, method, uri, query_param=None, request_param=None, headers=None, **kwargs):
         """
         Delegate requests to get/post/delete method.
         Each method implements by any http client, default client is requests.
@@ -39,10 +65,14 @@ class BaseAPI(object):
         :param uri: API Endpoint. 'uri' expects a URI excluded '/api/v2/' prefix
         :param query_param: dict of URL parameter. this will be url-encoded string
         :param request_param: dict of body parameter. this will use when invoke post request
-        :param headers: HTTP Header dict. Recommend value is None. if None, then use default implements of http client(requests).
+        :param headers: HTTP Header dict. Authentication headers are added automatically.
         :return: http response object
         """
-        query_param.setdefault("apiKey", self.api_key)
+        # Copy the arguments so that neither the caller's dicts nor any shared state are mutated.
+        query_param = dict(query_param or {})
+        request_param = dict(request_param or {})
+        headers = self._build_headers(headers)
+        kwargs.setdefault("timeout", self.timeout)
 
         method = method.lower()
 
@@ -100,64 +130,31 @@ class BacklogAPI(BaseAPI):
         self.category = Category(self)
         self.custom_field = CustomField(self)
 
-    def get(self, method, uri, query_param, request_param, headers, **kwargs):
-        _url = self.base_url + uri
-        if headers is not None:
-            resp = requests.get(_url, params=query_param, headers=headers, **kwargs)
-        else:
-            resp = requests.get(_url, params=query_param, **kwargs)
-
-        if resp.status_code // 100 == 2:
+    @staticmethod
+    def _raise_for_status(resp, ok):
+        if ok(resp.status_code):
             return resp
-
         raise BacklogError("Http response {status}: {message}".format(status=resp.status_code, message=resp.text))
 
-    def post(self, method, uri, query_param, request_param, headers, **kwargs):
-        _url = self.base_url + uri + "?" + urlencode(query_param)
-        if headers is not None:
-            resp = requests.post(_url, data=request_param, headers=headers, **kwargs)
-        else:
-            resp = requests.post(_url, data=request_param, **kwargs)
-
-        if resp.status_code // 100 == 2:
-            return resp
+    def get(self, method, uri, query_param, request_param, headers, **kwargs):
+        _url = self.base_url + uri
+        resp = requests.get(_url, params=query_param, headers=headers, **kwargs)
+        return self._raise_for_status(resp, lambda code: code // 100 == 2)
 
-        raise BacklogError("Http response {status}: {message}".format(status=resp.status_code, message=resp.text))
+    def post(self, method, uri, query_param, request_param, headers, **kwargs):
+        _url = self.base_url + uri
+        resp = requests.post(_url, params=query_param, data=request_param, headers=headers, **kwargs)
+        return self._raise_for_status(resp, lambda code: code // 100 == 2)
 
     def delete(self, method, uri, query_param, request_param, headers, **kwargs):
-        _url = self.base_url + uri + "?" + urlencode(query_param)
-        if headers is not None:
-            resp = requests.delete(_url, headers=headers, **kwargs)
-        else:
-            resp = requests.delete(_url, **kwargs)
-
-        if resp.status_code == 200:
-            return resp
-
-        raise BacklogError("Http response {status}: {message}".format(status=resp.status_code, message=resp.text))
+        _url = self.base_url + uri
+        resp = requests.delete(_url, params=query_param, data=request_param, headers=headers, **kwargs)
+        return self._raise_for_status(resp, lambda code: code // 100 == 2)
 
     def patch(self, method, uri, query_param, request_param, headers, **kwargs):
-        """
-        TODO: Implementation.
-
-        :param method:
-        :param uri:
-        :param query_param:
-        :param request_param:
-        :param headers:
-        :param kwargs:
-        :return:
-        """
-        _url = self.base_url + uri + "?" + urlencode(query_param)
-        if headers is not None:
-            resp = requests.ptach(_url, data=request_param, headers=headers, **kwargs)
-        else:
-            resp = requests.patch(_url, data=request_param, **kwargs)
-
-        if resp.status_code == 200:
-            return resp
-
-        raise BacklogError("Http response {status}: {message}".format(status=resp.status_code, message=resp.text))
+        _url = self.base_url + uri
+        resp = requests.patch(_url, params=query_param, data=request_param, headers=headers, **kwargs)
+        return self._raise_for_status(resp, lambda code: code // 100 == 2)
 
 
 class BacklogObject(object):

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/issue.py

@@ -124,7 +124,7 @@ class Issue(object):
         if attachmentId is not None:
             _data.update([("attachmentId[]", attachmentId)])
 
-        resp = self.api.invoke_method(_method, _uri, _data)
+        resp = self.api.invoke_method(_method, _uri, request_param=_data)
 
         return resp.json()
 

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/project.py

@@ -72,6 +72,7 @@ class Project(object):
         useOriginalImageSizeAtWiki: Optional[bool] = None,
         textFormattingRule: Optional[TextFormattingRule] = None,
         useDevAttributes: Optional[bool] = None,
+        chartEnabled: Optional[bool] = None,
     ) -> AddProjectResponse:
         """Add project
         https://developer.nulab.com/docs/backlog/api/2/add-project/#form-parameters
@@ -80,8 +81,10 @@ class Project(object):
         :type name: str
         :param key: Project Key (Uppercase letters (A-Z), numbers (0-9) and underscore (_) can be used.)
         :type key: str
-        :param chatEnabled: Enable chart
+        :param chatEnabled: Deprecated alias of chartEnabled, kept for backward compatibility
         :type chatEnabled: bool
+        :param chartEnabled: Enable chart
+        :type chartEnabled: bool
         :param useResolvedForChart: Consider Resolved and statuses after as Closed
         :type useResolvedForChart: bool
         :param subtaskingEnabled: Enable subtasking
@@ -109,10 +112,14 @@ class Project(object):
         """
         _path = "projects"
         _method = "POST"
+        if chartEnabled is not None and chatEnabled is not None and chartEnabled != chatEnabled:
+            raise ValueError("chartEnabled and its deprecated alias chatEnabled have conflicting values")
+        if chartEnabled is None:
+            chartEnabled = chatEnabled
         request_param = {
             "name": name,
             "key": key,
-            "chartEnabled": chatEnabled,
+            "chartEnabled": chartEnabled,
             "useResolvedForChart": useResolvedForChart,
             "subtaskingEnabled": subtaskingEnabled,
             "projectLeaderCanEditProjectLeader": projectLeaderCanEditProjectLeader,
@@ -241,7 +248,7 @@ class Project(object):
         _uri = "projects/{project_id_or_key}/users".format(project_id_or_key=projectIdOrKey)
         _method = "GET"
         _query_param = {
-            "excludeGroupMembers": "ture" if excludeGroupMembers else "false"
+            "excludeGroupMembers": "true" if excludeGroupMembers else "false"
         }
 
         resp = self.api.invoke_method(_method, _uri, query_param=_query_param)
@@ -361,7 +368,7 @@ class Project(object):
         )
         _method = "POST"
 
-        resp = self.api.invoke_method(_method, _uri)
+        resp = self.api.invoke_method(_method, _uri, request_param={"name": name})
 
         return resp.json()
 
@@ -380,7 +387,7 @@ class Project(object):
         )
         _method = "PATCH"
 
-        resp = self.api.invoke_method(_method, _uri)
+        resp = self.api.invoke_method(_method, _uri, request_param={"name": name})
 
         return resp.json()
 

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/user.py

@@ -51,7 +51,7 @@ class User(object):
         _method = "POST"
         params = dict(
             userId=userId,
-            passowrd=password,
+            password=password,
             name=name,
             mailAddress=mailAddress,
             roleType=roleType
@@ -61,7 +61,7 @@ class User(object):
 
         return resp.json()
 
-    def update(self, userId, password, name, mailAddress, roleType):
+    def update(self, userId, password=None, name=None, mailAddress=None, roleType=None):
         """
         https://developer.nulab.com/ja/docs/backlog/api/2/update-user/
 
@@ -75,12 +75,12 @@ class User(object):
         _uri = "users/{user_id}".format(user_id=userId)
         _method = "PATCH"
         params = dict(
-            userId=userId,
-            passowrd=password,
+            password=password,
             name=name,
             mailAddress=mailAddress,
             roleType=roleType
         )
+        params = {k: v for k, v in params.items() if v is not None}
 
         resp = self.api.invoke_method(_method, _uri, request_param=params)
 

{python_backlog-0.7.2 → python_backlog-0.7.6}/backlog/wiki.py

@@ -1,5 +1,22 @@
 # coding: utf-8
 
+from email.message import Message
+
+
+def _filename_from_response(resp):
+    """
+    Extract the file name from the Content-Disposition header (supports RFC 6266 filename*).
+
+    :return: file name, or None if the header does not contain one
+    """
+    _content_disposition = resp.headers.get("Content-Disposition")
+    if not _content_disposition:
+        return None
+    _message = Message()
+    _message["Content-Disposition"] = _content_disposition
+    return _message.get_filename()
+
+
 class Wiki(object):
     def __init__(self, api):
         """
@@ -146,7 +163,7 @@ class Wiki(object):
 
         return {
             "id": attachmentId,
-            "name": "test",
+            "name": _filename_from_response(resp),
             "data": resp.content
         }
 

{python_backlog-0.7.2 → python_backlog-0.7.6/python_backlog.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-backlog
-Version: 0.7.2
+Version: 0.7.6
 Summary: Backlog API v2 wrapper
 Home-page: https://github.com/hassaku63/pbl
 Author: hassaku63
@@ -19,6 +19,19 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests~=2.32.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # pbl
 
@@ -44,6 +57,8 @@ def main():
     """
     Initialize API Object
     """
+    # The API key is sent in the "Backlog-API-Key" request header.
+    # Requests time out after 30 seconds by default (configurable with `timeout=`).
     api = BacklogAPI("your-space", "your-api-key")
 
     """

{python_backlog-0.7.2 → python_backlog-0.7.6}/python_backlog.egg-info/SOURCES.txt

@@ -27,5 +27,6 @@ tests/test_custom_filed.py
 tests/test_git.py
 tests/test_issue.py
 tests/test_project.py
+tests/test_request_params.py
 tests/test_user.py
 tests/test_wiki.py

{python_backlog-0.7.2 → python_backlog-0.7.6}/tests/test_api.py

@@ -3,7 +3,8 @@
 import unittest
 import httpretty
 import json
-from backlog.base import BacklogAPI
+from unittest import mock
+from backlog.base import BacklogAPI, DEFAULT_TIMEOUT
 
 API_ENDPOINT = "https://{space}.backlog.jp/api/v2/{uri}"
 
@@ -115,6 +116,87 @@ class TestApi(unittest.TestCase):
         self.assertEqual(200, resp.status_code)
         self.assertEqual(expects, resp.json())
 
+    @httpretty.activate
+    def test_api_key_is_sent_in_header_not_query(self):
+        for _method in ["GET", "POST", "DELETE", "PATCH"]:
+            with self.subTest(method=_method):
+                httpretty.register_uri(
+                    getattr(httpretty, _method),
+                    API_ENDPOINT.format(space=self.space, uri="test"),
+                    body="{}",
+                    status=200
+                )
+
+                self.api.invoke_method(_method, "test")
+
+                req = httpretty.last_request()
+                self.assertEqual(self.api_key, req.headers.get("Backlog-API-Key"))
+                self.assertNotIn("apiKey", req.querystring)
+                self.assertNotIn(self.api_key, req.path)
+
+    @httpretty.activate
+    def test_api_key_does_not_leak_between_instances(self):
+        """Regression: a shared mutable default argument used to keep the first instance's API key."""
+        for _space in ["space-a", "space-b"]:
+            httpretty.register_uri(
+                httpretty.GET,
+                API_ENDPOINT.format(space=_space, uri="users"),
+                body="[]",
+                status=200
+            )
+        api_a = BacklogAPI("space-a", "KEY_A")
+        api_b = BacklogAPI("space-b", "KEY_B")
+
+        api_a.invoke_method("GET", "users")
+        api_b.invoke_method("GET", "users")
+
+        req = httpretty.last_request()
+        self.assertEqual("space-b.backlog.jp", req.headers.get("Host"))
+        self.assertEqual("KEY_B", req.headers.get("Backlog-API-Key"))
+
+    @httpretty.activate
+    def test_caller_arguments_are_not_mutated(self):
+        httpretty.register_uri(
+            httpretty.POST,
+            API_ENDPOINT.format(space=self.space, uri="test"),
+            body="{}",
+            status=200
+        )
+        query_param = {"q": "1"}
+        request_param = {"name": "x"}
+        headers = {"X-Test": "1"}
+
+        self.api.invoke_method("POST", "test", query_param=query_param, request_param=request_param, headers=headers)
+
+        self.assertEqual({"q": "1"}, query_param)
+        self.assertEqual({"name": "x"}, request_param)
+        self.assertEqual({"X-Test": "1"}, headers)
+        req = httpretty.last_request()
+        self.assertEqual("1", req.headers.get("X-Test"))
+        self.assertEqual(self.api_key, req.headers.get("Backlog-API-Key"))
+
+    def test_timeout(self):
+        resp = mock.Mock(status_code=200)
+        with mock.patch("backlog.base.requests.get", return_value=resp) as m:
+            self.api.invoke_method("GET", "test")
+            self.assertEqual(DEFAULT_TIMEOUT, m.call_args.kwargs["timeout"])
+
+            BacklogAPI("space", "api_key", timeout=5).invoke_method("GET", "test")
+            self.assertEqual(5, m.call_args.kwargs["timeout"])
+
+            self.api.invoke_method("GET", "test", timeout=1)
+            self.assertEqual(1, m.call_args.kwargs["timeout"])
+
+    def test_invalid_space(self):
+        for _space in ["", "evil.example.com/#", "space.backlog.com", "a b", "-space", None]:
+            with self.subTest(space=_space):
+                with self.assertRaises(ValueError):
+                    BacklogAPI(_space, "api_key")
+
+        for _space in ["space", "my-space", "Space01"]:
+            with self.subTest(space=_space):
+                BacklogAPI(_space, "api_key")
+
 
 if __name__ == "__main__":
     unittest.main(warnings='ignore')

python_backlog-0.7.6/tests/test_request_params.py

@@ -0,0 +1,193 @@
+# coding: utf-8
+"""
+Tests that assert what is actually sent to the Backlog API (method, query string and body),
+not only how responses are parsed.
+"""
+
+import json
+import os
+import tempfile
+import unittest
+from urllib.parse import parse_qs
+
+import httpretty
+
+from backlog.base import BacklogAPI
+
+API_ENDPOINT = "https://{space}.backlog.jp/api/v2/{uri}"
+
+
+def _form(req):
+    return {k: v if len(v) > 1 else v[0] for k, v in parse_qs(req.body.decode()).items()}
+
+
+class TestRequestParams(unittest.TestCase):
+    def setUp(self):
+        self.space = "space"
+        self.api = BacklogAPI(self.space, "api_key")
+
+    def _register(self, method, uri, body="{}", **kwargs):
+        httpretty.register_uri(
+            method,
+            API_ENDPOINT.format(space=self.space, uri=uri),
+            body=body,
+            content_type="application/json",
+            **kwargs
+        )
+
+    @httpretty.activate
+    def test_delete_sends_body(self):
+        self._register(httpretty.DELETE, "projects/1/issueTypes/2")
+
+        self.api.project.delete_issue_type(projectIdOrKey=1, id=2, substituteIssueTypeId=3)
+
+        self.assertEqual({"substituteIssueTypeId": "3"}, _form(httpretty.last_request()))
+
+    @httpretty.activate
+    def test_wiki_delete_sends_mail_notify(self):
+        self._register(httpretty.DELETE, "wikis/1")
+
+        self.api.wiki.delete(wikiId=1, mailNotify=True)
+
+        self.assertEqual({"mailNotify": "true"}, _form(httpretty.last_request()))
+
+    @httpretty.activate
+    def test_2xx_responses_are_success_for_delete_and_patch(self):
+        for _method in [httpretty.DELETE, httpretty.PATCH]:
+            with self.subTest(method=_method):
+                self._register(_method, "test", status=202)
+                resp = self.api.invoke_method(_method, "test")
+                self.assertEqual(202, resp.status_code)
+
+    @httpretty.activate
+    def test_add_comment_sends_content_in_body(self):
+        self._register(httpretty.POST, "issues/PRJ-1/comments")
+
+        self.api.issue.add_comment("PRJ-1", "hello", notifiedUserId=10, attachmentId=20)
+
+        req = httpretty.last_request()
+        self.assertEqual({}, req.querystring)
+        self.assertEqual(
+            {"content": "hello", "notifiedUserId[]": "10", "attachmentId[]": "20"},
+            _form(req)
+        )
+
+    @httpretty.activate
+    def test_project_add_category_sends_name(self):
+        self._register(httpretty.POST, "projects/1/categories")
+
+        self.api.project.add_category(projectIdOrKey=1, name="dev")
+
+        self.assertEqual({"name": "dev"}, _form(httpretty.last_request()))
+
+    @httpretty.activate
+    def test_project_update_category_sends_name(self):
+        self._register(httpretty.PATCH, "projects/1/categories/2")
+
+        self.api.project.update_category(projectIdOrKey=1, id=2, name="dev")
+
+        self.assertEqual({"name": "dev"}, _form(httpretty.last_request()))
+
+    @httpretty.activate
+    def test_project_list_users_exclude_group_members(self):
+        self._register(httpretty.GET, "projects/1/users", body="[]")
+
+        for _flag, _expected in [(True, "true"), (False, "false")]:
+            with self.subTest(excludeGroupMembers=_flag):
+                self.api.project.list_users(1, excludeGroupMembers=_flag)
+                self.assertEqual([_expected], httpretty.last_request().querystring["excludeGroupMembers"])
+
+    @httpretty.activate
+    def test_project_create_chart_enabled(self):
+        self._register(httpretty.POST, "projects")
+
+        for _kwargs in [{"chartEnabled": True}, {"chatEnabled": True}]:
+            with self.subTest(**_kwargs):
+                self.api.project.create(name="n", key="K", **_kwargs)
+                self.assertEqual("True", _form(httpretty.last_request())["chartEnabled"])
+
+        with self.assertRaises(ValueError):
+            self.api.project.create(name="n", key="K", chartEnabled=True, chatEnabled=False)
+
+    @httpretty.activate
+    def test_user_add_sends_password(self):
+        self._register(httpretty.POST, "users")
+
+        self.api.user.add(userId="u", password="p", name="n", mailAddress="m@example.com", roleType=2)
+
+        self.assertEqual(
+            {"userId": "u", "password": "p", "name": "n", "mailAddress": "m@example.com", "roleType": "2"},
+            _form(httpretty.last_request())
+        )
+
+    @httpretty.activate
+    def test_user_update_sends_only_given_fields(self):
+        self._register(httpretty.PATCH, "users/1")
+
+        self.api.user.update(1, password="p")
+
+        self.assertEqual({"password": "p"}, _form(httpretty.last_request()))
+
+    @httpretty.activate
+    def test_wiki_get_attachment_name(self):
+        _uri = "wikis/1/attachments/2"
+        cases = [
+            ("attachment;filename*=UTF-8''%E8%B3%87%E6%96%99.pdf", "資料.pdf"),
+            ('attachment; filename="report.pdf"', "report.pdf"),
+            (None, None),
+        ]
+        for _header, _expected in cases:
+            with self.subTest(header=_header):
+                _headers = {"Content-Disposition": _header} if _header else {}
+                httpretty.register_uri(
+                    httpretty.GET,
+                    API_ENDPOINT.format(space=self.space, uri=_uri),
+                    body=b"data",
+                    content_type="application/octet-stream",
+                    adding_headers=_headers
+                )
+
+                resp = self.api.wiki.get_attachment(wikiId=1, attachmentId=2)
+
+                self.assertEqual(_expected, resp["name"])
+                self.assertEqual(b"data", resp["data"])
+
+    @httpretty.activate
+    def test_attachment_upload_closes_file_and_sends_content_type(self):
+        self._register(httpretty.POST, "space/attachment", body=json.dumps({"id": 1}))
+        with tempfile.TemporaryDirectory() as d:
+            _path = os.path.join(d, "a.txt")
+            with open(_path, "w") as f:
+                f.write("hello")
+
+            with self.assertNoResourceWarning():
+                self.api.attachment.upload(_path)
+
+        body = httpretty.last_request().body
+        self.assertIn(b'filename="a.txt"', body)
+        self.assertIn(b"Content-Type: text/plain", body)
+
+    def assertNoResourceWarning(self):
+        test = self
+
+        class _Ctx:
+            def __enter__(self):
+                import warnings
+                import gc
+                self._gc = gc
+                self._cm = warnings.catch_warnings(record=True)
+                self._w = self._cm.__enter__()
+                warnings.simplefilter("always", ResourceWarning)
+                return self
+
+            def __exit__(self, *exc):
+                self._gc.collect()
+                self._cm.__exit__(*exc)
+                test.assertEqual([], [w for w in self._w if issubclass(w.category, ResourceWarning)])
+                return False
+
+        return _Ctx()
+
+
+if __name__ == "__main__":
+    unittest.main()

{python_backlog-0.7.2 → python_backlog-0.7.6}/tests/test_wiki.py

@@ -468,7 +468,8 @@ class TestWiki(unittest.TestCase):
                 httpretty.GET,
                 API_ENDPOINT.format(space=self.space, uri=_uri),
                 body=tmp.file.read(),
-                content_type="application/octet-stream"
+                content_type="application/octet-stream",
+                adding_headers={"Content-Disposition": "attachment;filename*=UTF-8''{}".format(_name)}
             )
 
             # test

python_backlog-0.7.2/VERSION

@@ -1 +0,0 @@
-0.7.2