diff --git a/PKG-INFO b/PKG-INFO index 0f9e8fd..11b200a 100644 --- a/PKG-INFO +++ b/PKG-INFO @@ -1,48 +1,48 @@ Metadata-Version: 2.1 Name: swh.web.client -Version: 0.2.1 +Version: 0.2.2 Summary: Software Heritage Web client Home-page: https://forge.softwareheritage.org/source/swh-web-client/ Author: Software Heritage developers Author-email: swh-devel@inria.fr License: UNKNOWN Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest Project-URL: Funding, https://www.softwareheritage.org/donate Project-URL: Source, https://forge.softwareheritage.org/source/swh-web-client Project-URL: Documentation, https://docs.softwareheritage.org/devel/swh-web-client/ Description: Software Heritage - Web client ============================== Client for Software Heritage Web applications, via their APIs. Sample usage ------------ .. code-block:: python from swh.web.client.client import WebAPIClient cli = WebAPIClient() # retrieve any archived object via its SWHID cli.get('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # same, but for specific object types cli.revision('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # get() always retrieve entire objects, following pagination # WARNING: this might *not* be what you want for large objects cli.get('swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a') # type-specific methods support explicit iteration through pages next(cli.snapshot('swh:1:snp:cabcc7d7bf639bbe1cc3b41989e1806618dd5764')) Platform: UNKNOWN Classifier: Programming Language :: Python :: 3 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3) Classifier: Operating System :: OS Independent Classifier: Development Status :: 3 - Alpha Requires-Python: >=3.7 Description-Content-Type: text/x-rst Provides-Extra: testing diff --git a/docs/index.rst b/docs/index.rst index 703f80e..3c82750 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,90 +1,94 @@ .. _swh-web-client: .. include:: README.rst .. _swh-web-client-auth: Authentication -------------- If you have a user account registered on `Software Heritage Identity Provider`_, it is possible to authenticate requests made to the Web APIs through the use of -a OpenID Connect bearer token. Sending authenticated requests can notably +an OpenID Connect bearer token. Sending authenticated requests can notably allow to lift API rate limiting depending on your permissions. To get this token, a dedicated CLI tool is made available when installing ``swh-web-client``: .. code-block:: text $ swh auth Usage: swh auth [OPTIONS] COMMAND [ARGS]... Authenticate Software Heritage users with OpenID Connect. This CLI tool eases the retrieval of bearer tokens to authenticate a user querying the Software Heritage Web API. Options: --oidc-server-url TEXT URL of OpenID Connect server (default to "https://auth.softwareheritage.org/auth/") + --realm-name TEXT Name of the OpenID Connect authentication realm (default to "SoftwareHeritage") + --client-id TEXT OpenID Connect client identifier in the realm (default to "swh-web") + -h, --help Show this message and exit. Commands: - login Login and create new offline OpenID Connect session. - logout Logout from an offline OpenID Connect session. + generate-token Generate a new bearer token for Web API authentication. + revoke-token Revoke a bearer token used for Web API authentication. -In order to get your tokens, you need to use the ``login`` subcommand of -that CLI tool by passing your username as argument. You will be prompted +In order to get your tokens, you need to use the ``generate-token`` subcommand of +the CLI tool by passing your username as argument. You will be prompted for your password and if the authentication succeeds a new OpenID Connect -session will be created and tokens will be dumped to standard output. +offline session will be created and token will be dumped to standard output. .. code-block:: text - $ swh auth login + $ swh auth generate-token Password: eyJhbGciOiJIUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJmNjMzMD... To authenticate yourself, you need to send that token value in request headers when querying the Web API. Considering you have stored that token value in a TOKEN environment variable, you can perform an authenticated call the following way using ``curl``: .. code-block:: text $ curl -H "Authorization: Bearer ${TOKEN}" https://archive.softwareheritage.org/api/1/ Note that if you intend to use the :class:`swh.web.client.client.WebAPIClient` class, you can activate authentication by using the following code snippet:: from swh.web.client.client import WebAPIClient TOKEN = '.......' # Use "swh auth login" command to get it client = WebAPIClient(bearer_token=TOKEN) # All requests to the Web API will be authenticated resp = client.get('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') -It is also possible to ``logout`` from the authenticated OpenID Connect session -which definitely revokes the token. +It is also possible to revoke a token, preventing future Web API authentication +when using it. The ``revoke-token`` subcommand of the CLI tool has to be used +to perform that task. .. code-block:: text - $ swh auth logout $REFRESH_TOKEN - Successfully logged out from OpenID Connect session + $ swh auth revoke-token $REFRESH_TOKEN + Token successfully revoked. API Reference ------------- .. toctree:: :maxdepth: 2 /apidoc/swh.web.client .. _Software Heritage Identity Provider: https://auth.softwareheritage.org/auth/realms/SoftwareHeritage/account/ diff --git a/swh.web.client.egg-info/PKG-INFO b/swh.web.client.egg-info/PKG-INFO index 0f9e8fd..11b200a 100644 --- a/swh.web.client.egg-info/PKG-INFO +++ b/swh.web.client.egg-info/PKG-INFO @@ -1,48 +1,48 @@ Metadata-Version: 2.1 Name: swh.web.client -Version: 0.2.1 +Version: 0.2.2 Summary: Software Heritage Web client Home-page: https://forge.softwareheritage.org/source/swh-web-client/ Author: Software Heritage developers Author-email: swh-devel@inria.fr License: UNKNOWN Project-URL: Bug Reports, https://forge.softwareheritage.org/maniphest Project-URL: Funding, https://www.softwareheritage.org/donate Project-URL: Source, https://forge.softwareheritage.org/source/swh-web-client Project-URL: Documentation, https://docs.softwareheritage.org/devel/swh-web-client/ Description: Software Heritage - Web client ============================== Client for Software Heritage Web applications, via their APIs. Sample usage ------------ .. code-block:: python from swh.web.client.client import WebAPIClient cli = WebAPIClient() # retrieve any archived object via its SWHID cli.get('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # same, but for specific object types cli.revision('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # get() always retrieve entire objects, following pagination # WARNING: this might *not* be what you want for large objects cli.get('swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a') # type-specific methods support explicit iteration through pages next(cli.snapshot('swh:1:snp:cabcc7d7bf639bbe1cc3b41989e1806618dd5764')) Platform: UNKNOWN Classifier: Programming Language :: Python :: 3 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3) Classifier: Operating System :: OS Independent Classifier: Development Status :: 3 - Alpha Requires-Python: >=3.7 Description-Content-Type: text/x-rst Provides-Extra: testing diff --git a/swh/web/client/cli.py b/swh/web/client/cli.py index 4c53093..31f548a 100644 --- a/swh/web/client/cli.py +++ b/swh/web/client/cli.py @@ -1,97 +1,117 @@ # Copyright (C) 2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information # WARNING: do not import unnecessary things here to keep cli startup time under # control import click from click.core import Context from swh.core.cli import swh as swh_cli_group CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"]) @swh_cli_group.group(name="auth", context_settings=CONTEXT_SETTINGS) @click.option( "--oidc-server-url", "oidc_server_url", default="https://auth.softwareheritage.org/auth/", help=( "URL of OpenID Connect server (default to " '"https://auth.softwareheritage.org/auth/")' ), ) @click.option( "--realm-name", "realm_name", default="SoftwareHeritage", help=( "Name of the OpenID Connect authentication realm " '(default to "SoftwareHeritage")' ), ) @click.option( "--client-id", "client_id", default="swh-web", help=("OpenID Connect client identifier in the realm " '(default to "swh-web")'), ) @click.pass_context def auth(ctx: Context, oidc_server_url: str, realm_name: str, client_id: str): """ Authenticate Software Heritage users with OpenID Connect. This CLI tool eases the retrieval of a bearer token to authenticate a user querying the Software Heritage Web API. """ from swh.web.client.auth import OpenIDConnectSession ctx.ensure_object(dict) ctx.obj["oidc_session"] = OpenIDConnectSession( oidc_server_url, realm_name, client_id ) -@auth.command("login") +@auth.command("generate-token") @click.argument("username") @click.pass_context -def login(ctx: Context, username: str): +def generate_token(ctx: Context, username: str): """ - Login and create new offline OpenID Connect session. + Generate a new bearer token for Web API authentication. Login with USERNAME, create a new OpenID Connect session and get bearer token. - User will be prompted for his password and tokens will be printed + User will be prompted for his password and token will be printed to standard output. The created OpenID Connect session is an offline one so the provided token has a much longer expiration time than classical OIDC sessions (usually several dozens of days). """ from getpass import getpass password = getpass() oidc_info = ctx.obj["oidc_session"].login(username, password) if "refresh_token" in oidc_info: print(oidc_info["refresh_token"]) else: print(oidc_info) -@auth.command("logout") +@auth.command("login", deprecated=True) +@click.argument("username") +@click.pass_context +def login(ctx: Context, username: str): + """ + Alias for 'generate-token' + """ + ctx.forward(generate_token) + + +@auth.command("revoke-token") @click.argument("token") @click.pass_context -def logout(ctx: Context, token: str): +def revoke_token(ctx: Context, token: str): """ - Logout from an offline OpenID Connect session. + Revoke a bearer token used for Web API authentication. Use TOKEN to logout from an offline OpenID Connect session. The token is definitely revoked after that operation. """ ctx.obj["oidc_session"].logout(token) - print("Successfully logged out from OpenID Connect session") + print("Token successfully revoked.") + + +@auth.command("logout", deprecated=True) +@click.argument("token") +@click.pass_context +def logout(ctx: Context, token: str): + """ + Alias for 'revoke-token' + """ + ctx.forward(revoke_token) diff --git a/swh/web/client/client.py b/swh/web/client/client.py index 4a495f3..c178526 100644 --- a/swh/web/client/client.py +++ b/swh/web/client/client.py @@ -1,509 +1,540 @@ # Copyright (C) 2019-2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information """Python client for the Software Heritage Web API Light wrapper around requests for the archive API, taking care of data conversions and pagination. .. code-block:: python from swh.web.client.client import WebAPIClient cli = WebAPIClient() # retrieve any archived object via its SWHID cli.get('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # same, but for specific object types cli.revision('swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6') # get() always retrieve entire objects, following pagination # WARNING: this might *not* be what you want for large objects cli.get('swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a') # type-specific methods support explicit iteration through pages next(cli.snapshot('swh:1:snp:cabcc7d7bf639bbe1cc3b41989e1806618dd5764')) """ +from datetime import datetime from typing import Any, Callable, Dict, Iterator, List, Optional, Union from urllib.parse import urlparse import dateutil.parser import requests from swh.model.identifiers import ( CONTENT, DIRECTORY, RELEASE, REVISION, SNAPSHOT, SWHID, parse_swhid, ) SWHIDish = Union[SWHID, str] ORIGIN_VISIT = "origin_visit" def _get_swhid(swhidish: SWHIDish) -> SWHID: """Parse string to SWHID if needed""" if isinstance(swhidish, str): return parse_swhid(swhidish) else: return swhidish def typify_json(data: Any, obj_type: str) -> Any: """Type API responses using pythonic types where appropriate The following conversions are performed: - identifiers are converted from strings to SWHID instances - timestamps are converted from strings to datetime.datetime objects """ - def to_swhid(object_type, s): + def to_swhid(object_type: str, s: Any) -> SWHID: return SWHID(object_type=object_type, object_id=s) - def to_date(s): - return dateutil.parser.parse(s) + def to_date(date: str) -> datetime: + return dateutil.parser.parse(date) + + def to_optional_date(date: Optional[str]) -> Optional[datetime]: + return None if date is None else to_date(date) + + # The date attribute is optional for Revision and Release object def obj_type_of_entry_type(s): if s == "file": return CONTENT elif s == "dir": return DIRECTORY elif s == "rev": return REVISION else: raise ValueError(f"invalid directory entry type: {s}") if obj_type == SNAPSHOT: for name, target in data.items(): if target["target_type"] != "alias": # alias targets do not point to objects via SWHIDs; others do target["target"] = to_swhid(target["target_type"], target["target"]) elif obj_type == REVISION: data["id"] = to_swhid(obj_type, data["id"]) data["directory"] = to_swhid(DIRECTORY, data["directory"]) for key in ("date", "committer_date"): - data[key] = to_date(data[key]) + data[key] = to_optional_date(data[key]) for parent in data["parents"]: parent["id"] = to_swhid(REVISION, parent["id"]) elif obj_type == RELEASE: data["id"] = to_swhid(obj_type, data["id"]) - data["date"] = to_date(data["date"]) + data["date"] = to_optional_date(data["date"]) data["target"] = to_swhid(data["target_type"], data["target"]) elif obj_type == DIRECTORY: dir_swhid = None for entry in data: dir_swhid = dir_swhid or to_swhid(obj_type, entry["dir_id"]) entry["dir_id"] = dir_swhid entry["target"] = to_swhid( obj_type_of_entry_type(entry["type"]), entry["target"] ) elif obj_type == CONTENT: pass # nothing to do for contents elif obj_type == ORIGIN_VISIT: data["date"] = to_date(data["date"]) if data["snapshot"] is not None: data["snapshot"] = to_swhid(SNAPSHOT, data["snapshot"]) else: raise ValueError(f"invalid object type: {obj_type}") return data class WebAPIClient: """Client for the Software Heritage archive Web API, see https://archive.softwareheritage.org/api/ """ def __init__( self, api_url: str = "https://archive.softwareheritage.org/api/1", bearer_token: Optional[str] = None, ): """Create a client for the Software Heritage Web API See: https://archive.softwareheritage.org/api/ Args: api_url: base URL for API calls (default: "https://archive.softwareheritage.org/api/1") bearer_token: optional bearer token to do authenticated API calls """ api_url = api_url.rstrip("/") u = urlparse(api_url) self.api_url = api_url self.api_path = u.path self.bearer_token = bearer_token self._getters: Dict[str, Callable[[SWHIDish, bool], Any]] = { CONTENT: self.content, DIRECTORY: self.directory, RELEASE: self.release, REVISION: self.revision, SNAPSHOT: self._get_snapshot, } def _call( self, query: str, http_method: str = "get", **req_args ) -> requests.models.Response: """Dispatcher for archive API invocation Args: query: API method to be invoked, rooted at api_url http_method: HTTP method to be invoked, one of: 'get', 'head' req_args: extra keyword arguments for requests.get()/.head() Raises: requests.HTTPError: if HTTP request fails and http_method is 'get' """ url = None if urlparse(query).scheme: # absolute URL url = query else: # relative URL; prepend base API URL url = "/".join([self.api_url, query]) r = None headers = {} if self.bearer_token is not None: headers = {"Authorization": f"Bearer {self.bearer_token}"} if http_method == "get": r = requests.get(url, **req_args, headers=headers) r.raise_for_status() + elif http_method == "post": + r = requests.post(url, **req_args, headers=headers) + r.raise_for_status() elif http_method == "head": r = requests.head(url, **req_args, headers=headers) else: raise ValueError(f"unsupported HTTP method: {http_method}") return r def _get_snapshot(self, swhid: SWHIDish, typify: bool = True) -> Dict[str, Any]: """Analogous to self.snapshot(), but zipping through partial snapshots, merging them together before returning """ snapshot = {} for snp in self.snapshot(swhid, typify): snapshot.update(snp) return snapshot def get(self, swhid: SWHIDish, typify: bool = True, **req_args) -> Any: """Retrieve information about an object of any kind Dispatcher method over the more specific methods content(), directory(), etc. Note that this method will buffer the entire output in case of long, iterable output (e.g., for snapshot()), see the iter() method for streaming. """ swhid_ = _get_swhid(swhid) return self._getters[swhid_.object_type](swhid_, typify) def iter( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> Iterator[Dict[str, Any]]: """Stream over the information about an object of any kind Streaming variant of get() """ swhid_ = _get_swhid(swhid) obj_type = swhid_.object_type if obj_type == SNAPSHOT: yield from self.snapshot(swhid_, typify) elif obj_type == REVISION: yield from [self.revision(swhid_, typify)] elif obj_type == RELEASE: yield from [self.release(swhid_, typify)] elif obj_type == DIRECTORY: yield from self.directory(swhid_, typify) elif obj_type == CONTENT: yield from [self.content(swhid_, typify)] else: raise ValueError(f"invalid object type: {obj_type}") def content( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> Dict[str, Any]: """Retrieve information about a content object Args: swhid: object persistent identifier typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Raises: requests.HTTPError: if HTTP request fails """ json = self._call( f"content/sha1_git:{_get_swhid(swhid).object_id}/", **req_args ).json() return typify_json(json, CONTENT) if typify else json def directory( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> List[Dict[str, Any]]: """Retrieve information about a directory object Args: swhid: object persistent identifier typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Raises: requests.HTTPError: if HTTP request fails """ json = self._call( f"directory/{_get_swhid(swhid).object_id}/", **req_args ).json() return typify_json(json, DIRECTORY) if typify else json def revision( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> Dict[str, Any]: """Retrieve information about a revision object Args: swhid: object persistent identifier typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Raises: requests.HTTPError: if HTTP request fails """ json = self._call(f"revision/{_get_swhid(swhid).object_id}/", **req_args).json() return typify_json(json, REVISION) if typify else json def release( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> Dict[str, Any]: """Retrieve information about a release object Args: swhid: object persistent identifier typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Raises: requests.HTTPError: if HTTP request fails """ json = self._call(f"release/{_get_swhid(swhid).object_id}/", **req_args).json() return typify_json(json, RELEASE) if typify else json def snapshot( self, swhid: SWHIDish, typify: bool = True, **req_args ) -> Iterator[Dict[str, Any]]: """Retrieve information about a snapshot object Args: swhid: object persistent identifier typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Returns: an iterator over partial snapshots (dictionaries mapping branch names to information about where they point to), each containing a subset of available branches Raises: requests.HTTPError: if HTTP request fails """ done = False r = None query = f"snapshot/{_get_swhid(swhid).object_id}/" while not done: r = self._call(query, http_method="get", **req_args) json = r.json()["branches"] yield typify_json(json, SNAPSHOT) if typify else json if "next" in r.links and "url" in r.links["next"]: query = r.links["next"]["url"] else: done = True def visits( self, origin: str, per_page: Optional[int] = None, last_visit: Optional[int] = None, typify: bool = True, **req_args, ) -> Iterator[Dict[str, Any]]: """List visits of an origin Args: origin: the URL of a software origin per_page: the number of visits to list last_visit: visit to start listing from typify: if True, convert return value to pythonic types wherever possible, otherwise return raw JSON types (default: True) req_args: extra keyword arguments for requests.get() Returns: an iterator over visits of the origin Raises: requests.HTTPError: if HTTP request fails """ done = False r = None params = [] if last_visit is not None: params.append(("last_visit", last_visit)) if per_page is not None: params.append(("per_page", per_page)) query = f"origin/{origin}/visits/" while not done: r = self._call(query, http_method="get", params=params, **req_args) yield from [typify_json(v, ORIGIN_VISIT) if typify else v for v in r.json()] if "next" in r.links and "url" in r.links["next"]: params = [] query = r.links["next"]["url"] else: done = True + def known( + self, swhids: Iterator[SWHIDish], **req_args + ) -> Dict[SWHID, Dict[Any, Any]]: + """Verify the presence in the archive of several objects at once + + Args: + swhids: SWHIDs of the objects to verify + + Returns: + a dictionary mapping object SWHIDs to archive information about them; the + dictionary includes a "known" key associated to a boolean value that is true + if and only if the object is known to the archive + + Raises: + requests.HTTPError: if HTTP request fails + + """ + r = self._call( + "known/", http_method="post", json=list(map(str, swhids)), **req_args + ) + return {parse_swhid(k): v for k, v in r.json().items()} + def content_exists(self, swhid: SWHIDish, **req_args) -> bool: """Check if a content object exists in the archive Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.head() Raises: requests.HTTPError: if HTTP request fails """ return bool( self._call( f"content/sha1_git:{_get_swhid(swhid).object_id}/", http_method="head", **req_args, ) ) def directory_exists(self, swhid: SWHIDish, **req_args) -> bool: """Check if a directory object exists in the archive Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.head() Raises: requests.HTTPError: if HTTP request fails """ return bool( self._call( f"directory/{_get_swhid(swhid).object_id}/", http_method="head", **req_args, ) ) def revision_exists(self, swhid: SWHIDish, **req_args) -> bool: """Check if a revision object exists in the archive Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.head() Raises: requests.HTTPError: if HTTP request fails """ return bool( self._call( f"revision/{_get_swhid(swhid).object_id}/", http_method="head", **req_args, ) ) def release_exists(self, swhid: SWHIDish, **req_args) -> bool: """Check if a release object exists in the archive Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.head() Raises: requests.HTTPError: if HTTP request fails """ return bool( self._call( f"release/{_get_swhid(swhid).object_id}/", http_method="head", **req_args, ) ) def snapshot_exists(self, swhid: SWHIDish, **req_args) -> bool: """Check if a snapshot object exists in the archive Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.head() Raises: requests.HTTPError: if HTTP request fails """ return bool( self._call( f"snapshot/{_get_swhid(swhid).object_id}/", http_method="head", **req_args, ) ) def content_raw(self, swhid: SWHIDish, **req_args) -> Iterator[bytes]: """Iterate over the raw content of a content object Args: swhid: object persistent identifier req_args: extra keyword arguments for requests.get() Raises: requests.HTTPError: if HTTP request fails """ r = self._call( f"content/sha1_git:{_get_swhid(swhid).object_id}/raw/", stream=True, **req_args, ) r.raise_for_status() yield from r.iter_content(chunk_size=None, decode_unicode=False) diff --git a/swh/web/client/tests/conftest.py b/swh/web/client/tests/conftest.py index 073bfb5..4c8e831 100644 --- a/swh/web/client/tests/conftest.py +++ b/swh/web/client/tests/conftest.py @@ -1,38 +1,51 @@ # Copyright (C) 2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import pytest from swh.web.client.client import WebAPIClient from .api_data import API_DATA, API_URL @pytest.fixture def web_api_mock(requests_mock): # monkey patch URLs that require a special response headers for api_call, data in API_DATA.items(): headers = {} if api_call == "snapshot/cabcc7d7bf639bbe1cc3b41989e1806618dd5764/": # to make the client init and follow pagination headers = { "Link": f'<{API_URL}/{api_call}?branches_count=1000&branches_from=refs/tags/v3.0-rc7>; rel="next"' # NoQA: E501 } elif ( api_call == "origin/https://github.com/NixOS/nixpkgs/visits/?last_visit=50&per_page=10" # NoQA: E501 ): # to make the client follow pagination headers = { "Link": f'<{API_URL}/origin/https://github.com/NixOS/nixpkgs/visits/?last_visit=40&per_page=10>; rel="next"' # NoQA: E501 } requests_mock.get(f"{API_URL}/{api_call}", text=data, headers=headers) + + def known_callback(request, context): + known_swhids = [ + "swh:1:cnt:fe95a46679d128ff167b7c55df5d02356c5a1ae1", + "swh:1:dir:977fc4b98c0e85816348cebd3b12026407c368b6", + "swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6", + "swh:1:rel:208f61cc7a5dbc9879ae6e5c2f95891e270f09ef", + "swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a", + ] + return {swhid: {"known": swhid in known_swhids} for swhid in request.json()} + + requests_mock.register_uri("POST", f"{API_URL}/known/", json=known_callback) + return requests_mock @pytest.fixture def web_api_client(): # use the fake base API URL that matches API data return WebAPIClient(api_url=API_URL) diff --git a/swh/web/client/tests/test_cli.py b/swh/web/client/tests/test_cli.py index f76af36..9021cb0 100644 --- a/swh/web/client/tests/test_cli.py +++ b/swh/web/client/tests/test_cli.py @@ -1,50 +1,54 @@ # Copyright (C) 2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information from click.testing import CliRunner from swh.web.client.cli import auth runner = CliRunner() oidc_profile = { "access_token": "some-access-token", "expires_in": 600, "refresh_expires_in": 0, "refresh_token": "some-refresh-token", "token_type": "bearer", "session_state": "some-state", "scope": "openid email profile offline_access", } -def test_auth_login(mocker): +def test_auth_generate_token(mocker): mock_getpass = mocker.patch("getpass.getpass") mock_getpass.return_value = "password" mock_oidc_session = mocker.patch("swh.web.client.auth.OpenIDConnectSession") mock_login = mock_oidc_session.return_value.login mock_login.return_value = oidc_profile - result = runner.invoke(auth, ["login", "username"], input="password\n") - assert result.exit_code == 0 - assert result.output[:-1] == oidc_profile["refresh_token"] + for command in ("generate-token", "login"): + mock_login.side_effect = None + result = runner.invoke(auth, [command, "username"], input="password\n") + assert result.exit_code == 0 + assert oidc_profile["refresh_token"] in result.output - mock_login.side_effect = Exception("Auth error") + mock_login.side_effect = Exception("Auth error") - result = runner.invoke(auth, ["login", "username"], input="password\n") - assert result.exit_code == 1 + result = runner.invoke(auth, [command, "username"], input="password\n") + assert result.exit_code == 1 -def test_auth_logout(mocker): +def test_auth_revoke_token(mocker): mock_oidc_session = mocker.patch("swh.web.client.auth.OpenIDConnectSession") mock_logout = mock_oidc_session.return_value.logout - result = runner.invoke(auth, ["logout", oidc_profile["refresh_token"]]) - assert result.exit_code == 0 + for command in ("revoke-token", "logout"): + mock_logout.side_effect = None + result = runner.invoke(auth, [command, oidc_profile["refresh_token"]]) + assert result.exit_code == 0 - mock_logout.side_effect = Exception("Auth error") - result = runner.invoke(auth, ["logout", oidc_profile["refresh_token"]]) - assert result.exit_code == 1 + mock_logout.side_effect = Exception("Auth error") + result = runner.invoke(auth, [command, oidc_profile["refresh_token"]]) + assert result.exit_code == 1 diff --git a/swh/web/client/tests/test_web_api_client.py b/swh/web/client/tests/test_web_api_client.py index 79842df..020b780 100644 --- a/swh/web/client/tests/test_web_api_client.py +++ b/swh/web/client/tests/test_web_api_client.py @@ -1,174 +1,208 @@ # Copyright (C) 2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import json from dateutil.parser import parse as parse_date -from swh.model.identifiers import parse_swhid +from swh.model.identifiers import REVISION, parse_swhid +from swh.web.client.client import typify_json from .api_data import API_DATA def test_get_content(web_api_client, web_api_mock): swhid = parse_swhid("swh:1:cnt:fe95a46679d128ff167b7c55df5d02356c5a1ae1") obj = web_api_client.get(swhid) assert obj["length"] == 151810 for key in ("length", "status", "checksums", "data_url"): assert key in obj assert obj["checksums"]["sha1_git"] == str(swhid).split(":")[3] assert obj["checksums"]["sha1"] == "dc2830a9e72f23c1dfebef4413003221baa5fb62" assert obj == web_api_client.content(swhid) def test_get_directory(web_api_client, web_api_mock): swhid = parse_swhid("swh:1:dir:977fc4b98c0e85816348cebd3b12026407c368b6") obj = web_api_client.get(swhid) assert len(obj) == 35 # number of directory entries assert all(map(lambda entry: entry["dir_id"] == swhid, obj)) dir_entry = obj[0] assert dir_entry["type"] == "file" assert dir_entry["target"] == parse_swhid( "swh:1:cnt:58471109208922c9ee8c4b06135725f03ed16814" ) assert dir_entry["name"] == ".bzrignore" assert dir_entry["length"] == 582 assert obj == web_api_client.directory(swhid) def test_get_release(web_api_client, web_api_mock): swhid = parse_swhid("swh:1:rel:b9db10d00835e9a43e2eebef2db1d04d4ae82342") obj = web_api_client.get(swhid) assert obj["id"] == swhid assert obj["author"]["fullname"] == "Paul Tagliamonte " assert obj["author"]["name"] == "Paul Tagliamonte" assert obj["date"] == parse_date("2013-07-06T19:34:11-04:00") assert obj["name"] == "0.9.9" assert obj["target_type"] == "revision" assert obj["target"] == parse_swhid( "swh:1:rev:e005cb773c769436709ca6a1d625dc784dbc1636" ) assert not obj["synthetic"] assert obj == web_api_client.release(swhid) def test_get_revision(web_api_client, web_api_mock): swhid = parse_swhid("swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6") obj = web_api_client.get(swhid) assert obj["id"] == swhid for role in ("author", "committer"): assert ( obj[role]["fullname"] == "Nicolas Dandrimont " ) assert obj[role]["name"] == "Nicolas Dandrimont" timestamp = parse_date("2014-08-18T18:18:25+02:00") assert obj["date"] == timestamp assert obj["committer_date"] == timestamp assert obj["message"].startswith("Merge branch") assert obj["merge"] assert len(obj["parents"]) == 2 assert obj["parents"][0]["id"] == parse_swhid( "swh:1:rev:26307d261279861c2d9c9eca3bb38519f951bea4" ) assert obj["parents"][1]["id"] == parse_swhid( "swh:1:rev:37fc9e08d0c4b71807a4f1ecb06112e78d91c283" ) assert obj == web_api_client.revision(swhid) def test_get_snapshot(web_api_client, web_api_mock): # small snapshot, the one from Web API doc swhid = parse_swhid("swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a") obj = web_api_client.get(swhid) assert len(obj) == 4 assert obj["refs/heads/master"]["target_type"] == "revision" assert obj["refs/heads/master"]["target"] == parse_swhid( "swh:1:rev:83c20a6a63a7ebc1a549d367bc07a61b926cecf3" ) assert obj["refs/tags/dpkt-1.7"]["target_type"] == "revision" assert obj["refs/tags/dpkt-1.7"]["target"] == parse_swhid( "swh:1:rev:0c9dbfbc0974ec8ac1d8253aa1092366a03633a8" ) def test_iter_snapshot(web_api_client, web_api_mock): # large snapshot from the Linux kernel, usually spanning two pages swhid = parse_swhid("swh:1:snp:cabcc7d7bf639bbe1cc3b41989e1806618dd5764") obj = web_api_client.snapshot(swhid) snp = {} for partial in obj: snp.update(partial) assert len(snp) == 1391 def test_authentication(web_api_client, web_api_mock): rel_id = "b9db10d00835e9a43e2eebef2db1d04d4ae82342" url = f"{web_api_client.api_url}/release/{rel_id}/" refresh_token = "user-refresh-token" web_api_client.bearer_token = refresh_token swhid = parse_swhid(f"swh:1:rel:{rel_id}") web_api_client.get(swhid) sent_request = web_api_mock._adapter.last_request assert sent_request.url == url assert "Authorization" in sent_request.headers assert sent_request.headers["Authorization"] == f"Bearer {refresh_token}" def test_get_visits(web_api_client, web_api_mock): obj = web_api_client.visits( "https://github.com/NixOS/nixpkgs", last_visit=50, per_page=10 ) visits = [v for v in obj] assert len(visits) == 20 timestamp = parse_date("2018-07-31 04:34:23.298931+00:00") assert visits[0]["date"] == timestamp assert visits[0]["snapshot"] is None snapshot_swhid = "swh:1:snp:456550ea74af4e2eecaa406629efaaf0b9b5f976" assert visits[7]["snapshot"] == parse_swhid(snapshot_swhid) +def test_known(web_api_client, web_api_mock): + # full list of SWHIDs for which we mock a {known: True} answer + known_swhids = [ + "swh:1:cnt:fe95a46679d128ff167b7c55df5d02356c5a1ae1", + "swh:1:dir:977fc4b98c0e85816348cebd3b12026407c368b6", + "swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6", + "swh:1:rel:208f61cc7a5dbc9879ae6e5c2f95891e270f09ef", + "swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a", + ] + bogus_swhids = [s[:20] + "c0ffee" + s[26:] for s in known_swhids] + all_swhids = known_swhids + bogus_swhids + + known_res = web_api_client.known(all_swhids) + + assert {str(k) for k in known_res} == set(all_swhids) + for swhid, info in known_res.items(): + assert info["known"] == (str(swhid) in known_swhids) + + def test_get_json(web_api_client, web_api_mock): swhids = [ "swh:1:cnt:fe95a46679d128ff167b7c55df5d02356c5a1ae1", "swh:1:dir:977fc4b98c0e85816348cebd3b12026407c368b6", "swh:1:rel:b9db10d00835e9a43e2eebef2db1d04d4ae82342", "swh:1:rev:aafb16d69fd30ff58afdd69036a26047f3aebdc6", "swh:1:snp:6a3a2cf0b2b90ce7ae1cf0a221ed68035b686f5a", ] for swhid in swhids: actual = web_api_client.get(swhid, typify=False) expected = None # Fetch raw JSON data from the generated API_DATA for url, data in API_DATA.items(): object_id = swhid[len("swh:1:XXX:") :] if object_id in url: expected = json.loads(data) # Special case: snapshots response differs slightly from the Web API if swhid.startswith("swh:1:snp:"): expected = expected["branches"] break assert actual == expected + + +def test_typify_json_minimal_revision(): + revision_data = { + "id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "directory": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "date": None, + "committer_date": None, + "parents": [], + } + revision_typed = typify_json(revision_data, REVISION) + pid = "swh:1:rev:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + assert revision_typed["id"] == parse_swhid(pid) + assert revision_typed["date"] is None