osgithub 0.4.0__tar.gz → 0.6.0__tar.gz

osgithub-0.6.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: osgithub
+Version: 0.6.0
+Home-page: https://github.com/opensafely-core/osgithub
+Author: OpenSAFELY
+Author-email: tech@opensafely.org
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: requests-cache
+Requires-Dist: furl
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

{osgithub-0.4.0 → osgithub-0.6.0}/README.md

@@ -3,109 +3,131 @@
 A thin wrapper around the GitHub API.
 
 ## Environment
+
 Set the following environment variables:
- - `GITHUB_USER_AGENT` - a string to identify your application
- - `GITHUB_TOKEN` - optional; default token to use.
- - `REQUESTS_CACHE_NAME` - optional, defaults to "http_cache"
+
+- `GITHUB_USER_AGENT` - a string to identify your application
+- `GITHUB_TOKEN` - optional; default token to use.
+- `REQUESTS_CACHE_NAME` - optional, defaults to "http_cache"
 
 ## Usage
 
 ### Create a client
-```
+
+```py
 from github_api_cache import GithubClient
 # Use the default token, if one is set in the environment.
 client = GithubClient()
 ```
 
 ### get a repo (returns a GithubRepo)
-```
+
+```py
 repo = client.get_repo("opensafely-core/osgithub")
 ```
 
 #### get a list of branches
-```
+
+```py
 repo.get_branches()
 ```
+
 And branch count:
-```
+
+```py
 repo.branch_count
 ```
 
 #### get a list of pull requests
+
 Provide a `page` argument to get more pages than just the first one (30 result are returned per page).
-```
+
+```py
 repo.get_pull_requests(page=1)
 ```
 
-By default, this fetches open PRs only.  To retrieve other states, pass `state="closed"` or `state="open"`
+By default, this fetches open PRs only. To retrieve other states, pass `state="closed"` or `state="open"`
 
 Pull request counts:
-```
+
+```py
 repo.pull_request_count
 repo.open_pull_request_count
 ```
 
 #### get the contents of the `osgithub` directory on branch `main`
-```
+
+```py
 # returns a list of GithubContentFile objects
 repo.get_contents("osgithub", "main")
 ```
 
 #### get a single file; returns a GithubContentFile
-```
+
+```py
 repo.get_contents("osgithub/__init__.py", "main")
 ```
 
 #### get_commits_for_file(self, path, ref, number_of_commits=1):
+
 Returns a list of commits, just the last one by default
-```
+
+```py
 repo.get_commits_for_file("osgithub", "main")
 ```
+
 To return more commits:
-```
+
+```py
 repo.get_commits_for_file("osgithub", "main", number_of_commits=10)
 ```
 
 Get details for a single commit by sha - returns author and date of the commit
-```
+
+```py
 repo.get_commit("7a6f60e8e74b9c93a9c6322b3151ee437fa4be61")
 ```
 
-
 #### Repo information
 
 Fetch the HTML from the README.md of repo:
-```
+
+```py
 repo.get_readme(tag="main")
 ```
 
 Fetch the About and Name of the repo:
-```
+
+```py
 repo.get_details()
 ```
 
 Fetch tags with name and sha:
-```
+
+```py
 repo.get_tags()
 ```
 
-
 ### Caching
+
 Requests can optionally be cached, using a sqlite backend.
 
 To use caching:
-```
+
+```py
 client = GithubClient(use_cache=True)
 ```
 
 Set a global expiry for the session (never expires by default):
-```
+
+```py
 # expire all cached requests after 300s
 client = GithubClient(expire_after=300)
 ```
 
 Set expiry on specific url patterns (falls back to `expire_after` if no match found)
-```
+
+```py
 urls_expire_after = {
     '*/pulls': 60,  # expire requests to get pull requests after 60 secs
     '*/branches': 60 * 5, # expire requests to get branches after 5 mins
@@ -115,7 +137,8 @@ client = GithubClient(urls_expire_after=urls_expire_after)
 ```
 
 #### Clear the cache for this repo
-```
+
+```py
 repo.clear_cache()
 ```
 

{osgithub-0.4.0 → osgithub-0.6.0}/osgithub/github.py

@@ -446,6 +446,20 @@ class GithubRepo:
         contrib_list = [contrib["login"] for contrib in content]
         return contrib_list
 
+    def get_topics(self):
+        """
+        Gets the repo's topics.
+
+        If the repo's name and about are also being fetched from GitHub,
+        consider setting `use_cache` to True in the GithubClient to avoid
+        duplicate calls to the repo endpoint.
+
+        Returns:
+            list[str]: list of topics
+        """
+        content = self.client.get_json(self.repo_path_segments)
+        return content["topics"]
+
     def clear_cache(self):
         """Clears all request cache urls for this repo"""
         cached_urls = self.client.session.cache.urls()

osgithub-0.6.0/osgithub.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: osgithub
+Version: 0.6.0
+Home-page: https://github.com/opensafely-core/osgithub
+Author: OpenSAFELY
+Author-email: tech@opensafely.org
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: requests-cache
+Requires-Dist: furl
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

{osgithub-0.4.0 → osgithub-0.6.0}/osgithub.egg-info/SOURCES.txt

@@ -8,4 +8,5 @@ osgithub.egg-info/PKG-INFO
 osgithub.egg-info/SOURCES.txt
 osgithub.egg-info/dependency_links.txt
 osgithub.egg-info/requires.txt
-osgithub.egg-info/top_level.txt
+osgithub.egg-info/top_level.txt
+tests/test_github.py

osgithub-0.6.0/tests/test_github.py

@@ -0,0 +1,737 @@
+import json
+from base64 import b64encode
+from datetime import datetime, timezone
+from os import environ
+
+import pytest
+from furl import furl
+from requests.exceptions import HTTPError
+
+from osgithub import GithubAPIException, GithubClient, GithubRepo
+
+from .conftest import remove_cache_file_if_exists
+
+
+def register_uri(httpretty, path, queryparams=None, status=200, body=None):
+    url = furl("https://api.github.com")
+    url.path.segments += [*path.split("/")]
+    if queryparams:
+        url.add(queryparams)
+    httpretty.register_uri(
+        httpretty.GET,
+        url.url,
+        status=status,
+        body=json.dumps(body or ""),
+        match_querystring=True,
+    )
+
+
+def test_github_client_get_repo(httpretty):
+    # Mock the github request
+    register_uri(httpretty, "repos/test/foo", body={"name": "foo", "description": ""})
+    client = GithubClient()
+    repo = client.get_repo("test", "foo")
+    assert repo.repo_path_segments == ["repos", "test", "foo"]
+
+
+def test_github_client_token(reset_environment_after_test):
+    """Authorization headers is set based on environment variable"""
+    environ["GITHUB_TOKEN"] = "test"
+    client = GithubClient()
+    assert client.headers["Authorization"] == "token test"
+
+    del environ["GITHUB_TOKEN"]
+    client = GithubClient()
+    assert "Authorization" not in client.headers
+
+
+def test_github_repo_get_url():
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    assert repo._url is None
+    assert repo.url == "https://github.com/test/foo"
+    assert repo._url == repo.url
+
+
+def test_github_client_get_repo_not_found(httpretty):
+    # Mock the github request
+    register_uri(httpretty, "repos/test/bar", status=404, body={"message": "Not found"})
+    client = GithubClient()
+    with pytest.raises(GithubAPIException, match="Not found"):
+        client.get_repo("test", "bar")
+
+
+@pytest.mark.parametrize("use_cache", [True, False])
+def test_github_client_get_repo_with_cache(httpretty, use_cache):
+    client = GithubClient(use_cache=use_cache)
+
+    # set up mock request with valid response and call it
+    register_uri(
+        httpretty, "repos/test/test-cache", body={"name": "foo", "description": ""}
+    )
+    client.get_repo("test", "test-cache")
+
+    # re-mock the repos request to a 404, should raise an exception if called directly
+    register_uri(
+        httpretty, "repos/test/test-cache", status=404, body={"message": "Not found"}
+    )
+
+    if use_cache:
+        # No exception raised because the first response was cached
+        client.get_repo("test", "test-cache")
+    else:
+        # Exception raised because the repos endpoint was fetched again
+        with pytest.raises(GithubAPIException, match="Not found"):
+            client.get_repo("test", "test-cache")
+
+
+@pytest.mark.parametrize("state", ["open", "closed"])
+def test_github_repo_get_pull_requests(httpretty, state):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    pull_requests = {
+        "open": [
+            {
+                "url": "https://api.github.com/repos/test/foo/pulls/1",
+                "id": 1,
+                "state": "open",
+                "title": "Open PR",
+                "user": {"login": "testuser", "id": 123},
+                "body": "",
+                "created_at": "2021-08-16T04:11:31Z",
+                "updated_at": None,
+                "closed_at": None,
+                "merged_at": None,
+            }
+        ],
+        "closed": [
+            {
+                "url": "https://api.github.com/repos/test/foo/pulls/2",
+                "id": 2,
+                "state": "closed",
+                "title": "Closed PR",
+                "user": {"login": "testuser", "id": 123},
+                "body": "",
+                "created_at": "2021-08-01T10:00:00Z",
+                "updated_at": None,
+                "closed_at": "2021-08-12T09:11:00Z",
+                "merged_at": None,
+            }
+        ],
+    }
+    # Mock the github requests
+    register_uri(
+        httpretty,
+        "repos/test/foo/pulls",
+        queryparams=dict(state=state, page=1, per_page=30),
+        body=pull_requests[state],
+    )
+    pulls = repo.get_pull_requests(state)
+    assert pulls == pull_requests[state]
+
+
+def test_github_repo_get_open_pull_request_count(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    pull_requests = [
+        {
+            "url": "https://api.github.com/repos/test/foo/pulls/1",
+            "id": 1,
+            "state": "open",
+        },
+        {
+            "url": "https://api.github.com/repos/test/foo/pulls/2",
+            "id": 2,
+            "state": "open",
+        },
+    ]
+    # Mock the github requests
+    register_uri(
+        httpretty,
+        "repos/test/foo/pulls",
+        queryparams=dict(state="open", page=1, per_page=30),
+        body=pull_requests,
+    )
+    assert repo.open_pull_request_count == 2
+
+
+def test_github_repo_get_branches(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    sha1 = "1" * 40
+    sha2 = "2" * 40
+    branches = [
+        {
+            "name": "test_branch",
+            "commit": {
+                "sha": sha1,
+                "url": f"https://api.github.com/repos/test/foo/commits/{sha1}",
+            },
+            "protected": False,
+        },
+        {
+            "name": "test_branch1",
+            "commit": {
+                "sha": sha2,
+                "url": f"https://api.github.com/repos/test/foo/commits/{sha2}",
+            },
+            "protected": False,
+        },
+    ]
+    # Mock the github requests
+    register_uri(httpretty, "repos/test/foo/branches", body=branches)
+    assert repo.get_branches() == branches
+    assert repo.branch_count == 2
+
+
+def test_github_repo_get_multipage_pull_request_count(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    for i in range(1, 3):
+        pull_requests = [
+            {
+                "url": f"https://api.github.com/repos/test/foo/pulls/{pr_num * i}",
+                "id": pr_num * i,
+                "state": "open",
+            }
+            for pr_num in range(1, 31)
+        ]
+        # Mock the github request
+        register_uri(
+            httpretty,
+            "repos/test/foo/pulls",
+            queryparams=dict(state="open", page=i, per_page=30),
+            body=pull_requests,
+        )
+    last_page_pull_requests = [
+        {
+            "url": f"https://api.github.com/repos/test/foo/pulls/{pr_num * 3}",
+            "id": pr_num * 3,
+            "state": "open",
+        }
+        for pr_num in range(1, 11)
+    ]
+    register_uri(
+        httpretty,
+        "repos/test/foo/pulls",
+        queryparams=dict(state="open", page=3, per_page=30),
+        body=last_page_pull_requests,
+    )
+
+    assert repo.open_pull_request_count == 70
+
+
+def test_github_repo_get_contents_single_file(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    str_content = """
+        <html>
+            <head>
+                <style type="text/css">body {margin: 0;}</style>
+                <style type="text/css">a {background-color: red;}</style>
+                <script src="https://a-js-package.js"></script>
+            </head>
+            <body><p>foo</p></body>
+        </html>
+    """
+    # Content retrieved from GitHub is base64-encoded, decoded to str for json
+    b64_content = b64encode(bytes(str_content, encoding="utf-8")).decode()
+    # Mock the github request
+    reponse_json = {
+        "name": "test-file.html",
+        "path": "test-folder/test-file.html",
+        "sha": "abcd1234",
+        "size": 1234,
+        "encoding": "base64",
+        "content": b64_content,
+    }
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder/test-file.html",
+        queryparams=dict(ref="main"),
+        body=reponse_json,
+    )
+
+    commits_response = [{"commit": {"committer": {"date": "2021-03-01T10:00:00Z"}}}]
+    register_uri(
+        httpretty,
+        "repos/test/foo/commits",
+        queryparams=dict(sha="main", path="test-folder/test-file.html", per_page=1),
+        body=commits_response,
+    )
+
+    content_file = repo.get_contents("test-folder/test-file.html", ref="main")
+    assert content_file.name == "test-file.html"
+    # decoded content retrieves the original str contents
+    assert content_file.decoded_content == str_content
+
+    # get contents with content fetch type
+    content_file, fetch_type = repo.get_contents(
+        "test-folder/test-file.html", ref="main", return_fetch_type=True
+    )
+    assert content_file.name == "test-file.html"
+    assert fetch_type == "contents"
+
+
+def test_github_repo_get_last_updated(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    commit_dates = [
+        "2021-03-01T10:00:00Z",
+        "2021-02-14T10:00:00Z",
+        "2021-02-01T10:00:00Z",
+    ]
+    commits_response = [
+        {"commit": {"committer": {"date": commit_date}}} for commit_date in commit_dates
+    ]
+    register_uri(
+        httpretty,
+        "repos/test/foo/commits",
+        queryparams=dict(sha="main", path="test-folder/test-file.html", per_page=1),
+        body=commits_response,
+    )
+
+    last_updated = repo.get_last_updated(path="test-folder/test-file.html", ref="main")
+    assert last_updated == datetime(2021, 3, 1, 10, 0, 0, tzinfo=timezone.utc)
+
+
+@pytest.mark.parametrize(
+    "status_code,body,expected_exception,expected_match",
+    [
+        (404, {"message": "Not found"}, GithubAPIException, "Not found"),
+        (
+            403,
+            {"errors": [{"code": "other_code", "message": "An unexpected 403"}]},
+            HTTPError,
+            "Forbidden for url",
+        ),
+        (
+            401,
+            {"errors": [{"code": "other_code", "message": "An unexpected 403"}]},
+            HTTPError,
+            "Unauthorized for url",
+        ),
+        (
+            403,
+            {
+                "unknown": [
+                    {"code": "other_code", "message": "A 403 without an 'errors' key"}
+                ]
+            },
+            GithubAPIException,
+            "A 403 without an 'errors' key",
+        ),
+    ],
+)
+def test_github_repo_get_contents_exceptions(
+    httpretty, status_code, body, expected_exception, expected_match
+):
+    """
+    Test expected and unexpected exceptions from get_contents
+    """
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    # Mock the github request
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder/test-file.html",
+        queryparams=dict(ref="main"),
+        status=status_code,
+        body=body,
+    )
+    with pytest.raises(expected_exception, match=expected_match):
+        repo.get_contents("test-folder/test-file.html", ref="main")
+
+
+@pytest.mark.parametrize(
+    "filepath,expected_filename",
+    [
+        ("test-folder/test-file.html", "test-file.html"),
+        ("test-folder/test-file1.html", "test-file1.html"),
+        ("test-folder/test-file2.html", None),
+    ],
+)
+def test_github_repo_matching_file_from_parent_contents(
+    httpretty, filepath, expected_filename
+):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    # Mock the github requests
+    # get the parent folder contents
+    response_json = [
+        {
+            "name": "test-file.html",
+            "path": "test-folder/test-file.html",
+            "sha": "abcd1234",
+            "size": 1234,
+            "encoding": "base64",
+        },
+        {
+            "name": "test-file1.html",
+            "path": "test-folder/test-file1.html",
+            "sha": "abcd2345",
+            "size": 1234,
+            "encoding": "base64",
+        },
+    ]
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder",
+        queryparams=dict(ref="main"),
+        body=response_json,
+    )
+
+    matching_file = repo.get_matching_file_from_parent_contents(filepath, "main")
+    if expected_filename is None:
+        assert matching_file is None
+    else:
+        assert matching_file.name == expected_filename
+
+
+def test_github_repo_get_contents_folder(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    # Mock the github request
+    response_json = [
+        {
+            "name": "test-file1.html",
+            "path": "test-folder/test-file1.html",
+            "sha": "abcd1234",
+            "size": 1234,
+            "encoding": "base64",
+        },
+        {
+            "name": "test-file2.html",
+            "path": "test-folder/test-file2.html",
+            "sha": "abcd5678",
+            "size": 1234,
+            "encoding": "base64",
+        },
+    ]
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder",
+        queryparams=dict(ref="main"),
+        body=response_json,
+    )
+    contents = repo.get_contents("test-folder", ref="main")
+    assert isinstance(contents, list)
+    assert len(contents) == 2
+    assert contents[0].name == "test-file1.html"
+    assert contents[1].name == "test-file2.html"
+    # decoded content returns None when the ContntFile was generated from a list of files
+    # returned from github
+    assert contents[0].decoded_content is None
+    assert contents[1].decoded_content is None
+
+
+def test_github_repo_get_contents_from_git_blob(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    str_content = """
+        <html>
+            <head>
+                <style type="text/css">body {margin: 0;}</style>
+                <style type="text/css">a {background-color: red;}</style>
+                <script src="https://a-js-package.js"></script>
+            </head>
+            <body><p>foo</p></body>
+        </html>
+    """
+    # Content retrieved from GitHub is base64-encoded, decoded to str for json
+    b64_content = b64encode(bytes(str_content, encoding="utf-8")).decode()
+    # Mock the github requests
+    # get the parent folder contents
+    response_json = [
+        {
+            "name": "test-file.html",
+            "path": "test-folder/test-file.html",
+            "sha": "abcd1234",
+            "size": 1234,
+            "encoding": "base64",
+        },
+    ]
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder",
+        queryparams=dict(ref="main"),
+        body=response_json,
+    )
+
+    # get the git blob
+    response_json = {
+        "name": "test-file.html",
+        "path": "test-folder/test-file.html",
+        "sha": "abcd1234",
+        "size": 1234,
+        "encoding": "base64",
+        "content": b64_content,
+    }
+    register_uri(httpretty, "repos/test/foo/git/blobs/abcd1234", body=response_json)
+
+    # get the commits for last updated
+    commits_response = [{"commit": {"committer": {"date": "2021-03-01T10:00:00Z"}}}]
+    register_uri(
+        httpretty,
+        "repos/test/foo/commits",
+        queryparams=dict(sha="main", path="test-folder/test-file.html", per_page=1),
+        body=commits_response,
+    )
+
+    content_file = repo.get_contents(
+        "test-folder/test-file.html", "main", from_git_blob=True
+    )
+    assert content_file.name == "test-file.html"
+    # decoded content retrieves the original str contents
+    assert content_file.decoded_content == str_content
+
+
+def test_github_repo_get_contents_too_large_file(httpretty):
+    """
+    Test get_contents with a too-large file resorts to fetching content from the git blob
+    """
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    str_content = """
+        <html>
+            <head>
+                <style type="text/css">body {margin: 0;}</style>
+                <style type="text/css">a {background-color: red;}</style>
+                <script src="https://a-js-package.js"></script>
+            </head>
+            <body><p>foo</p></body>
+        </html>
+    """
+    # Content retrieved from GitHub is base64-encoded, decoded to str for json
+    b64_content = b64encode(bytes(str_content, encoding="utf-8")).decode()
+
+    # Mock the github requests
+    # First tries the contents endpoint and gets a 403
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder/test-file.html",
+        status=200,
+        queryparams=dict(ref="main"),
+        body={
+            "name": "test-file.html",
+            "path": "test-folder/test-file.html",
+            "sha": "abcd1234",
+            "size": 1234,
+            "encoding": "base64",
+            "content": "",
+        },
+    )
+
+    # gets the parent folder contents
+    register_uri(
+        httpretty,
+        "repos/test/foo/contents/test-folder",
+        status=200,
+        queryparams=dict(ref="main"),
+        body=[
+            {
+                "name": "test-file.html",
+                "path": "test-folder/test-file.html",
+                "sha": "abcd1234",
+                "size": 1234,
+                "encoding": "base64",
+            },
+        ],
+    )
+
+    # then gets the git blob
+    register_uri(
+        httpretty,
+        "repos/test/foo/git/blobs/abcd1234",
+        status=200,
+        body={
+            "name": "test-file.html",
+            "path": "test-folder/test-file.html",
+            "sha": "abcd1234",
+            "size": 1234,
+            "encoding": "base64",
+            "content": b64_content,
+        },
+    )
+
+    # get the commits for last updated
+    commits_response = [{"commit": {"committer": {"date": "2021-03-01T10:00:00Z"}}}]
+    register_uri(
+        httpretty,
+        "repos/test/foo/commits",
+        queryparams=dict(sha="main", path="test-folder/test-file.html", per_page=1),
+        body=commits_response,
+    )
+
+    content_file = repo.get_contents("test-folder/test-file.html", ref="main")
+    assert content_file.decoded_content == str_content
+    assert content_file.last_updated == datetime(
+        2021, 3, 1, 10, 0, 0, tzinfo=timezone.utc
+    )
+
+
+def test_github_repo_get_readme(httpretty):
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    readme_content = b"<div id='readme'><h1>Foo</h1><p>A README.</p></div>"
+    httpretty.register_uri(
+        httpretty.GET,
+        "https://api.github.com/repos/test/foo/readme?ref=main",
+        status=200,
+        body=readme_content,
+        match_querystring=True,
+    )
+    readme_content = repo.get_readme(tag="main")
+    assert readme_content == "<div id='readme'><h1>Foo</h1><p>A README.</p></div>"
+
+
+def test_github_repo_details(httpretty):
+    register_uri(
+        httpretty,
+        "repos/test/foo",
+        status=200,
+        body={"name": "foo", "description": "A test repo"},
+    )
+    # If the repo is instantiated with an "about", the endpoint isn't called
+    repo = GithubRepo(
+        client=GithubClient(use_cache=False),
+        owner="test",
+        name="foo",
+        about="A different description",
+    )
+    details = repo.get_repo_details()
+    assert details == {"name": "foo", "about": "A different description"}
+    assert httpretty.latest_requests() == []
+
+    # instantiate with no "about" arg, need to fetch it for the details
+    repo1 = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    details = repo1.get_repo_details()
+    assert details == {"name": "foo", "about": "A test repo"}
+    latest_requests = httpretty.latest_requests()
+    assert len(latest_requests) == 1
+    assert latest_requests[0].url == "https://api.github.com/repos/test/foo"
+
+
+def test_github_repo_get_tags(httpretty):
+    sha1 = "1" * 40
+    sha2 = "2" * 40
+    tags = [
+        {"name": "v1.0", "commit": {"sha": sha1}},
+        {"name": "v2.0", "commit": {"sha": sha2}},
+    ]
+    register_uri(httpretty, "repos/test/foo/tags", status=200, body=tags)
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    assert repo.get_tags() == [
+        {"tag_name": "v1.0", "sha": sha1},
+        {"tag_name": "v2.0", "sha": sha2},
+    ]
+
+
+def test_github_repo_get_commit(httpretty):
+    sha = "1" * 40
+    commit_body = {
+        "author": {"name": "Donald Duck"},
+        "committer": {"date": "2021-03-01T10:00:00Z"},
+    }
+    register_uri(
+        httpretty, f"repos/test/foo/git/commits/{sha}", status=200, body=commit_body
+    )
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    assert repo.get_commit(sha) == {
+        "author": "Donald Duck",
+        "date": "2021-03-01T10:00:00Z",
+    }
+
+
+def test_github_repo_get_contributors(httpretty):
+    contribs = [{"login": "octocat"}, {"login": "octodog"}]
+    register_uri(httpretty, "repos/test/foo/contributors", status=200, body=contribs)
+    repo = GithubRepo(client=GithubClient(use_cache=False), owner="test", name="foo")
+    assert repo.get_contributors() == ["octocat", "octodog"]
+
+
+@pytest.mark.parametrize(
+    "use_cache,num_requests",
+    [
+        (True, 1),
+        (False, 2),
+    ],
+)
+def test_github_repo_get_topics(httpretty, use_cache, num_requests):
+    register_uri(
+        httpretty,
+        "repos/test/foo",
+        status=200,
+        body={"name": "foo", "description": "a description", "topics": ["bar", "baz"]},
+    )
+    repo = GithubClient(use_cache=use_cache).get_repo("test", "foo")
+    assert repo.get_topics() == ["bar", "baz"]
+    assert len(httpretty.latest_requests()) == num_requests
+
+
+def test_clear_cache(httpretty, reset_environment_after_test):
+    # mock the requests
+    register_uri(httpretty, "repos/test/foo", body={"name": "foo", "description": ""})
+    httpretty.register_uri(httpretty.GET, "https://www.test.com/", status=200)
+
+    # make sure we start with a fresh cache
+    remove_cache_file_if_exists()
+    client = GithubClient(use_cache=True)
+    # no github requests have been made, so cache is currently clear
+    assert client.session.cache.urls() == []
+
+    # A real repo
+    repo = client.get_repo("test", "foo")
+
+    # 1 call made, to get contents
+    assert len(client.session.cache.urls()) == 1
+    # make another request using this cache session
+    client.session.get("https://www.test.com/")
+    assert len(client.session.cache.urls()) == 2
+    # Clearing the cache only clears urls related to this report
+    repo.clear_cache()
+    assert client.session.cache.urls() == ["https://www.test.com/"]
+
+
+@pytest.mark.integration
+def test_integration(reset_environment_after_test):
+    """Test repo methods with a real github repo"""
+    # make sure we start with a fresh cache
+    remove_cache_file_if_exists()
+    client = GithubClient(use_cache=True)
+    # Set up a real repo
+    repo = client.get_repo("opensafely", "output-explorer-test-repo")
+
+    # Fetch a known folder
+    contents = repo.get_contents("test-outputs", ref="master")
+    assert len(contents) == 4
+    assert sorted([contentfile.name for contentfile in contents]) == [
+        "output.html",
+        "sro-measures.html",
+        "vaccine-coverage-new.html",
+        "vaccine-coverage-original.html",
+    ]
+
+    # Fetch a file
+    contents, fetch_type = repo.get_contents(
+        "test-outputs/output.html", ref="master", return_fetch_type=True
+    )
+    assert contents.name == "output.html"
+    assert fetch_type == "contents"
+
+    # Fetch a non-existent file
+    with pytest.raises(GithubAPIException):
+        repo.get_contents("test-outputs/output-unknown.html", ref="master")
+
+    # Fetch a non-existent branch
+    with pytest.raises(GithubAPIException):
+        repo.get_contents("test-outputs/output.html", ref="foo")
+
+    # Fetch README
+    readme = repo.get_readme(tag="master")
+    assert readme.startswith("<div")
+    assert "This is a test repo for use by output-explorer's tests." in readme
+
+    # Fetch details
+    details = repo.get_repo_details()
+    assert details == {
+        "name": "output-explorer-test-repo",
+        "about": "A test repo for output-explorer's tests",
+    }
+
+    # Fetch tags
+    tagged_sha = "7a6f60e8e74b9c93a9c6322b3151ee437fa4be61"
+    tags = repo.get_tags()
+    assert len(tags) >= 1
+    assert {"tag_name": "test-tag", "sha": tagged_sha} in tags
+
+    # get commit details
+    commit = repo.get_commit(sha=tagged_sha)
+    assert commit == {"author": "Ben Butler-Cole", "date": "2021-06-02T10:52:37Z"}

osgithub-0.4.0/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: osgithub
-Version: 0.4.0
-Summary: UNKNOWN
-Home-page: https://github.com/opensafely-core/osgithub
-Author: OpenSAFELY
-Author-email: tech@opensafely.org
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.9
-License-File: LICENSE
-
-UNKNOWN
-

osgithub-0.4.0/osgithub.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: osgithub
-Version: 0.4.0
-Summary: UNKNOWN
-Home-page: https://github.com/opensafely-core/osgithub
-Author: OpenSAFELY
-Author-email: tech@opensafely.org
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.9
-License-File: LICENSE
-
-UNKNOWN
-