def test_get_self_error(foss_server: str, foss: Fossology):
if versiontuple(foss.version) >= versiontuple("1.2.3"):
responses.add(
responses.GET, f"{foss_server}/api/v1/users/self", status=500,
)
with pytest.raises(FossologyApiError):
foss.get_self()
def test_move_upload_nogroup(foss: Fossology, upload: Upload,
move_folder: Folder):
with pytest.raises(AuthorizationError) as excinfo:
foss.move_upload(upload, move_folder, group="test")
assert (
f"Moving upload {upload.id} for group test in folder {move_folder.id} not authorized"
in str(excinfo.value))
def test_delete_unknown_upload_unknown_group(foss: Fossology):
if versiontuple(foss.version) > versiontuple("1.0.16"):
upload = Upload(
foss.rootFolder,
"Root Folder",
secrets.randbelow(1000),
"",
"Non Upload",
"2020-05-05",
hash={
"sha1": None,
"md5": None,
"sha256": None,
"size": None
},
)
else:
upload = Upload(
foss.rootFolder,
"Root Folder",
secrets.randbelow(1000),
"",
"Non Upload",
"2020-05-05",
filesize="1024",
filesha1="597d209fd962f401866f12db9fa1f7301aee15a9",
)
with pytest.raises(FossologyApiError):
foss.delete_upload(upload)
with pytest.raises(AuthorizationError) as excinfo:
foss.delete_upload(upload, group="test")
assert f"Deleting upload {upload.id} for group test not authorized" in str(
excinfo.value)
def test_filesearch(foss: Fossology, scanned_upload: Upload):
if versiontuple(foss.version) > versiontuple("1.0.16"):
filelist = [
{
"md5": "F921793D03CC6D63EC4B15E9BE8FD3F8"
},
{
"sha1": scanned_upload.hash.sha1
},
]
search_result = foss.filesearch(filelist=filelist)
assert len(search_result) == 2
assert (
f"File with SHA1 {scanned_upload.hash.sha1} doesn't have any concluded license yet"
in str(search_result[1]))
filelist = [{"sha1": "FAKE"}]
result = foss.filesearch(filelist=filelist)
assert result == "Unable to get a result with the given filesearch criteria"
assert foss.filesearch() == []
else:
with pytest.raises(FossologyUnsupported) as excinfo:
foss.filesearch(filelist=[], group="test")
assert (
"Endpoint /filesearch is not supported by your Fossology API version"
in str(excinfo.value))
def test_move_copy_arbitrary_folder(foss: Fossology, upload: Upload):
non_folder = Folder(secrets.randbelow(1000), "Non folder", "",
foss.rootFolder)
with pytest.raises(AuthorizationError):
foss.move_upload(upload, non_folder)
with pytest.raises(AuthorizationError):
foss.copy_upload(upload, non_folder)
def test_paginated_list_jobs(foss: Fossology, scanned_upload: Upload):
# Versions prior to 1.3.2 return corrupt number of pages
if versiontuple(foss.version) > versiontuple("1.3.1"):
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
page=1)
assert len(jobs) == 1
assert total_pages == 2
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
page=2)
assert len(jobs) == 1
assert total_pages == 2
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=2,
page=1)
assert len(jobs) == 2
assert total_pages == 1
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
all_pages=True)
assert len(jobs) == 2
assert total_pages == 2
def test_schedule_job_error(foss_server: str, foss: Fossology, upload: Upload):
responses.add(responses.POST, f"{foss_server}/api/v1/jobs", status=404)
with pytest.raises(FossologyApiError) as excinfo:
foss.schedule_jobs(foss.rootFolder, upload, {})
assert f"Scheduling jobs for upload {upload.uploadname} failed" in str(
excinfo.value
)
def test_paginated_list_jobs(foss: Fossology, scanned_upload: Upload):
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
page=1)
print(jobs, total_pages)
assert len(jobs) == 1
assert total_pages == 3
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
page=2)
print(jobs, total_pages)
assert len(jobs) == 1
assert total_pages == 3
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=2,
page=1)
print(jobs, total_pages)
assert len(jobs) == 2
assert total_pages == 2
jobs, total_pages = foss.list_jobs(upload=scanned_upload,
page_size=1,
all_pages=True)
assert len(jobs) == 2
def test_create_folder_nogroup(foss: Fossology):
name = "FossPythonTest"
desc = "Created via the Fossology Python API"
with pytest.raises(AuthorizationError) as excinfo:
foss.create_folder(foss.rootFolder, name, description=desc, group="test")
assert "Folder creation for group test in folder 1 not authorized" in str(
excinfo.value
)
def test_delete_folder_error(foss_server: str, foss: Fossology):
folder = Folder(secrets.randbelow(1000), "Folder", "", foss.rootFolder)
responses.add(
responses.DELETE, f"{foss_server}/api/v1/folders/{folder.id}", status=404
)
with pytest.raises(FossologyApiError) as excinfo:
foss.delete_folder(folder)
assert f"Unable to delete folder {folder.id}" in str(excinfo.value)
def test_report_nogroup(foss: Fossology, upload: Upload):
with pytest.raises(AuthorizationError) as excinfo:
foss.generate_report(upload,
report_format=ReportFormat.SPDX2,
group="test")
assert (
f"Generating report for upload {upload.id} for group test not authorized"
in str(excinfo.value))
def test_get_upload_error(foss: Fossology, foss_server: str):
upload_id = 100
responses.add(
responses.GET, f"{foss_server}/api/v1/uploads/{upload_id}", status=500,
)
with pytest.raises(FossologyApiError) as excinfo:
foss.detail_upload(upload_id)
assert f"Error while getting details for upload {upload_id}" in str(excinfo.value)
def test_delete_user(foss_server: str, foss: Fossology):
user = Mock(name="Test User", id=secrets.randbelow(1000))
responses.add(responses.DELETE, f"{foss_server}/api/v1/users/{user.id}", status=202)
responses.add(responses.DELETE, f"{foss_server}/api/v1/users/{user.id}", status=404)
assert not foss.delete_user(user)
with pytest.raises(FossologyApiError) as excinfo:
foss.delete_user(user)
assert f"Error while deleting user {user.name} ({user.id})" in str(excinfo.value)
def test_nogroup_jobs(foss: Fossology, upload: Upload,
foss_schedule_agents: Dict):
# Create jobs for unknown group
with pytest.raises(AuthorizationError) as excinfo:
foss.schedule_jobs(foss.rootFolder,
upload,
foss_schedule_agents,
group="test")
assert "Scheduling job for group test not authorized" in str(excinfo.value)
def test_delete_folder(foss: Fossology):
folder = foss.create_folder(foss.rootFolder, "ToBeDeleted",
"Test folder deletion via API")
foss.delete_folder(folder)
time.sleep(3)
with pytest.raises(FossologyApiError) as excinfo:
foss.detail_folder(folder)
assert f"Error while getting details for folder ToBeDeleted ({folder.id})" in str(
excinfo.value)
def test_get_upload_unauthorized(foss: Fossology, upload: Upload):
with pytest.raises(AuthorizationError) as excinfo:
foss.detail_upload(
upload.id,
group="test",
)
assert (
f"Getting details for upload {upload.id} for group test not authorized"
in str(excinfo.value))
def upload(foss: Fossology, test_file_path: str) -> Upload:
test_upload = foss.upload_file(
foss.rootFolder,
file=test_file_path,
description="Test upload via fossology-python lib",
access_level=AccessLevel.PUBLIC,
)
time.sleep(3)
yield test_upload
foss.delete_upload(test_upload)
def test_create_folder_returns_200_but_folder_does_not_exists(
foss_server: str, foss: Fossology
):
responses.add(responses.POST, f"{foss_server}/api/v1/folders", status=200)
with pytest.raises(FossologyApiError) as excinfo:
foss.create_folder(foss.rootFolder, "NoFolder")
assert (
f"Folder 'NoFolder' exists but was not found under the folder {foss.rootFolder.name} ({foss.rootFolder.id})"
in str(excinfo.value)
)
def test_patch_license_error(foss_server: str, foss: fossology.Fossology,
test_license: License):
if fossology.versiontuple(foss.version) >= fossology.versiontuple("1.3.0"):
responses.add(responses.PATCH,
f"{foss_server}/api/v1/license/License-1.0",
status=500)
with pytest.raises(FossologyApiError) as excinfo:
foss.update_license(test_license.shortName)
assert f"Unable to update license {test_license.shortName}" in str(
excinfo.value)
def test_upload_error(foss: Fossology, foss_server: str, test_file_path: str):
responses.add(
responses.POST, f"{foss_server}/api/v1/uploads", status=500,
)
description = "Test upload API error"
with pytest.raises(FossologyApiError) as excinfo:
foss.upload_file(
foss.rootFolder, file=test_file_path, description=description,
)
assert f"Upload {description} could not be performed" in str(excinfo.value)
def foss(foss_server: str, foss_token: str, foss_agents: Agents) -> Fossology:
try:
foss = Fossology(foss_server, foss_token, "fossy")
except (FossologyApiError, AuthenticationError) as error:
exit(error.message)
# Configure all license agents besides 'ojo'
foss.user.agents = foss_agents
yield foss
foss.close()
def test_download_report_error(foss_server: str, foss: Fossology):
report_id = secrets.randbelow(1000)
responses.add(
responses.GET,
f"{foss_server}/api/v1/report/{report_id}",
status=500,
)
with pytest.raises(FossologyApiError) as excinfo:
foss.download_report(report_id)
assert f"Download of report {report_id} failed" in str(excinfo.value)
def test_add_license_error(foss_server: str, foss: fossology.Fossology,
test_license: License):
if fossology.versiontuple(foss.version) >= fossology.versiontuple("1.3.0"):
responses.add(responses.POST,
f"{foss_server}/api/v1/license",
status=500)
with pytest.raises(FossologyApiError) as excinfo:
foss.add_license(test_license)
assert f"Error while adding new license {test_license.shortName}" in str(
excinfo.value)
def test_detail_job_error(foss_server: str, foss: Fossology):
job_id = secrets.randbelow(1000)
responses.add(responses.GET, f"{foss_server}/api/v1/jobs/{job_id}", status=404)
responses.add(responses.GET, f"{foss_server}/api/v1/jobs/{job_id}", status=404)
with pytest.raises(FossologyApiError) as excinfo:
foss.detail_job(job_id, wait=True)
assert f"Error while getting details for job {job_id}" in str(excinfo.value)
with pytest.raises(FossologyApiError) as excinfo:
foss.detail_job(job_id)
assert f"Error while getting details for job {job_id}" in str(excinfo.value)
def test_patch_license_and_get_by_shortname(foss: fossology.Fossology,
test_another_license: License):
if fossology.versiontuple(foss.version) >= fossology.versiontuple("1.3.0"):
foss.add_license(test_another_license)
foss.update_license(test_another_license.shortName,
fullname="Inner Source license 2.0",
risk=1)
license_found = foss.detail_license(test_another_license.shortName)
assert license_found.shortName == "License-2.0"
assert license_found.fullName == "Inner Source license 2.0"
assert license_found.risk == 1
def test_filesearch_nogroup(foss: Fossology):
if versiontuple(foss.version) > versiontuple("1.0.16"):
with pytest.raises(AuthorizationError) as excinfo:
foss.filesearch(filelist=[], group="test")
assert "Searching for group test not authorized" in str(excinfo.value)
else:
with pytest.raises(FossologyUnsupported) as excinfo:
foss.filesearch(filelist=[], group="test")
assert (
"Endpoint /filesearch is not supported by your Fossology API version"
in str(excinfo.value))
def test_detail_license(foss: fossology.Fossology):
if fossology.versiontuple(foss.version) < fossology.versiontuple("1.1.3"):
with pytest.raises(FossologyUnsupported) as excinfo:
foss.detail_license(short)
assert (
"Endpoint /license is not supported by your Fossology API version"
in str(excinfo.value))
else:
license = foss.detail_license(short)
assert license
assert type(license) == License
def test_report_error(foss_server: str, foss: Fossology, upload: Upload):
responses.add(
responses.GET,
f"{foss_server}/api/v1/report",
status=503,
headers={"Retry-After": "1"},
)
responses.add(responses.GET, f"{foss_server}/api/v1/report", status=404)
with pytest.raises(FossologyApiError) as excinfo:
foss.generate_report(upload)
assert f"Report generation for upload {upload.uploadname} failed" in str(
excinfo.value)
def test_health_does_not_return_200(foss_server: str, foss: Fossology):
if versiontuple(foss.version) < versiontuple("1.3.3"):
return
responses.add(
responses.GET,
f"{foss_server}/api/v1/health",
status=503,
)
with pytest.raises(FossologyApiError) as excinfo:
foss.get_health()
assert "Error while getting health info" in str(excinfo.value)
def scanned_upload(foss: Fossology, test_file_path: str,
foss_schedule_agents: Dict) -> Upload:
test_upload = foss.upload_file(
foss.rootFolder,
file=test_file_path,
description="Test upload via fossology-python lib",
access_level=AccessLevel.PUBLIC,
)
time.sleep(3)
foss.schedule_jobs(foss.rootFolder, test_upload, foss_schedule_agents)
yield test_upload
foss.delete_upload(test_upload)
