def test_list_versions_tools(monkeypatch, spec_regex, os_name, target, in_file,
expect_out_file):
_html = (Path(__file__).parent / "data" / in_file).read_text("utf-8")
monkeypatch.setattr(MetadataFactory, "fetch_http",
lambda *args, **kwargs: _html)
expected = json.loads(
(Path(__file__).parent / "data" / expect_out_file).read_text("utf-8"))
# Test 'aqt list-tool'
tools = MetadataFactory(ArchiveId("tools", os_name, target)).getList()
assert tools == expected["tools"]
for ext, expected_output in expected["qt"].items():
# Test 'aqt list-qt'
archive_id = ArchiveId("qt", os_name, target,
ext if ext != "qt" else "")
all_versions = MetadataFactory(archive_id).getList()
if len(expected_output) == 0:
assert not all_versions
else:
assert f"{all_versions}" == "\n".join(expected_output)
# Filter for the latest version only
latest_ver = MetadataFactory(archive_id,
is_latest_version=True).getList()
if len(expected_output) == 0:
assert not latest_ver
else:
assert f"{latest_ver}" == expected_output[-1].split(" ")[-1]
for row in expected_output:
spec_str = spec_regex.search(row).group(1)
spec = SimpleSpec(spec_str) if not ext.endswith(
"preview") else SimpleSpec(spec_str + ".0-preview")
# Find the latest version for a particular spec
latest_ver_for_spec = MetadataFactory(
archive_id,
spec=spec,
is_latest_version=True,
).getList()
assert f"{latest_ver_for_spec}" == row.split(" ")[-1]
# Find all versions for a particular spec
all_ver_for_spec = MetadataFactory(
archive_id,
spec=spec,
).getList()
assert f"{all_ver_for_spec}" == row
def test_list_to_version(monkeypatch, archive_id, spec, version_str, expect):
_html = (Path(__file__).parent / "data" /
"mac-desktop.html").read_text("utf-8")
monkeypatch.setattr(MetadataFactory, "fetch_http", lambda self, _: _html)
if isinstance(expect, Exception):
with pytest.raises(CliInputError) as error:
MetadataFactory(archive_id, spec=spec)._to_version(version_str)
assert error.type == CliInputError
assert str(expect) == str(error.value)
else:
assert MetadataFactory(archive_id,
spec=spec)._to_version(version_str) == expect
def test_list_archives(monkeypatch, capsys, version: str, arch: str,
modules_to_query: List[str],
modules_failed_query: List[str]):
archive_id = ArchiveId("qt", "windows", "desktop")
in_file = f"{archive_id.host}-{version.replace('.', '')}-update.xml"
expect_out_file = f"{archive_id.host}-{version.replace('.', '')}-expect.json"
_xml = (Path(__file__).parent / "data" / in_file).read_text("utf-8")
monkeypatch.setattr(MetadataFactory, "fetch_http", lambda self, _: _xml)
expect = json.loads(
(Path(__file__).parent / "data" / expect_out_file).read_text("utf-8"))
if not modules_to_query:
expected_qt_archives = expect["qt_base_pkgs_by_arch"][arch][
"DownloadableArchives"]
expected = set([arc.split("-")[0] for arc in expected_qt_archives])
else:
expected_mod_metadata = expect["modules_metadata_by_arch"][arch]
if "all" not in modules_to_query:
expected_mod_metadata = filter(
lambda mod: mod["Name"].split(".")[-2] in modules_to_query,
expected_mod_metadata)
expected = set([
arc.split("-")[0] for mod in expected_mod_metadata
for arc in mod["DownloadableArchives"]
])
archives_query = [version, arch, *modules_to_query]
cli_args = ["list-qt", "windows", "desktop", "--archives", *archives_query]
if not modules_failed_query:
meta = set(
MetadataFactory(archive_id,
archives_query=archives_query).getList())
assert meta == expected
cli = Cli()
assert 0 == cli.run(cli_args)
out, err = capsys.readouterr()
assert out.rstrip() == " ".join(sorted(expected))
return
expected_err_msg = f"The requested modules were not located: {sorted(modules_failed_query)}"
with pytest.raises(CliInputError) as err:
MetadataFactory(archive_id, archives_query=archives_query).getList()
assert err.type == CliInputError
assert format(err.value).startswith(expected_err_msg)
cli = Cli()
assert 1 == cli.run(cli_args)
out, err = capsys.readouterr()
assert expected_err_msg in err
def test_fetch_http_download_error(monkeypatch):
urls_requested = set()
def _mock(url, **kwargs):
urls_requested.add(url)
raise ArchiveDownloadError()
monkeypatch.setattr("aqt.metadata.getUrl", _mock)
with pytest.raises(ArchiveDownloadError) as e:
MetadataFactory.fetch_http("some_url")
assert e.type == ArchiveDownloadError
# Require that a fallback url was tried
assert len(urls_requested) == 2
def test_list_choose_tool_by_version(simple_spec, expected_name):
tools_data = {
"mytool.999": {
"Version": "9.9.9",
"Name": "mytool.999"
},
"mytool.355": {
"Version": "3.5.5",
"Name": "mytool.355"
},
"mytool.350": {
"Version": "3.5.0",
"Name": "mytool.350"
},
"mytool.300": {
"Version": "3.0.0",
"Name": "mytool.300"
},
}
item = MetadataFactory.choose_highest_version_in_spec(
tools_data, simple_spec)
if item is not None:
assert item["Name"] == expected_name
else:
assert expected_name is None
def test_tool_modules(monkeypatch, host: str, target: str, tool_name: str):
archive_id = ArchiveId("tools", host, target)
in_file = "{}-{}-{}-update.xml".format(host, target, tool_name)
expect_out_file = "{}-{}-{}-expect.json".format(host, target, tool_name)
_xml = (Path(__file__).parent / "data" / in_file).read_text("utf-8")
expect = json.loads(
(Path(__file__).parent / "data" / expect_out_file).read_text("utf-8"))
monkeypatch.setattr(MetadataFactory, "fetch_http", lambda self, _: _xml)
modules = MetadataFactory(archive_id, tool_name=tool_name).getList()
assert modules == expect["modules"]
table = MetadataFactory(archive_id,
tool_name=tool_name,
is_long_listing=True).getList()
assert table._rows() == expect["long_listing"]
def test_list_architectures_and_modules(monkeypatch, version: str,
extension: str, in_file: str,
expect_out_file: str):
archive_id = ArchiveId("qt", "windows", "desktop", extension)
_xml = (Path(__file__).parent / "data" / in_file).read_text("utf-8")
expect = json.loads(
(Path(__file__).parent / "data" / expect_out_file).read_text("utf-8"))
monkeypatch.setattr(MetadataFactory, "fetch_http", lambda self, _: _xml)
for arch in expect["architectures"]:
modules = MetadataFactory(archive_id).fetch_modules(
Version(version), arch)
assert modules == sorted(expect["modules_by_arch"][arch])
arches = MetadataFactory(archive_id).fetch_arches(Version(version))
assert arches == expect["architectures"]
def test_fetch_http_ok(monkeypatch):
monkeypatch.setattr(
"aqt.metadata.get_hash",
lambda *args, **kwargs: hashlib.sha256(b"some_html_content").hexdigest(
))
monkeypatch.setattr("aqt.metadata.getUrl",
lambda **kwargs: "some_html_content")
assert MetadataFactory.fetch_http("some_url") == "some_html_content"
def test_fetch_http_download_error(monkeypatch, exception_on_error):
urls_requested = set()
def _mock(url, **kwargs):
urls_requested.add(url)
raise exception_on_error()
monkeypatch.setattr(
"aqt.metadata.get_hash",
lambda *args, **kwargs: hashlib.sha256(b"some_html_content").hexdigest(
))
monkeypatch.setattr("aqt.metadata.getUrl", _mock)
with pytest.raises(exception_on_error) as e:
MetadataFactory.fetch_http("some_url")
assert e.type == exception_on_error
# Require that a fallback url was tried
assert len(urls_requested) == 2
def test_list_src_doc_examples_modules(monkeypatch, win_5152_sde_xml_file,
cmd_type: str, host: str, version: str,
expected: Set[str]):
monkeypatch.setattr(MetadataFactory, "fetch_http",
lambda self, _: win_5152_sde_xml_file)
archive_id = ArchiveId("qt", host, "desktop", "src_doc_examples")
modules = set(
MetadataFactory(archive_id).fetch_modules_sde(cmd_type,
Version(version)))
assert modules == expected
def test_fetch_http_failover(monkeypatch):
urls_requested = set()
def _mock(url, **kwargs):
urls_requested.add(url)
if len(urls_requested) <= 1:
raise ArchiveDownloadError()
return "some_html_content"
monkeypatch.setattr("aqt.metadata.getUrl", _mock)
# Require that the first attempt failed, but the second did not
assert MetadataFactory.fetch_http("some_url") == "some_html_content"
assert len(urls_requested) == 2
def test_list_archives_bad_xml(monkeypatch):
archive_id = ArchiveId("qt", "windows", "desktop")
archives_query = ["5.15.2", "win32_mingw81", "qtcharts"]
xml_no_name = "<Updates><PackageUpdate><badname></badname></PackageUpdate></Updates>"
xml_empty_name = "<Updates><PackageUpdate><Name></Name></PackageUpdate></Updates>"
xml_broken = "<Updates></PackageUpdate><PackageUpdate></Updates><Name></Name>"
for _xml in (xml_no_name, xml_empty_name, xml_broken):
monkeypatch.setattr(MetadataFactory, "fetch_http",
lambda self, _: _xml)
with pytest.raises(ArchiveListError) as e:
MetadataFactory(archive_id,
archives_query=archives_query).getList()
assert e.type == ArchiveListError
def test_show_list_tools(monkeypatch, capsys):
page = (Path(__file__).parent / "data" /
"mac-desktop.html").read_text("utf-8")
monkeypatch.setattr(MetadataFactory, "fetch_http", lambda self, _: page)
expect_file = Path(__file__).parent / "data" / "mac-desktop-expect.json"
expect = "\n".join(json.loads(
expect_file.read_text("utf-8"))["tools"]) + "\n"
meta = MetadataFactory(ArchiveId("tools", "mac", "desktop"))
show_list(meta)
out, err = capsys.readouterr()
sys.stdout.write(out)
sys.stderr.write(err)
assert out == expect
def test_list_fetch_tool_by_simple_spec(monkeypatch):
update_xml = (
Path(__file__).parent / "data" /
"windows-desktop-tools_vcredist-update.xml").read_text("utf-8")
monkeypatch.setattr(MetadataFactory, "fetch_http",
lambda self, _: update_xml)
expect_json = (
Path(__file__).parent / "data" /
"windows-desktop-tools_vcredist-expect.json").read_text("utf-8")
expected = json.loads(expect_json)["modules_data"]
def check(actual, expect):
for key in (
"Description",
"DisplayName",
"DownloadableArchives",
"ReleaseDate",
"SHA1",
"Version",
"Virtual",
):
assert actual[key] == expect[key]
meta = MetadataFactory(ArchiveId("tools", "windows", "desktop"))
check(
meta.fetch_tool_by_simple_spec(tool_name="tools_vcredist",
simple_spec=SimpleSpec("2011")),
expected["qt.tools.vcredist"],
)
check(
meta.fetch_tool_by_simple_spec(tool_name="tools_vcredist",
simple_spec=SimpleSpec("2014")),
expected["qt.tools.vcredist_msvc2013_x86"],
)
nonexistent = meta.fetch_tool_by_simple_spec(
tool_name="tools_vcredist", simple_spec=SimpleSpec("1970"))
assert nonexistent is None
# Simulate a broken Updates.xml file, with invalid versions
highest_module_info = MetadataFactory.choose_highest_version_in_spec(
all_tools_data={"some_module": {
"Version": "not_a_version"
}},
simple_spec=SimpleSpec("*"),
)
assert highest_module_info is None
def test_list_describe_filters(meta: MetadataFactory, expect: str):
assert meta.describe_filters() == expect
sys.stderr.write(err)
assert expected_msg in err
mac_qt = ArchiveId("qt", "mac", "desktop")
mac_wasm = ArchiveId("qt", "mac", "desktop", "wasm")
wrong_tool_name_msg = "Please use 'aqt list-tool mac desktop' to check what tools are available."
wrong_qt_version_msg = "Please use 'aqt list-qt mac desktop' to show versions of Qt available."
wrong_ext_msg = "Please use 'aqt list-qt mac desktop --extensions <QT_VERSION>' to list valid extensions."
wrong_arch_msg = "Please use 'aqt list-qt mac desktop --arch <QT_VERSION>' to list valid architectures."
@pytest.mark.parametrize(
"meta, expected_message",
(
(MetadataFactory(mac_qt), []),
(
MetadataFactory(mac_qt, spec=SimpleSpec("5.0")),
[
"Please use 'aqt list-qt mac desktop' to check that versions of qt exist within the spec '5.0'."
],
),
(
MetadataFactory(ArchiveId("tools", "mac", "desktop"),
tool_name="ifw"),
[wrong_tool_name_msg],
),
(
MetadataFactory(mac_qt, architectures_ver="1.2.3"),
[wrong_qt_version_msg],
),
def test_fetch_http_ok(monkeypatch):
monkeypatch.setattr("aqt.metadata.getUrl",
lambda **kwargs: "some_html_content")
assert MetadataFactory.fetch_http("some_url") == "some_html_content"