Files
MikrotikManager/backend/scripts/acceptance/chr-netflow-collector-container.test.py
T

144 lines
6.8 KiB
Python

import json
import runpy
import unittest
from pathlib import Path
owner = runpy.run_path(str(Path(__file__).with_name('chr-netflow-collector-container.py')))
RUN = 'a012bcde'
PG_ID = 'a' * 64
NODE_ID = 'b' * 64
PACKET = 'd' * 64
IMAGE_ID = 'sha256:' + 'c' * 64
STARTED = '2026-11-04T12:00:00.000Z'
class DockerFixture:
def __init__(self):
self.calls = []
self.records = {}
self.lose_create = False
def __call__(self, *args):
self.calls.append(args)
if args[:2] == ('image', 'inspect'):
return json.dumps([{'Id': IMAGE_ID, 'Os': 'linux', 'RepoDigests': [args[2]]}])
if args[0] == 'create':
if self.lose_create:
raise RuntimeError('lost ACK')
pg = '--network=none' in args
role, cid = ('postgres', PG_ID) if pg else ('collector', NODE_ID)
self.records[cid] = {'Id': cid, 'Image': IMAGE_ID, 'Config': {'Labels': {
owner['LABEL']: RUN, 'io.mmapp.netflow.role': role}},
'HostConfig': {'NetworkMode': 'none' if pg else 'container:' + PG_ID, 'Privileged': False,
'PortBindings': None, 'ReadonlyRootfs': True, 'CapDrop': ['ALL'], 'CapAdd': None,
'Memory': (192 if pg else 320) * 1024 * 1024,
'MemorySwap': (192 if pg else 320) * 1024 * 1024},
'State': {'Running': False, 'Status': 'created', 'Pid': 0}}
return cid
cid = args[-1]
if args[:2] == ('container', 'inspect'):
return json.dumps([self.records[cid]])
if args[0] == 'start':
self.records[cid]['State'] = {'Running': True, 'Status': 'running', 'Pid': 42, 'StartedAt': STARTED}
elif args[0] == 'stop':
self.records[cid]['State'] = {'Running': False, 'Status': 'exited', 'Pid': 0, 'StartedAt': STARTED, 'ExitCode': 0}
elif args[0] == 'rm':
del self.records[cid]
else:
raise AssertionError(args)
return cid
class TestCollectorLauncher(unittest.TestCase):
def test_exact_images_no_pull_no_privilege_and_fixed_namespace(self):
pg = owner['build_pg'](RUN, 1000, 1000)
node = owner['build_node'](RUN, 1000, 1000, PG_ID, 50100, (4, 5), (4, 6), PACKET)
self.assertIn('--network=none', pg)
self.assertIn('--network=container:' + PG_ID, node)
self.assertIn('listen_addresses=', pg)
for argv in (pg, node):
self.assertIn('--pull=never', argv)
self.assertIn('--cap-drop=ALL', argv)
self.assertNotIn('--privileged', argv)
self.assertNotIn('/var/run/docker.sock', ' '.join(argv))
self.assertNotIn('POSTGRES_PASSWORD=', ' '.join(pg))
with self.assertRaisesRegex(ValueError, 'NAMESPACE_PINS'):
owner['build_node'](RUN, 1000, 1000, PG_ID, 50100, (4, 5), (4, 5), PACKET)
self.assertIn('EN10MB', owner['capture_args'](RUN, '198.18.241.2', '198.18.241.9', 50100))
def test_one_shot_ack_exact_ids_and_verified_cleanup(self):
docker, journal = DockerFixture(), []
launcher = owner['CollectorContainerOwner'](RUN, docker, lambda *entry: journal.append(entry))
self.assertEqual(launcher.create_anchor(1000, 1000), PG_ID)
self.assertEqual(launcher.start_anchor(), 42)
with self.assertRaisesRegex(ValueError, 'ADOPTION_UNCONFIRMED'):
launcher.create_collector(1000, 1000, 50100, (4, 5), (4, 6), PACKET, lambda: None)
anchor = {'containerId': PG_ID, 'pid': 42, 'startedAt': STARTED, 'namespace': [4, 5], 'hostNamespace': [4, 6]}
launcher.anchor_namespace = lambda: anchor
name = 'nf' + RUN + 'nc'
class Topology:
def namespace(self, target):
return [4, 5] if target == name else None
def root_baseline(self):
return 'root-baseline'
class Journal:
value = {}
def provision(backend, journal, planned, pins, read_collector_anchor):
journal.value.update(collectorAnchor=read_collector_anchor(), rootBaseline='root-baseline', state='created')
return {'ns:' + name: backend.namespace(name)}
def cleanup(backend, journal, planned, assert_collector_anchor_exited):
assert_collector_anchor_exited(journal.value['collectorAnchor'])
journal.value['state'] = 'retired'
topology, topology_journal, planned = Topology(), Journal(), {'names': {'C': name}}
launcher.create_linux_topology(provision, topology, topology_journal, planned, {'nonce': RUN + '0' * 24})
self.assertEqual(launcher.create_collector(1000, 1000, 50100, (4, 5), (4, 6), PACKET, lambda: None), NODE_ID)
with self.assertRaisesRegex(ValueError, 'EXIT_NOT_OWNED'):
launcher.cleanup_linux_topology(cleanup, topology, topology_journal, planned)
def attach(cid):
self.assertEqual(cid, NODE_ID)
docker.records[cid]['State'] = {'Running': False, 'Status': 'exited', 'Pid': 0, 'ExitCode': 0, 'StartedAt': STARTED}
return 0
launcher.start_collector(attach)
launcher.retire_exited('collector')
launcher.stop_anchor(lambda: None)
with self.assertRaisesRegex(ValueError, 'C_RETIREMENT_UNCONFIRMED'):
launcher.retire_exited('postgres')
launcher.cleanup_linux_topology(cleanup, topology, topology_journal, planned)
launcher.retire_exited('postgres')
self.assertEqual(docker.records, {})
self.assertIn(('collector', 'exit-verified', NODE_ID), journal)
self.assertEqual([call for call in docker.calls if call[0] == 'rm'], [('rm', NODE_ID), ('rm', PG_ID)])
def test_lost_create_ack_is_not_replayed_or_cleaned_by_name(self):
docker, journal = DockerFixture(), []
docker.lose_create = True
launcher = owner['CollectorContainerOwner'](RUN, docker, lambda *entry: journal.append(entry))
with self.assertRaisesRegex(RuntimeError, 'lost ACK'):
launcher.create_anchor(1000, 1000)
with self.assertRaisesRegex(ValueError, 'REPLAY'):
launcher.create_anchor(1000, 1000)
self.assertEqual(journal, [('postgres', 'create-intent', None)])
self.assertEqual([call[0] for call in docker.calls], ['image', 'create'])
def test_anchor_process_replaced_under_same_container_id_is_never_stopped(self):
docker = DockerFixture()
launcher = owner['CollectorContainerOwner'](RUN, docker, lambda *_: None)
launcher.create_anchor(1000, 1000)
launcher.start_anchor()
docker.records[PG_ID]['State']['StartedAt'] = '2026-11-04T13:00:00.000Z'
with self.assertRaisesRegex(ValueError, 'ANCHOR_START_DRIFT'):
launcher.stop_anchor(lambda: None)
self.assertFalse(any(call[0] == 'stop' for call in docker.calls))
if __name__ == '__main__':
unittest.main()