345 lines
18 KiB
Python
345 lines
18 KiB
Python
import importlib.util
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
spec = importlib.util.spec_from_file_location("setup", Path(__file__).with_name("setup-docker.py"))
|
|
setup = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(setup)
|
|
|
|
|
|
class DockerSetupTests(unittest.TestCase):
|
|
def setUp(self):
|
|
directory = tempfile.TemporaryDirectory()
|
|
self.addCleanup(directory.cleanup)
|
|
environment = patch.dict(os.environ, {"XDG_CONFIG_HOME": directory.name})
|
|
environment.start()
|
|
self.addCleanup(environment.stop)
|
|
|
|
def test_verified_client_default_preserves_unrelated_settings_and_warns_on_override(self):
|
|
path = Path(os.environ["XDG_CONFIG_HOME"])/"pipelines/client.json"
|
|
path.parent.mkdir()
|
|
path.write_text('{"server_url":"ws://old/connect","custom":"keep"}')
|
|
with tempfile.TemporaryDirectory() as directory, patch.dict(os.environ, {"PIPELINES_URL":"ws://old/connect"}):
|
|
setup.Setup(directory).configure_client("ws://127.0.0.1:8081/connect")
|
|
self.assertEqual(setup.json.loads(path.read_text()), {"server_url":"ws://127.0.0.1:8081/connect","custom":"keep"})
|
|
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
|
|
|
|
def test_client_config_symlink_and_malformed_content_are_not_overwritten(self):
|
|
path = Path(os.environ["XDG_CONFIG_HOME"])/"pipelines/client.json"
|
|
path.parent.mkdir()
|
|
target = path.parent/"custom.json"
|
|
target.write_text("private custom settings")
|
|
path.symlink_to(target)
|
|
with self.assertRaises(ValueError): setup.Setup(".").configure_client("ws://127.0.0.1:8081/connect")
|
|
self.assertEqual(target.read_text(),"private custom settings")
|
|
path.unlink()
|
|
path.write_text("not JSON")
|
|
with self.assertRaises(ValueError): setup.Setup(".").configure_client("ws://127.0.0.1:8081/connect")
|
|
self.assertEqual(path.read_text(), "not JSON")
|
|
|
|
def test_host_verification_rejects_wrong_unconfigured_server(self):
|
|
def runner(command, **kwargs):
|
|
return subprocess.CompletedProcess(command, 0, stdout='{"ntfy":{"health":"not configured"}}', stderr="")
|
|
with patch.object(setup.shutil,"which",return_value="/fixture/go"), self.assertRaises(ValueError):
|
|
setup.Setup(".",runner=runner).verify_host_endpoint("ws://127.0.0.1:8081/connect")
|
|
|
|
def test_validation_primes_its_own_service_and_passes_model_as_argument(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root=Path(directory);(root/".env").write_text("CUSTOM=keep\n")
|
|
opencode=root/"opencode"
|
|
opencode.write_text('''#!/bin/sh
|
|
if [ "$1" = api ]; then
|
|
touch "$FIXTURE/primed"
|
|
echo '{"data":[]}'
|
|
elif [ "$1" = models ]; then
|
|
echo 'opencode-go/deepseek-v4.1-flash'
|
|
else
|
|
exit 9
|
|
fi
|
|
''');opencode.chmod(0o700)
|
|
pipelines=root/"pipelines"
|
|
pipelines.write_text('''#!/bin/sh
|
|
test -f "$FIXTURE/primed" || exit 8
|
|
test "$1" = provider-check || exit 9
|
|
printf '%s' "$3" > "$FIXTURE/model"
|
|
echo '{"healthy":true,"session_id":"ses_validation"}'
|
|
''');pipelines.chmod(0o700)
|
|
def runner(command,**kwargs):
|
|
index=command.index("-c")
|
|
# Each one-off container has a separate service/catalog.
|
|
(root/"primed").unlink(missing_ok=True)
|
|
return subprocess.run(["sh",*command[index:]],capture_output=True,text=True,
|
|
env=dict(os.environ,PATH=str(root)+os.pathsep+os.environ["PATH"],FIXTURE=str(root)))
|
|
installer=setup.Setup(directory,runner=runner)
|
|
installer.validate_provider(setup.arguments(["--model","opencode-go/deepseek-v4.1-flash"]))
|
|
self.assertEqual((root/"model").read_text(),"opencode-go/deepseek-v4.1-flash")
|
|
self.assertIn("CUSTOM=keep\n",(root/".env").read_text())
|
|
|
|
def test_native_login_ui_uses_same_primed_container(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root=Path(directory)
|
|
executable=root/"opencode"
|
|
executable.write_text('''#!/bin/sh
|
|
if [ "$1" = api ]; then
|
|
touch "$FIXTURE/primed"
|
|
echo '{"data":[]}'
|
|
elif [ "$1 $2" = 'auth login' ]; then
|
|
test -f "$FIXTURE/primed" || exit 8
|
|
touch "$FIXTURE/logged"
|
|
else
|
|
exit 9
|
|
fi
|
|
''')
|
|
executable.chmod(0o700)
|
|
logins=[]
|
|
def runner(command,**kwargs):
|
|
if command[-4:]==["auth","list","--format","json"]:
|
|
accounts='[{"id":"opencode-go","connections":[{"id":"fixture"}]}]' if (root/"logged").exists() else '[]'
|
|
return subprocess.CompletedProcess(command,0,stdout=accounts,stderr="")
|
|
logins.append(command)
|
|
self.assertNotIn("-T",command,"interactive login lost its terminal")
|
|
return subprocess.run(["sh","-c",command[-1]],
|
|
env=dict(os.environ,PATH=str(root)+os.pathsep+os.environ["PATH"],FIXTURE=str(root)))
|
|
setup.Setup(directory,runner=runner).authenticate()
|
|
self.assertEqual(len(logins),1)
|
|
self.assertTrue((root/"logged").exists())
|
|
|
|
def test_model_discovery_primes_catalog_and_retries_in_one_container(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root=Path(directory)
|
|
executable=root/"opencode"
|
|
executable.write_text('''#!/bin/sh
|
|
if [ "$1" = api ]; then
|
|
touch "$FIXTURE/primed"
|
|
echo '{"data":[]}'
|
|
elif [ "$1" = models ]; then
|
|
test -f "$FIXTURE/primed" || exit 8
|
|
if [ ! -f "$FIXTURE/first-read" ]; then
|
|
touch "$FIXTURE/first-read"
|
|
else
|
|
echo 'opencode-go/deepseek-v4.1-flash'
|
|
fi
|
|
else
|
|
exit 9
|
|
fi
|
|
''')
|
|
executable.chmod(0o700)
|
|
calls=[]
|
|
def runner(command,**kwargs):
|
|
calls.append(command)
|
|
self.assertIn("sh",command)
|
|
return subprocess.run(["sh","-c",command[-1]],capture_output=True,text=True,
|
|
env=dict(os.environ,PATH=str(root)+os.pathsep+os.environ["PATH"],FIXTURE=str(root)))
|
|
models=setup.Setup(directory,runner=runner).discover_models()
|
|
self.assertEqual(models,["opencode-go/deepseek-v4.1-flash"])
|
|
self.assertEqual(len(calls),1,"retry started a fresh container/service")
|
|
|
|
def test_empty_catalog_does_not_blame_or_replace_saved_key(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path=Path(directory,".env");path.write_text("CUSTOM=keep\n")
|
|
def runner(command,**kwargs):
|
|
return subprocess.CompletedProcess(command,0,stdout="",stderr="")
|
|
installer=setup.Setup(directory,runner=runner)
|
|
installer.accounts=[{"id":"opencode-go","connections":[{"id":"saved-account"}]}]
|
|
with self.assertRaises(ValueError) as raised:
|
|
installer.validate_provider(setup.arguments([]))
|
|
self.assertIn("NOT proof it is invalid",str(raised.exception))
|
|
self.assertIn("opencode-go",str(raised.exception))
|
|
self.assertNotIn("--relogin",str(raised.exception))
|
|
self.assertEqual(path.read_text(),"CUSTOM=keep\n")
|
|
|
|
def test_provider_validation_failure_preserves_saved_model(self):
|
|
for report in ['{"healthy":false,"diagnostic":"quota exhausted","session_id":"ses_failed"}',
|
|
'{"healthy":true}', '[]', 'not-json']:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path=Path(directory,".env")
|
|
path.write_text("PIPELINES_DEFAULT_MODEL=fixture/previous\nCUSTOM=keep\n")
|
|
before=path.read_bytes()
|
|
calls=[]
|
|
def runner(command,**kwargs):
|
|
calls.append(command)
|
|
out="fixture/new\n" if "opencode models" in command[-1] else report
|
|
return subprocess.CompletedProcess(command,0,stdout=out,stderr="")
|
|
installer=setup.Setup(directory,runner=runner)
|
|
with patch("sys.stderr"),self.assertRaises(ValueError):
|
|
installer.validate_provider(setup.arguments(["--model","fixture/new"]))
|
|
self.assertEqual(before,path.read_bytes())
|
|
self.assertTrue(any(any("provider-check" in arg for arg in command) for command in calls))
|
|
|
|
def test_unavailable_model_does_not_attempt_generation(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
Path(directory,".env").write_text("CUSTOM=keep\n")
|
|
calls=[]
|
|
def runner(command,**kwargs):
|
|
calls.append(command)
|
|
return subprocess.CompletedProcess(command,0,stdout="fixture/available\n",stderr="")
|
|
with self.assertRaises(ValueError):
|
|
setup.Setup(directory,runner=runner).validate_provider(setup.arguments(["--model","fixture/unavailable"]))
|
|
self.assertFalse(any(any("provider-check" in arg for arg in command) for command in calls))
|
|
|
|
def test_ctrl_c_exits_cleanly_and_retains_configuration(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root=Path(directory);scripts=root/"scripts";scripts.mkdir()
|
|
for name in ["setup-docker.py","lan-address.py","configure-compose.py","save-ntfy-token.py"]:
|
|
shutil.copy2(Path(__file__).with_name(name),scripts/name)
|
|
marker=root/"waiting"
|
|
docker=root/"docker"
|
|
docker.write_text('#!/bin/sh\ncase "$*" in *" up "*) touch "'+str(marker)+'"; exec sleep 30;; esac\n')
|
|
docker.chmod(0o700)
|
|
go=root/"go";go.write_text('#!/bin/sh\nexit 0\n');go.chmod(0o700)
|
|
process=subprocess.Popen([sys.executable,str(scripts/"setup-docker.py"),
|
|
"--ntfy-url","http://192.168.1.25:8090","--bind-address","192.168.1.25","--timezone","UTC"],
|
|
env=dict(os.environ,PATH=str(root)+os.pathsep+os.environ["PATH"]),
|
|
stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,start_new_session=True)
|
|
try:
|
|
deadline=time.monotonic()+5
|
|
while not marker.exists() and process.poll() is None and time.monotonic()<deadline:
|
|
time.sleep(.02)
|
|
self.assertTrue(marker.exists(),"installer did not reach Docker startup")
|
|
os.killpg(process.pid,signal.SIGINT)
|
|
stdout,stderr=process.communicate(timeout=5)
|
|
self.assertEqual(process.returncode,130)
|
|
self.assertNotIn("Traceback",stdout+stderr)
|
|
self.assertIn("Setup canceled",stderr)
|
|
self.assertTrue((root/".env").exists())
|
|
finally:
|
|
if process.poll() is None:
|
|
os.killpg(process.pid,signal.SIGTERM)
|
|
process.communicate(timeout=5)
|
|
|
|
def test_fresh_defaults_configure_lan_without_any_input(self):
|
|
with tempfile.TemporaryDirectory() as directory, \
|
|
patch.object(setup.lan,"detect_lan",return_value="192.168.1.25"), \
|
|
patch.object(setup.configure,"host_timezone",return_value="Europe/London"), \
|
|
patch("builtins.input",side_effect=AssertionError("must not ask for network settings")):
|
|
setup.Setup(directory).settings(setup.arguments([]))
|
|
text=Path(directory,".env").read_text()
|
|
self.assertIn("NTFY_BASE_URL=http://192.168.1.25:8090\n",text)
|
|
self.assertIn("NTFY_BIND_ADDRESS=0.0.0.0\n",text)
|
|
self.assertIn("TZ=Europe/London\n",text)
|
|
|
|
def test_timezone_fallback_does_not_prompt(self):
|
|
with tempfile.TemporaryDirectory() as directory, \
|
|
patch.object(setup.lan,"detect_lan",return_value="192.168.1.25"), \
|
|
patch.object(setup.configure,"host_timezone",side_effect=ValueError("unknown")):
|
|
setup.Setup(directory).settings(setup.arguments([]))
|
|
self.assertIn("TZ=UTC\n",Path(directory,".env").read_text())
|
|
|
|
def test_missing_lan_fails_without_partial_settings_or_prompt(self):
|
|
with tempfile.TemporaryDirectory() as directory, \
|
|
patch.object(setup.lan,"detect_lan",side_effect=ValueError("No LAN")):
|
|
with self.assertRaises(ValueError):
|
|
setup.Setup(directory).settings(setup.arguments([]))
|
|
self.assertFalse(Path(directory,".env").exists())
|
|
|
|
def exercise(self, directory, existing=False, fail=None, confirm="yes"):
|
|
calls = []
|
|
token = "tk_" + "a" * 29
|
|
logged = existing
|
|
|
|
def runner(command, **kwargs):
|
|
nonlocal logged
|
|
args = command[2:]
|
|
calls.append(args)
|
|
code, out = 0, ""
|
|
if args[-4:] == ["auth", "list", "--format", "json"]:
|
|
out = '[{"id":"fixture","connections":[{"id":"fixture"}]}]' if logged else '[]'
|
|
if "opencode models" in args[-1]:
|
|
out = "fixture/test-model\n"
|
|
if any("provider-check" in arg for arg in args):
|
|
out = '{"healthy":true,"session_id":"ses_fixture"}'
|
|
if "exec opencode auth login" in args[-1] and confirm == "yes":
|
|
logged = True
|
|
if "token" in args:
|
|
out = f"token {token} created\n"
|
|
if args[-2:] == ["status", "--json"]:
|
|
out = '{"ntfy":{"health":"healthy","url":"http://192.168.1.20:8090"},"topic":"pipelines"}'
|
|
if args[:1] == ["port"]:
|
|
out = "127.0.0.1:8081\n"
|
|
if fail and (fail in args or (fail=="login" and "exec opencode auth login" in args[-1]) or (fail=="provider-check" and any("provider-check" in arg for arg in args))):
|
|
code, out = 9, "private provider data/token"
|
|
if fail == "host" and command[0] != "docker" and args[-2:] == ["status", "--json"]:
|
|
code, out = 9, '{"ntfy":{"health":"not configured"}}'
|
|
return subprocess.CompletedProcess(command, code, stdout=out, stderr="")
|
|
|
|
args = setup.arguments([] if existing else ["--ntfy-url", "http://192.168.1.20:8090",
|
|
"--bind-address", "192.168.1.20", "--timezone", "Europe/London"])
|
|
installer = setup.Setup(directory, runner=runner, prompt=lambda _: "1")
|
|
with patch.object(setup.lan,"detect_lan",return_value="192.168.1.20"):
|
|
installer.run(args)
|
|
return calls, token
|
|
|
|
def test_fresh_setup_wires_notifications_and_runs_container_login(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
calls, token = self.exercise(directory)
|
|
self.assertTrue(any("exec opencode auth login" in c[-1] for c in calls))
|
|
self.assertTrue(any("--force-recreate" in c for c in calls))
|
|
self.assertEqual(Path(directory, "secrets/ntfy-token.txt").read_text(), token + "\n")
|
|
self.assertFalse(any(token in " ".join(c) for c in calls))
|
|
self.assertLess(next(i for i,c in enumerate(calls) if "token" in c), next(i for i,c in enumerate(calls) if "build" in c))
|
|
self.assertLess(next(i for i,c in enumerate(calls) if "exec opencode auth login" in c[-1]), next(i for i,c in enumerate(calls) if "--force-recreate" in c))
|
|
self.assertTrue(any("curl --config -" in " ".join(c) for c in calls))
|
|
config = Path(os.environ["XDG_CONFIG_HOME"])/"pipelines/client.json"
|
|
self.assertEqual(setup.json.loads(config.read_text())["server_url"],"ws://127.0.0.1:8081/connect")
|
|
|
|
def test_reinstall_preserves_configuration_tokens_and_provider_setup(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
self.exercise(directory)
|
|
files = [Path(directory, ".env"), Path(directory, "secrets/ntfy-token.txt")]
|
|
before = [p.read_bytes() for p in files]
|
|
calls, _ = self.exercise(directory, existing=True)
|
|
self.assertFalse(any("exec opencode auth login" in c[-1] or "token" in c for c in calls))
|
|
self.assertEqual(before[1],files[1].read_bytes())
|
|
self.assertEqual(files[0].read_bytes(),before[0].replace(b"NTFY_BIND_ADDRESS=192.168.1.20",b"NTFY_BIND_ADDRESS=0.0.0.0")+b"PIPELINES_BIND_ADDRESS=0.0.0.0\n")
|
|
normalized=files[0].read_bytes()
|
|
self.exercise(directory,existing=True)
|
|
self.assertEqual(normalized,files[0].read_bytes())
|
|
|
|
def test_login_failure_or_cancel_does_not_mark_complete_or_start_server(self):
|
|
for fail, confirm in [("login", "yes"), (None, "no")]:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
with self.assertRaises(ValueError) as raised:
|
|
self.exercise(directory, fail=fail, confirm=confirm)
|
|
self.assertNotIn("private provider", str(raised.exception))
|
|
self.assertTrue(Path(directory, "secrets/ntfy-token.txt").stat().st_size)
|
|
|
|
def test_status_and_publication_failures_are_not_success(self):
|
|
for failure in ["status", "sh", "provider-check", "host"]:
|
|
with tempfile.TemporaryDirectory() as directory, self.assertRaises(ValueError):
|
|
self.exercise(directory, fail=failure)
|
|
|
|
def test_existing_env_is_not_replaced_by_flags(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = Path(directory, ".env")
|
|
path.write_text("existing settings")
|
|
with self.assertRaises(ValueError):
|
|
setup.Setup(directory).settings(setup.arguments(["--ntfy-url", "https://example.com"]))
|
|
self.assertEqual(path.read_text(), "existing settings")
|
|
|
|
def test_existing_env_rejects_unsafe_bind_override(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path=Path(directory,".env");path.write_text("NTFY_BIND_ADDRESS=127.0.0.1\n")
|
|
with self.assertRaises(ValueError):
|
|
setup.Setup(directory).settings(setup.arguments(["--bind-address","0.0.0.0\nOTHER=bad"]))
|
|
self.assertEqual(path.read_text(),"NTFY_BIND_ADDRESS=127.0.0.1\n")
|
|
|
|
def test_existing_env_symlink_is_not_modified(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
target=Path(directory,"custom.env");target.write_text("keep")
|
|
Path(directory,".env").symlink_to(target)
|
|
with self.assertRaises(ValueError):
|
|
setup.Setup(directory).settings(setup.arguments([]))
|
|
self.assertEqual(target.read_text(),"keep")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|