synapse 2.196.0__py311-none-any.whl → 2.198.0__py311-none-any.whl

synapse/tests/test_lib_auth.py

@@ -1,9 +1,15 @@
 import string
 import pathlib
 
+from unittest import mock
+
 import synapse.exc as s_exc
+import synapse.common as s_common
 import synapse.telepath as s_telepath
-import synapse.lib.hiveauth as s_hiveauth
+
+import synapse.lib.auth as s_auth
+import synapse.lib.cell as s_cell
+import synapse.lib.lmdbslab as s_lmdbslab
 
 import synapse.tests.utils as s_test
 
@@ -426,6 +432,126 @@ class AuthTest(s_test.SynTest):
             with self.raises(s_exc.SchemaViolation):
                 await core.auth.allrole.setRules([(True, )])
 
+    async def test_auth_archived_locked_interaction(self):
+
+        # Check that we can't unlock an archived user
+        async with self.getTestCore() as core:
+            lowuser = await core.addUser('lowuser')
+            useriden = lowuser.get('iden')
+
+            await core.setUserArchived(useriden, True)
+
+            udef = await core.getUserDef(useriden)
+            self.true(udef.get('archived'))
+            self.true(udef.get('locked'))
+
+            # Unlocking an archived user is invalid
+            with self.raises(s_exc.BadArg) as exc:
+                await core.setUserLocked(useriden, False)
+            self.eq(exc.exception.get('mesg'), 'Cannot unlock archived user.')
+            self.eq(exc.exception.get('user'), useriden)
+            self.eq(exc.exception.get('username'), 'lowuser')
+
+        # Check our cell migration that locks archived users
+        async with self.getRegrCore('unlocked-archived-users') as core:
+            for ii in range(10):
+                user = await core.getUserDefByName(f'lowuser{ii:02d}')
+                self.nn(user)
+                self.true(user.get('archived'))
+                self.true(user.get('locked'))
+
+        # Check behavior of upgraded mirrors and non-upgraded leader
+        async with self.getTestAha() as aha:
+
+            with self.getTestDir() as dirn:
+                path00 = s_common.gendir(dirn, 'cell00')
+                path01 = s_common.gendir(dirn, 'cell01')
+
+                with mock.patch('synapse.lib.cell.NEXUS_VERSION', (2, 177)):
+                    async with self.addSvcToAha(aha, '00.cell', s_cell.Cell, dirn=path00) as cell00:
+                        lowuser = await cell00.addUser('lowuser')
+                        useriden = lowuser.get('iden')
+                        await cell00.setUserArchived(useriden, True)
+
+                        with mock.patch('synapse.lib.cell.NEXUS_VERSION', (2, 198)):
+                            async with self.addSvcToAha(aha, '01.cell', s_cell.Cell, dirn=path01, provinfo={'mirror': 'cell'}) as cell01:
+                                await cell01.sync()
+                                udef = await cell01.getUserDef(useriden)
+                                self.true(udef.get('locked'))
+                                self.true(udef.get('archived'))
+
+                                # Simulate a call to cell00.setUserLocked(useriden, False) to bypass
+                                # the check in cell00.auth.setUserInfo()
+                                await cell00.auth._push('user:info', useriden, 'locked', False)
+                                await cell01.sync()
+
+                                udef00 = await cell00.getUserDef(useriden)
+                                self.true(udef00.get('archived'))
+                                self.false(udef00.get('locked'))
+
+                                udef01 = await cell01.getUserDef(useriden)
+                                self.true(udef01.get('archived'))
+                                self.false(udef01.get('locked'))
+
+        # Check that we don't blowup/schism if an upgraded mirror is behind a leader with a pending
+        # user:info event that unlocks an archived user
+        async with self.getTestAha() as aha:
+
+            with self.getTestDir() as dirn:
+                path00 = s_common.gendir(dirn, 'cell00')
+                path01 = s_common.gendir(dirn, 'cell01')
+
+                async with self.addSvcToAha(aha, '00.cell', s_cell.Cell, dirn=path00) as cell00:
+                    lowuser = await cell00.addUser('lowuser')
+                    useriden = lowuser.get('iden')
+                    await cell00.setUserLocked(useriden, True)
+
+                    async with self.addSvcToAha(aha, '01.cell', s_cell.Cell, dirn=path01, provinfo={'mirror': 'cell'}) as cell01:
+                        await cell01.sync()
+                        udef = await cell01.getUserDef(useriden)
+                        self.true(udef.get('locked'))
+                        self.false(udef.get('archived'))
+
+                    # Set user locked while cell01 is offline so it will get the edit when it comes
+                    # back
+                    await cell00.setUserLocked(useriden, False)
+                    await cell00.sync()
+
+                # Edit the slabs on both cells directly to archive the user
+                lmdb00 = s_common.genpath(path00, 'slabs', 'cell.lmdb')
+                lmdb01 = s_common.genpath(path01, 'slabs', 'cell.lmdb')
+
+                slab00 = await s_lmdbslab.Slab.anit(lmdb00, map_size=s_cell.SLAB_MAP_SIZE)
+                slab01 = await s_lmdbslab.Slab.anit(lmdb01, map_size=s_cell.SLAB_MAP_SIZE)
+
+                # Simulate the cell migration which locks archived users
+                for slab in (slab00, slab01):
+                    authkv = slab.getSafeKeyVal('auth')
+                    userkv = authkv.getSubKeyVal('user:info:')
+
+                    info = userkv.get(useriden)
+                    info['archived'] = True
+                    info['locked'] = True
+                    userkv.set(useriden, info)
+
+                await slab00.fini()
+                await slab01.fini()
+
+                # Spin the cells back up and wait for the edit to sync to cell01
+                async with self.addSvcToAha(aha, '00.cell', s_cell.Cell, dirn=path00) as cell00:
+                    udef = await cell00.getUserDef(useriden)
+                    self.true(udef.get('archived'))
+                    self.true(udef.get('locked'))
+
+                    async with self.addSvcToAha(aha, '01.cell', s_cell.Cell, dirn=path01, provinfo={'mirror': 'cell'}) as cell01:
+                        await cell01.sync()
+                        udef = await cell01.getUserDef(useriden)
+                        self.true(udef.get('archived'))
+                        self.true(udef.get('locked'))
+
+                        self.ge(cell00.nexsvers, (2, 198))
+                        self.ge(cell01.nexsvers, (2, 198))
+
     async def test_auth_password_policy(self):
         policy = {
             'complexity': {
@@ -446,6 +572,21 @@ class AuthTest(s_test.SynTest):
         pass3 = 'ZXN-pyv7ber-kzq2kgh'
 
         conf = {'auth:passwd:policy': policy}
+        async with self.getTestCore(conf=conf) as core:
+
+            user = await core.auth.addUser('blackout@vertex.link')
+
+            self.none(user.info.get('policy:previous'))
+            await user.setPasswd(pass1, nexs=False)
+            await user.setPasswd(pass2, nexs=False)
+            await user.setPasswd(pass3, nexs=False)
+            self.len(2, user.info.get('policy:previous'))
+
+            await user.tryPasswd('newp')
+            self.eq(1, user.info.get('policy:attempts'))
+            await user.setLocked(False, logged=False)
+            self.eq(0, user.info.get('policy:attempts'))
+
         async with self.getTestCore(conf=conf) as core:
             auth = core.auth
             self.nn(auth.policy)
@@ -708,7 +849,7 @@ class AuthTest(s_test.SynTest):
             await core.callStorm('auth.role.addrule ninjas --gate $gate another.rule',
                                  opts={'vars': {'gate': fork}})
 
-            user = await core.auth.getUserByName('lowuser')  # type: s_hiveauth.HiveUser
+            user = await core.auth.getUserByName('lowuser')  # type: s_auth.User
             self.false(user.allowed(('hehe',)))
             self.false(user.allowed(('hehe',), deepdeny=True))
             self.true(user.allowed(('hehe', 'haha')))

synapse/tests/test_lib_boss.py

@@ -3,13 +3,21 @@ import asyncio
 import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.lib.boss as s_boss
+import synapse.lib.cell as s_cell
 import synapse.tests.utils as s_test
 
+class BossCell(s_cell.Cell):
+    async def initServiceRuntime(self):
+        self.cboss = await s_boss.Boss.anit()
+        self.onfini(self.cboss)
+
 class BossTest(s_test.SynTest):
 
     async def test_boss_base(self):
 
-        async with await s_boss.Boss.anit() as boss:
+        async with self.getTestCell(BossCell) as bcell:
+            boss = bcell.cboss
+            root = await bcell.auth.getUserByName('root')
 
             evnt = asyncio.Event()
 
@@ -20,18 +28,19 @@ class BossTest(s_test.SynTest):
 
             self.len(0, boss.ps())
 
-            synt = await boss.promote('test', None, info={'hehe': 'haha'})
+            synt = await boss.promote('test', root, info={'hehe': 'haha'})
 
             self.len(1, boss.ps())
 
             self.eq('test', synt.name)
             self.eq('haha', synt.info.get('hehe'))
+            self.eq(root.iden, synt.user.iden)
 
-            synt0 = await boss.execute(testloop(), 'testloop', None, info={'foo': 'bar'})
+            synt0 = await boss.execute(testloop(), 'testloop', root, info={'foo': 'bar'})
             iden = synt0.iden
 
             with self.raises(s_exc.BadArg):
-                _ = await boss.execute(asyncio.sleep(1), 'testsleep', None, iden=iden)
+                _ = await boss.execute(asyncio.sleep(1), 'testsleep', root, iden=iden)
 
             await evnt.wait()
 
@@ -47,8 +56,8 @@ class BossTest(s_test.SynTest):
                 iden = s_common.guid()
 
                 async def double_promote():
-                    await boss.promote(f'double', None, taskiden=iden)
-                    await boss.promote(f'double', None, taskiden=iden + iden)
+                    await boss.promote(f'double', root, taskiden=iden)
+                    await boss.promote(f'double', root, taskiden=iden + iden)
 
                 coro = boss.schedCoro(double_promote())
                 self.true(await stream.wait(timeout=6))

synapse/tests/test_lib_cell.py

@@ -3417,3 +3417,46 @@ class CellTest(s_t_utils.SynTest):
                 pass
             async for item in cell.callPeerGenr(todo):
                 pass
+
+    async def test_cell_task_apis(self):
+        async with self.getTestAha() as aha:
+
+            # test some of the gather API implementations...
+            purl00 = await aha.addAhaSvcProv('00.cell')
+            purl01 = await aha.addAhaSvcProv('01.cell', provinfo={'mirror': 'cell'})
+
+            cell00 = await aha.enter_context(self.getTestCell(conf={'aha:provision': purl00}))
+            cell01 = await aha.enter_context(self.getTestCell(conf={'aha:provision': purl01}))
+
+            await cell01.sync()
+
+            async def sleep99(cell):
+                await cell.boss.promote('sleep99', cell.auth.rootuser)
+                await cell00.fire('sleep99')
+                await asyncio.sleep(99)
+
+            async with cell00.waiter(2, 'sleep99', timeout=6):
+                task00 = cell00.schedCoro(sleep99(cell00))
+                task01 = cell01.schedCoro(sleep99(cell01))
+
+            tasks = [task async for task in cell00.getTasks(timeout=6)]
+
+            self.len(2, tasks)
+            self.eq(tasks[0]['service'], '00.cell.synapse')
+            self.eq(tasks[1]['service'], '01.cell.synapse')
+            self.eq(('sleep99', 'sleep99'), [task.get('name') for task in tasks])
+            self.eq(('root', 'root'), [task.get('username') for task in tasks])
+
+            self.eq(tasks[0], await cell00.getTask(tasks[0].get('iden')))
+            self.eq(tasks[1], await cell00.getTask(tasks[1].get('iden')))
+            self.none(await cell00.getTask(tasks[1].get('iden'), peers=False))
+
+            self.true(await cell00.killTask(tasks[0].get('iden')))
+
+            task01 = tasks[1].get('iden')
+            self.false(await cell00.killTask(task01, peers=False))
+
+            self.true(await cell00.killTask(task01))
+
+            self.none(await cell00.getTask(task01))
+            self.false(await cell00.killTask(task01))

synapse/tests/test_lib_grammar.py

@@ -735,6 +735,17 @@ Queries = [
     '[test:str=foo :$foo*$bar.baz=heval]',
     '[test:str=foo :$foo*$bar.("baz")=heval]',
     '[test:str=foo :$foo*$bar.baz()=heval]',
+    '[test:str=foo +(refs)> $n]',
+    '[test:str=foo +(refs)> $n.baz()]',
+    '[test:str=foo -(refs)> $n]',
+    '[test:str=foo <(refs)+ $n]',
+    '[test:str=foo <(refs)+ $n.baz()]',
+    '[test:str=foo <(refs)- $n]',
+    '[test:str=foo :bar++=([1, 2])]',
+    '[test:str=foo :$foo++=([1, 2])]',
+    '[test:str=foo :bar--=(foo, bar)]',
+    '[test:str=foo :bar?++=$baz]',
+    '[test:str=foo :bar?--={[it:dev:str=foo]}]',
 ]
 
 # Generated with print_parse_list below
@@ -778,7 +789,7 @@ _ParseResults = [
     'Query: [TryCatch: [Query: [LiftPropBy: [Const: inet:ipv4, Const: =, Const: asdf]], CatchBlock: [Const: TypeError, Const: err, Query: []]]]',
     'Query: [TryCatch: [Query: [LiftPropBy: [Const: inet:ipv4, Const: =, Const: asdf]], CatchBlock: [Const: FooBar, Const: err, Query: []], CatchBlock: [Const: *, Const: err, Query: []]]]',
     'Query: [LiftByArray: [Const: test:array, Const: =, Const: 1.2.3.4]]',
-    'Query: [CmdOper: [Const: macro.set, List: [Const: hehe, EmbedQuery: inet:ipv4]]]',
+    'Query: [CmdOper: [Const: macro.set, List: [Const: hehe, EmbedQuery:  inet:ipv4 ]]]',
     'Query: [SetVarOper: [Const: q, EmbedQuery: #foo.bar]]',
     'Query: [CmdOper: [Const: metrics.edits.byprop, List: [Const: inet:fqdn:domain, Const: --newv, VarDeref: [VarValue: [Const: lib], Const: null]]]]',
     'Query: [CmdOper: [Const: tee, Const: ()]]',
@@ -1364,7 +1375,7 @@ _ParseResults = [
     'Query: [SetVarOper: [Const: p, Const: names], LiftPropBy: [Const: ps:contact:name, Const: =, Const: foo], EditPropSet: [RelProp: [VarValue: [Const: p]], Const: ?-=, Const: bar]]',
     'Query: [SetVarOper: [Const: pvar, Const: stuff], LiftProp: [Const: test:arrayprop], FiltOper: [Const: +, ArrayCond: [RelProp: [VarValue: [Const: pvar]], Const: =, Const: neato]]]',
     'Query: [SetVarOper: [Const: pvar, Const: ints], LiftProp: [Const: test:arrayprop], FiltOper: [Const: +, ArrayCond: [RelProp: [VarValue: [Const: pvar]], Const: =, VarValue: [Const: othervar]]]]',
-    'Query: [SetVarOper: [Const: foo, DollarExpr: [ExprDict: [Const: foo, EmbedQuery: inet:fqdn]]]]',
+    'Query: [SetVarOper: [Const: foo, DollarExpr: [ExprDict: [Const: foo, EmbedQuery:  inet:fqdn ]]]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [Const: hehe], CondSetOper: [Const: unset], Const: heval]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [Const: hehe], CondSetOper: [VarValue: [Const: foo]], Const: heval]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [VarValue: [Const: foo]], CondSetOper: [Const: unset], Const: heval]]',
@@ -1372,6 +1383,17 @@ _ParseResults = [
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [VarValue: [Const: foo]], CondSetOper: [VarDeref: [VarValue: [Const: bar], Const: baz]], Const: heval]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [VarValue: [Const: foo]], CondSetOper: [VarDeref: [VarValue: [Const: bar], DollarExpr: [Const: baz]]], Const: heval]]',
     'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditCondPropSet: [RelProp: [VarValue: [Const: foo]], CondSetOper: [FuncCall: [VarDeref: [VarValue: [Const: bar], Const: baz], CallArgs: [], CallKwargs: []]], Const: heval]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeAdd: [Const: refs, VarValue: [Const: n]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeAdd: [Const: refs, FuncCall: [VarDeref: [VarValue: [Const: n], Const: baz], CallArgs: [], CallKwargs: []]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeDel: [Const: refs, VarValue: [Const: n]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeAdd: [Const: refs, VarValue: [Const: n]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeAdd: [Const: refs, FuncCall: [VarDeref: [VarValue: [Const: n], Const: baz], CallArgs: [], CallKwargs: []]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditEdgeDel: [Const: refs, VarValue: [Const: n]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: ++=, DollarExpr: [ExprList: [Const: 1, Const: 2]]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [VarValue: [Const: foo]], Const: ++=, DollarExpr: [ExprList: [Const: 1, Const: 2]]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: --=, List: [Const: foo, Const: bar]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: ?++=, VarValue: [Const: baz]]]',
+    'Query: [EditNodeAdd: [FormName: [Const: test:str], Const: =, Const: foo], EditPropSetMulti: [RelProp: [Const: bar], Const: ?--=, SubQuery: [Query: [EditNodeAdd: [FormName: [Const: it:dev:str], Const: =, Const: foo]]]]]',
 ]
 
 class GrammarTest(s_t_utils.SynTest):
@@ -1663,6 +1685,27 @@ class GrammarTest(s_t_utils.SynTest):
         errinfo = cm.exception.errinfo
         self.eq(1, errinfo.get('mesg').count('#'))
 
+        query = '$q = ${ /* secret comment */ $lib.print([hello) } $lib.macro.set(hehe, $q)'
+        parser = s_parser.Parser(query)
+        with self.raises(s_exc.BadSyntax) as cm:
+            _ = parser.query()
+        info = cm.exception.errinfo.get('highlight')
+        self.eq((40, 41), info['offsets'])
+        self.eq((1, 1), info['lines'])
+        self.eq((41, 42), info['columns'])
+
+        query = """function test(hello) {
+                    +'''asdf
+                    asdfasdf'''
+        }"""
+        parser = s_parser.Parser(query)
+        with self.raises(s_exc.BadSyntax) as cm:
+            _ = parser.query()
+        info = cm.exception.errinfo.get('highlight')
+        self.eq((44, 83), info['offsets'])
+        self.eq((2, 3), info['lines'])
+        self.eq((22, 31), info['columns'])
+
     async def test_quotes(self):
 
         # Test vectors
@@ -1766,6 +1809,15 @@ class GrammarTest(s_t_utils.SynTest):
         self.false(s_grammar.isPropName('.hehe'))
         self.false(s_grammar.isPropName('testcmd'))
 
+    async def test_embed_offsets(self):
+
+        embq = ' /* secret comment */ $lib.print(hello) /* haha */ $lib.print(goodbye) /*foo */ '
+        query = f'$q = ${{{embq}}} $lib.print($q)'
+        parser = s_parser.Parser(query)
+        q = parser.query()
+        embed = q.kids[0].kids[1]
+        self.eq(embq, embed.getAstText())
+
 def gen_parse_list():
     '''
     Prints out the Asts for a list of queries in order to compare ASTs between versions of parsers

synapse/tests/test_lib_lmdbslab.py

@@ -371,6 +371,30 @@ class LmdbSlabTest(s_t_utils.SynTest):
                 'vm.dirty_ratio',
             ], msgs[0].get('sysctls', {}).keys())
 
+    async def test_lmdbslab_commit_over_max_xactops(self):
+
+        # Make sure that we don't confuse the periodic commit with the max replay log commit
+        with (self.getTestDir() as dirn,
+              patch('synapse.lib.lmdbslab.Slab.WARN_COMMIT_TIME_MS', 1),
+              patch('synapse.lib.lmdbslab.Slab.COMMIT_PERIOD', 100)
+              ):
+            path = os.path.join(dirn, 'test.lmdb')
+
+            async with await s_lmdbslab.Slab.anit(path, max_replay_log=100, map_size=100_000_000) as slab:
+                foo = slab.initdb('foo', dupsort=True)
+
+                byts = b'\x00' * 256
+                for i in range(1000):
+                    slab.put(b'\xff\xff\xff\xff' + s_common.guid(i).encode('utf8'), byts, db=foo)
+                    await asyncio.sleep(0)
+
+            # Let the slab close and then grab its stats
+            stats = slab.statinfo()
+            commitstats = stats.get('commitstats', ())
+            self.gt(len(commitstats), 0)
+            commitstats = [x[1] for x in commitstats if x[1] != 0]
+            self.eq(commitstats, (100, 100, 100, 100, 100, 100, 100, 100, 100, 100))
+
     async def test_lmdbslab_max_replay(self):
         with self.getTestDir() as dirn:
             path = os.path.join(dirn, 'test.lmdb')

synapse/tests/test_lib_storm.py

@@ -143,6 +143,26 @@ class StormTest(s_t_utils.SynTest):
             self.eq(props.get('name'), 'org name 77')
             self.eq(props.get('desc'), 'an org desc')
 
+            nodes = await core.nodes('ou:org=({"name": "the vertex project", "type": "lulz"})')
+            self.len(1, nodes)
+            orgn = nodes[0].ndef
+            self.eq(orgn, nodes11[0].ndef)
+
+            q = '[ ps:contact=* :org={ ou:org=({"name": "the vertex project", "type": "lulz"}) } ]'
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            cont = nodes[0]
+            self.eq(cont.get('org'), orgn[1])
+
+            nodes = await core.nodes('ps:contact:org=({"name": "the vertex project", "type": "lulz"})')
+            self.len(1, nodes)
+            self.eq(nodes[0].ndef, cont.ndef)
+
+            self.len(0, await core.nodes('ps:contact:org=({"name": "vertex", "type": "newp"})'))
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('inet:flow:from=({"name": "vertex", "type": "newp"})')
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 

synapse/tests/test_lib_stormlib_index.py

@@ -0,0 +1,39 @@
+import synapse.tests.utils as s_test
+
+count_prop_00 = '''
+ Count        | Layer Iden                       | Layer Name
+==============|==================================|============
+ 16           | 5cc56afbb22fad9b96c51110812af8f7 |
+ 16           | 2371390b1fd0162ba6820f85a863e7b2 | default
+Total: 32
+'''
+
+count_prop_01 = '''
+ Count        | Layer Iden                       | Layer Name
+==============|==================================|============
+ 16           | 9782c920718d3059b8806fddaf917bd8 |
+ 0            | 511122a9b2d576c5be2cdfcaef541bb9 | default
+Total: 16
+'''
+
+class StormIndexTest(s_test.SynTest):
+
+    async def test_lib_stormlib_index(self):
+
+        async with self.getTestCore() as core:
+            viewiden = await core.callStorm('return($lib.view.get().fork().iden)')
+            viewopts = {'view': viewiden}
+            await core.nodes('[ inet:ipv4=1.2.3.0/28 :asn=19 ]')
+            await core.nodes('[ inet:ipv4=1.2.4.0/28 :asn=42 ]', opts=viewopts)
+
+            msgs = await core.stormlist('index.count.prop inet:ipv4', opts=viewopts)
+            self.stormIsInPrint(count_prop_00, msgs, deguid=True, whitespace=False)
+
+            msgs = await core.stormlist('index.count.prop inet:ipv4:asn', opts=viewopts)
+            self.stormIsInPrint(count_prop_00, msgs, deguid=True, whitespace=False)
+
+            msgs = await core.stormlist('index.count.prop inet:ipv4:asn --value 42', opts=viewopts)
+            self.stormIsInPrint(count_prop_01, msgs, deguid=True, whitespace=False)
+
+            msgs = await core.stormlist('index.count.prop inet:ipv4:newp', opts=viewopts)
+            self.stormIsInErr('No property named inet:ipv4:newp', msgs)

synapse/tests/test_lib_stormlib_macro.py

@@ -89,7 +89,7 @@ class MacroTest(s_test.SynTest):
             name = 'v' * 491
             q = '$lib.macro.set($name, ${ help }) return ( $lib.macro.get($name) )'
             mdef = await core.callStorm(q, opts={'vars': {'name': name}})
-            self.eq(mdef.get('storm'), 'help')
+            self.eq(mdef.get('storm'), ' help ')
 
             badname = 'v' * 492
             with self.raises(s_exc.BadArg):
@@ -381,7 +381,7 @@ class MacroTest(s_test.SynTest):
                     self.eq('storm:macro:add', addmesg['data']['event'])
                     macro = addmesg['data']['info']['macro']
                     self.eq(macro['name'], 'foobar')
-                    self.eq(macro['storm'], 'file:bytes | [+#neato]')
+                    self.eq(macro['storm'], ' file:bytes | [+#neato] ')
                     self.ne(visi.iden, macro['user'])
                     self.ne(visi.iden, macro['creator'])
                     self.nn(macro['iden'])
@@ -390,7 +390,7 @@ class MacroTest(s_test.SynTest):
                     self.eq('storm:macro:mod', setmesg['data']['event'])
                     event = setmesg['data']['info']
                     self.nn(event['macro'])
-                    self.eq(event['info']['storm'], 'inet:ipv4 | [+#burrito]')
+                    self.eq(event['info']['storm'], ' inet:ipv4 | [+#burrito] ')
                     self.nn(event['info']['updated'])
 
                     modmesg = await sock.receive_json()

synapse/tests/test_lib_stormtypes.py

@@ -749,7 +749,7 @@ class StormTypesTest(s_test.SynTest):
             self.stormIsInPrint("['1', 2, '3']", mesgs)
 
             mesgs = await core.stormlist('$lib.print(${ $foo=bar })')
-            self.stormIsInPrint('storm:query: "$foo=bar"', mesgs)
+            self.stormIsInPrint('storm:query: " $foo=bar "', mesgs)
 
             mesgs = await core.stormlist('$lib.print($lib.set(1,2,3))')
             self.stormIsInPrint("'1'", mesgs)
@@ -1168,7 +1168,7 @@ class StormTypesTest(s_test.SynTest):
             fires = [m for m in msgs if m[0] == 'storm:fire']
             self.len(1, fires)
             self.eq(fires[0][1].get('data').get('q'),
-                    "$lib.print('fire in the hole')")
+                    " $lib.print('fire in the hole') ")
 
             q = '''
             $q=${ [test:int=1 test:int=2] }
@@ -1409,6 +1409,18 @@ class StormTypesTest(s_test.SynTest):
             with self.raises(s_exc.BadJsonText):
                 await core.callStorm('return(("foo").json())')
 
+            with self.raises(s_exc.BadArg):
+                await core.nodes("$lib.regex.search('?id=([0-9]+)', 'foo')")
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes("$lib.regex.search('(?au)\\w', 'foo')")
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes("$lib.regex.replace('(?P<a>x)', '\\g<ab>', 'xx')")
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes("$lib.regex.replace('(?P<a>x)', '(?au)\\w', 'xx')")
+
     async def test_storm_lib_bytes_gzip(self):
         async with self.getTestCore() as core:
             hstr = 'ohhai'

synapse/tests/test_lib_task.py

@@ -2,12 +2,14 @@ import asyncio
 
 import synapse.exc as s_exc
 import synapse.lib.boss as s_boss
+import synapse.lib.cell as s_cell
 import synapse.lib.task as s_task
 import synapse.tests.utils as s_test
 
-class FakeUser:
-    def __init__(self, name):
-        self.name = name
+class BossCell(s_cell.Cell):
+    async def initServiceRuntime(self):
+        self.cboss = await s_boss.Boss.anit()
+        self.onfini(self.cboss)
 
 class TaskTest(s_test.SynTest):
 
@@ -19,15 +21,27 @@ class TaskTest(s_test.SynTest):
 
     async def test_task_module(self):
 
-        async with await s_boss.Boss.anit() as boss:
+        async with self.getTestCell(BossCell) as bcell:
+            boss = bcell.cboss
+            root = await bcell.auth.getUserByName('root')
 
-            user = FakeUser('visi')
+            synt = await boss.promote('test', root, info={'hehe': 'haha'})
 
-            synt = await boss.promote('test', user, info={'hehe': 'haha'})
-
-            self.eq(s_task.user(), user)
+            self.eq(s_task.user(), root)
             self.eq(s_task.current(), synt)
-            self.eq(s_task.username(), 'visi')
+            self.eq(s_task.username(), 'root')
+
+            ret = synt.pack()
+            self.nn(ret.pop('iden'))
+            self.nn(ret.pop('tick'))
+            self.eq(ret, {'name': 'test', 'info': {'hehe': 'haha'},
+                          'user': 'root', 'kids': {}})
+
+            ret = synt.packv2()
+            self.nn(ret.pop('iden'))
+            self.nn(ret.pop('tick'))
+            self.eq(ret, {'name': 'test', 'info': {'hehe': 'haha'},
+                          'user': root.iden, 'username': 'root', 'kids': {}})
 
     async def test_taskvars(self):
         s_task.varset('test', 'foo')
@@ -51,7 +65,11 @@ class TaskTest(s_test.SynTest):
         self.eq(s_task.varget('test'), 'foo')
 
     async def test_task_iden(self):
-        with self.raises(s_exc.BadArg):
-            await s_task.Task.anit(None, asyncio.current_task(), None, None, iden=10)
-        with self.raises(s_exc.BadArg):
-            await s_task.Task.anit(None, asyncio.current_task(), None, None, iden='woot')
+        async with self.getTestCell(BossCell) as bcell:
+            root = await bcell.auth.getUserByName('root')
+            boss = bcell.cboss
+
+            with self.raises(s_exc.BadArg):
+                await s_task.Task.anit(boss, asyncio.current_task(), None, root, iden=10)
+            with self.raises(s_exc.BadArg):
+                await s_task.Task.anit(boss, asyncio.current_task(), None, root, iden='woot')

synapse/tests/test_model_doc.py

@@ -49,3 +49,41 @@ class DocModelTest(s_tests.SynTest):
             self.eq('V-99', nodes[0].get('id'))
             self.nn(nodes[0].get('policy'))
             self.len(1, await core.nodes('doc:standard -> doc:policy'))
+
+            nodes = await core.nodes('''
+                [ doc:requirement=*
+                    :id=V-99
+                    :priority=low
+                    :optional=(false)
+                    :summary="Some requirement text."
+                    :standard={doc:standard}
+                ]
+            ''')
+            self.eq('V-99', nodes[0].get('id'))
+            self.eq('Some requirement text.', nodes[0].get('summary'))
+            self.eq(20, nodes[0].get('priority'))
+            self.false(nodes[0].get('optional'))
+            self.nn(nodes[0].get('standard'))
+            self.len(1, await core.nodes('doc:requirement -> doc:standard'))
+
+            nodes = await core.nodes('''
+                [ doc:resume=*
+                    :id=V-99
+                    :contact={[ ps:contact=* :name=visi ]}
+                    :summary="Thought leader seeks..."
+                    :workhist={[ ps:workhist=* ]}
+                    :education={[ ps:education=* ]}
+                    :achievements={[ ps:achievement=* ]}
+                ]
+            ''')
+            self.eq('V-99', nodes[0].get('id'))
+            self.eq('Thought leader seeks...', nodes[0].get('summary'))
+            self.nn(nodes[0].get('contact'))
+            self.len(1, nodes[0].get('workhist'))
+            self.len(1, nodes[0].get('education'))
+            self.len(1, nodes[0].get('achievements'))
+
+            self.len(1, await core.nodes('doc:resume :contact -> ps:contact'))
+            self.len(1, await core.nodes('doc:resume :workhist -> ps:workhist'))
+            self.len(1, await core.nodes('doc:resume :education -> ps:education'))
+            self.len(1, await core.nodes('doc:resume :achievements -> ps:achievement'))