Turn a ~$5 AliExpress clock into a physical AI usage dashboard (Claude, Codex, multi-account). No firmware flashing.
import contextlib
import io
import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from unittest import mock
from token_tv import cli, sources
from token_tv.display import STYLES
sys.path.insert(0, str(Path(__file__).resolve().parent)) # helpers.py, however the tests are run
from helpers import temp_dir
def run(*argv):
out, err = io.StringIO(), io.StringIO()
# Commands TokenTV prints follow how it was started; these tests read them as an installed `token-tv`.
with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err), \
mock.patch('token_tv.autostart.how', return_value='token-tv'):
code = cli.main(list(argv))
return code, out.getvalue(), err.getvalue()
class CliTest(unittest.TestCase):
def setUp(self):
self.tmp = temp_dir(self)
self.config = self.tmp / 'config.json'
def test_setup_writes_metadata_only_and_never_overwrites(self):
code, out, _ = run('setup', '--config', str(self.config), '--yes',
'--claude-email', '[email protected]', '--device-url', 'http://10.0.0.9/')
self.assertEqual(code, 0)
data = json.loads(self.config.read_text(encoding='utf-8'))
self.assertEqual(data['device_url'], 'http://10.0.0.9')
self.assertEqual(data['accounts'][0], {'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude',
'email': '[email protected]', 'source_home': '~/.claude'})
sources.load_config(self.config) # the daemon accepts what setup writes
before = self.config.read_text(encoding='utf-8')
code, _, err = run('setup', '--config', str(self.config), '--yes', '--codex-email', '[email protected]')
self.assertEqual(code, 1)
self.assertIn('never overwrites', err)
self.assertEqual(self.config.read_text(encoding='utf-8'), before)
def test_setup_without_accounts_fails_and_writes_nothing(self):
code, _, err = run('setup', '--config', str(self.config), '--yes')
self.assertEqual(code, 1)
self.assertFalse(self.config.exists())
self.assertIn('--claude-email', err)
def test_doctor_points_missing_logins_at_connect(self):
home = self.tmp / 'codex-home'
self.config.write_text(json.dumps({'accounts': [
{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex', 'email': '[email protected]',
'source_home': str(home)}]}), encoding='utf-8')
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/codex'):
code, out, _ = run('doctor', '--config', str(self.config))
self.assertEqual(code, 1)
self.assertIn('token-tv connect --config', out)
home.mkdir()
(home / 'auth.json').write_text('{}', encoding='utf-8') # existence only; doctor never opens it
code, out, _ = run('doctor', '--config', str(self.config))
self.assertEqual(code, 0)
self.assertIn('not verified', out)
self.assertNotIn('Ready', out)
bad = {'status': 'identity_mismatch', 'identity_verified': False}
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/codex'), \
mock.patch('token_tv.sources.fetch_account', return_value=bad):
code, out, _ = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 1)
self.assertIn('IDENTITY_MISMATCH', out)
good = {'status': 'ok', 'identity_verified': True}
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/codex'), \
mock.patch('token_tv.sources.fetch_account', return_value=good):
code, out, _ = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 0)
self.assertIn('Ready', out)
def test_doctor_never_calls_an_unchecked_keychain_ready(self):
self.config.write_text(json.dumps({'accounts': [
{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude', 'email': '[email protected]',
'source_home': str(self.tmp / 'empty')}]}), encoding='utf-8')
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/claude'), \
mock.patch.object(cli.sys, 'platform', 'darwin'):
code, out, _ = run('doctor', '--config', str(self.config))
self.assertEqual(code, 1)
self.assertIn('Keychain unchecked', out)
def test_doctor_checks_codexbar_instead_of_a_login_file(self):
self.config.write_text(json.dumps({'accounts': [
{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude', 'email': '[email protected]',
'codexbar_command': str(self.tmp / 'missing-codexbar'), 'codexbar_source': 'oauth'}]}), encoding='utf-8')
code, out, _ = run('doctor', '--config', str(self.config))
self.assertEqual(code, 1)
self.assertIn('install the CodexBar CLI', out)
self.assertNotIn('token-tv connect', out)
unreported = {'status': 'ok', 'identity_verified': False}
with mock.patch('token_tv.sources.fetch_account', return_value=unreported):
code, out, _ = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 0)
self.assertIn('CodexBar did not report the email for CLAUDE A', out)
failed = {'status': 'error', 'identity_verified': False}
with mock.patch('token_tv.sources.fetch_account', return_value=failed):
code, out, _ = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 1)
self.assertIn('live check ERROR', out)
def test_doctor_live_names_each_failing_account_and_exits_non_zero(self):
self.config.write_text(json.dumps({'accounts': [
{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude', 'email': '[email protected]', 'source_home': '~/.claude'},
{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex', 'email': '[email protected]', 'source_home': '~/.codex'},
{'key': 'copilot_a', 'alias': 'COPILOT A', 'provider': 'copilot', 'email': '[email protected]',
'codexbar_command': 'codexbar'}]}), encoding='utf-8')
rows = {'claude_a': {'status': 'stale', 'error_code': 'http_401', 'identity_verified': True},
'codex_a': {'status': 'ok', 'identity_verified': True},
'copilot_a': {'status': 'error', 'error_code': 'format_changed', 'identity_verified': False}}
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), \
mock.patch('token_tv.sources.fetch_account', side_effect=lambda a: dict(rows[a['key']], key=a['key'])):
code, out, err = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 1)
failing = [line for line in out.splitlines() if line.startswith('failing: ')]
self.assertEqual(failing, ['failing: provider=claude alias="CLAUDE A" status=stale error_code=http_401',
'failing: provider=copilot alias="COPILOT A" status=error error_code=format_changed'])
self.assertNotIn('example.com', out + err)
rows.update(claude_a={'status': 'ok', 'identity_verified': True}, copilot_a={'status': 'ok', 'identity_verified': True})
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), \
mock.patch('token_tv.sources.fetch_account', side_effect=lambda a: dict(rows[a['key']], key=a['key'])):
code, out, _ = run('doctor', '--config', str(self.config), '--live')
self.assertEqual(code, 0)
self.assertNotIn('failing: ', out)
def test_broken_config_gets_a_sentence_not_a_traceback(self):
self.config.write_text('{"accounts": [', encoding='utf-8')
for command in ('doctor', 'run'):
code, _, err = run(command, '--config', str(self.config))
self.assertEqual(code, 1)
self.assertIn('not a valid TokenTV config', err)
def test_setup_two_accounts_reuse_then_isolate(self):
code, out, _ = run('setup', '--config', str(self.config), '--yes',
'--codex-email', '[email protected]', '--codex-email', '[email protected]')
self.assertEqual(code, 0)
a, b = json.loads(self.config.read_text(encoding='utf-8'))['accounts']
self.assertEqual((a['key'], a['source_home']), ('codex_a', '~/.codex'))
self.assertEqual((b['key'], b['alias'], b['source_home']),
('codex_b', 'CODEX B', str(self.tmp / 'homes' / 'codex_b')))
self.assertIn('separate login', out)
sources.load_config(self.config)
def test_setup_isolate_never_points_at_the_everyday_home(self):
run('setup', '--config', str(self.config), '--yes', '--isolate', '--claude-email', '[email protected]')
self.assertNotEqual(json.loads(self.config.read_text(encoding='utf-8'))['accounts'][0]['source_home'], '~/.claude')
def test_bad_clock_address_is_rejected_before_writing(self):
for bad in ('ftp://clock', 'http://', 'http://clock/photo', 'http://clock:99999'):
code, _, err = run('setup', '--config', str(self.config), '--yes',
'--claude-email', '[email protected]', '--device-url', bad)
self.assertEqual(code, 1, bad)
self.assertFalse(self.config.exists())
self.assertEqual(cli.device_address('http://10.0.0.9:8080/'), 'http://10.0.0.9:8080')
code, _, _ = run('setup', '--config', str(self.config), '--yes', '--claude-email', '[email protected]',
'--device-url', '192.168.0.50') # a bare address, as start takes it
self.assertEqual((code, json.loads(self.config.read_text(encoding='utf-8'))['device_url']), (0, 'http://192.168.0.50'))
def test_doctor_without_config_points_to_start(self):
code, _, err = run('doctor', '--config', str(self.config))
self.assertEqual(code, 1)
self.assertIn('token-tv start', err)
def test_demo_renders_every_face_from_sample_data(self):
code, out, _ = run('demo', '--out', str(self.tmp / 'demo'), '--scale', '2')
self.assertEqual(code, 0)
files = list((self.tmp / 'demo').iterdir())
self.assertEqual(len([p for p in files if '@' not in p.name]), len(STYLES))
self.assertIn('demo-space.gif', [p.name for p in files])
signature = {'.jpg': b'\xff\xd8\xff', '.gif': b'GIF8', '.png': b'\x89PNG'}
for path in files: # every extension matches the bytes inside
self.assertTrue(path.read_bytes().startswith(signature[path.suffix]), path.name)
self.assertIn('Sample data only', out)
class KeychainTest(unittest.TestCase):
def test_service_names_follow_claude_code(self):
root = Path('/Users/me/.token-tv/claude-b')
self.assertEqual(sources.keychain_services(root), ['Claude Code-credentials-' + __import__('hashlib')
.sha256(str(root).encode()).hexdigest()[:8]])
default = Path('~/.claude').expanduser()
self.assertEqual(sources.keychain_services(default)[-1], 'Claude Code-credentials')
def test_keychain_is_used_only_on_macos_without_a_file(self):
root = temp_dir(self)
with mock.patch.object(sources.sys, 'platform', 'linux'):
with self.assertRaises(FileNotFoundError):
sources.claude_token(root)
found = mock.Mock(returncode=0, stdout=json.dumps({'claudeAiOauth': {'accessToken': 'synthetic'}}))
with mock.patch.object(sources.sys, 'platform', 'darwin'), \
mock.patch.object(sources.subprocess, 'run', return_value=found) as call, \
mock.patch.dict(os.environ, {'USER': 'me'}):
self.assertEqual(sources.claude_token(root), 'synthetic')
self.assertEqual(call.call_args[0][0][:5], ['security', 'find-generic-password', '-a', 'me', '-w'])
missing = mock.Mock(returncode=44, stdout='')
with mock.patch.object(sources.sys, 'platform', 'darwin'), \
mock.patch.object(sources.subprocess, 'run', return_value=missing):
with self.assertRaises(sources.SourceError):
sources.claude_token(root)
if __name__ == '__main__':
unittest.main()
class ConnectGuardTest(unittest.TestCase):
def test_everyday_login_is_kept_without_explicit_replace(self):
from token_tv import connect
home = temp_dir(self)
(home / '.codex').mkdir()
(home / '.codex' / 'auth.json').write_text('{}', encoding='utf-8')
config = home / 'config.json'
config.write_text(json.dumps({'accounts': [{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex',
'email': '[email protected]', 'source_home': '~/.codex'}]}), encoding='utf-8')
with mock.patch.dict(os.environ, {'HOME': str(home), 'USERPROFILE': str(home)}), \
mock.patch.object(connect.subprocess, 'run') as login, \
mock.patch.object(connect.sys, 'argv', ['connect', '--config', str(config), '--account', 'codex_a']):
out = io.StringIO()
with contextlib.redirect_stdout(out):
connect.main()
login.assert_not_called()
self.assertIn('Kept the existing login', out.getvalue())
def test_macos_keychain_login_is_protected_without_a_file(self):
from token_tv import connect
home = temp_dir(self) # no ~/.claude/.credentials.json at all
config = home / 'config.json'
config.write_text(json.dumps({'accounts': [{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude',
'email': '[email protected]', 'source_home': '~/.claude'}]}), encoding='utf-8')
with mock.patch.dict(os.environ, {'HOME': str(home)}), \
mock.patch.object(connect.sys, 'platform', 'darwin'), \
mock.patch.object(connect.subprocess, 'run') as login, \
mock.patch.object(connect.sys, 'argv', ['connect', '--config', str(config), '--account', 'claude_a']):
out = io.StringIO()
with contextlib.redirect_stdout(out):
connect.main()
login.assert_not_called()
self.assertIn('Keychain', out.getvalue())
class AddTest(unittest.TestCase):
def test_another_account_gets_its_own_login_and_is_signed_in(self):
from token_tv import connect
config = temp_dir(self) / 'config.json'
config.write_text(json.dumps({'accounts': [{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex',
'email': '[email protected]', 'source_home': '~/.codex'}]}), encoding='utf-8')
with mock.patch.object(connect, 'main') as login:
code, out, _ = run('add', 'codex', '--email', '[email protected]', '--config', str(config))
self.assertEqual(code, 0)
added = json.loads(config.read_text(encoding='utf-8'))['accounts'][1]
self.assertEqual((added['key'], added['alias'], added['email']), ('codex_b', 'CODEX B', '[email protected]'))
self.assertEqual(added['source_home'], str(config.parent / 'homes' / 'codex_b')) # the everyday login untouched
login.assert_called_once()
code, _, err = run('add', 'codex', '--config', str(config)) # no email, not at a terminal
self.assertEqual(code, 1)
self.assertIn('--email', err)
class ConfigWriteTest(unittest.TestCase):
def test_a_change_from_the_command_line_keeps_what_the_running_copy_saved_meanwhile(self):
config = temp_dir(self) / 'config.json'
stale = {'display_style': 'pixel', 'accounts': []}
config.write_text(json.dumps(dict(stale, display_style='neon')), encoding='utf-8') # the dashboard switched to neon
with contextlib.redirect_stdout(io.StringIO()):
cli.save_clock(config, dict(stale), '192.168.0.9')
saved = json.loads(config.read_text(encoding='utf-8'))
self.assertEqual((saved['display_style'], saved['device_url']), ('neon', 'http://192.168.0.9'))
def test_printed_commands_carry_a_custom_config(self):
with mock.patch('token_tv.autostart.how', return_value='npx token-tv'):
cli.CONFIG = '/tmp/other/config.json'
self.assertEqual(cli.cmd('doctor'), 'npx token-tv doctor --config /tmp/other/config.json')
cli.CONFIG = cli.default_config()
self.assertEqual(cli.cmd('doctor'), 'npx token-tv doctor')
cli.CONFIG = None
class PortTest(unittest.TestCase):
def test_another_program_on_8787_moves_the_dashboard_to_the_next_free_port(self):
import socket
with socket.socket() as taken:
try:
taken.bind(('127.0.0.1', 8787))
except OSError:
self.skipTest('8787 is in use here already')
taken.listen()
with mock.patch.object(cli, 'running', return_value=False):
port, already = cli.dashboard_port()
self.assertEqual((port, already), (8788, False))
def test_a_dashboard_already_answering_is_reused(self):
with mock.patch.object(cli, 'running', side_effect=lambda port: port == 8789):
with mock.patch('socket.socket.bind', side_effect=OSError):
self.assertEqual(cli.dashboard_port(), (8789, True))
class StartTest(unittest.TestCase):
def setUp(self):
self.config = temp_dir(self) / 'config.json'
def start(self, *extra, emails=None, found=(), already=False, yes=True):
from token_tv import live
emails = emails or {'claude': '[email protected]', 'codex': None}
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), \
mock.patch.object(cli, 'login_state', side_effect=lambda p, h: 'yes' if p != 'grok' else 'no'), \
mock.patch('token_tv.sources.logged_in_email', side_effect=lambda p, h, why=None: emails.get(p)) as detect, \
mock.patch('token_tv.device.find_clocks', return_value=list(found)) as scan, \
mock.patch('token_tv.device.clock_info', return_value=None), \
mock.patch.object(cli, 'dashboard_port', return_value=(8787, already)), \
mock.patch.object(live, 'main') as run:
code, out, err = run_cli('start', '--config', str(self.config), *(['--yes'] if yes else []), '--no-browser', *extra)
self.scan = scan
return code, out, err, detect, run
def test_finds_the_clock_on_the_wifi_and_defaults_to_arcade(self):
code, out, _, _, run = self.start(found=['http://192.168.219.105'])
self.assertEqual(code, 0)
data = json.loads(self.config.read_text(encoding='utf-8'))
self.assertEqual((data['device_url'], data['display_style']), ('http://192.168.219.105', 'arcade'))
self.assertIn('Found a clock at 192.168.219.105', out)
run.assert_called_once()
def test_no_clock_found_runs_the_dashboard_alone(self):
code, out, _, _, run = self.start()
self.assertEqual(code, 0)
self.assertNotIn('device_url', json.loads(self.config.read_text(encoding='utf-8')))
self.assertIn('No clock found', out)
def test_started_again_by_hand_it_looks_for_the_clock_but_never_on_its_own(self):
self.start() # set up with no clock
self.assertNotIn('device_url', json.loads(self.config.read_text(encoding='utf-8')))
self.start() # --yes, as the computer starts it: a lone clock on a shared Wi-Fi may be someone else's
self.scan.assert_not_called()
with mock.patch('sys.stdin.isatty', return_value=True), mock.patch('builtins.input', return_value=''):
code, out, _, _, _ = self.start(found=['http://192.168.0.77'], already=True, yes=False)
self.assertEqual(code, 0)
self.assertEqual(json.loads(self.config.read_text(encoding='utf-8'))['device_url'], 'http://192.168.0.77')
self.assertIn('Found a clock at 192.168.0.77', out)
def test_an_https_address_is_kept_as_the_http_the_clock_speaks(self):
self.start('--device-url', 'https://192.168.0.50')
self.assertEqual(json.loads(self.config.read_text(encoding='utf-8'))['device_url'], 'http://192.168.0.50')
def test_an_address_given_is_not_searched_for(self):
self.start('--device-url', '192.168.0.50')
self.scan.assert_not_called()
def test_only_and_face_from_the_web_demo(self):
both = {'claude': '[email protected]', 'codex': '[email protected]'}
code, _, _, _, _ = self.start('--only', 'codex', '--face', 'pixel', '--device-url', '10.0.0.5', emails=both)
self.assertEqual(code, 0)
data = json.loads(self.config.read_text(encoding='utf-8'))
self.assertEqual([a['provider'] for a in data['accounts']], ['codex'])
self.assertEqual(data['display_style'], 'pixel')
@unittest.skipIf(sys.platform == 'win32', 'the stand-in codexbar is a script with a #! line')
def test_a_codexbar_user_is_set_up_from_what_codexbar_reads(self):
import os, stat, sys
folder = temp_dir(self)
fake = folder / 'codexbar' # answers like `codexbar usage --provider <p> --format json`
fake.write_text(f"""#!{sys.executable}
import json, sys
provider = sys.argv[sys.argv.index('--provider') + 1]
usage = {{'primary': {{'usedPercent': 12, 'windowMinutes': 300}}}}
if provider == 'codex':
usage['accountEmail'] = '[email protected]'
if provider == 'claude':
print(json.dumps([{{'provider': 'claude', 'error': {{'message': 'not signed in'}}}}])); sys.exit(1)
print(json.dumps([{{'provider': provider, 'usage': usage}}]))
""", encoding='utf-8')
fake.chmod(fake.stat().st_mode | stat.S_IXUSR)
with mock.patch.dict(os.environ, {'PATH': f'{folder}{os.pathsep}{os.environ["PATH"]}'}):
code, out, _, _, run = self.start('--device-url', '10.0.0.5', emails={'claude': None, 'codex': None})
self.assertEqual(code, 0)
accounts = json.loads(self.config.read_text(encoding='utf-8'))['accounts']
self.assertEqual([(a['provider'], a['email'], a['codexbar_command']) for a in accounts],
[('codex', '[email protected]', 'codexbar'), ('copilot', 'not reported by CodexBar', 'codexbar'),
('antigravity', 'not reported by CodexBar', 'codexbar')])
self.assertIn('Copilot: through CodexBar', out)
run.assert_called_once()
def test_only_a_codexbar_service_without_codexbar_says_how(self):
with mock.patch('shutil.which', return_value=None):
code, _, err, _, _ = self.start('--only', 'copilot')
self.assertEqual(code, 1)
self.assertIn('install CodexBar', err)
def test_on_a_mac_a_browser_only_claude_user_is_told_about_codexbar(self):
with mock.patch('sys.platform', 'darwin'), mock.patch('shutil.which', return_value=None):
code, _, err, _, _ = self.start(emails={'claude': None, 'codex': None})
self.assertEqual(code, 1)
self.assertIn('Claude in the browser only, on a Mac', err)
with mock.patch('sys.platform', 'linux'), mock.patch('shutil.which', return_value=None):
_, _, err, _, _ = self.start(emails={'claude': None, 'codex': None})
self.assertNotIn('on a Mac', err)
def test_only_a_service_not_signed_in_says_which(self):
code, _, err, _, run = self.start('--only', 'codex')
self.assertEqual(code, 1)
self.assertIn('No signed-in Codex CLI', err)
run.assert_not_called()
def test_only_naming_more_than_is_signed_in_still_sets_up(self):
code, _, _, _, run = self.start('--only', 'claude,codex', '--device-url', '10.0.0.5') # only Claude signed in
self.assertEqual(code, 0)
self.assertEqual([a['provider'] for a in json.loads(self.config.read_text(encoding='utf-8'))['accounts']], ['claude'])
run.assert_called_once()
def test_already_running_still_refuses_a_conflicting_only_and_switches_the_face(self):
self.config.write_text(json.dumps({'accounts': [
{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude', 'email': '[email protected]', 'source_home': '~/.claude'}]}), encoding='utf-8')
code, _, err, _, _ = self.start('--only', 'codex', already=True)
self.assertEqual(code, 1)
self.assertIn('claude as well', err)
with mock.patch.object(cli, 'show_face') as face:
code, out, _, _, _ = self.start('--face', 'neon', already=True)
self.assertEqual(code, 0)
face.assert_called_once_with(8787, 'neon')
def test_a_login_that_did_not_answer_says_why(self):
def refused(p, h, why=None):
why.append('refused' if p == 'claude' else 'not_chatgpt')
return None
from token_tv import live
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), mock.patch.object(cli, 'login_state', return_value='yes'), \
mock.patch('token_tv.sources.logged_in_email', side_effect=refused), mock.patch('token_tv.device.find_clocks', return_value=[]), \
mock.patch.object(cli, 'dashboard_port', return_value=(8787, False)), mock.patch.object(live, 'main'):
code, _, err = run_cli('start', '--config', str(self.config), '--yes', '--no-browser', '--only', 'claude,codex')
self.assertEqual(code, 1)
self.assertIn('Claude: signed in, but the saved login was refused', err)
self.assertIn('Codex: signed in with an API key', err)
self.assertNotIn('Grok:', err) # only the tools asked for
def test_only_rejects_unknown_services(self):
code, _, err, _, _ = self.start('--only', 'gemini')
self.assertEqual(code, 1)
self.assertIn('--only takes', err)
def test_a_face_given_again_is_kept_in_the_existing_config(self):
self.saved_config('http://192.168.0.50')
code, _, _, _, run = self.start('--face', 'neon')
self.assertEqual(code, 0)
self.assertEqual(json.loads(self.config.read_text(encoding='utf-8'))['display_style'], 'neon')
run.assert_called_once()
def test_already_running_opens_it_and_starts_no_second_copy(self):
code, out, _, detect, run = self.start(already=True)
self.assertEqual(code, 0)
self.assertIn('already running', out)
self.assertFalse(self.config.exists())
run.assert_not_called()
def test_the_background_question_is_asked_only_when_the_config_is_made(self):
from token_tv import autostart, live
self.saved_config('http://192.168.0.50')
with mock.patch.object(cli, 'dashboard_port', return_value=(8787, False)), \
mock.patch('sys.stdin.isatty', return_value=True), mock.patch.object(cli, 'ask', return_value='y') as ask, \
mock.patch.object(autostart, 'status', return_value='off'), mock.patch.object(live, 'main'):
run_cli('start', '--config', str(self.config), '--no-browser')
self.assertFalse(any('computer' in c.args[0] for c in ask.call_args_list))
def test_asked_once_to_start_with_the_computer(self):
from token_tv import autostart, live
for answer, background in (('y', True), ('n', False)):
self.config.unlink(missing_ok=True)
with mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), \
mock.patch.object(cli, 'login_state', return_value='yes'), \
mock.patch('token_tv.sources.logged_in_email', side_effect=lambda p, h, why=None: '[email protected]' if p == 'codex' else None), \
mock.patch('token_tv.device.find_clocks', return_value=[]), \
mock.patch.object(cli, 'dashboard_port', side_effect=[(8787, False), (8788, True)]), \
mock.patch('sys.stdin.isatty', return_value=True), \
mock.patch.object(cli, 'ask', side_effect=lambda prompt, default='': answer if 'computer' in prompt else 'y' if '[Y/n]' in prompt else ''), \
mock.patch.object(autostart, 'status', return_value='off'), \
mock.patch.object(autostart, 'install', return_value='Runs in the background now') as install, \
mock.patch.object(live, 'main') as run:
code, out, _ = run_cli('start', '--config', str(self.config), '--no-browser')
self.assertEqual(code, 0)
self.assertEqual(install.called, background, answer)
self.assertEqual(run.called, not background, answer)
if background:
self.assertIn('Dashboard: http://127.0.0.1:8788', out) # where the background copy answered
def test_a_background_copy_that_never_answers_is_reported(self):
from token_tv import autostart, live
with mock.patch.object(cli, 'dashboard_port', return_value=(8787, False)), \
mock.patch.object(cli, 'cli_path', return_value='/usr/bin/x'), mock.patch.object(cli, 'login_state', return_value='yes'), \
mock.patch('token_tv.sources.logged_in_email', side_effect=lambda p, h, why=None: '[email protected]' if p == 'codex' else None), \
mock.patch('token_tv.device.find_clocks', return_value=[]), \
mock.patch('sys.stdin.isatty', return_value=True), mock.patch.object(cli, 'ask', return_value='y'), \
mock.patch.object(autostart, 'status', return_value='off'), \
mock.patch.object(autostart, 'install', return_value='ok'), mock.patch.object(cli.time, 'sleep'), \
mock.patch.object(live, 'main') as run:
code, _, err = run_cli('start', '--config', str(self.config), '--no-browser')
self.assertEqual(code, 1)
self.assertIn('autostart status', err)
run.assert_not_called()
def test_only_on_an_existing_config_with_other_services_is_refused(self):
self.config.write_text(json.dumps({'accounts': [
{'key': 'claude_a', 'alias': 'CLAUDE A', 'provider': 'claude', 'email': '[email protected]', 'source_home': '~/.claude'},
{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex', 'email': '[email protected]', 'source_home': '~/.codex'}]}), encoding='utf-8')
code, _, err, _, run = self.start('--only', 'codex')
self.assertEqual(code, 1)
self.assertIn('claude as well', err)
run.assert_not_called()
def test_detects_signed_in_email_and_runs(self):
code, out, _, detect, run = self.start('--device-url', '192.168.0.50')
self.assertEqual(code, 0)
data = json.loads(self.config.read_text(encoding='utf-8'))
self.assertEqual([(a['provider'], a['email']) for a in data['accounts']], [('claude', '[email protected]')])
self.assertEqual(data['device_url'], 'http://192.168.0.50') # bare IP is accepted
run.assert_called_once()
def test_existing_config_skips_detection(self):
self.config.write_text(json.dumps({'accounts': [{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex',
'email': '[email protected]', 'source_home': '~/.codex'}]}), encoding='utf-8')
code, _, _, detect, run = self.start()
self.assertEqual(code, 0)
detect.assert_not_called()
run.assert_called_once()
def saved_config(self, device_url):
config = {'device_url': device_url, 'accounts': [{'key': 'codex_a', 'alias': 'CODEX A', 'provider': 'codex',
'email': '[email protected]', 'source_home': '~/.codex'}]}
self.config.write_text(json.dumps(config), encoding='utf-8')
return config
def test_a_clock_address_given_later_is_kept_in_the_config(self):
# Reported in #7 (an address silently ignored) and by QA: a clock added after the first start.
self.saved_config('http://192.168.0.50')
code, out, _, _, run = self.start('--device-url', '192.168.0.77')
self.assertEqual(code, 0)
self.assertIn('http://192.168.0.77', out)
self.assertEqual(json.loads(self.config.read_text(encoding='utf-8'))['device_url'], 'http://192.168.0.77')
run.assert_called_once()
self.config.write_text(json.dumps({'accounts': json.loads(self.config.read_text(encoding='utf-8'))['accounts']})) # no clock yet
code, _, _, _, run = self.start('--device-url', '10.0.0.9', already=True) # while one runs: it takes it up
self.assertEqual((code, json.loads(self.config.read_text(encoding='utf-8'))['device_url']), (0, 'http://10.0.0.9'))
code, _, err, _, _ = self.start('--device-url', 'ftp://nope')
self.assertEqual(code, 1)
def test_same_clock_address_with_existing_config_runs(self):
self.saved_config('http://192.168.0.50')
code, _, err, _, run = self.start('--device-url', '192.168.0.50')
self.assertEqual((code, err), (0, ''))
run.assert_called_once()
def test_nothing_signed_in_explains_next_step(self):
from token_tv import live
with mock.patch.object(cli, 'cli_path', return_value=None), mock.patch.object(live, 'main') as run:
code, _, err = run_cli('start', '--config', str(self.config), '--yes', '--no-browser')
self.assertEqual(code, 1)
self.assertIn('token-tv demo', err)
self.assertFalse(self.config.exists())
run.assert_not_called()
def run_cli(*argv):
return run(*argv)