macOS / Tests (AppleSilicon) (push) Canceled after 0s
macOS / Tests (Intel) (push) Canceled after 0s
macOS / Build (AppleSilicon) (push) Canceled after 0s
macOS / Build (Intel) (push) Canceled after 0s
macOS / Publish the GitHub Release (push) Canceled after 0s
465 lines
20 KiB
Python
465 lines
20 KiB
Python
"""Round 129: the macOS port of Cassette, DJ mode's vocal splitters, AirPlay's
|
||
helper download and the rest of their machine-local paths.
|
||
|
||
Every Mac branch keys off ``lintunes.paths.IS_MAC`` (and ``FROZEN``), so
|
||
these flip it with monkeypatch. Each Mac test has a Linux twin pinning that
|
||
nothing there changed: the same paths, words and commands as before.
|
||
"""
|
||
import hashlib
|
||
import io
|
||
import os
|
||
import sys
|
||
import tarfile
|
||
from pathlib import Path
|
||
|
||
import pytest
|
||
|
||
from lintunes import paths
|
||
|
||
|
||
@pytest.fixture
|
||
def mac(monkeypatch):
|
||
monkeypatch.setattr(paths, "IS_MAC", True)
|
||
return monkeypatch
|
||
|
||
|
||
@pytest.fixture
|
||
def home(tmp_path, monkeypatch):
|
||
home = tmp_path / "home"
|
||
home.mkdir()
|
||
monkeypatch.setenv("HOME", str(home))
|
||
for var in ("XDG_CONFIG_HOME", "XDG_CACHE_HOME", "XDG_DATA_HOME",
|
||
"XDG_STATE_HOME", "STCONFDIR", "STHOMEDIR"):
|
||
monkeypatch.delenv(var, raising=False)
|
||
from lintunes import sync_identity
|
||
sync_identity.reset_cache()
|
||
yield home
|
||
sync_identity.reset_cache()
|
||
|
||
|
||
def _syncthing_config(folder: Path, key="k3y", address="127.0.0.1:8384"):
|
||
folder.mkdir(parents=True, exist_ok=True)
|
||
(folder / "config.xml").write_text(
|
||
f'<configuration><device id="ABCDEFG-XYZ" name="Laptop"/>'
|
||
f'<gui><address>{address}</address><apikey>{key}</apikey></gui>'
|
||
f'</configuration>')
|
||
return folder
|
||
|
||
|
||
# ---- Syncthing's config ----
|
||
|
||
class TestSyncthingConfig:
|
||
def test_linux_looks_where_it_always_did(self, home):
|
||
from lintunes import sync_identity
|
||
assert sync_identity.config_dirs() == (
|
||
"$XDG_STATE_HOME/syncthing", "~/.local/state/syncthing",
|
||
"~/.config/syncthing", "~/.syncthing")
|
||
# A Mac-style folder means nothing on Linux.
|
||
_syncthing_config(home / "Library/Application Support/Syncthing")
|
||
assert sync_identity._config_dir() is None
|
||
|
||
def test_mac_finds_application_support(self, home, mac):
|
||
from lintunes import sync_identity
|
||
from lintunes.cassette import syncthing_api as st
|
||
folder = _syncthing_config(home / "Library/Application Support/Syncthing")
|
||
assert sync_identity._config_dir() == folder
|
||
assert st.read_gui_config() == st.Endpoint("127.0.0.1:8384", "k3y")
|
||
assert sync_identity.device_names() == {"ABCDEFG": "Laptop"}
|
||
|
||
def test_mac_honours_stconfdir_first(self, home, mac, tmp_path):
|
||
from lintunes import sync_identity
|
||
_syncthing_config(home / "Library/Application Support/Syncthing")
|
||
custom = _syncthing_config(tmp_path / "elsewhere", key="other")
|
||
mac.setenv("STCONFDIR", str(custom))
|
||
assert sync_identity._config_dir() == custom
|
||
mac.setenv("STCONFDIR", "") # set to nothing: skipped, not "."
|
||
assert sync_identity._config_dir() == (
|
||
home / "Library/Application Support/Syncthing")
|
||
|
||
def test_mac_still_finds_a_unix_style_home(self, home, mac):
|
||
from lintunes import sync_identity
|
||
folder = _syncthing_config(home / ".config/syncthing")
|
||
assert sync_identity._config_dir() == folder
|
||
|
||
def test_not_running_words(self, mac):
|
||
from lintunes.cassette import syncthing_api as st
|
||
hint = st.not_running_hint("press Retry")
|
||
assert "brew install" in hint and "syncthing.net" in hint
|
||
assert hint.startswith("Open the Syncthing app")
|
||
assert ", then press Retry." in hint
|
||
|
||
def test_not_running_words_on_linux_are_the_callers(self):
|
||
from lintunes.cassette import syncthing_api as st
|
||
assert st.not_running_hint("press Retry") is None
|
||
|
||
@pytest.mark.parametrize("on_mac", [False, True])
|
||
def test_service_status_when_syncthing_is_down(self, qapp, tmp_path,
|
||
monkeypatch, on_mac):
|
||
from lintunes.cassette import service as svc
|
||
from lintunes.cassette import syncthing_api as st
|
||
monkeypatch.setattr(paths, "IS_MAC", on_mac)
|
||
service = svc.CassetteService.__new__(svc.CassetteService)
|
||
svc.QObject.__init__(service)
|
||
import threading
|
||
service._lock = threading.Lock()
|
||
service._api = svc.Status("x", "", "")
|
||
service._set_api_down(st.SyncthingError("s", "d", st.NOT_RUNNING))
|
||
detail = service._api.hint
|
||
if on_mac:
|
||
assert "brew install" in detail
|
||
else:
|
||
assert detail == ("Start Syncthing, then press Retry in Sync "
|
||
"Settings ▸ General.")
|
||
|
||
|
||
# ---- the cassette folders ----
|
||
|
||
class TestCassetteFolders:
|
||
def test_root_on_linux_unchanged(self, home, monkeypatch, tmp_path):
|
||
from lintunes.cassette import state
|
||
monkeypatch.setattr(state, "load_config", lambda: {})
|
||
assert state.cassette_root() == home / ".local/share/lintunes/cassette"
|
||
monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "xdg"))
|
||
assert state.cassette_root() == tmp_path / "xdg/lintunes/cassette"
|
||
|
||
def test_root_on_mac(self, home, mac):
|
||
from lintunes.cassette import state
|
||
mac.setattr(state, "load_config", lambda: {})
|
||
assert state.cassette_root() == (
|
||
home / "Library/Application Support/LinTunes/cassette")
|
||
mac.setattr(state, "load_config", lambda: {"cassette_root": "~/C"})
|
||
assert state.cassette_root() == home / "C"
|
||
|
||
def test_stignore_on_linux_unchanged(self, tmp_path):
|
||
from lintunes.cassette import publish
|
||
publish.prepare_out_dir(tmp_path / "out")
|
||
assert (tmp_path / "out/.stignore").read_text() == (
|
||
"// written by LinTunes\n*.tmp\n*.part\n")
|
||
publish.prepare_in_dir(tmp_path / "in")
|
||
assert (tmp_path / "in").is_dir()
|
||
assert not (tmp_path / "in/.stignore").exists()
|
||
|
||
def test_stignore_on_mac_keeps_finder_out(self, tmp_path, mac):
|
||
from lintunes.cassette import publish
|
||
publish.prepare_out_dir(tmp_path / "out")
|
||
text = (tmp_path / "out/.stignore").read_text()
|
||
assert text.startswith("// written by LinTunes\n*.tmp\n*.part\n")
|
||
assert "(?d).DS_Store" in text and "(?d)._*" in text
|
||
publish.prepare_in_dir(tmp_path / "in")
|
||
assert "(?d).DS_Store" in (tmp_path / "in/.stignore").read_text()
|
||
|
||
def test_finder_litter_is_never_a_delivery(self, tmp_path):
|
||
from lintunes.cassette import delivery
|
||
outbox = tmp_path / "outbox"
|
||
outbox.mkdir()
|
||
(outbox / ".DS_Store").write_bytes(b"x")
|
||
(outbox / "._12 ~ song.mp3").write_bytes(b"x")
|
||
(outbox / "12 ~ song.mp3").write_bytes(b"x")
|
||
assert list(delivery.list_outbox(outbox)) == [12]
|
||
|
||
def test_mac_hostname_drops_dot_local(self, mac):
|
||
from lintunes.cassette import host
|
||
mac.setattr(host.socket, "gethostname", lambda: "Travs-MacBook.local")
|
||
assert host.hostname() == "Travs-MacBook"
|
||
|
||
def test_linux_hostname_unchanged(self, monkeypatch):
|
||
from lintunes.cassette import host
|
||
monkeypatch.setattr(host.socket, "gethostname", lambda: "box.local")
|
||
assert host.hostname() == "box.local"
|
||
|
||
def test_mac_asks_syncthing_by_its_nfc_name(self, tmp_path, mac):
|
||
import unicodedata
|
||
from lintunes.cassette import service as svc
|
||
from lintunes.cassette.state import Friend, in_dir
|
||
asked = []
|
||
|
||
class Client:
|
||
def file_info(self, folder, name):
|
||
asked.append(name)
|
||
return None
|
||
service = svc.CassetteService.__new__(svc.CassetteService)
|
||
import threading
|
||
service._lock = threading.Lock()
|
||
service.root = tmp_path
|
||
friend = Friend(token="t", device_id="D", name="F", role="inviter",
|
||
out_folder="o", in_folder="i", added="")
|
||
service._state = type("S", (), {"friends": {"t": friend}})()
|
||
service.client = lambda: Client()
|
||
nfd = unicodedata.normalize("NFD", "Beyoncé.mp3")
|
||
assert service.is_complete("t", in_dir(tmp_path, "t") / nfd)
|
||
assert asked == [unicodedata.normalize("NFC", "Beyoncé.mp3")]
|
||
|
||
|
||
# ---- AirPlay's helper ----
|
||
|
||
class TestCliAirPlay:
|
||
@pytest.mark.parametrize("machine, key", [("arm64", "macos-arm64"),
|
||
("x86_64", "macos-x86_64")])
|
||
def test_mac_builds_are_pinned(self, mac, machine, key):
|
||
from lintunes.airplay import cli
|
||
mac.setattr(cli.platform, "machine", lambda: machine)
|
||
assert cli._arch() == key and cli.supported()
|
||
assert cli._asset(key) == f"cliairplay-{key}"
|
||
assert len(cli._SHA256[key]) == 64
|
||
|
||
def test_mac_download_uses_the_mac_asset(self, mac, tmp_path):
|
||
from lintunes.airplay import cli
|
||
data = b"pretend mac binary"
|
||
mac.setenv("XDG_DATA_HOME", str(tmp_path))
|
||
mac.setattr(cli.platform, "machine", lambda: "arm64")
|
||
mac.setitem(cli._SHA256, "macos-arm64", hashlib.sha256(data).hexdigest())
|
||
urls = []
|
||
path = cli.ensure_binary(fetch=lambda url: urls.append(url) or data)
|
||
assert urls == [cli._RELEASE + "cliairplay-macos-arm64"]
|
||
assert path == tmp_path / "lintunes/bin" / f"cliairplay-{cli.VERSION}-macos-arm64"
|
||
assert os.access(path, os.X_OK)
|
||
|
||
def test_linux_binary_dir_unchanged(self, home):
|
||
from lintunes.airplay import cli
|
||
assert cli.binary_dir() == home / ".local/share/lintunes/bin"
|
||
|
||
def test_https_context(self, monkeypatch):
|
||
import ssl
|
||
from lintunes.airplay import cli
|
||
assert cli.https_context() is None
|
||
monkeypatch.setattr(paths, "IS_MAC", True)
|
||
assert isinstance(cli.https_context(), ssl.SSLContext)
|
||
|
||
|
||
# ---- the splitters' venvs ----
|
||
|
||
def _uv_tarball(target: str, payload=b"#!/bin/sh\necho uv\n") -> bytes:
|
||
buf = io.BytesIO()
|
||
with tarfile.open(fileobj=buf, mode="w:gz") as tar:
|
||
info = tarfile.TarInfo(f"uv-{target}/uv")
|
||
info.size = len(payload)
|
||
tar.addfile(info, io.BytesIO(payload))
|
||
info = tarfile.TarInfo(f"uv-{target}/uvx")
|
||
info.size = 1
|
||
tar.addfile(info, io.BytesIO(b"x"))
|
||
return buf.getvalue()
|
||
|
||
|
||
class TestVenvTool:
|
||
def test_linux_checkout_makes_venvs_as_before(self, monkeypatch):
|
||
from lintunes.dj import venv_tool
|
||
monkeypatch.setattr(paths, "FROZEN", False)
|
||
venv = Path("/v")
|
||
assert not venv_tool.uses_uv()
|
||
assert venv_tool.create_command(venv) == [sys.executable, "-m", "venv", "/v"]
|
||
assert venv_tool.install_command(venv, ["a", "b"]) == [
|
||
"/v/bin/python", "-m", "pip", "install", "--quiet", "a", "b"]
|
||
assert venv_tool.run_env() is None
|
||
assert venv_tool.child_env() is None
|
||
env = {"X": "1"}
|
||
assert venv_tool.child_env(env) is env
|
||
cmd, pre = venv_tool.niced(["x"], 5)
|
||
assert cmd == ["x"] and callable(pre)
|
||
|
||
def test_mac_makes_venvs_with_uv(self, mac, home):
|
||
from lintunes.dj import venv_tool
|
||
venv = Path("/v")
|
||
assert venv_tool.uses_uv()
|
||
uv = str(venv_tool.uv_path())
|
||
assert uv == str(home / "Library/Application Support/LinTunes/bin"
|
||
/ f"uv-{venv_tool.UV_VERSION}")
|
||
assert venv_tool.create_command(venv) == [
|
||
uv, "venv", "--quiet", "--python", venv_tool.PYTHON_VERSION, "/v"]
|
||
assert venv_tool.install_command(venv, ["a"], "https://idx") == [
|
||
uv, "pip", "install", "--quiet", "--python", "/v/bin/python",
|
||
"--index-url", "https://idx", "a"]
|
||
cmd, pre = venv_tool.niced(["x"], 19)
|
||
assert cmd == ["/usr/bin/nice", "-n", "19", "x"] and pre is None
|
||
|
||
def test_frozen_linux_uses_uv_too(self, monkeypatch):
|
||
from lintunes.dj import venv_tool
|
||
monkeypatch.setattr(paths, "FROZEN", True)
|
||
assert venv_tool.uses_uv()
|
||
|
||
def test_uv_env_is_ours_and_clean(self, mac, home):
|
||
from lintunes.dj import venv_tool
|
||
env = venv_tool.uv_env({"PYTHONHOME": "/app", "PYTHONPATH": "/app",
|
||
"VIRTUAL_ENV": "/x", "PATH": "/bin"})
|
||
assert "PYTHONHOME" not in env and "PYTHONPATH" not in env
|
||
assert "VIRTUAL_ENV" not in env and env["PATH"] == "/bin"
|
||
assert env["UV_MANAGED_PYTHON"] == "1"
|
||
assert env["UV_PYTHON_INSTALL_DIR"].startswith(str(home / "Library"))
|
||
assert env["UV_CACHE_DIR"] == str(home / "Library/Caches/LinTunes/uv")
|
||
assert os.path.isfile(env["SSL_CERT_FILE"])
|
||
|
||
@pytest.mark.parametrize("machine, target", [
|
||
("arm64", "aarch64-apple-darwin"), ("x86_64", "x86_64-apple-darwin")])
|
||
def test_uv_targets(self, mac, machine, target):
|
||
from lintunes.dj import venv_tool
|
||
mac.setattr(venv_tool.platform, "machine", lambda: machine)
|
||
assert venv_tool.uv_target() == target
|
||
assert len(venv_tool._UV_SHA256[target]) == 64
|
||
|
||
def test_ensure_uv_verifies_then_unpacks(self, mac, tmp_path):
|
||
from lintunes.dj import venv_tool
|
||
mac.setenv("XDG_DATA_HOME", str(tmp_path))
|
||
mac.setattr(venv_tool.platform, "machine", lambda: "arm64")
|
||
target = "aarch64-apple-darwin"
|
||
archive = _uv_tarball(target)
|
||
with pytest.raises(venv_tool.VenvError):
|
||
venv_tool.ensure_uv(fetch=lambda url: archive) # real pin: mismatch
|
||
assert not venv_tool.uv_path().exists()
|
||
mac.setitem(venv_tool._UV_SHA256, target, hashlib.sha256(archive).hexdigest())
|
||
urls = []
|
||
path = venv_tool.ensure_uv(fetch=lambda url: urls.append(url) or archive)
|
||
assert urls == [venv_tool._UV_RELEASE + f"uv-{target}.tar.gz"]
|
||
assert path.read_bytes() == b"#!/bin/sh\necho uv\n"
|
||
assert os.access(path, os.X_OK)
|
||
assert venv_tool.ensure_uv(fetch=lambda url: 1 / 0) == path # kept
|
||
|
||
def test_an_archive_without_uv_is_refused(self, mac, tmp_path):
|
||
from lintunes.dj import venv_tool
|
||
mac.setenv("XDG_DATA_HOME", str(tmp_path))
|
||
mac.setattr(venv_tool.platform, "machine", lambda: "arm64")
|
||
target = "aarch64-apple-darwin"
|
||
archive = _uv_tarball("something-else")
|
||
mac.setitem(venv_tool._UV_SHA256, target, hashlib.sha256(archive).hexdigest())
|
||
with pytest.raises(venv_tool.VenvError):
|
||
venv_tool.ensure_uv(fetch=lambda url: archive)
|
||
assert not venv_tool.uv_path().exists()
|
||
|
||
|
||
class TestDemucs:
|
||
def test_linux_paths_and_words_unchanged(self, home, monkeypatch, tmp_path):
|
||
from lintunes.dj import stems
|
||
monkeypatch.setattr(paths, "FROZEN", False)
|
||
assert stems.venv_dir() == home / ".local/share/lintunes/demucs"
|
||
assert stems.cache_root() == home / ".cache/lintunes/stems"
|
||
v = stems.venv_dir()
|
||
assert stems.setup_command() == (
|
||
f"python3 -m venv {v} && {v}/bin/pip install torch --index-url "
|
||
f"https://download.pytorch.org/whl/cpu && {v}/bin/pip install numpy demucs")
|
||
assert not stems.setup_in_app()
|
||
monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "d"))
|
||
monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "c"))
|
||
assert stems.venv_dir() == tmp_path / "d/lintunes/demucs"
|
||
assert stems.cache_root() == tmp_path / "c/lintunes/stems"
|
||
|
||
def test_mac_paths(self, home, mac):
|
||
from lintunes.dj import instant, stems
|
||
assert stems.venv_dir() == home / "Library/Application Support/LinTunes/demucs"
|
||
assert stems.cache_root() == home / "Library/Caches/LinTunes/stems"
|
||
assert instant.venv_dir() == home / "Library/Application Support/LinTunes/spleeter"
|
||
assert stems.setup_in_app()
|
||
assert "Preferences › DJ" in stems.setup_command()
|
||
|
||
def test_mac_packages(self, mac):
|
||
from lintunes.dj import stems
|
||
mac.setattr(stems.platform, "machine", lambda: "arm64")
|
||
[(_t, packages, index)] = stems.install_steps()
|
||
assert index is None and "torch==2.8.0" in packages
|
||
assert "torchaudio==2.8.0" in packages and "soundfile" in packages
|
||
mac.setattr(stems.platform, "machine", lambda: "x86_64")
|
||
[(_t, packages, index)] = stems.install_steps()
|
||
assert "torch==2.2.2" in packages and "numpy<2" in packages
|
||
|
||
def test_mac_setup_runs_uv(self, qapp, home, mac):
|
||
from lintunes.dj import stems, venv_tool
|
||
mac.setattr(stems.platform, "machine", lambda: "arm64")
|
||
mac.setattr(venv_tool, "ensure_uv", lambda fetch=None: venv_tool.uv_path())
|
||
calls = []
|
||
|
||
class Done:
|
||
returncode = 0
|
||
stderr = stdout = ""
|
||
mac.setattr(stems.subprocess, "run",
|
||
lambda cmd, **kw: calls.append((cmd, kw["env"])) or Done())
|
||
setup = stems.DemucsSetup()
|
||
said, finished, failed = [], [], []
|
||
setup.progress.connect(said.append)
|
||
setup.finished.connect(lambda: finished.append(1))
|
||
setup.failed.connect(failed.append)
|
||
setup._run()
|
||
assert failed == [] and finished == [1]
|
||
uv = str(venv_tool.uv_path())
|
||
assert calls[0][0][:2] == [uv, "venv"]
|
||
assert calls[1][0][:3] == [uv, "pip", "install"]
|
||
assert "demucs==4.0.1" in calls[1][0]
|
||
assert all(env["UV_MANAGED_PYTHON"] == "1" for _c, env in calls)
|
||
|
||
def test_mac_split_is_niced_by_command(self, tmp_path, mac):
|
||
from types import SimpleNamespace
|
||
from lintunes.dj import stems
|
||
song = tmp_path / "s.mp3"
|
||
song.write_bytes(b"x")
|
||
mac.setenv("XDG_CACHE_HOME", str(tmp_path / "c"))
|
||
mac.setattr(stems, "available", lambda: True)
|
||
mac.setattr(stems, "audio_hash", lambda path: None)
|
||
mac.setattr(stems.os, "cpu_count", lambda: 8)
|
||
seen = {}
|
||
|
||
class Proc:
|
||
stderr = SimpleNamespace(read=lambda n: b"")
|
||
|
||
def wait(self):
|
||
return 1
|
||
|
||
def popen(cmd, **kw):
|
||
seen.update(cmd=cmd, **kw)
|
||
return Proc()
|
||
mac.setattr(stems.subprocess, "Popen", popen)
|
||
mac.setenv("PYTHONHOME", "/Applications/LinTunes.app")
|
||
with pytest.raises(OSError):
|
||
stems.split(str(song), "htdemucs", True)
|
||
assert seen["cmd"][:3] == ["/usr/bin/nice", "-n", "19"]
|
||
assert seen["preexec_fn"] is None
|
||
assert "PYTHONHOME" not in seen["env"]
|
||
assert seen["env"]["OMP_NUM_THREADS"] == "2"
|
||
|
||
|
||
class TestInstant:
|
||
def test_mac_setup_runs_uv(self, qapp, home, mac):
|
||
from lintunes.dj import instant, venv_tool
|
||
mac.setattr(venv_tool, "ensure_uv", lambda fetch=None: venv_tool.uv_path())
|
||
mac.setattr(instant, "install_models", lambda fetch=None: None)
|
||
calls = []
|
||
|
||
class Done:
|
||
returncode = 0
|
||
stderr = stdout = ""
|
||
mac.setattr(instant.subprocess, "run",
|
||
lambda cmd, **kw: calls.append(cmd) or Done())
|
||
setup = instant.InstantSetup()
|
||
failed = []
|
||
setup.failed.connect(failed.append)
|
||
setup._run()
|
||
assert failed == []
|
||
uv = str(venv_tool.uv_path())
|
||
assert calls[0][:2] == [uv, "venv"]
|
||
assert calls[1][:3] == [uv, "pip", "install"]
|
||
assert f"sherpa-onnx=={instant.SHERPA_VERSION}" in calls[1]
|
||
|
||
def test_linux_setup_unchanged(self, qapp, home, monkeypatch):
|
||
from lintunes.dj import instant
|
||
monkeypatch.setattr(paths, "FROZEN", False)
|
||
monkeypatch.setattr(instant, "install_models", lambda fetch=None: None)
|
||
calls = []
|
||
|
||
class Done:
|
||
returncode = 0
|
||
stderr = stdout = ""
|
||
monkeypatch.setattr(instant.subprocess, "run",
|
||
lambda cmd, **kw: calls.append((cmd, kw.get("env"))) or Done())
|
||
instant.InstantSetup()._run()
|
||
venv = instant.venv_dir()
|
||
assert calls == [
|
||
([sys.executable, "-m", "venv", str(venv)], None),
|
||
([str(venv / "bin/python"), "-m", "pip", "install", "--quiet",
|
||
f"sherpa-onnx=={instant.SHERPA_VERSION}", "numpy"], None)]
|
||
|
||
def test_the_runner_ships_beside_the_module(self):
|
||
from lintunes.dj import instant
|
||
assert instant.RUNNER.is_file()
|
||
|
||
|
||
def test_dj_output_tries_any_rate_only_on_a_mac(monkeypatch):
|
||
from lintunes.dj import output
|
||
assert not output._converts_any_rate()
|
||
monkeypatch.setattr(paths, "IS_MAC", True)
|
||
assert output._converts_any_rate()
|