catarrh
6bea57599c
A suite may carry `start_reset` (store schema v2, default false; the editor's
"Start with card reset" checkbox): before the run, the server physically
resets the card and runs the full re-initialization - `_card_reset_reinit`
(extracted from the eSIM profile-switch reinit) does reset_card() + equip +
_apply_equipped_card + the shell registration probe.
The reset runs in _test_suite_run_request before the preset/ADM checks:
- the run's preset must still match the post-reset ICCID (a mismatch refuses
the start with a re-select hint),
- a require_adm suite re-verifies the ADM for the new card session (the
latch is per session).
The suite report carries start_reset + reset {ok, iccid, ms}; the PWA shows
"started with a card reset" in the report header and a RESET badge in the
suite list. Mid-run resets stay fatal.
Documented caveat: the init drain consumes the card's initial proactive
commands, so a script cannot catch the first command after the reset (they
stay in the proactive log).
Docs: test-scripts.md, api.md, help EN/RU, repo AGENTS.
Tests: 843 frontend + 827 Python; sw cache simple-v413.
340 lines
17 KiB
Python
340 lines
17 KiB
Python
"""Test suite store tests (server-side suites, v3.22.0).
|
|
|
|
A suite groups the test scripts: the root object, holding the ordered member
|
|
list by reference (setup first, members, teardown last - the store
|
|
normalises the order), the per-member on_fail policy and the suite-level
|
|
require_adm flag. The cross-store rules live in the HTTP layer; this file
|
|
covers the store's own shape, ordering, persistence and import behaviour.
|
|
"""
|
|
|
|
import json
|
|
import pathlib
|
|
import tempfile
|
|
import unittest
|
|
|
|
from pysim_simple_server import test_suites
|
|
|
|
SID_A = 'a' * 32
|
|
SID_B = 'b' * 32
|
|
SID_C = 'c' * 32
|
|
|
|
|
|
def make_store(tmp):
|
|
return test_suites.TestSuiteStore(pathlib.Path(tmp) / 'test_suites.json')
|
|
|
|
|
|
def suite(name='demo', scripts=None, **kw):
|
|
s = {'name': name, 'scripts': scripts if scripts is not None else []}
|
|
s.update(kw)
|
|
return s
|
|
|
|
|
|
class StoreCrudTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.store = make_store(self.tmp.name)
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_add_list_get_and_remove(self):
|
|
s = self.store.add(suite())
|
|
self.assertEqual(len(s['id']), 32)
|
|
self.assertEqual(s['name'], 'demo')
|
|
self.assertEqual(s['require_adm'], False)
|
|
self.assertEqual(self.store.list()[0]['id'], s['id'])
|
|
self.assertTrue(self.store.remove(s['id']))
|
|
self.assertEqual(self.store.list(), [])
|
|
self.assertFalse(self.store.remove(s['id']))
|
|
self.assertIsNone(self.store.get('nope'))
|
|
|
|
def test_start_reset_round_trips(self):
|
|
# v3.23.0: a suite may start with a card reset (the full re-init); the
|
|
# flag defaults false and survives add/update/reload
|
|
s = self.store.add(suite(name='reset me', start_reset=True))
|
|
self.assertTrue(s['start_reset'])
|
|
# a partial update keeps it; a reload keeps it
|
|
updated = self.store.update(s['id'], {'name': 'renamed'})
|
|
self.assertTrue(updated['start_reset'])
|
|
reloaded = make_store(self.tmp.name)
|
|
self.assertTrue(reloaded.get(s['id'])['start_reset'])
|
|
# an explicit false clears it
|
|
self.assertFalse(self.store.update(s['id'], {'start_reset': False})['start_reset'])
|
|
self.assertFalse(self.store.add(suite())['start_reset'])
|
|
|
|
def test_callers_never_mutate_the_store(self):
|
|
s = self.store.add(suite(scripts=[
|
|
{'script_id': SID_A, 'role': 'member', 'on_fail': 'stop'}]))
|
|
s['scripts'][0]['on_fail'] = 'continue'
|
|
s['name'] = 'hacked'
|
|
self.assertEqual(self.store.get(s['id'])['name'], 'demo')
|
|
self.assertEqual(self.store.get(s['id'])['scripts'][0]['on_fail'], 'stop')
|
|
|
|
def test_roles_are_ordered_setup_first_teardown_last(self):
|
|
# a caller may send any order; the store normalises it and marks the
|
|
# roles - setup first, teardown last, members keep their order
|
|
s = self.store.add(suite(scripts=[
|
|
{'script_id': SID_C, 'role': 'teardown', 'on_fail': 'stop'},
|
|
{'script_id': SID_A, 'role': 'member', 'on_fail': 'continue'},
|
|
{'script_id': SID_B, 'role': 'member', 'on_fail': 'stop'},
|
|
{'script_id': SID_A.replace('a', 'd'), 'role': 'setup', 'on_fail': 'stop'},
|
|
]))
|
|
ids = [e['script_id'] for e in s['scripts']]
|
|
self.assertEqual(ids[0], 'd' * 32)
|
|
self.assertEqual(ids[-1], SID_C)
|
|
self.assertEqual(ids[1:3], [SID_A, SID_B])
|
|
roles = [e['role'] for e in s['scripts']]
|
|
self.assertEqual(roles, ['setup', 'member', 'member', 'teardown'])
|
|
self.assertEqual(s['scripts'][1]['on_fail'], 'continue')
|
|
|
|
def test_shape_is_validated(self):
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add('nope')
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts='nope'))
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[{'script_id': 'short'}]))
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[{'script_id': SID_A, 'role': 'boss'}]))
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[{'script_id': SID_A, 'on_fail': 'maybe'}]))
|
|
# one script appears once per suite
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[
|
|
{'script_id': SID_A}, {'script_id': SID_A}]))
|
|
# at most one setup / teardown
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[
|
|
{'script_id': SID_A, 'role': 'setup'},
|
|
{'script_id': SID_B, 'role': 'setup'}]))
|
|
with self.assertRaises(test_suites.TestSuiteError):
|
|
self.store.add(suite(scripts=[
|
|
{'script_id': SID_A, 'role': 'teardown'},
|
|
{'script_id': SID_B, 'role': 'teardown'}]))
|
|
|
|
def test_update_keeps_id_and_created(self):
|
|
s = self.store.add(suite(name='one'))
|
|
updated = self.store.update(s['id'], {
|
|
'name': 'two', 'require_adm': True,
|
|
'scripts': [{'script_id': SID_A, 'role': 'member', 'on_fail': 'stop'}]})
|
|
self.assertEqual(updated['id'], s['id'])
|
|
self.assertEqual(updated['created'], s['created'])
|
|
self.assertEqual(updated['name'], 'two')
|
|
self.assertTrue(updated['require_adm'])
|
|
self.assertEqual(len(updated['scripts']), 1)
|
|
self.assertIsNone(self.store.update('nope', {'name': 'x'}))
|
|
|
|
def test_find_by_name(self):
|
|
self.store.add(suite(name='alpha'))
|
|
self.assertEqual(self.store.find_by_name('alpha')['name'], 'alpha')
|
|
self.assertIsNone(self.store.find_by_name('beta'))
|
|
|
|
|
|
class StorePersistenceTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.path = pathlib.Path(self.tmp.name) / 'test_suites.json'
|
|
self.store = test_suites.TestSuiteStore(self.path)
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_round_trip_keeps_ids_and_timestamps(self):
|
|
s = self.store.add(suite(require_adm=True, scripts=[
|
|
{'script_id': SID_A, 'role': 'member', 'on_fail': 'stop'}]))
|
|
again = test_suites.TestSuiteStore(self.path)
|
|
got = again.get(s['id'])
|
|
self.assertEqual(got['name'], s['name'])
|
|
self.assertEqual(got['created'], s['created'])
|
|
self.assertTrue(got['require_adm'])
|
|
self.assertEqual(got['scripts'], s['scripts'])
|
|
|
|
def test_the_file_carries_the_schema_version(self):
|
|
self.store.add(suite())
|
|
data = json.loads(self.path.read_text())
|
|
self.assertEqual(data['version'], test_suites.SCHEMA_VERSION)
|
|
|
|
def test_an_entry_with_a_dangling_reference_is_kept(self):
|
|
# a referenced script removed by hand (or an import that lost it): the
|
|
# suite keeps loading - it is served (the editor shows the missing
|
|
# reference) and the HTTP layer refuses a save/run until it is fixed
|
|
self.store.add(suite(scripts=[{'script_id': SID_A, 'role': 'member',
|
|
'on_fail': 'stop'}]))
|
|
again = test_suites.TestSuiteStore(self.path)
|
|
self.assertEqual(len(again.list()), 1)
|
|
self.assertEqual(again.list()[0]['scripts'][0]['script_id'], SID_A)
|
|
|
|
def test_a_shape_invalid_entry_is_dropped_with_a_log(self):
|
|
# an unreadable entry (a malformed script id) is not servable: unlike
|
|
# the engine-validated scripts, the store's own shape check drops it
|
|
self.store.add(suite())
|
|
raw = json.loads(self.path.read_text())
|
|
raw['suites'][0]['scripts'] = [{'script_id': 'short', 'role': 'member',
|
|
'on_fail': 'stop'}]
|
|
self.path.write_text(json.dumps(raw))
|
|
again = test_suites.TestSuiteStore(self.path)
|
|
self.assertEqual(again.list(), [])
|
|
|
|
|
|
class StoreImportTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.store = make_store(self.tmp.name)
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_import_merge_and_replace(self):
|
|
self.store.add(suite(name='old'))
|
|
result = self.store.import_suites([suite(name='new', scripts=[
|
|
{'script_id': SID_A, 'role': 'member', 'on_fail': 'stop'}])])
|
|
self.assertEqual(result['added'], 1)
|
|
self.assertEqual(result['skipped'], 0)
|
|
self.assertEqual([s['name'] for s in self.store.list()], ['old', 'new'])
|
|
result = self.store.import_suites([suite(name='third')], 'replace')
|
|
self.assertEqual(result['added'], 1)
|
|
self.assertEqual([s['name'] for s in self.store.list()], ['third'])
|
|
|
|
def test_import_keeps_a_given_id_and_reassigns_a_duplicate(self):
|
|
s = self.store.add(suite(name='one'))
|
|
entry = dict(s, name='copy')
|
|
result = self.store.import_suites([entry])
|
|
self.assertEqual(result['added'], 1)
|
|
ids = sorted(x['id'] for x in self.store.list())
|
|
self.assertEqual(len(set(ids)), 2)
|
|
self.assertIn(s['id'], ids)
|
|
|
|
def test_import_reports_invalid_entries(self):
|
|
result = self.store.import_suites([suite(name='bad', scripts=[
|
|
{'script_id': 'nope'}]), suite(name='ok')])
|
|
self.assertEqual(result['added'], 1)
|
|
self.assertEqual(result['skipped'], 1)
|
|
self.assertTrue(result['errors'])
|
|
|
|
|
|
class MigrationTests(unittest.TestCase):
|
|
"""v3.21.0 -> v3.22.0: scripts without a suite are attached to an
|
|
auto-created "Imported scripts" suite, once (idempotent)."""
|
|
|
|
def test_orphans_are_attached_to_the_imported_suite(self):
|
|
from pysim_simple_server import server as srv
|
|
from pysim_simple_server import test_scripts
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
scripts = test_scripts.TestScriptStore(pathlib.Path(tmp) / 's.json')
|
|
suites = test_suites.TestSuiteStore(pathlib.Path(tmp) / 'u.json')
|
|
step = {'type': 'action', 'kind': 'status', 'params': {'attempts': 1}}
|
|
a = scripts.add({'name': 'a', 'steps': [step]})
|
|
b = scripts.add({'name': 'b', 'steps': [step]})
|
|
self.assertEqual(srv.migrate_scripts_to_suites(scripts, suites), 2)
|
|
suite = suites.find_by_name('Imported scripts')
|
|
self.assertIsNotNone(suite)
|
|
self.assertEqual([e['script_id'] for e in suite['scripts']],
|
|
[a['id'], b['id']])
|
|
self.assertEqual([e['role'] for e in suite['scripts']],
|
|
['member', 'member'])
|
|
self.assertEqual(scripts.get(a['id'])['suite_id'], suite['id'])
|
|
# idempotent: nothing left to attach
|
|
self.assertEqual(srv.migrate_scripts_to_suites(scripts, suites), 0)
|
|
|
|
def test_a_duplicate_listing_is_pruned_to_the_explicit_owner(self):
|
|
# v3.22.3: the reconciliation keeps a script in the suite its
|
|
# suite_id names and prunes the other listings (a hand edit or an
|
|
# interrupted move must not leave two owners).
|
|
from pysim_simple_server import server as srv
|
|
from pysim_simple_server import test_scripts
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
scripts = test_scripts.TestScriptStore(pathlib.Path(tmp) / 's.json')
|
|
suites = test_suites.TestSuiteStore(pathlib.Path(tmp) / 'u.json')
|
|
step = {'type': 'action', 'kind': 'status', 'params': {'attempts': 1}}
|
|
a = suites.add({'name': 'A'})
|
|
b = suites.add({'name': 'B'})
|
|
s = scripts.add({'name': 'x', 'suite_id': b['id'], 'steps': [step]})
|
|
for su in (a, b):
|
|
suites.update(su['id'], {'scripts': [
|
|
{'script_id': s['id'], 'role': 'member', 'on_fail': 'stop'}]})
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(scripts, suites), 1)
|
|
self.assertEqual(suites.get(a['id'])['scripts'], [])
|
|
self.assertEqual([e['script_id'] for e in suites.get(b['id'])['scripts']],
|
|
[s['id']])
|
|
self.assertEqual(scripts.get(s['id'])['suite_id'], b['id'])
|
|
# idempotent
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(scripts, suites), 0)
|
|
|
|
def test_a_duplicate_listing_with_a_stale_owner_keeps_the_first_lister(self):
|
|
from pysim_simple_server import server as srv
|
|
from pysim_simple_server import test_scripts
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
scripts = test_scripts.TestScriptStore(pathlib.Path(tmp) / 's.json')
|
|
suites = test_suites.TestSuiteStore(pathlib.Path(tmp) / 'u.json')
|
|
step = {'type': 'action', 'kind': 'status', 'params': {'attempts': 1}}
|
|
a = suites.add({'name': 'A'})
|
|
b = suites.add({'name': 'B'})
|
|
s = scripts.add({'name': 'x', 'suite_id': 'f' * 32, 'steps': [step]})
|
|
for su in (a, b):
|
|
suites.update(su['id'], {'scripts': [
|
|
{'script_id': s['id'], 'role': 'member', 'on_fail': 'stop'}]})
|
|
# the prune of B plus the adoption of the first lister A
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(scripts, suites), 2)
|
|
self.assertEqual([e['script_id'] for e in suites.get(a['id'])['scripts']],
|
|
[s['id']])
|
|
self.assertEqual(suites.get(b['id'])['scripts'], [])
|
|
self.assertEqual(scripts.get(s['id'])['suite_id'], a['id'])
|
|
|
|
def test_an_invalid_script_is_still_listed_by_the_reconciliation(self):
|
|
# The script store keeps an entry that no longer validates (a
|
|
# tightened rule must not destroy it). Its suite_id write is refused
|
|
# by the same validator, but the member list is authoritative: the
|
|
# script must be listed, or it would be invisible in the PWA and
|
|
# could never be fixed in the editor.
|
|
from pysim_simple_server import server as srv
|
|
from pysim_simple_server import test_scripts
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
path = pathlib.Path(tmp) / 's.json'
|
|
step = {'type': 'action', 'kind': 'status', 'params': {'attempts': 1}}
|
|
scripts = test_scripts.TestScriptStore(path) # permissive
|
|
script = scripts.add({'name': 'stale', 'steps': [step]})
|
|
|
|
def validator(raw):
|
|
raise ValueError('the rule tightened')
|
|
|
|
strict = test_scripts.TestScriptStore(path, validator=validator)
|
|
suites = test_suites.TestSuiteStore(pathlib.Path(tmp) / 'u.json')
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(strict, suites), 1)
|
|
imported = suites.find_by_name('Imported scripts')
|
|
self.assertEqual([e['script_id'] for e in imported['scripts']],
|
|
[script['id']])
|
|
# the suite_id write could not go through - the listing is what
|
|
# keeps the script visible and fixable
|
|
self.assertIsNone(strict.get(script['id'])['suite_id'])
|
|
|
|
def test_the_reconciliation_adopts_listed_and_missing_suite_scripts(self):
|
|
# The general invariant repair: a script whose suite_id points at a
|
|
# missing suite (a suites import with mode replace) joins "Imported
|
|
# scripts"; a script a suite lists but whose suite_id is empty or
|
|
# wrong adopts the listing suite (the member list is authoritative).
|
|
from pysim_simple_server import server as srv
|
|
from pysim_simple_server import test_scripts
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
scripts = test_scripts.TestScriptStore(pathlib.Path(tmp) / 's.json')
|
|
suites = test_suites.TestSuiteStore(pathlib.Path(tmp) / 'u.json')
|
|
step = {'type': 'action', 'kind': 'status', 'params': {'attempts': 1}}
|
|
suite_a = suites.add({'name': 'A'})
|
|
gone = 'f' * 32
|
|
lost = scripts.add({'name': 'lost', 'suite_id': gone, 'steps': [step]})
|
|
listed = scripts.add({'name': 'listed', 'steps': [step]})
|
|
suites.update(suite_a['id'], {'scripts': [
|
|
{'script_id': listed['id'], 'role': 'setup', 'on_fail': 'stop'}]})
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(scripts, suites), 2)
|
|
# the listing suite wins (its role is kept)
|
|
self.assertEqual(scripts.get(listed['id'])['suite_id'], suite_a['id'])
|
|
# the lost one is adopted by "Imported scripts"
|
|
imported = suites.find_by_name('Imported scripts')
|
|
self.assertEqual(scripts.get(lost['id'])['suite_id'], imported['id'])
|
|
self.assertEqual([e['script_id'] for e in imported['scripts']], [lost['id']])
|
|
# idempotent
|
|
self.assertEqual(srv.reconcile_scripts_to_suites(scripts, suites), 0)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|