synapse 2.214.0__py311-none-any.whl → 2.216.0__py311-none-any.whl

synapse/tests/test_cortex.py

@@ -8776,6 +8776,268 @@ class CortexBasicTest(s_t_utils.SynTest):
                 self.eq(core._test_pre_nexus_index, offs)
                 self.ge(core._test_post_nexus_index, core._test_pre_nexus_index)
 
+    async def test_cortex_safemode(self):
+        safemode = {'safemode': True}
+        nosafe = {'safemode': False}
+
+        # Cortex safemode disables the following functionality:
+        # - crons
+        # - triggers
+        # - dmons
+        # - storm package onloads
+        # - merge tasks (e.g. for quorum)
+        # - storm pools
+
+        # Make sure we're logging the message
+        with self.getStructuredAsyncLoggerStream('synapse.lib.cell', 'Booting cortex in safe-mode.') as stream:
+            async with self.getTestCore(conf=safemode) as core:
+                self.true(core.safemode)
+                self.true(await stream.wait(10))
+        msgs = stream.jsonlines()
+        self.len(1, msgs)
+        self.eq(msgs[0].get('message'), 'Booting cortex in safe-mode. Some functionality may be disabled.')
+        self.eq(msgs[0].get('level'), 'WARNING')
+
+        # Check crons, triggers, dmons in this section
+        with self.getTestDir() as dirn:
+
+            # Setup the cortex
+            async with self.getTestCore(dirn=dirn) as core:
+                await core.addCoreQueue('queue:safemode:done', {})
+                # Add a cron job and immediately disable it
+                q = '''
+                cron.add --minute +1 {
+                    $now = $lib.cast(time, now)
+                    $lib.log.warning(`SAFEMODE CRON: {$now}`)
+                    [ test:str=CRON :tick=$now ]
+                } |
+                $job = $lib.cron.list().0
+                cron.disable $job.iden
+                '''
+                await core.callStorm(q)
+                jobs = await core.listCronJobs()
+                self.len(1, jobs)
+                self.eq(jobs[0].get('enabled'), False)
+
+                # Add a regular trigger
+                q = '''
+                $lib.log.warning(`SAFEMODE TRIGGER: {$node}`)
+                $tick = :tick
+                $str = { [( test:str=TRIGGER :hehe=$tick )] }
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue.put($tick)
+                '''
+                opts = {'vars': {'query': q}}
+                await core.callStorm(f'trigger.add prop:set --prop test:str:tick --query {{{q}}}')
+
+                # Add an async trigger
+                q = '''
+                $lib.log.warning(`SAFEMODE ATRIGGER: {$node}`)
+                $tick = :tick
+                $str = { [( test:str=ATRIGGER :hehe=$tick )] }
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue.put($tick)
+                '''
+                opts = {'vars': {'query': q}}
+                await core.callStorm(f'trigger.add prop:set --prop test:str:tick --async --query {{{q}}}')
+
+                # Add a dmon
+                q = '''
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue2 = $lib.queue.gen(queue:safemode:done)
+                while (true) {
+                    ($offs, $item) = $queue.get()
+                    $lib.log.warning(`SAFEMODE DMON: {$item}`)
+                    [ test:str=DMON :hehe=$item ]
+                    $queue2.put($item)
+                }
+                '''
+                await core.callStorm(f'$iden = $lib.dmon.add(${{{q}}}) $lib.dmon.start($iden)')
+
+                nodes = await core.nodes('test:str')
+                self.len(0, nodes)
+
+            # Run in safemode and verify cron, trigger, and dmons don't execute
+            with self.getLoggerStream('synapse.storm') as stream:
+                async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                    await core.callStorm('cron.enable $lib.cron.list().0.iden')
+                    # Increment the cron tick to get it to fire
+                    core.agenda._addTickOff(60)
+
+                    # Add a test:str:tick to get the trigger to fire
+                    await core.callStorm('[ test:str=newp :tick=1234 ]')
+
+                    # Check for test:strs
+                    nodes = await core.nodes('test:str')
+                    self.len(1, nodes)
+                    self.eq(nodes[0].repr(), 'newp')
+
+                    with self.raises(TimeoutError):
+                        await s_common.wait_for(core.coreQueueGet('queue:safemode:done', wait=True), timeout=2)
+
+                    # Add a dmon to make sure it doesn't start
+                    await core.addCoreQueue('queue:safemode:started', {})
+                    q = '''
+                    $queue = $lib.queue.gen(queue:safemode)
+                    $queue2 = $lib.queue.get(queue:safemode:started)
+                    while (true) {
+                        $queue2.put(foo)
+                        $lib.log.warning(`SAFEMODE DMON START`)
+                        ($offs, $item) = $queue.get()
+                    }
+                    '''
+                    await core.callStorm(f'$iden = $lib.dmon.add(${{{q}}}) $lib.dmon.start($iden)')
+
+                    with self.raises(TimeoutError):
+                        await s_common.wait_for(core.coreQueueGet('queue:safemode:started', wait=True), timeout=2)
+
+                stream.seek(0)
+                data = stream.read()
+                self.notin('SAFEMODE CRON', data)
+                self.notin('SAFEMODE TRIGGER', data)
+                self.notin('SAFEMODE ATRIGGER', data)
+                self.notin('SAFEMODE DMON', data)
+
+            with self.getLoggerStream('synapse.storm') as stream:
+                async with self.getTestCore(dirn=dirn) as core:
+                    core.agenda._addTickOff(60)
+
+                    item = await s_common.wait_for(core.coreQueueGet('queue:safemode:done', wait=True), timeout=5)
+                    self.len(2, item)
+
+                    nodes = await core.nodes('test:str')
+                    self.len(5, nodes)
+                    self.sorteq(
+                        ['newp', 'CRON', 'TRIGGER', 'DMON', 'ATRIGGER'],
+                        [k.repr() for k in nodes]
+                    )
+
+                stream.seek(0)
+                data = stream.read()
+                self.isin('SAFEMODE CRON', data)
+                self.isin('SAFEMODE TRIGGER', data)
+                self.isin('SAFEMODE ATRIGGER', data)
+                self.isin('SAFEMODE DMON', data)
+
+        # Check storm package onload handlers are not executed
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                pkgdef = {
+                    'name': 'foopkg',
+                    'version': (0, 0, 1),
+                    'onload': '$lib.import(foo.setup).onload()',
+                    'modules': (
+                        {
+                            'name': 'foo.setup',
+                            'storm': '''
+                                function onload() {
+                                    $lib.warn('foopkg onload')
+                                }
+                            ''',
+                        },
+                    )
+                }
+
+                waiter = core.waiter(1, 'core:pkg:onload:skipped')
+                await core.addStormPkg(pkgdef)
+                events = await waiter.wait(timeout=10)
+                self.nn(events)
+                self.len(1, events)
+                self.eq(events, (('core:pkg:onload:skipped', {'pkg': 'foopkg', 'reason': 'safemode'}),))
+
+            with self.getAsyncLoggerStream('synapse.cortex', 'foopkg onload output: foopkg onload') as stream:
+                async with self.getTestCore(dirn=dirn, conf=nosafe) as core:
+                    self.false(core.safemode)
+                    await stream.wait(timeout=10)
+
+        # Check merge tasks are not executed
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                alliden = core.auth.allrole.iden
+
+                blackout = await core.auth.addUser('blackout')
+                await blackout.allow(('view', 'read'))
+
+                await core.auth.rootuser.grant(alliden)
+
+                view = core.getView()
+                qnfo = {
+                    'count': 1,
+                    'roles': [alliden],
+                }
+                await view.setViewInfo('quorum', qnfo)
+
+                forkiden = (await view.fork()).get('iden')
+
+                opts = {'view': forkiden}
+
+                nodes = await core.nodes('[ test:str=fork ]', opts=opts)
+                self.len(1, nodes)
+
+                await core.callStorm('$lib.view.get().setMergeRequest()', opts=opts)
+                await core.callStorm('$lib.view.get().setMergeVote()', opts=opts | {'user': blackout.iden})
+
+                fork = core.getView(forkiden)
+
+                self.true(await fork.isMergeReady())
+                self.none(fork.mergetask)
+
+                self.len(0, await core.nodes('test:str'))
+
+            async with self.getTestCore(dirn=dirn, conf=nosafe) as core:
+                nodes = await core.nodes('test:str')
+                self.len(1, nodes)
+                self.eq(nodes[0].repr(), 'fork')
+
+        # Check storm pools are not enabled
+        async with self.getTestAha() as aha:
+
+            ahanet = aha.conf.req('aha:network')
+
+            async with await s_base.Base.anit() as base:
+
+                with self.getTestDir() as dirn:
+
+                    dirn00 = s_common.genpath(dirn, 'cell00')
+                    dirn01 = s_common.genpath(dirn, 'cell01')
+
+                    core00 = await base.enter_context(self.addSvcToAha(aha, '00.core', s_cortex.Cortex, dirn=dirn00,
+                                                                       conf=safemode))
+                    provinfo = {'mirror': 'core'}
+                    core01 = await base.enter_context(self.addSvcToAha(aha, '01.core', s_cortex.Cortex, dirn=dirn01,
+                                                                       provinfo=provinfo))
+
+                    msgs = await core01.stormlist('aha.pool.add pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Created AHA service pool: pool00.synapse', msgs)
+
+                    msgs = await core01.stormlist('aha.pool.svc.add pool00... 01.core...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('AHA service (01.core...) added to service pool (pool00.synapse)', msgs)
+
+                    msgs = await core00.stormlist('cortex.storm.pool.set --connection-timeout 1 --sync-timeout 1 aha://pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Storm pool configuration set.', msgs)
+
+                    # Make sure queries still work
+                    nodes = await core00.nodes('[ it:dev:str="stormpools!" ]', opts={'mirror': True})
+                    self.len(1, nodes)
+
+                    self.none(core00.stormpool)
+
+                    await core00.fini()
+
+                    # Now disable safemode and check that the stormpool is enabled
+                    core00 = await base.enter_context(self.getTestCore(dirn=dirn00, conf=nosafe))
+
+                    nodes = await core00.nodes('it:dev:str', opts={'mirror': True})
+                    self.len(1, nodes)
+
+                    self.nn(core00.stormpool)
+
+                    await core00.fini()
+                    await core01.fini()
+
     async def test_cortex_queue_mirror_authgates(self):
         async with self.getRegrCore('2.213.0-queue-authgates') as core:
             self.nn(await core.getAuthGate('queue:stillhere'))

synapse/tests/test_lib_auth.py

@@ -431,6 +431,8 @@ class AuthTest(s_test.SynTest):
                 await core.auth.allrole.setRules([(True, ('hehe', 'haha'), 'newp')])
             with self.raises(s_exc.SchemaViolation):
                 await core.auth.allrole.setRules([(True, )])
+            with self.raises(s_exc.SchemaViolation):
+                await core.auth.allrole.setRules([(True, '')])
 
     async def test_auth_archived_locked_interaction(self):
 

synapse/tests/test_lib_jsonstor.py

@@ -1,4 +1,5 @@
 import synapse.exc as s_exc
+import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.lib.jsonstor as s_jsonstor
 
 import synapse.tests.utils as s_test
@@ -125,3 +126,47 @@ class JsonStorTest(s_test.SynTest):
 
                     self.true(await prox.delQueue('hehe'))
                     self.false(await prox.delQueue('hehe'))
+
+    async def test_lib_jsonstor_syncing(self):
+
+        with self.getTestDir() as dirn:
+            async with self.getTestJsonStor(dirn=dirn) as jsonstor:
+                async with jsonstor.getLocalProxy() as prox:
+
+                    await prox.setPathObj('foo/bar', {'hehe': 'haha'})
+                    await s_lmdbslab.Slab.syncLoopOnce()
+
+                    self.true(await prox.setPathObjProp('foo/bar', 'zip', 'zop'))
+                    self.len(1, jsonstor.jsonstor.dirty.items())
+
+                    await s_lmdbslab.Slab.syncLoopOnce()
+                    self.len(0, jsonstor.jsonstor.dirty.items())
+
+                    self.eq({'hehe': 'haha', 'zip': 'zop'}, await prox.getPathObj('foo/bar'))
+
+                    self.true(await prox.delPathObjProp('foo/bar', 'zip'))
+                    self.len(1, jsonstor.jsonstor.dirty.items())
+
+                    await s_lmdbslab.Slab.syncLoopOnce()
+                    self.len(0, jsonstor.jsonstor.dirty.items())
+
+                    self.eq({'hehe': 'haha'}, await prox.getPathObj('foo/bar'))
+
+                    self.true(await prox.cmpDelPathObjProp('foo/bar', 'hehe', 'haha'))
+                    self.len(1, jsonstor.jsonstor.dirty.items())
+
+                    await s_lmdbslab.Slab.syncLoopOnce()
+                    self.len(0, jsonstor.jsonstor.dirty.items())
+
+                    self.eq({}, await prox.getPathObj('foo/bar'))
+
+                    self.true(await prox.setPathObjProp('foo/bar', 'zip', 'zop'))
+                    await s_lmdbslab.Slab.syncLoopOnce()
+
+                    self.true(await prox.popPathObjProp('foo/bar', 'zip'))
+                    self.len(1, jsonstor.jsonstor.dirty.items())
+
+                    await s_lmdbslab.Slab.syncLoopOnce()
+                    self.len(0, jsonstor.jsonstor.dirty.items())
+
+                    self.eq({}, await prox.getPathObj('foo/bar'))

synapse/tests/test_lib_layer.py

@@ -1281,6 +1281,16 @@ class LayerTest(s_t_utils.SynTest):
 
             self.len(0, list(layr.dataslab.scanByDups(abrv, db=layr.dataname)))
 
+            await core.addTagProp('score2', ('int', {}), {})
+            nodes = await core.nodes('[test:str=multi +#foo:score=5 +#foo:score2=6]')
+            self.eq(('score', 'score2'), nodes[0].getTagProps('foo'))
+
+            nodes = await core.nodes('test:str=multi [-#foo:score]')
+            self.eq(('score2',), nodes[0].getTagProps('foo'))
+
+            nodes = await core.nodes('test:str=multi')
+            self.eq(('score2',), nodes[0].getTagProps('foo'))
+
     async def test_layer_waitForHot(self):
         self.thisHostMust(hasmemlocking=True)
 

synapse/tests/test_lib_storm.py

@@ -101,7 +101,8 @@ class StormTest(s_t_utils.SynTest):
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ ou:org=({}) ]')
 
-            self.len(1, await core.nodes('[ ou:org=() ]'))
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('[ ou:org=() ]')
 
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ ou:org=({}) ]')
@@ -293,6 +294,56 @@ class StormTest(s_t_utils.SynTest):
 
             self.len(0, await core.nodes('inet:service:platform:name=barplat'))
 
+            # Gutors work for props
+            nodes = await core.nodes('''[
+                test:str=guidprop
+                    :gprop=({'name': 'someprop', '$props': {'size': 5}})
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'guidprop'))
+            self.nn(node.get('gprop'))
+
+            nodes = await core.nodes('test:str=guidprop -> test:guid')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'someprop')
+            self.eq(node.get('size'), 5)
+
+            with self.raises(s_exc.BadTypeValu) as cm:
+                nodes = await core.nodes('''[
+                    test:str=newpprop
+                        :gprop=({'size': 'newp'})
+                ]''')
+
+            self.eq(cm.exception.get('form'), 'test:guid')
+            self.eq(cm.exception.get('prop'), 'size')
+            self.true(cm.exception.get('mesg').startswith('Bad value for prop test:guid:size: invalid literal'))
+
+            nodes = await core.nodes('''[
+                test:str=newpprop
+                    :gprop?=({'size': 'newp'})
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'newpprop'))
+            self.none(node.get('gprop'))
+
+            nodes = await core.nodes('''
+                [ test:str=methset ]
+                $node.props.gprop = ({'name': 'someprop'})
+            ''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'methset'))
+            self.nn(node.get('gprop'))
+
+            nodes = await core.nodes('test:str=methset -> test:guid')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'someprop')
+            self.eq(node.get('size'), 5)
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 

synapse/tests/test_lib_stormlib_iters.py

@@ -94,7 +94,7 @@ class StormLibItersTest(s_test.SynTest):
                 self.stormIsInErr(err, msgs)
 
                 async def boom(self, genr):
-                    print(newp)
+                    raise NameError("name 'newp' is not defined")
                     yield True
 
                 with mock.patch.object(s_stormlib_iters.LibIters, 'enum', boom):

synapse/tests/test_lib_stormsvc.py

@@ -780,7 +780,7 @@ class StormSvcTest(s_test.SynTest):
                     }
                     with patchcore(core, 'setStormSvcEvents', badSetStormSvcEvents):
                         svci = await core.addStormSvc(sdef)
-                        self.true(await core.waitStormSvc('dead', timeout=6))
+                        self.true(await core.waitStormSvc('dead', timeout=12))
                         await core.delStormSvc(svci.get('iden'))
 
                     self.len(1, badiden)
@@ -792,7 +792,7 @@ class StormSvcTest(s_test.SynTest):
 
                     with patchcore(core, '_runStormSvcAdd', badRunStormSvcAdd):
                         svci = await core.addStormSvc(sdef)
-                        self.true(await core.waitStormSvc('dead', timeout=6))
+                        self.true(await core.waitStormSvc('dead', timeout=12))
                         await core.delStormSvc(svci.get('iden'))
                     self.len(1, badiden)
                     self.eq(svci.get('iden'), badiden[0])

synapse/tests/test_lib_stormtypes.py

@@ -2999,6 +2999,21 @@ class StormTypesTest(s_test.SynTest):
                 self.eq((5, 'baz'), await core.callStorm('return($lib.queue.get(poptest).pop())'))
                 self.none(await core.callStorm('return($lib.queue.get(poptest).pop())'))
 
+                # Coverage for the Cortex queue:del nexus handler
+                name = 'deleteme'
+                iden = s_common.guid()
+                await core.addCoreQueue(
+                    name,
+                    {'name': name,
+                     'creator': core.auth.rootuser.iden,
+                     'created': s_common.now(),
+                     'iden': iden}
+                )
+                await core.auth.delAuthGate(f'queue:{name}')
+                await core.delCoreQueue(name)
+                with self.raises(s_exc.NoSuchName):
+                    await core.getCoreQueue(name)
+
     async def test_storm_node_data(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_types.py

@@ -1,5 +1,6 @@
 import math
 import decimal
+import datetime
 import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.datamodel as s_datamodel
@@ -315,6 +316,12 @@ class TypesTest(s_t_utils.SynTest):
         self.true(s_common.isguid(lnorm))
         self.eq(lnorm, tnorm)
 
+        with self.raises(s_exc.BadTypeValu) as exc:
+            model.type('guid').norm(())
+        self.eq(exc.exception.get('name'), 'guid')
+        self.eq(exc.exception.get('valu'), ())
+        self.eq(exc.exception.get('mesg'), 'Guid list values cannot be empty.')
+
     async def test_hex(self):
 
         async with self.getTestCore() as core:
@@ -1320,7 +1327,10 @@ class TypesTest(s_t_utils.SynTest):
             nodes = await core.nodes('test:str:tick=201401*')
             self.eq({node.ndef[1] for node in nodes}, {'a'})
 
-            nodes = await core.nodes('test:str:tick*range=("-6000 days", now)')
+            utc = datetime.timezone.utc
+            delta = datetime.datetime.now(tz=utc) - datetime.datetime(2014, 1, 1, tzinfo=utc)
+            days = delta.days + 14
+            nodes = await core.nodes(f'test:str:tick*range=("-{days} days", now)')
             self.eq({node.ndef[1] for node in nodes}, {'a', 'b', 'c', 'd'})
 
             opts = {'vars': {'tick': tick, 'tock': tock}}

synapse/tests/test_model_inet.py

@@ -3017,6 +3017,8 @@ class InetModelTest(s_t_utils.SynTest):
             platinst = nodes[0]
             app00 = nodes[0].get('app')
 
+            self.len(1, await core.nodes('inet:service:instance:id=T2XK1223Y -> inet:service:app [ :provider=* :provider:name=vertex ] :provider -> ou:org'))
+
             q = '''
             [
                 (inet:service:account=(blackout, account, vertex, slack)

synapse/tests/test_model_infotech.py

@@ -2438,3 +2438,34 @@ class InfotechModelTest(s_t_utils.SynTest):
             self.eq(2, nodes[0].get('assets:vulns:preexisting'))
 
             self.len(1, await core.nodes('it:sec:metrics -> ou:org +:name=vertex'))
+
+    async def test_infotech_windows(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('''
+                [ it:os:windows:service=*
+                    :name=Woot
+                    :host=*
+                    :type=(0x20)
+                    :start=(0x20)
+                    :errorcontrol=(0x20)
+                    :displayname="Foo Bar Baz"
+                    :imagepath=c:/windows/system32/woot.exe
+                    :description="Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+                ]
+            ''')
+
+            self.len(1, nodes)
+            self.eq(nodes[0].get('name'), 'woot')
+            self.eq(nodes[0].get('type'), 0x20)
+            self.eq(nodes[0].get('start'), 0x20)
+            self.eq(nodes[0].get('errorcontrol'), 0x20)
+            self.eq(nodes[0].get('displayname'), 'foo bar baz')
+            self.eq(nodes[0].get('imagepath'), 'c:/windows/system32/woot.exe')
+            self.eq(nodes[0].get('description'), 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.')
+
+            self.len(1, await core.nodes('it:os:windows:service -> it:host'))
+            self.len(1, await core.nodes('it:os:windows:service -> file:path'))
+
+            self.len(1, await core.nodes('[ it:exec:proc=* :windows:service={ it:os:windows:service } ] -> it:os:windows:service'))

synapse/tests/test_tools_cryo_cat.py

@@ -93,14 +93,9 @@ class CryoCatTest(s_t_utils.SynTest):
             stdout.buffer = io.BytesIO()
 
             with mock.patch('sys.stdout', stdout):
-                with self.getLoggerStream('synapse.tools.cryo.cat') as stream:
-                    argv = ['--verbose', '--msgpack', '--size', '20', cryourl]
-                    retn, _ = await self.execToolMain(s_cryocat.main, argv)
-                    self.eq(0, retn)
-
-                stream.seek(0)
-                mesgs = stream.read()
-                self.isin(f'connecting to: {cryourl}', mesgs)
+                argv = ['--msgpack', '--size', '20', cryourl]
+                retn, _ = await self.execToolMain(s_cryocat.main, argv)
+                self.eq(0, retn)
 
             stdout.buffer.seek(0)
             outdata = list(msgpack.Unpacker(stdout.buffer, raw=False, use_list=False))

synapse/tests/test_tools_storm.py

@@ -62,7 +62,8 @@ class StormCliTest(s_test.SynTest):
 
             await core.addTagProp('foo', ('int', {}), {})
 
-            pars = s_t_storm.getArgParser()
+            outp = self.getTestOutp()
+            pars = s_t_storm.getArgParser(outp)
             opts = pars.parse_args(('woot',))
             self.eq('woot', opts.cortex)
             self.none(opts.view)
@@ -263,7 +264,7 @@ class StormCliTest(s_test.SynTest):
 
             url = core.getLocalUrl()
 
-            pars = s_t_storm.getArgParser()
+            pars = s_t_storm.getArgParser(self.getTestOutp())
             opts = pars.parse_args(('woot', '--view', '246e7d5dab883eb28d345a33abcdb577'))
             self.eq(opts.view, '246e7d5dab883eb28d345a33abcdb577')
 

synapse/tests/utils.py

@@ -439,6 +439,7 @@ testmodel = {
 
         ('test:guid', {}, (
             ('size', ('test:int', {}), {}),
+            ('name', ('test:str', {}), {}),
             ('tick', ('test:time', {}), {}),
             ('posneg', ('test:sub', {}), {}),
             ('posneg:isbig', ('bool', {}), {}),
@@ -459,6 +460,7 @@ testmodel = {
             ('hehe', ('str', {}), {}),
             ('ndefs', ('array', {'type': 'ndef'}), {}),
             ('somestr', ('test:str', {}), {}),
+            ('gprop', ('test:guid', {}), {}),
         )),
         ('test:strregex', {}, ()),
 

synapse/tools/aha/clone.py

@@ -1,11 +1,7 @@
-import sys
-import asyncio
-import argparse
-
 import synapse.exc as s_exc
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
 
 descr = '''
@@ -19,8 +15,7 @@ Examples:
 
 async def main(argv, outp=s_output.stdout):
 
-    pars = argparse.ArgumentParser(prog='synapse.tools.aha.clone', description=descr,
-                        formatter_class=argparse.RawDescriptionHelpFormatter)
+    pars = s_cmd.Parser(prog='synapse.tools.aha.clone', outp=outp, description=descr)
 
     pars.add_argument('dnsname', help='The DNS name of the new AHA server.')
     pars.add_argument('--port', type=int, default=27492, help='The port that the new AHA server should listen on.')
@@ -49,10 +44,5 @@ async def main(argv, outp=s_output.stdout):
             outp.printf(f'ERROR: {mesg}')
             return 1
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
-
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)