def test_legacy_swhid_browse(archive_data, client, origin):
snapshot = archive_data.snapshot_get_latest(origin["url"])
revision = archive_data.snapshot_get_head(snapshot)
directory = archive_data.revision_get(revision)["directory"]
directory_content = archive_data.directory_ls(directory)
directory_file = random.choice(
[e for e in directory_content if e["type"] == "file"])
legacy_swhid = gen_swhid(
CONTENT,
directory_file["checksums"]["sha1_git"],
metadata={"origin": origin["url"]},
)
url = reverse("browse-swhid", url_args={"swhid": legacy_swhid})
resp = check_html_get_response(client, url, status_code=302)
resp = check_html_get_response(client,
resp["location"],
status_code=200,
template_used="browse/content.html")
swhid = gen_swhid(
CONTENT,
directory_file["checksums"]["sha1_git"],
metadata={
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(REVISION, revision),
},
)
assert_contains(resp, swhid)
def test_origin_release_browse(client, archive_data, origin):
snapshot = archive_data.snapshot_get_latest(origin["url"])
release = [
b for b in snapshot["branches"].values() if b["target_type"] == "release"
][-1]
release_data = archive_data.release_get(release["target"])
revision_data = archive_data.revision_get(release_data["target"])
url = reverse(
"browse-origin-directory",
query_params={"origin_url": origin["url"], "release": release_data["name"]},
)
resp = check_html_get_response(
client, url, status_code=200, template_used="browse/directory.html"
)
assert_contains(resp, release_data["name"])
assert_contains(resp, release["target"])
swhid_context = {
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(RELEASE, release_data["id"]),
}
swh_dir_id = gen_swhid(
DIRECTORY, revision_data["directory"], metadata=swhid_context
)
swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
assert_contains(resp, swh_dir_id)
assert_contains(resp, swh_dir_id_url)
def test_api_known_swhid_some_present(api_client, content, directory):
content_ = gen_swhid(CONTENT, content["sha1_git"])
directory_ = gen_swhid(DIRECTORY, directory)
unknown_revision_ = gen_swhid(REVISION, random_sha1())
unknown_release_ = gen_swhid(RELEASE, random_sha1())
unknown_snapshot_ = gen_swhid(SNAPSHOT, random_sha1())
input_swhids = [
content_,
directory_,
unknown_revision_,
unknown_release_,
unknown_snapshot_,
]
url = reverse("api-1-known")
resp = check_api_post_responses(api_client, url, data=input_swhids, status_code=200)
assert resp.data == {
content_: {"known": True},
directory_: {"known": True},
unknown_revision_: {"known": False},
unknown_release_: {"known": False},
unknown_snapshot_: {"known": False},
}
def test_resolve_swhid_legacy(content, directory, release, revision, snapshot):
for obj_type, obj_id in (
(CONTENT, content["sha1_git"]),
(DIRECTORY, directory),
(RELEASE, release),
(REVISION, revision),
(SNAPSHOT, snapshot),
):
swhid = gen_swhid(obj_type, obj_id)
url_args = {}
if obj_type == CONTENT:
url_args["query_string"] = f"sha1_git:{obj_id}"
elif obj_type == SNAPSHOT:
url_args["snapshot_id"] = obj_id
else:
url_args["sha1_git"] = obj_id
query_params = {"origin_url": "some-origin"}
browse_url = reverse(f"browse-{obj_type}",
url_args=url_args,
query_params=query_params)
resolved_swhid = resolve_swhid(swhid, query_params)
assert isinstance(resolved_swhid["swhid_parsed"], QualifiedSWHID)
assert str(resolved_swhid["swhid_parsed"]) == swhid
assert resolved_swhid["browse_url"] == browse_url
with pytest.raises(BadInputExc, match="'ori' is not a valid ObjectType"):
resolve_swhid(f"swh:1:ori:{random_sha1()}")
def test_content_view_text(client, archive_data, content):
sha1_git = content["sha1_git"]
url = reverse(
"browse-content",
url_args={"query_string": content["sha1"]},
query_params={"path": content["path"]},
)
url_raw = reverse("browse-content-raw",
url_args={"query_string": content["sha1"]})
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/content.html")
content_display = _process_content_for_display(archive_data, content)
mimetype = content_display["mimetype"]
if mimetype.startswith("text/"):
assert_contains(resp,
'<code class="%s">' % content_display["language"])
assert_contains(resp, escape(content_display["content_data"]))
assert_contains(resp, url_raw)
swh_cnt_id = gen_swhid(CONTENT, sha1_git)
swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
assert_contains(resp, swh_cnt_id)
assert_contains(resp, swh_cnt_id_url)
assert_not_contains(resp, "swh-metadata-popover")
def test_content_id_optional_parts_browse(client, archive_data, content):
cnt_sha1_git = content["sha1_git"]
origin_url = "https://github.com/user/repo"
archive_data.origin_add([Origin(url=origin_url)])
swhid = gen_swhid(
CONTENT,
cnt_sha1_git,
metadata={
"lines": "4-20",
"origin": origin_url
},
)
url = reverse("browse-swhid", url_args={"swhid": swhid})
query_string = "sha1_git:" + cnt_sha1_git
content_browse_url = reverse(
"browse-content",
url_args={"query_string": query_string},
query_params={"origin_url": origin_url},
)
content_browse_url += "#L4-L20"
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == content_browse_url
def test_api_known_swhid_all_present(
api_client, content, directory, release, revision, snapshot
):
input_swhids = [
gen_swhid(CONTENT, content["sha1_git"]),
gen_swhid(DIRECTORY, directory),
gen_swhid(REVISION, revision),
gen_swhid(RELEASE, release),
gen_swhid(SNAPSHOT, snapshot),
]
url = reverse("api-1-known")
resp = check_api_post_responses(api_client, url, data=input_swhids, status_code=200)
assert resp.data == {swhid: {"known": True} for swhid in input_swhids}
def test_resolve_swhid_with_malformed_origin_url(archive_data, directory):
origin_url = "http://example.org/project/abc"
malformed_origin_url = "http:/example.org/project/abc"
archive_data.origin_add([Origin(url=origin_url)])
swhid = gen_swhid(DIRECTORY,
directory,
metadata={"origin": malformed_origin_url})
resolved_swhid = resolve_swhid(swhid)
assert origin_url in resolved_swhid["browse_url"]
def test_directory_id_browse(client, directory):
swhid = gen_swhid(DIRECTORY, directory)
url = reverse("browse-swhid", url_args={"swhid": swhid})
directory_browse_url = reverse("browse-directory",
url_args={"sha1_git": directory})
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == directory_browse_url
def test_resolve_swhid_with_escaped_chars(directory):
origin = "http://example.org/?project=abc;"
origin_swhid_escaped = quote(origin, safe="/?:@&")
origin_swhid_url_escaped = quote(origin, safe="/:@;")
swhid = gen_swhid(DIRECTORY,
directory,
metadata={"origin": origin_swhid_escaped})
resolved_swhid = resolve_swhid(swhid)
assert resolved_swhid["swhid_parsed"].origin == origin_swhid_escaped
assert origin_swhid_url_escaped in resolved_swhid["browse_url"]
def test_content_id_browse(client, content):
cnt_sha1_git = content["sha1_git"]
swhid = gen_swhid(CONTENT, cnt_sha1_git)
url = reverse("browse-swhid", url_args={"swhid": swhid})
query_string = "sha1_git:" + cnt_sha1_git
content_browse_url = reverse("browse-content",
url_args={"query_string": query_string})
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == content_browse_url
def test_resolve_directory_swhid_path_without_trailing_slash(
archive_data, directory):
dir_content = archive_data.directory_ls(directory)
dir_subdirs = [e for e in dir_content if e["type"] == "dir"]
dir_subdir = random.choice(dir_subdirs)
dir_subdir_path = dir_subdir["name"]
anchor = gen_swhid(DIRECTORY, directory)
swhid = gen_swhid(
DIRECTORY,
dir_subdir["target"],
metadata={
"anchor": anchor,
"path": "/" + dir_subdir_path
},
)
resolved_swhid = resolve_swhid(swhid)
browse_url = reverse(
"browse-directory",
url_args={"sha1_git": directory},
query_params={"path": dir_subdir_path},
)
assert resolved_swhid["browse_url"] == browse_url
def test_browse_swhid_special_characters_escaping(client, archive_data,
directory):
origin = "http://example.org/?project=abc;"
archive_data.origin_add([Origin(url=origin)])
origin_swhid_escaped = quote(origin, safe="/?:@&")
origin_swhid_url_escaped = quote(origin, safe="/:@;")
swhid = gen_swhid(DIRECTORY,
directory,
metadata={"origin": origin_swhid_escaped})
url = reverse("browse-swhid", url_args={"swhid": swhid})
resp = check_html_get_response(client, url, status_code=302)
assert origin_swhid_url_escaped in resp["location"]
def test_api_endpoints_have_cors_headers(client, content, directory, revision):
url = reverse("api-1-stat-counters")
resp = check_http_get_response(client,
url,
status_code=200,
http_origin="https://example.org")
assert ACCESS_CONTROL_ALLOW_ORIGIN in resp
swhids = [
gen_swhid(CONTENT, content["sha1_git"]),
gen_swhid(DIRECTORY, directory),
gen_swhid(REVISION, revision),
]
url = reverse("api-1-known")
ac_request_method = "POST"
ac_request_headers = "Content-Type"
resp = client.options(
url,
HTTP_ORIGIN="https://example.org",
HTTP_ACCESS_CONTROL_REQUEST_METHOD=ac_request_method,
HTTP_ACCESS_CONTROL_REQUEST_HEADERS=ac_request_headers,
)
assert resp.status_code == 200
assert ACCESS_CONTROL_ALLOW_ORIGIN in resp
assert ACCESS_CONTROL_ALLOW_METHODS in resp
assert ac_request_method in resp[ACCESS_CONTROL_ALLOW_METHODS]
assert ACCESS_CONTROL_ALLOW_HEADERS in resp
assert ac_request_headers.lower() in resp[ACCESS_CONTROL_ALLOW_HEADERS]
resp = resp = check_http_post_response(client,
url,
data=swhids,
status_code=200,
http_origin="https://example.org")
assert ACCESS_CONTROL_ALLOW_ORIGIN in resp
def test_content_view_no_utf8_text(client, archive_data, content):
sha1_git = content["sha1_git"]
url = reverse("browse-content", url_args={"query_string": content["sha1"]})
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/content.html")
content_display = _process_content_for_display(archive_data, content)
swh_cnt_id = gen_swhid(CONTENT, sha1_git)
swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
assert_contains(resp, swh_cnt_id_url)
assert_contains(resp, escape(content_display["content_data"]))
def test_get_swhid(content, directory, release, revision, snapshot):
for obj_type, obj_id in (
(CONTENT, content["sha1_git"]),
(DIRECTORY, directory),
(RELEASE, release),
(REVISION, revision),
(SNAPSHOT, snapshot),
):
swhid = gen_swhid(obj_type, obj_id)
swh_parsed_swhid = get_swhid(swhid)
assert isinstance(swh_parsed_swhid, QualifiedSWHID)
assert str(swh_parsed_swhid) == swhid
with pytest.raises(BadInputExc, match="Error when parsing identifier"):
get_swhid("foo")
def test_group_swhids(content, directory, release, revision, snapshot):
swhids = []
expected = {}
for obj_type, obj_id in (
(CONTENT, content["sha1_git"]),
(DIRECTORY, directory),
(RELEASE, release),
(REVISION, revision),
(SNAPSHOT, snapshot),
):
swhid = gen_swhid(obj_type, obj_id)
swhid = get_swhid(swhid)
swhids.append(swhid)
expected[obj_type] = [hash_to_bytes(obj_id)]
swhid_groups = group_swhids(swhids)
assert swhid_groups == expected
def test_swhid_resolve_success(
api_client, client, origin, content, directory, release, revision, snapshot
):
for obj_type, obj_id in (
(CONTENT, content["sha1_git"]),
(DIRECTORY, directory),
(RELEASE, release),
(REVISION, revision),
(SNAPSHOT, snapshot),
):
swhid = gen_swhid(obj_type, obj_id, metadata={"origin": origin["url"]})
url = reverse("api-1-resolve-swhid", url_args={"swhid": swhid})
resp = check_api_get_responses(api_client, url, status_code=200)
if obj_type == CONTENT:
url_args = {"query_string": "sha1_git:%s" % obj_id}
elif obj_type == SNAPSHOT:
url_args = {"snapshot_id": obj_id}
else:
url_args = {"sha1_git": obj_id}
browse_rev_url = reverse(
"browse-%s" % obj_type,
url_args=url_args,
query_params={"origin_url": origin["url"]},
request=resp.wsgi_request,
)
expected_result = {
"browse_url": browse_rev_url,
"metadata": {"origin": origin["url"]},
"namespace": "swh",
"object_id": obj_id,
"object_type": obj_type,
"scheme_version": 1,
}
assert resp.data == expected_result
def test_revision_id_browse(client, revision):
swhid = gen_swhid(REVISION, revision)
url = reverse("browse-swhid", url_args={"swhid": swhid})
revision_browse_url = reverse("browse-revision",
url_args={"sha1_git": revision})
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == revision_browse_url
query_params = {"origin_url": "https://github.com/user/repo"}
url = reverse("browse-swhid",
url_args={"swhid": swhid},
query_params=query_params)
revision_browse_url = reverse("browse-revision",
url_args={"sha1_git": revision},
query_params=query_params)
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == revision_browse_url
def test_get_swhids_info_revision_context(archive_data, revision):
revision_data = archive_data.revision_get(revision)
directory = revision_data["directory"]
dir_content = archive_data.directory_ls(directory)
dir_entry = random.choice(dir_content)
swh_objects = [
SWHObjectInfo(object_type=REVISION, object_id=revision),
SWHObjectInfo(object_type=DIRECTORY, object_id=directory),
]
extra_context = {"revision": revision, "path": "/"}
if dir_entry["type"] == "file":
swh_objects.append(
SWHObjectInfo(object_type=CONTENT,
object_id=dir_entry["checksums"]["sha1_git"]))
extra_context["filename"] = dir_entry["name"]
swhids = get_swhids_info(
swh_objects,
snapshot_context=None,
extra_context=extra_context,
)
assert swhids[0]["context"] == {}
swhid_dir_parsed = get_swhid(swhids[1]["swhid_with_context"])
anchor = gen_swhid(REVISION, revision)
assert swhid_dir_parsed.qualifiers() == {
"anchor": anchor,
}
if dir_entry["type"] == "file":
swhid_cnt_parsed = get_swhid(swhids[2]["swhid_with_context"])
assert swhid_cnt_parsed.qualifiers() == {
"anchor": anchor,
"path": f'/{dir_entry["name"]}',
}
def test_swhid_resolve_not_found(
api_client,
unknown_content,
unknown_directory,
unknown_release,
unknown_revision,
unknown_snapshot,
):
for obj_type, obj_id in (
(CONTENT, unknown_content["sha1_git"]),
(DIRECTORY, unknown_directory),
(RELEASE, unknown_release),
(REVISION, unknown_revision),
(SNAPSHOT, unknown_snapshot),
):
swhid = gen_swhid(obj_type, obj_id)
url = reverse("api-1-resolve-swhid", url_args={"swhid": swhid})
check_api_get_responses(api_client, url, status_code=404)
def test_snapshot_id_browse(client, snapshot):
swhid = gen_swhid(SNAPSHOT, snapshot)
url = reverse("browse-swhid", url_args={"swhid": swhid})
snapshot_browse_url = reverse("browse-snapshot",
url_args={"snapshot_id": snapshot})
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == snapshot_browse_url
query_params = {"origin_url": "https://github.com/user/repo"}
url = reverse("browse-swhid",
url_args={"swhid": swhid},
query_params=query_params)
release_browse_url = reverse("browse-snapshot",
url_args={"snapshot_id": snapshot},
query_params=query_params)
resp = check_html_get_response(client, url, status_code=302)
assert resp["location"] == release_browse_url
def test_gen_swhid(content):
swh_object_type = CONTENT
sha1_git = content["sha1_git"]
expected_swhid = "swh:1:cnt:" + sha1_git
assert gen_swhid(swh_object_type, sha1_git) == expected_swhid
assert (gen_swhid(swh_object_type, sha1_git,
metadata={"origin":
"test"}) == expected_swhid + ";origin=test")
assert (gen_swhid(swh_object_type, sha1_git,
metadata={"origin": None}) == expected_swhid)
with pytest.raises(BadInputExc) as e:
gen_swhid("foo", sha1_git)
assert e.match("Invalid object")
with pytest.raises(BadInputExc) as e:
gen_swhid(swh_object_type, "not a valid id")
assert e.match("Invalid object")
def test_get_snapshot_context_no_origin(archive_data, snapshot):
for browse_context, kwargs in (
("content", {
"snapshot_id": snapshot,
"path": "/some/path"
}),
("directory", {
"snapshot_id": snapshot
}),
("log", {
"snapshot_id": snapshot
}),
):
url_args = {"snapshot_id": snapshot}
query_params = dict(kwargs)
query_params.pop("snapshot_id")
snapshot_context = get_snapshot_context(**kwargs,
browse_context=browse_context)
branches, releases, _ = get_snapshot_content(snapshot)
releases = list(reversed(releases))
revision_id = None
root_directory = None
for branch in branches:
if branch["name"] == "HEAD":
revision_id = branch["revision"]
root_directory = branch["directory"]
branch["url"] = reverse(
f"browse-snapshot-{browse_context}",
url_args=url_args,
query_params={
"branch": branch["name"],
**query_params
},
)
for release in releases:
release["url"] = reverse(
f"browse-snapshot-{browse_context}",
url_args=url_args,
query_params={
"release": release["name"],
**query_params
},
)
branches_url = reverse("browse-snapshot-branches", url_args=url_args)
releases_url = reverse("browse-snapshot-releases", url_args=url_args)
is_empty = not branches and not releases
snapshot_swhid = gen_swhid("snapshot", snapshot)
snapshot_sizes = archive_data.snapshot_count_branches(snapshot)
expected = SnapshotContext(
branch="HEAD",
branch_alias=True,
branches=branches,
branches_url=branches_url,
is_empty=is_empty,
origin_info=None,
origin_visits_url=None,
release=None,
release_alias=False,
release_id=None,
query_params=query_params,
releases=releases,
releases_url=releases_url,
revision_id=revision_id,
revision_info=_get_revision_info(archive_data, revision_id),
root_directory=root_directory,
snapshot_id=snapshot,
snapshot_sizes=snapshot_sizes,
snapshot_swhid=snapshot_swhid,
url_args=url_args,
visit_info=None,
)
if revision_id:
expected["revision_info"]["revision_url"] = gen_revision_url(
revision_id, snapshot_context)
assert snapshot_context == expected
_check_branch_release_revision_parameters(archive_data, expected,
browse_context, kwargs,
branches, releases)
def test_get_snapshot_context_with_origin(archive_data, origin):
origin_visits = get_origin_visits(origin)
timestamp = format_utc_iso_date(origin_visits[0]["date"],
"%Y-%m-%dT%H:%M:%SZ")
visit_id = origin_visits[1]["visit"]
for browse_context, kwargs in (
("content", {
"origin_url": origin["url"],
"path": "/some/path"
}),
("directory", {
"origin_url": origin["url"]
}),
("log", {
"origin_url": origin["url"]
}),
(
"directory",
{
"origin_url": origin["url"],
"timestamp": timestamp,
},
),
(
"directory",
{
"origin_url": origin["url"],
"visit_id": visit_id,
},
),
):
visit_id = kwargs["visit_id"] if "visit_id" in kwargs else None
visit_ts = kwargs["timestamp"] if "timestamp" in kwargs else None
visit_info = get_origin_visit({"url": kwargs["origin_url"]},
visit_ts=visit_ts,
visit_id=visit_id)
snapshot = visit_info["snapshot"]
snapshot_context = get_snapshot_context(**kwargs,
browse_context=browse_context)
query_params = dict(kwargs)
branches, releases, _ = get_snapshot_content(snapshot)
releases = list(reversed(releases))
revision_id = None
root_directory = None
for branch in branches:
if branch["name"] == "HEAD":
revision_id = branch["revision"]
root_directory = branch["directory"]
branch["url"] = reverse(
f"browse-origin-{browse_context}",
query_params={
"branch": branch["name"],
**query_params
},
)
for release in releases:
release["url"] = reverse(
f"browse-origin-{browse_context}",
query_params={
"release": release["name"],
**query_params
},
)
query_params.pop("path", None)
branches_url = reverse("browse-origin-branches",
query_params=query_params)
releases_url = reverse("browse-origin-releases",
query_params=query_params)
origin_visits_url = reverse(
"browse-origin-visits",
query_params={"origin_url": kwargs["origin_url"]})
is_empty = not branches and not releases
snapshot_swhid = gen_swhid("snapshot", snapshot)
snapshot_sizes = archive_data.snapshot_count_branches(snapshot)
visit_info["url"] = reverse("browse-origin-directory",
query_params=query_params)
visit_info["formatted_date"] = format_utc_iso_date(visit_info["date"])
if "path" in kwargs:
query_params["path"] = kwargs["path"]
expected = SnapshotContext(
branch="HEAD",
branch_alias=True,
branches=branches,
branches_url=branches_url,
is_empty=is_empty,
origin_info={"url": origin["url"]},
origin_visits_url=origin_visits_url,
release=None,
release_alias=False,
release_id=None,
query_params=query_params,
releases=releases,
releases_url=releases_url,
revision_id=revision_id,
revision_info=_get_revision_info(archive_data, revision_id),
root_directory=root_directory,
snapshot_id=snapshot,
snapshot_sizes=snapshot_sizes,
snapshot_swhid=snapshot_swhid,
url_args={},
visit_info=visit_info,
)
if revision_id:
expected["revision_info"]["revision_url"] = gen_revision_url(
revision_id, snapshot_context)
assert snapshot_context == expected
_check_branch_release_revision_parameters(archive_data, expected,
browse_context, kwargs,
branches, releases)
def _revision_browse_checks(client,
archive_data,
revision,
origin_url=None,
snapshot=None):
query_params = {}
if origin_url:
query_params["origin_url"] = origin_url
if snapshot:
query_params["snapshot"] = snapshot["id"]
url = reverse("browse-revision",
url_args={"sha1_git": revision},
query_params=query_params)
revision_data = archive_data.revision_get(revision)
author_name = revision_data["author"]["name"]
committer_name = revision_data["committer"]["name"]
dir_id = revision_data["directory"]
if origin_url:
snapshot = archive_data.snapshot_get_latest(origin_url)
history_url = reverse(
"browse-origin-log",
query_params={
"revision": revision,
**query_params
},
)
elif snapshot:
history_url = reverse(
"browse-snapshot-log",
url_args={"snapshot_id": snapshot["id"]},
query_params={"revision": revision},
)
else:
history_url = reverse("browse-revision-log",
url_args={"sha1_git": revision})
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/revision.html")
assert_contains(resp, author_name)
assert_contains(resp, committer_name)
assert_contains(resp, history_url)
for parent in revision_data["parents"]:
parent_url = reverse("browse-revision",
url_args={"sha1_git": parent},
query_params=query_params)
assert_contains(
resp, '<a href="%s">%s</a>' % (escape(parent_url), parent[:7]))
author_date = revision_data["date"]
committer_date = revision_data["committer_date"]
message_lines = revision_data["message"].split("\n")
assert_contains(resp, format_utc_iso_date(author_date))
assert_contains(resp, format_utc_iso_date(committer_date))
assert_contains(resp, escape(message_lines[0]))
assert_contains(resp, escape("\n".join(message_lines[1:])))
assert_contains(resp, "vault-cook-directory")
assert_contains(resp, "vault-cook-revision")
swh_rev_id = gen_swhid("revision", revision)
swh_rev_id_url = reverse("browse-swhid", url_args={"swhid": swh_rev_id})
assert_contains(resp, swh_rev_id)
assert_contains(resp, swh_rev_id_url)
swh_dir_id = gen_swhid("directory", dir_id)
swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
assert_contains(resp, swh_dir_id)
assert_contains(resp, swh_dir_id_url)
if origin_url:
assert_contains(resp, "swh-take-new-snapshot")
swh_rev_id = gen_swhid(REVISION, revision)
swh_rev_id_url = reverse("browse-swhid", url_args={"swhid": swh_rev_id})
if origin_url:
browse_origin_url = reverse("browse-origin",
query_params={"origin_url": origin_url})
assert_contains(resp, f'href="{browse_origin_url}"')
elif snapshot:
swh_snp_id = gen_swhid("snapshot", snapshot["id"])
swh_snp_id_url = reverse("browse-swhid",
url_args={"swhid": swh_snp_id})
assert_contains(resp, f'href="{swh_snp_id_url}"')
swhid_context = {}
if origin_url:
swhid_context["origin"] = origin_url
if snapshot:
swhid_context["visit"] = gen_swhid(SNAPSHOT, snapshot["id"])
swh_rev_id = gen_swhid(REVISION, revision, metadata=swhid_context)
swh_rev_id_url = reverse("browse-swhid", url_args={"swhid": swh_rev_id})
assert_contains(resp, swh_rev_id)
assert_contains(resp, swh_rev_id_url)
swhid_context["anchor"] = gen_swhid(REVISION, revision)
swh_dir_id = gen_swhid(DIRECTORY, dir_id, metadata=swhid_context)
swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
assert_contains(resp, swh_dir_id)
assert_contains(resp, swh_dir_id_url)
def test_content_origin_snapshot_release_browse(client, archive_data, origin):
visits = archive_data.origin_visit_get(origin["url"])
visit = random.choice(visits)
snapshot = archive_data.snapshot_get(visit["snapshot"])
snapshot_sizes = archive_data.snapshot_count_branches(visit["snapshot"])
branches, releases, _ = process_snapshot_branches(snapshot)
release_info = random.choice(releases)
directory_content = archive_data.directory_ls(release_info["directory"])
directory_file = random.choice(
[e for e in directory_content if e["type"] == "file"])
url = reverse(
"browse-content",
url_args={"query_string": directory_file["checksums"]["sha1"]},
query_params={
"origin_url": origin["url"],
"snapshot": snapshot["id"],
"release": release_info["name"],
"path": directory_file["name"],
},
)
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/content.html")
_check_origin_snapshot_related_html(resp, origin, snapshot, snapshot_sizes,
branches, releases)
assert_contains(resp, directory_file["name"])
assert_contains(resp, f"Release: <strong>{release_info['name']}</strong>")
cnt_swhid = gen_swhid(
CONTENT,
directory_file["checksums"]["sha1_git"],
metadata={
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(RELEASE, release_info["id"]),
"path": f"/{directory_file['name']}",
},
)
assert_contains(resp, cnt_swhid)
dir_swhid = gen_swhid(
DIRECTORY,
release_info["directory"],
metadata={
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(RELEASE, release_info["id"]),
},
)
assert_contains(resp, dir_swhid)
rev_swhid = gen_swhid(
REVISION,
release_info["target"],
metadata={
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
},
)
assert_contains(resp, rev_swhid)
rel_swhid = gen_swhid(
RELEASE,
release_info["id"],
metadata={
"origin": origin["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
},
)
assert_contains(resp, rel_swhid)
snp_swhid = gen_swhid(
SNAPSHOT,
snapshot["id"],
metadata={
"origin": origin["url"],
},
)
assert_contains(resp, snp_swhid)
def test_content_view_text_with_path(client, archive_data, content):
path = content["path"]
url = reverse(
"browse-content",
url_args={"query_string": content["sha1"]},
query_params={"path": path},
)
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/content.html")
assert_contains(resp, '<nav class="bread-crumbs')
content_display = _process_content_for_display(archive_data, content)
mimetype = content_display["mimetype"]
if mimetype.startswith("text/"):
hljs_language = content["hljs_language"]
assert_contains(resp, '<code class="%s">' % hljs_language)
assert_contains(resp, escape(content_display["content_data"]))
split_path = path.split("/")
root_dir_sha1 = split_path[0]
filename = split_path[-1]
path = path.replace(root_dir_sha1 + "/", "").replace(filename, "")
swhid_context = {
"anchor": gen_swhid(DIRECTORY, root_dir_sha1),
"path": f"/{path}{filename}",
}
swh_cnt_id = gen_swhid(CONTENT,
content["sha1_git"],
metadata=swhid_context)
swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
assert_contains(resp, swh_cnt_id)
assert_contains(resp, swh_cnt_id_url)
path_info = gen_path_info(path)
root_dir_url = reverse("browse-directory",
url_args={"sha1_git": root_dir_sha1})
assert_contains(resp, '<li class="swh-path">', count=len(path_info) + 1)
assert_contains(
resp, '<a href="' + root_dir_url + '">' + root_dir_sha1[:7] + "</a>")
for p in path_info:
dir_url = reverse(
"browse-directory",
url_args={"sha1_git": root_dir_sha1},
query_params={"path": p["path"]},
)
assert_contains(resp,
'<a href="' + dir_url + '">' + p["name"] + "</a>")
assert_contains(resp, "<li>" + filename + "</li>")
url_raw = reverse(
"browse-content-raw",
url_args={"query_string": content["sha1"]},
query_params={"filename": filename},
)
assert_contains(resp, url_raw)
url = reverse(
"browse-content",
url_args={"query_string": content["sha1"]},
query_params={"path": filename},
)
resp = check_html_get_response(client,
url,
status_code=200,
template_used="browse/content.html")
assert_not_contains(resp, '<nav class="bread-crumbs')
invalid_path = "%s/foo/bar/baz" % root_dir_sha1
url = reverse(
"browse-content",
url_args={"query_string": content["sha1"]},
query_params={"path": invalid_path},
)
resp = check_html_get_response(client,
url,
status_code=404,
template_used="error.html")
def _origin_directory_view_test_helper(
client,
archive_data,
origin_info,
origin_visit,
snapshot_sizes,
origin_branches,
origin_releases,
root_directory_sha1,
directory_entries,
visit_id=None,
timestamp=None,
snapshot_id=None,
path=None,
):
dirs = [e for e in directory_entries if e["type"] in ("dir", "rev")]
files = [e for e in directory_entries if e["type"] == "file"]
if not visit_id and not snapshot_id:
visit_id = origin_visit["visit"]
query_params = {"origin_url": origin_info["url"]}
if timestamp:
query_params["timestamp"] = timestamp
elif visit_id:
query_params["visit_id"] = visit_id
else:
query_params["snapshot"] = snapshot_id
if path:
query_params["path"] = path
url = reverse("browse-origin-directory", query_params=query_params)
resp = check_html_get_response(
client, url, status_code=200, template_used="browse/directory.html"
)
assert_contains(resp, '<td class="swh-directory">', count=len(dirs))
assert_contains(resp, '<td class="swh-content">', count=len(files))
if timestamp:
query_params["timestamp"] = format_utc_iso_date(
parse_iso8601_date_to_utc(timestamp).isoformat(), "%Y-%m-%dT%H:%M:%SZ"
)
for d in dirs:
if d["type"] == "rev":
dir_url = reverse("browse-revision", url_args={"sha1_git": d["target"]})
else:
dir_path = d["name"]
if path:
dir_path = "%s/%s" % (path, d["name"])
query_params["path"] = dir_path
dir_url = reverse("browse-origin-directory", query_params=query_params,)
assert_contains(resp, dir_url)
for f in files:
file_path = f["name"]
if path:
file_path = "%s/%s" % (path, f["name"])
query_params["path"] = file_path
file_url = reverse("browse-origin-content", query_params=query_params)
assert_contains(resp, file_url)
if "path" in query_params:
del query_params["path"]
root_dir_branch_url = reverse("browse-origin-directory", query_params=query_params)
nb_bc_paths = 1
if path:
nb_bc_paths = len(path.split("/")) + 1
assert_contains(resp, '<li class="swh-path">', count=nb_bc_paths)
assert_contains(
resp, '<a href="%s">%s</a>' % (root_dir_branch_url, root_directory_sha1[:7])
)
origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
assert_contains(resp, f'href="{escape(origin_branches_url)}"')
assert_contains(resp, f"Branches ({snapshot_sizes['revision']})")
origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
nb_releases = len(origin_releases)
if nb_releases > 0:
assert_contains(resp, f'href="{escape(origin_releases_url)}"')
assert_contains(resp, f"Releases ({snapshot_sizes['release']})")
if path:
query_params["path"] = path
assert_contains(resp, '<li class="swh-branch">', count=len(origin_branches))
for branch in origin_branches:
query_params["branch"] = branch["name"]
root_dir_branch_url = reverse(
"browse-origin-directory", query_params=query_params
)
assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
assert_contains(resp, '<li class="swh-release">', count=len(origin_releases))
query_params["branch"] = None
for release in origin_releases:
query_params["release"] = release["name"]
root_dir_release_url = reverse(
"browse-origin-directory", query_params=query_params
)
assert_contains(resp, 'href="%s"' % root_dir_release_url)
assert_contains(resp, "vault-cook-directory")
assert_contains(resp, "vault-cook-revision")
snapshot = archive_data.snapshot_get(origin_visit["snapshot"])
head_rev_id = archive_data.snapshot_get_head(snapshot)
swhid_context = {
"origin": origin_info["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(REVISION, head_rev_id),
"path": f"/{path}" if path else None,
}
swh_dir_id = gen_swhid(
DIRECTORY, directory_entries[0]["dir_id"], metadata=swhid_context
)
swh_dir_id_url = reverse("browse-swhid", url_args={"swhid": swh_dir_id})
assert_contains(resp, swh_dir_id)
assert_contains(resp, swh_dir_id_url)
assert_contains(resp, "swh-take-new-snapshot")
_check_origin_link(resp, origin_info["url"])
assert_not_contains(resp, "swh-metadata-popover")
def _origin_content_view_test_helper(
client,
archive_data,
origin_info,
origin_visit,
snapshot_sizes,
origin_branches,
origin_releases,
root_dir_sha1,
content,
visit_id=None,
timestamp=None,
snapshot_id=None,
):
content_path = "/".join(content["path"].split("/")[1:])
if not visit_id and not snapshot_id:
visit_id = origin_visit["visit"]
query_params = {"origin_url": origin_info["url"], "path": content_path}
if timestamp:
query_params["timestamp"] = timestamp
if visit_id:
query_params["visit_id"] = visit_id
elif snapshot_id:
query_params["snapshot"] = snapshot_id
url = reverse("browse-origin-content", query_params=query_params)
resp = check_html_get_response(
client, url, status_code=200, template_used="browse/content.html"
)
assert type(content["data"]) == str
assert_contains(resp, '<code class="%s">' % content["hljs_language"])
assert_contains(resp, escape(content["data"]))
split_path = content_path.split("/")
filename = split_path[-1]
path = content_path.replace(filename, "")[:-1]
path_info = gen_path_info(path)
del query_params["path"]
if timestamp:
query_params["timestamp"] = format_utc_iso_date(
parse_iso8601_date_to_utc(timestamp).isoformat(), "%Y-%m-%dT%H:%M:%SZ"
)
root_dir_url = reverse("browse-origin-directory", query_params=query_params)
assert_contains(resp, '<li class="swh-path">', count=len(path_info) + 1)
assert_contains(resp, '<a href="%s">%s</a>' % (root_dir_url, root_dir_sha1[:7]))
for p in path_info:
query_params["path"] = p["path"]
dir_url = reverse("browse-origin-directory", query_params=query_params)
assert_contains(resp, '<a href="%s">%s</a>' % (dir_url, p["name"]))
assert_contains(resp, "<li>%s</li>" % filename)
query_string = "sha1_git:" + content["sha1_git"]
url_raw = reverse(
"browse-content-raw",
url_args={"query_string": query_string},
query_params={"filename": filename},
)
assert_contains(resp, url_raw)
if "path" in query_params:
del query_params["path"]
origin_branches_url = reverse("browse-origin-branches", query_params=query_params)
assert_contains(resp, f'href="{escape(origin_branches_url)}"')
assert_contains(resp, f"Branches ({snapshot_sizes['revision']})")
origin_releases_url = reverse("browse-origin-releases", query_params=query_params)
assert_contains(resp, f'href="{escape(origin_releases_url)}">')
assert_contains(resp, f"Releases ({snapshot_sizes['release']})")
assert_contains(resp, '<li class="swh-branch">', count=len(origin_branches))
query_params["path"] = content_path
for branch in origin_branches:
root_dir_branch_url = reverse(
"browse-origin-content",
query_params={"branch": branch["name"], **query_params},
)
assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
assert_contains(resp, '<li class="swh-release">', count=len(origin_releases))
query_params["branch"] = None
for release in origin_releases:
root_dir_release_url = reverse(
"browse-origin-content",
query_params={"release": release["name"], **query_params},
)
assert_contains(resp, '<a href="%s">' % root_dir_release_url)
url = reverse("browse-origin-content", query_params=query_params)
resp = check_html_get_response(
client, url, status_code=200, template_used="browse/content.html"
)
snapshot = archive_data.snapshot_get(origin_visit["snapshot"])
head_rev_id = archive_data.snapshot_get_head(snapshot)
swhid_context = {
"origin": origin_info["url"],
"visit": gen_swhid(SNAPSHOT, snapshot["id"]),
"anchor": gen_swhid(REVISION, head_rev_id),
"path": f"/{content_path}",
}
swh_cnt_id = gen_swhid(CONTENT, content["sha1_git"], metadata=swhid_context)
swh_cnt_id_url = reverse("browse-swhid", url_args={"swhid": swh_cnt_id})
assert_contains(resp, swh_cnt_id)
assert_contains(resp, swh_cnt_id_url)
assert_contains(resp, "swh-take-new-snapshot")
_check_origin_link(resp, origin_info["url"])
assert_not_contains(resp, "swh-metadata-popover")
