def test_api_vault_cook_uppercase_hash(api_client, directory, revision):
for obj_type, obj_id in (
("directory", directory),
("revision_gitfast", revision),
):
url = reverse(
f"api-1-vault-cook-{obj_type}-uppercase-checksum",
url_args={f"{obj_type[:3]}_id": obj_id.upper()},
)
rv = check_http_post_response(api_client,
url,
data={"email": "*****@*****.**"},
status_code=302)
redirect_url = reverse(f"api-1-vault-cook-{obj_type}",
url_args={f"{obj_type[:3]}_id": obj_id})
assert rv["location"] == redirect_url
fetch_url = reverse(
f"api-1-vault-fetch-{obj_type}-uppercase-checksum",
url_args={f"{obj_type[:3]}_id": obj_id.upper()},
)
rv = check_http_get_response(api_client, fetch_url, status_code=302)
redirect_url = reverse(
f"api-1-vault-fetch-{obj_type}",
url_args={f"{obj_type[:3]}_id": obj_id},
)
assert rv["location"] == redirect_url
def test_enrich_snapshot(api_request_factory, archive_data, snapshot):
snapshot_data = archive_data.snapshot_get(snapshot)
url = reverse("api-1-snapshot", url_args={"snapshot_id": snapshot})
request = api_request_factory.get(url)
actual_snapshot = utils.enrich_snapshot(snapshot_data, request)
for _, b in snapshot_data["branches"].items():
if b["target_type"] in ("directory", "revision", "release"):
b["target_url"] = reverse(
f'api-1-{b["target_type"]}',
url_args={"sha1_git": b["target"]},
request=request,
)
elif b["target_type"] == "content":
b["target_url"] = reverse(
"api-1-content",
url_args={"q": f'sha1_git:{b["target"]}'},
request=request,
)
for _, b in snapshot_data["branches"].items():
if b["target_type"] == "alias":
target = resolve_branch_alias(snapshot_data, b)
b["target_url"] = target["target_url"]
assert actual_snapshot == snapshot_data
def get_revision_log_url(revision_id, snapshot_context=None):
"""
Utility function for getting the URL for a revision log HTML view
(possibly in the context of an origin).
Args:
revision_id (str): revision identifier the history heads to
snapshot_context (dict): if provided, generate snapshot-dependent
browsing link
Returns:
The revision log view URL
"""
query_params = {}
if snapshot_context:
query_params = _snapshot_context_query_params(snapshot_context)
query_params["revision"] = revision_id
if snapshot_context and snapshot_context["origin_info"]:
revision_log_url = reverse("browse-origin-log", query_params=query_params)
elif snapshot_context:
url_args = {"snapshot_id": snapshot_context["snapshot_id"]}
del query_params["snapshot"]
revision_log_url = reverse(
"browse-snapshot-log", url_args=url_args, query_params=query_params
)
else:
revision_log_url = reverse(
"browse-revision-log", url_args={"sha1_git": revision_id}
)
return revision_log_url
def test_api_lookup_origin_visit(self, new_origin, visit_dates,
new_snapshots):
origin_id = self.storage.origin_add_one(new_origin)
new_origin['id'] = origin_id
for i, visit_date in enumerate(visit_dates):
origin_visit = self.storage.origin_visit_add(origin_id, visit_date)
visit_id = origin_visit['visit']
self.storage.snapshot_add(origin_id, origin_visit['visit'],
new_snapshots[i])
url = reverse('api-origin-visit',
url_args={'origin_id': origin_id,
'visit_id': visit_id})
rv = self.client.get(url)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv['Content-Type'], 'application/json')
expected_visit = self.origin_visit_get_by(origin_id, visit_id)
origin_url = reverse('api-origin',
url_args={'origin_id': origin_id})
snapshot_url = reverse(
'api-snapshot',
url_args={'snapshot_id': expected_visit['snapshot']})
expected_visit['origin_url'] = origin_url
expected_visit['snapshot_url'] = snapshot_url
self.assertEqual(rv.data, expected_visit)
def test_enrich_content_with_hashes(api_request_factory, content):
for algo in DEFAULT_ALGORITHMS:
content_data = dict(content)
query_string = "%s:%s" % (algo, content_data[algo])
url = reverse("api-1-content", url_args={"q": query_string})
request = api_request_factory.get(url)
enriched_content = utils.enrich_content(content_data,
query_string=query_string,
request=request)
content_data["data_url"] = reverse("api-1-content-raw",
url_args={"q": query_string},
request=request)
content_data["filetype_url"] = reverse("api-1-content-filetype",
url_args={"q": query_string},
request=request)
content_data["language_url"] = reverse("api-1-content-language",
url_args={"q": query_string},
request=request)
content_data["license_url"] = reverse("api-1-content-license",
url_args={"q": query_string},
request=request)
assert enriched_content == content_data
def test_content_raw_text(client, archive_data, content):
url = reverse("browse-content-raw",
url_args={"query_string": content["sha1"]})
resp = check_http_get_response(client,
url,
status_code=200,
content_type="text/plain")
content_data = archive_data.content_get_data(content["sha1"])["data"]
assert resp["Content-Type"] == "text/plain"
assert resp["Content-disposition"] == ("filename=%s_%s" %
("sha1", content["sha1"]))
assert resp.content == content_data
filename = content["path"].split("/")[-1]
url = reverse(
"browse-content-raw",
url_args={"query_string": content["sha1"]},
query_params={"filename": filename},
)
resp = check_http_get_response(client,
url,
status_code=200,
content_type="text/plain")
assert resp["Content-Type"] == "text/plain"
assert resp["Content-disposition"] == "filename=%s" % filename
assert resp.content == content_data
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_revision_request_errors(client, revision, unknown_revision,
new_origin):
url = reverse("browse-revision", url_args={"sha1_git": unknown_revision})
resp = check_html_get_response(client,
url,
status_code=404,
template_used="error.html")
assert_contains(resp,
"Revision with sha1_git %s not found" % unknown_revision,
status_code=404)
url = reverse(
"browse-revision",
url_args={"sha1_git": revision},
query_params={"origin_url": new_origin.url},
)
resp = check_html_get_response(client,
url,
status_code=404,
template_used="error.html")
assert_contains(resp, "the origin mentioned in your request"
" appears broken",
status_code=404)
def test_api_revision_log(self, revision):
per_page = 10
url = reverse('api-revision-log',
url_args={'sha1_git': revision},
query_params={'per_page': per_page})
rv = self.client.get(url)
expected_log = self.revision_log(revision, limit=per_page + 1)
expected_log = list(map(self._enrich_revision, expected_log))
has_next = len(expected_log) > per_page
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv['Content-Type'], 'application/json')
self.assertEqual(rv.data,
expected_log[:-1] if has_next else expected_log)
if has_next:
self.assertIn('Link', rv)
next_log_url = reverse(
'api-revision-log',
url_args={'sha1_git': expected_log[-1]['id']},
query_params={'per_page': per_page})
self.assertIn(next_log_url, rv['Link'])
def enrich_directory_entry(
directory: Dict[str, str], request: Optional[HttpRequest] = None
) -> Dict[str, str]:
"""Enrich directory entry with url to target.
Args:
directory: dict of data associated to a swh directory entry
request: Absolute URIs will be generated if provided
Returns:
An enriched directory dict filled with additional url
"""
if "type" in directory:
target_type = directory["type"]
target = directory["target"]
if target_type == "file":
directory["target_url"] = reverse(
"api-1-content", url_args={"q": "sha1_git:%s" % target}, request=request
)
elif target_type == "dir":
directory["target_url"] = reverse(
"api-1-directory", url_args={"sha1_git": target}, request=request
)
else:
directory["target_url"] = reverse(
"api-1-revision", url_args={"sha1_git": target}, request=request
)
return directory
def test_api_origin_search_visit_type(api_client, mocker, backend):
if backend != "swh-search":
# equivalent to not configuring search in the config
mocker.patch("swh.web.common.archive.search", None)
expected_origins = {
"https://github.com/wcoder/highlightjs-line-numbers.js",
"https://github.com/memononen/libtess2",
}
url = reverse(
"api-1-origin-search",
url_args={
"url_pattern": "github com",
},
query_params={"visit_type": "git"},
)
rv = check_api_get_responses(api_client, url, status_code=200)
assert {origin["url"] for origin in rv.data} == expected_origins
url = reverse(
"api-1-origin-search",
url_args={
"url_pattern": "github com",
},
query_params={"visit_type": "foo"},
)
rv = check_api_get_responses(api_client, url, status_code=200)
assert rv.data == []
def _get_branch_url(target_type, target):
url = None
if target_type == 'revision':
url = reverse('api-revision', url_args={'sha1_git': target})
if target_type == 'release':
url = reverse('api-release', url_args={'sha1_git': target})
return url
def test_origin_visits_browse(self, origin):
url = reverse('browse-origin-visits',
url_args={'origin_type': origin['type'],
'origin_url': origin['url']})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed('origin-visits.html')
url = reverse('browse-origin-visits',
url_args={'origin_url': origin['url']})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed('origin-visits.html')
visits = self.origin_visit_get(origin['id'])
for v in visits:
vdate = format_utc_iso_date(v['date'], '%Y-%m-%dT%H:%M:%SZ')
browse_dir_url = reverse('browse-origin-directory',
url_args={'origin_url': origin['url'],
'timestamp': vdate})
self.assertContains(resp, browse_dir_url)
def test_api_content_uppercase(api_client, content):
url = reverse("api-1-content-uppercase-checksum",
url_args={"q": content["sha1"].upper()})
rv = check_http_get_response(api_client, url, status_code=302)
redirect_url = reverse("api-1-content", url_args={"q": content["sha1"]})
assert rv["location"] == redirect_url
def test_release_id_browse(self, release):
swh_id = swh_id_prefix + 'rel:' + release
url = reverse('browse-swh-id',
url_args={'swh_id': swh_id})
release_browse_url = reverse('browse-release',
url_args={'sha1_git': release})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp['location'], release_browse_url)
query_params = {'origin_type': 'git',
'origin': 'https://github.com/user/repo'}
url = reverse('browse-swh-id',
url_args={'swh_id': swh_id},
query_params=query_params)
release_browse_url = reverse('browse-release',
url_args={'sha1_git': release},
query_params=query_params)
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp['location'], release_browse_url)
def test_api_revision_log_by(self, origin):
per_page = 10
url = reverse('api-revision-origin-log',
url_args={'origin_id': origin['id']},
query_params={'per_page': per_page})
rv = self.client.get(url)
snapshot = self.snapshot_get_latest(origin['id'])
expected_log = self.revision_log(
snapshot['branches']['HEAD']['target'], limit=per_page + 1)
expected_log = list(map(self._enrich_revision, expected_log))
has_next = len(expected_log) > per_page
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv['Content-Type'], 'application/json')
self.assertEqual(rv.data,
expected_log[:-1] if has_next else expected_log)
if has_next:
self.assertIn('Link', rv)
next_log_url = reverse('api-revision-origin-log',
url_args={
'origin_id': origin['id'],
'branch_name': 'HEAD'
},
query_params={
'per_page': per_page,
'sha1_git': expected_log[-1]['id']
})
self.assertIn(next_log_url, rv['Link'])
def test_badge_endpoints_have_cors_header(client, origin, release):
url = reverse("swh-badge",
url_args={
"object_type": "origin",
"object_id": origin["url"]
})
resp = check_http_get_response(
client,
url,
status_code=200,
content_type="image/svg+xml",
http_origin="https://example.org",
)
assert ACCESS_CONTROL_ALLOW_ORIGIN in resp
release_swhid = str(
QualifiedSWHID(object_type=ObjectType.RELEASE,
object_id=hash_to_bytes(release)))
url = reverse("swh-badge-swhid", url_args={"object_swhid": release_swhid})
resp = check_http_get_response(
client,
url,
status_code=200,
content_type="image/svg+xml",
http_origin="https://example.org",
)
assert ACCESS_CONTROL_ALLOW_ORIGIN in resp
def test_content_raw_text(self, content):
url = reverse('browse-content-raw',
url_args={'query_string': content['sha1']})
resp = self.client.get(url)
content_data = self.content_get(content['sha1'])['data']
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['Content-Type'], 'text/plain')
self.assertEqual(resp['Content-disposition'],
'filename=%s_%s' % ('sha1', content['sha1']))
self.assertEqual(resp.content, content_data)
filename = content['path'].split('/')[-1]
url = reverse(
'browse-content-raw',
url_args={'query_string': content['sha1']}, # noqa
query_params={'filename': filename})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['Content-Type'], 'text/plain')
self.assertEqual(resp['Content-disposition'], 'filename=%s' % filename)
self.assertEqual(resp.content, content_data)
def test_content_raw_bin(client, archive_data, content):
url = reverse("browse-content-raw",
url_args={"query_string": content["sha1"]})
resp = check_http_get_response(client,
url,
status_code=200,
content_type="application/octet-stream")
filename = content["path"].split("/")[-1]
content_data = archive_data.content_get_data(content["sha1"])["data"]
assert resp["Content-Type"] == "application/octet-stream"
assert resp["Content-disposition"] == "attachment; filename=%s_%s" % (
"sha1",
content["sha1"],
)
assert resp.content == content_data
url = reverse(
"browse-content-raw",
url_args={"query_string": content["sha1"]},
query_params={"filename": filename},
)
resp = check_http_get_response(client,
url,
status_code=200,
content_type="application/octet-stream")
assert resp["Content-Type"] == "application/octet-stream"
assert resp["Content-disposition"] == "attachment; filename=%s" % filename
assert resp.content == content_data
def test_content_raw_bin(self, content):
url = reverse('browse-content-raw',
url_args={'query_string': content['sha1']})
resp = self.client.get(url)
filename = content['path'].split('/')[-1]
content_data = self.content_get(content['sha1'])['data']
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['Content-Type'], 'application/octet-stream')
self.assertEqual(
resp['Content-disposition'],
'attachment; filename=%s_%s' % ('sha1', content['sha1']))
self.assertEqual(resp.content, content_data)
url = reverse('browse-content-raw',
url_args={'query_string': content['sha1']},
query_params={'filename': filename})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp['Content-Type'], 'application/octet-stream')
self.assertEqual(resp['Content-disposition'],
'attachment; filename=%s' % filename)
self.assertEqual(resp.content, content_data)
def _check_origin_snapshot_related_html(resp, origin, snapshot, snapshot_sizes,
branches, releases):
browse_origin_url = reverse("browse-origin",
query_params={"origin_url": origin["url"]})
assert_contains(resp, f'href="{browse_origin_url}"')
origin_branches_url = reverse(
"browse-origin-branches",
query_params={
"origin_url": origin["url"],
"snapshot": snapshot["id"]
},
)
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={
"origin_url": origin["url"],
"snapshot": snapshot["id"]
},
)
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(branches))
assert_contains(resp, '<li class="swh-release">', count=len(releases))
def test_content_view_text(self, 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 = self.client.get(url)
content_display = self._process_content_for_display(content)
mimetype = content_display['mimetype']
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed('browse/content.html')
if mimetype.startswith('text/'):
self.assertContains(
resp, '<code class="%s">' % content_display['language'])
self.assertContains(resp, escape(content_display['content_data']))
self.assertContains(resp, url_raw)
swh_cnt_id = get_swh_persistent_id('content', sha1_git)
swh_cnt_id_url = reverse('browse-swh-id',
url_args={'swh_id': swh_cnt_id})
self.assertContains(resp, swh_cnt_id)
self.assertContains(resp, swh_cnt_id_url)
def test_enrich_directory_entry_with_type(api_request_factory, archive_data,
directory):
dir_content = archive_data.directory_ls(directory)
dir_entry = random.choice(dir_content)
url = reverse("api-1-directory", url_args={"sha1_git": directory})
request = api_request_factory.get(url)
actual_directory = utils.enrich_directory_entry(dir_entry, request)
if dir_entry["type"] == "file":
dir_entry["target_url"] = reverse(
"api-1-content",
url_args={"q": f'sha1_git:{dir_entry["target"]}'},
request=request,
)
elif dir_entry["type"] == "dir":
dir_entry["target_url"] = reverse(
"api-1-directory",
url_args={"sha1_git": dir_entry["target"]},
request=request,
)
elif dir_entry["type"] == "rev":
dir_entry["target_url"] = reverse(
"api-1-revision",
url_args={"sha1_git": dir_entry["target"]},
request=request,
)
assert actual_directory == dir_entry
def test_content_view_text_no_highlight(self, content):
sha1_git = content['sha1_git']
url = reverse('browse-content',
url_args={'query_string': content['sha1']})
url_raw = reverse('browse-content-raw',
url_args={'query_string': content['sha1']})
resp = self.client.get(url)
content_display = self._process_content_for_display(content)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed('browse/content.html')
self.assertContains(resp, '<code class="nohighlight">')
self.assertContains(resp,
escape(content_display['content_data'])) # noqa
self.assertContains(resp, url_raw)
swh_cnt_id = get_swh_persistent_id('content', sha1_git)
swh_cnt_id_url = reverse('browse-swh-id',
url_args={'swh_id': swh_cnt_id})
self.assertContains(resp, swh_cnt_id)
self.assertContains(resp, swh_cnt_id_url)
def test_enrich_revision_without_children_or_parent(api_request_factory,
archive_data, revision):
revision_data = archive_data.revision_get(revision)
del revision_data["parents"]
url = reverse("api-1-revision", url_args={"sha1_git": revision})
request = api_request_factory.get(url)
actual_revision = utils.enrich_revision(revision_data, request)
revision_data["url"] = reverse("api-1-revision",
url_args={"sha1_git": revision},
request=request)
revision_data["history_url"] = reverse("api-1-revision-log",
url_args={"sha1_git": revision},
request=request)
revision_data["directory_url"] = reverse(
"api-1-directory",
url_args={"sha1_git": revision_data["directory"]},
request=request,
)
assert actual_revision == revision_data
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_enrich_origin_search_result(api_request_factory, origin):
url = reverse("api-1-origin-search",
url_args={"url_pattern": origin["url"]})
request = api_request_factory.get(url)
origin_visits_url = reverse("api-1-origin-visits",
url_args={"origin_url": origin["url"]},
request=request)
origin_search_result_data = (
[{
"url": origin["url"]
}],
None,
)
enriched_origin_search_result = (
[{
"url": origin["url"],
"origin_visits_url": origin_visits_url
}],
None,
)
assert (utils.enrich_origin_search_result(
origin_search_result_data,
request=request) == enriched_origin_search_result)
def test_snapshot_id_browse(self, snapshot):
swh_id = swh_id_prefix + 'snp:' + snapshot
url = reverse('browse-swh-id',
url_args={'swh_id': swh_id})
snapshot_browse_url = reverse('browse-snapshot',
url_args={'snapshot_id': snapshot})
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp['location'], snapshot_browse_url)
query_params = {'origin_type': 'git',
'origin': 'https://github.com/user/repo'}
url = reverse('browse-swh-id',
url_args={'swh_id': swh_id},
query_params=query_params)
release_browse_url = reverse('browse-snapshot',
url_args={'snapshot_id': snapshot},
query_params=query_params)
resp = self.client.get(url)
self.assertEqual(resp.status_code, 302)
self.assertEqual(resp['location'], release_browse_url)
def get_readme_to_display(readmes):
"""
Process a list of readme files found in a directory
in order to find the adequate one to display.
Args:
readmes: a list of dict where keys are readme file names and values
are readme sha1s
Returns:
A tuple (readme_name, readme_sha1)
"""
readme_name = None
readme_url = None
readme_sha1 = None
readme_html = None
lc_readmes = {k.lower(): {"orig_name": k, "sha1": v} for k, v in readmes.items()}
# look for readme names according to the preference order
# defined by the _common_readme_names list
for common_readme_name in _common_readme_names:
if common_readme_name in lc_readmes:
readme_name = lc_readmes[common_readme_name]["orig_name"]
readme_sha1 = lc_readmes[common_readme_name]["sha1"]
readme_url = reverse(
"browse-content-raw",
url_args={"query_string": readme_sha1},
query_params={"re_encode": "true"},
)
break
# otherwise pick the first readme like file if any
if not readme_name and len(readmes.items()) > 0:
readme_name = next(iter(readmes))
readme_sha1 = readmes[readme_name]
readme_url = reverse(
"browse-content-raw",
url_args={"query_string": readme_sha1},
query_params={"re_encode": "true"},
)
# convert rst README to html server side as there is
# no viable solution to perform that task client side
if readme_name and readme_name.endswith(".rst"):
cache_entry_id = "readme_%s" % readme_sha1
cache_entry = cache.get(cache_entry_id)
if cache_entry:
readme_html = cache_entry
else:
try:
rst_doc = request_content(readme_sha1)
readme_html = rst_to_html(rst_doc["raw_data"])
cache.set(cache_entry_id, readme_html)
except Exception as exc:
sentry_sdk.capture_exception(exc)
readme_html = "Readme bytes are not available"
return readme_name, readme_url, readme_html
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
