synapse 2.170.0__py311-none-any.whl → 2.172.0__py311-none-any.whl

synapse/tests/test_lib_layer.py

@@ -4,11 +4,14 @@ import asyncio
 
 import synapse.exc as s_exc
 import synapse.common as s_common
+import synapse.cortex as s_cortex
 import synapse.telepath as s_telepath
 
 import synapse.lib.time as s_time
 import synapse.lib.layer as s_layer
 import synapse.lib.msgpack as s_msgpack
+import synapse.lib.spooled as s_spooled
+import synapse.lib.hiveauth as s_hiveauth
 
 import synapse.tools.backup as s_tools_backup
 
@@ -16,6 +19,8 @@ import synapse.tests.utils as s_t_utils
 
 from synapse.tests.utils import alist
 
+from unittest import mock
+
 async def iterPropForm(self, form=None, prop=None):
     bad_valu = [(b'foo', "bar"), (b'bar', ('bar',)), (b'biz', 4965), (b'baz', (0, 56))]
     bad_valu += [(b'boz', 'boz')] * 10
@@ -1014,6 +1019,20 @@ class LayerTest(s_t_utils.SynTest):
                 if offs == layr.nodeeditlog.index() - 1:
                     break
 
+            fwdedits = [item async for item in core0.getLayer().syncNodeEdits(0, wait=False)]
+            revedits = [item async for item in core0.getLayer().syncNodeEdits(0xffffffff, wait=False, reverse=True)]
+
+            self.eq(fwdedits, list(reversed(revedits)))
+
+            fwdedit = await core0.callStorm('for $item in $lib.layer.get().edits() { return($item) }')
+            revedit = await core0.callStorm('for $item in $lib.layer.get().edits(reverse=(true)) { return($item) }')
+
+            self.nn(await core0.callStorm('return($lib.layer.get().edited())'))
+
+            self.ne(fwdedit, revedit)
+            self.eq(fwdedits[0], fwdedit)
+            self.eq(revedits[0], revedit)
+
             async with self.getTestCore() as core1:
 
                 url = core1.getLocalUrl('*/layer')
@@ -1897,74 +1916,164 @@ class LayerTest(s_t_utils.SynTest):
 
     async def test_layer_edit_perms(self):
 
-        async with self.getTestCore() as core:
-
-            viewiden = await core.callStorm('''
-                $lyr = $lib.layer.add()
-                $view = $lib.view.add(($lyr.iden,))
-                return($view.iden)
-            ''')
+        class Dict(s_spooled.Dict):
+            async def __anit__(self, dirn=None, size=1, cell=None):
+                await super().__anit__(dirn=dirn, size=size, cell=cell)
 
-            opts = {'view': viewiden}
-
-            await core.addTagProp('score', ('int', {}), {})
+        with mock.patch('synapse.lib.spooled.Dict', Dict):
+            async with self.getTestCore() as core:
 
-            await core.nodes('[ test:str=bar ]', opts=opts)
+                user = await core.auth.addUser('blackout@vertex.link')
 
-            await core.nodes('''
-                [ test:str=foo
-                    :hehe=bar
-                    +#foo:score=2
-                    +#foo.bar
-                    <(refs)+ { test:str=bar }
-                ]
-                $node.data.set(foo, bar)
-            ''', opts=opts)
-
-            await core.nodes('''
-                test:str=foo
-                [ <(refs)- { test:str=bar } ]
-                $node.data.pop(foo)
-                | delnode
-            ''', opts=opts)
-
-            layr = core.views[viewiden].layers[0]
-
-            nodeedits = []
-            async for _, edits, _ in layr.iterNodeEditLog():
-                nodeedits.extend(edits)
-
-            perms = [perm for permoffs, perm in s_layer.getNodeEditPerms(nodeedits)]
-
-            self.eq({
-                ('node', 'add', 'test:str'),
-                ('node', 'del', 'test:str'),
-
-                ('node', 'add', 'syn:tag'),
-
-                ('node', 'prop', 'set', 'test:str:.created'),
-                ('node', 'prop', 'del', 'test:str:.created'),
+                viewiden = await core.callStorm('''
+                    $lyr = $lib.layer.add()
+                    $view = $lib.view.add(($lyr.iden,))
+                    return($view.iden)
+                ''')
 
-                ('node', 'prop', 'set', 'test:str:hehe'),
-                ('node', 'prop', 'del', 'test:str:hehe'),
+                layr = core.views[viewiden].layers[0]
 
-                ('node', 'prop', 'set', 'syn:tag:up'),
-                ('node', 'prop', 'set', 'syn:tag:base'),
-                ('node', 'prop', 'set', 'syn:tag:depth'),
-                ('node', 'prop', 'set', 'syn:tag:.created'),
+                opts = {'view': viewiden}
 
-                ('node', 'tag', 'add', 'foo'),
-                ('node', 'tag', 'del', 'foo'),
+                await core.addTagProp('score', ('int', {}), {})
 
-                ('node', 'tag', 'add', 'foo', 'bar'),
-                ('node', 'tag', 'del', 'foo', 'bar'),
+                await core.nodes('[ test:str=bar +#foo.bar ]', opts=opts)
 
-                ('node', 'data', 'set', 'foo'),
-                ('node', 'data', 'pop', 'foo'),
+                await core.nodes('''
+                    [ test:str=foo
+                        :hehe=bar
+                        +#foo:score=2
+                        +#foo.bar.baz
+                        +#bar:score=2
+                        <(refs)+ { test:str=bar }
+                    ]
+                    $node.data.set(foo, bar)
+                ''', opts=opts)
+
+                parent = core.view.layers[0]
+
+                seen = set()
+                def confirm(self, perm, default=None, gateiden=None):
+                    seen.add(perm)
+                    return True
+
+                def confirmPropSet(self, user, prop, layriden):
+                    seen.add(prop.setperms[0])
+                    seen.add(prop.setperms[1])
+
+                def confirmPropDel(self, user, prop, layriden):
+                    seen.add(prop.delperms[0])
+                    seen.add(prop.delperms[1])
+
+                with mock.patch.object(s_hiveauth.HiveUser, 'confirm', confirm):
+                    with mock.patch.object(s_cortex.Cortex, 'confirmPropSet', confirmPropSet):
+                        with mock.patch.object(s_cortex.Cortex, 'confirmPropDel', confirmPropDel):
+                            await layr.confirmLayerEditPerms(user, parent.iden)
+
+                self.eq(seen, {
+                    # Node add
+                    ('node', 'add', 'syn:tag'),
+                    ('node', 'add', 'test:str'),
+
+                    # Old style prop set
+                    ('node', 'prop', 'set', 'test:str:hehe'),
+                    ('node', 'prop', 'set', 'test:str.created'),
+
+                    ('node', 'prop', 'set', 'syn:tag:up'),
+                    ('node', 'prop', 'set', 'syn:tag:base'),
+                    ('node', 'prop', 'set', 'syn:tag:depth'),
+                    ('node', 'prop', 'set', 'syn:tag.created'),
+
+                    # New style prop set
+                    ('node', 'prop', 'set', 'test:str', 'hehe'),
+                    ('node', 'prop', 'set', 'test:str', '.created'),
+
+                    ('node', 'prop', 'set', 'syn:tag', 'up'),
+                    ('node', 'prop', 'set', 'syn:tag', 'base'),
+                    ('node', 'prop', 'set', 'syn:tag', 'depth'),
+                    ('node', 'prop', 'set', 'syn:tag', '.created'),
+
+                    # Tag/tagprop add
+                    ('node', 'tag', 'add', 'foo'),
+                    ('node', 'tag', 'add', 'bar'),
+                    ('node', 'tag', 'add', 'foo', 'bar'),
+                    ('node', 'tag', 'add', 'foo', 'bar', 'baz'),
+
+                    # Nodedata set
+                    ('node', 'data', 'set', 'foo'),
+
+                    # Edge add
+                    ('node', 'edge', 'add', 'refs'),
+                })
 
-                ('node', 'edge', 'add', 'refs'),
-                ('node', 'edge', 'del', 'refs'),
-            }, set(perms))
+                await core.nodes('''
+                    test:str=foo
+                    [ <(refs)- { test:str=bar } ]
+                    $node.data.pop(foo)
+                    | delnode
+                ''', opts=opts)
+
+                seen.clear()
+                with mock.patch.object(s_hiveauth.HiveUser, 'confirm', confirm):
+                    with mock.patch.object(s_cortex.Cortex, 'confirmPropSet', confirmPropSet):
+                        with mock.patch.object(s_cortex.Cortex, 'confirmPropDel', confirmPropDel):
+                            await layr.confirmLayerEditPerms(user, parent.iden)
+
+                self.eq(seen, {
+                    # Node add
+                    ('node', 'add', 'syn:tag'),
+                    ('node', 'add', 'test:str'),
+
+                    # Old style prop set
+                    ('node', 'prop', 'set', 'test:str.created'),
+
+                    ('node', 'prop', 'set', 'syn:tag:up'),
+                    ('node', 'prop', 'set', 'syn:tag:base'),
+                    ('node', 'prop', 'set', 'syn:tag:depth'),
+                    ('node', 'prop', 'set', 'syn:tag.created'),
+
+                    # New style prop set
+                    ('node', 'prop', 'set', 'test:str', '.created'),
+
+                    ('node', 'prop', 'set', 'syn:tag', 'up'),
+                    ('node', 'prop', 'set', 'syn:tag', 'base'),
+                    ('node', 'prop', 'set', 'syn:tag', 'depth'),
+                    ('node', 'prop', 'set', 'syn:tag', '.created'),
+
+                    # Tag/tagprop add
+                    ('node', 'tag', 'add', 'foo', 'bar'),
+                })
+
+                seen.clear()
+                with mock.patch.object(s_hiveauth.HiveUser, 'confirm', confirm):
+                    with mock.patch.object(s_cortex.Cortex, 'confirmPropSet', confirmPropSet):
+                        with mock.patch.object(s_cortex.Cortex, 'confirmPropDel', confirmPropDel):
+                            await layr.confirmLayerEditPerms(user, layr.iden, delete=True)
+
+                self.eq(seen, {
+                    # Node del
+                    ('node', 'del', 'syn:tag'),
+                    ('node', 'del', 'test:str'),
+
+                    # Old style prop del
+                    ('node', 'prop', 'del', 'test:str.created'),
+
+                    ('node', 'prop', 'del', 'syn:tag:up'),
+                    ('node', 'prop', 'del', 'syn:tag:base'),
+                    ('node', 'prop', 'del', 'syn:tag:depth'),
+                    ('node', 'prop', 'del', 'syn:tag.created'),
+
+                    # New style prop del
+                    ('node', 'prop', 'del', 'test:str', '.created'),
+
+                    ('node', 'prop', 'del', 'syn:tag', 'up'),
+                    ('node', 'prop', 'del', 'syn:tag', 'base'),
+                    ('node', 'prop', 'del', 'syn:tag', 'depth'),
+                    ('node', 'prop', 'del', 'syn:tag', '.created'),
+
+                    # Tag/tagprop del
+                    ('node', 'tag', 'del', 'foo', 'bar'),
+                })
 
     async def test_layer_v9(self):
         async with self.getRegrCore('2.101.1-hugenum-indxprec') as core:

synapse/tests/test_lib_lmdbslab.py

@@ -57,9 +57,11 @@ class LmdbSlabTest(s_t_utils.SynTest):
 
                 testgenr = slab.scanKeys(db=testdb)
                 dupsgenr = slab.scanKeys(db=dupsdb)
+                nodupsgenr = slab.scanKeys(db=dupsdb, nodup=True)
 
                 testlist = [next(testgenr)]
                 dupslist = [next(dupsgenr)]
+                nodupslist = [next(nodupsgenr)]
 
                 slab.put(b'derp', b'derp', db=editdb)
 
@@ -68,16 +70,25 @@ class LmdbSlabTest(s_t_utils.SynTest):
 
                 testlist.extend(testgenr)
                 dupslist.extend(dupsgenr)
+                nodupslist.extend(nodupsgenr)
 
                 self.eq(testlist, (b'hehe', b'hoho'))
                 self.eq(dupslist, (b'hehe', b'hehe', b'hoho'))
+                self.eq(nodupslist, (b'hehe', b'hoho'))
+
+                self.eq([b'hehe', b'hehe', b'hoho'], list(slab.scanKeysByPref(b'h', db=dupsdb)))
+                self.eq([b'hehe', b'hoho'], list(slab.scanKeysByPref(b'h', db=dupsdb, nodup=True)))
+
+                self.eq(3, await slab.countByPref(b'h', db=dupsdb))
 
                 # now lets delete the key we're on
                 testgenr = slab.scanKeys(db=testdb)
                 dupsgenr = slab.scanKeys(db=testdb)
+                nodupsgenr = slab.scanKeys(db=testdb, nodup=True)
 
                 testlist = [next(testgenr)]
                 dupslist = [next(dupsgenr)]
+                nodupslist = [next(nodupsgenr)]
 
                 slab.delete(b'hehe', db=testdb)
                 for lkey, lval in slab.scanByDups(b'hehe', db=dupsdb):
@@ -87,9 +98,11 @@ class LmdbSlabTest(s_t_utils.SynTest):
 
                 testlist.extend(testgenr)
                 dupslist.extend(dupsgenr)
+                nodupslist.extend(nodupsgenr)
 
                 self.eq(testlist, (b'hehe', b'hoho'))
                 self.eq(dupslist, (b'hehe', b'hoho'))
+                self.eq(nodupslist, (b'hehe', b'hoho'))
 
                 # by pref
                 self.eq([b'hoho'], list(slab.scanKeysByPref(b'h', db=dupsdb)))
@@ -649,6 +662,42 @@ class LmdbSlabTest(s_t_utils.SynTest):
                 self.eq((b'1', b'1'), next(it))
                 self.raises(StopIteration, next, it)
 
+    async def test_lmdbslab_scanback(self):
+
+        with self.getTestDir() as dirn:
+
+            path = os.path.join(dirn, 'test.lmdb')
+
+            async with await s_lmdbslab.Slab.anit(path, map_size=100000, growsize=10000) as slab:
+
+                foodup = slab.initdb('foodup', dupsort=True)
+                foonodup = slab.initdb('foonodup', dupsort=False)
+
+                for db in (foodup, foonodup):
+                    slab.put(b'\x01', b'foo', db=db)
+                    slab.put(b'\x01\x01', b'bar', db=db)
+                    slab.put(b'\x01\x03', b'baz', db=db)
+                    slab.put(b'\x02', b'faz', db=db)
+
+                items = list(slab.scanByPrefBack(b'\x01', db=foonodup))
+                self.eq(items, (
+                    (b'\x01\x03', b'baz'),
+                    (b'\x01\x01', b'bar'),
+                    (b'\x01', b'foo')
+                ))
+
+                self.eq((), list(slab.scanByPrefBack(b'\x00', db=foonodup)))
+
+                slab.put(b'\x01\x03', b'waz', db=foodup)
+
+                items = list(slab.scanByPrefBack(b'\x01', db=foodup))
+                self.eq(items, (
+                    (b'\x01\x03', b'waz'),
+                    (b'\x01\x03', b'baz'),
+                    (b'\x01\x01', b'bar'),
+                    (b'\x01', b'foo')
+                ))
+
     async def test_lmdbslab_count_empty(self):
 
         with self.getTestDir() as dirn:

synapse/tests/test_lib_stormlib_auth.py

@@ -628,6 +628,28 @@ class StormLibAuthTest(s_test.SynTest):
 
             self.nn(await core.tryUserPasswd('hehe', 'haha'))
 
+            hehe = await core.callStorm('''
+                            $hehe = $lib.auth.users.byname(hehe)
+                            $hehe.setArchived($lib.true)
+                            return($hehe)
+                        ''')
+            self.eq(True, hehe['archived'])
+            self.eq(True, hehe['locked'])
+
+            self.none(await core.tryUserPasswd('hehe', 'haha'))
+
+            hehe = await core.callStorm('''
+                            $hehe = $lib.auth.users.byname(hehe)
+                            $hehe.setArchived($lib.false)
+                            return($hehe)
+                        ''')
+            self.eq(True, hehe['locked'])
+            self.eq(False, hehe['archived'])
+            self.none(await core.tryUserPasswd('hehe', 'haha'))
+
+            await core.callStorm('$lib.auth.users.byname(hehe).setLocked($lib.false)')
+            self.nn(await core.tryUserPasswd('hehe', 'haha'))
+
             self.nn(await core.callStorm('''
                 $visi = $lib.auth.users.byname(visi)
                 if $( $visi.name = "visi" ) {

synapse/tests/test_lib_stormlib_cell.py

@@ -312,3 +312,50 @@ class StormCellTest(s_test.SynTest):
             self.len(1, await core.nodes('it:sec:cpe:v2_2', opts={'view': view0}))
             self.len(2, await core.nodes('it:sec:cpe:v2_2', opts={'view': view1}))
             self.len(1, await core.nodes('it:sec:cpe:v2_2', opts={'view': view2}))
+
+    async def test_stormfix_riskhasvuln(self):
+
+        async with self.getTestCore() as core:
+
+            view0 = core.getView().iden
+            view1 = await core.callStorm('return($lib.view.get().fork().iden)')
+            view2 = await core.callStorm('return($lib.view.add(($lib.layer.add().iden,)).iden)')
+
+            self.len(1, await core.nodes('''
+                [ risk:hasvuln=*
+                    :vuln={[ risk:vuln=* ]}
+                    :software={[ it:prod:softver=* :name=view0 ]}
+                ]
+            ''', opts={'view': view0}))
+
+            self.len(1, await core.nodes('''
+                risk:hasvuln
+                [ :software={[ it:prod:softver=* :name=view1 ]} ]
+            ''', opts={'view': view1}))
+
+            self.len(1, await core.nodes('''
+                [ risk:hasvuln=*
+                    :vuln={[ risk:vuln=* ]}
+                    :host={[ it:host=* :name=view2 ]}
+                ]
+            ''', opts={'view': view2}))
+
+            opts = {'vars': {'key': s_stormlib_cell.runtime_fixes_key, 'valu': (2, 0, 0)}}
+            await core.callStorm('$lib.globals.set($key, $valu)', opts)
+
+            msgs = await core.stormlist('$lib.cell.hotFixesCheck()')
+            printmesgs = [m[1]['mesg'] for m in msgs if m[0] == 'print']
+            self.isin('Would apply fix (3, 0, 0)', printmesgs[0])
+            self.eq('', printmesgs[1])
+            self.isin('Would apply fix (4, 0, 0)', printmesgs[2])
+            self.eq('', printmesgs[3])
+            self.isin('This hotfix should', printmesgs[4])
+            self.eq('', printmesgs[-1])
+
+            msgs = await core.stormlist('$lib.cell.hotFixesApply()')
+            self.stormIsInPrint('Applying hotfix (4, 0, 0) for [Create risk:vulnerable nodes', msgs)
+            self.stormIsInPrint('Applied hotfix (4, 0, 0)', msgs)
+
+            self.len(1, await core.nodes('risk:vulnerable -> it:prod:softver +:name=view0', opts={'view': view0}))
+            self.len(1, await core.nodes('risk:vulnerable -> it:prod:softver +:name=view1', opts={'view': view1}))
+            self.len(1, await core.nodes('risk:vulnerable -> it:host', opts={'view': view2}))

synapse/tests/test_lib_stormlib_env.py

@@ -0,0 +1,25 @@
+import os
+import synapse.exc as s_exc
+import synapse.tests.utils as s_test
+
+class StormLibEnvTest(s_test.SynTest):
+
+    async def test_stormlib_env(self):
+
+        with self.setTstEnvars(SYN_STORM_ENV_WOOT='woot'):
+
+            async with self.getTestCore() as core:
+
+                self.eq('woot', await core.callStorm('return($lib.env.get(SYN_STORM_ENV_WOOT))'))
+                self.eq('hehe', await core.callStorm('return($lib.env.get(SYN_STORM_ENV_HEHE, default=hehe))'))
+
+                self.none(await core.callStorm('return($lib.env.get(SYN_STORM_ENV_HEHE))'))
+
+                visi = await core.auth.addUser('visi')
+
+                with self.raises(s_exc.AuthDeny):
+                    opts = {'user': visi.iden}
+                    await core.callStorm('return($lib.env.get(SYN_STORM_ENV_WOOT))', opts=opts)
+
+                with self.raises(s_exc.BadArg):
+                    await core.callStorm('return($lib.env.get(USER))')

synapse/tests/test_lib_stormtypes.py

@@ -6758,10 +6758,12 @@ words\tword\twrd'''
             self.eq([], await core.callStorm(merging))
 
             # merge a view with a fork
-            fork00 = await core.getView().fork()
+            mainview = core.getView()
+            fork00 = await mainview.fork()
             midfork = core.getView(fork00['iden'])
 
             fork01 = await midfork.fork()
+            fork01_iden = fork01['iden']
             self.true(midfork.hasKids())
 
             opts = {'view': midfork.iden}
@@ -6769,11 +6771,20 @@ words\tword\twrd'''
 
             self.eq([midfork.iden], await core.callStorm(merging))
 
+            layridens = [lyr['iden'] for lyr in fork01['layers'] if lyr['iden'] != midfork.layers[0].iden]
+            events = [
+                {'event': 'view:setlayers', 'info': {'iden': fork01_iden, 'layers': layridens}},
+                {'event': 'view:set', 'info': {'iden': fork01_iden, 'name': 'parent', 'valu': mainview.iden}}
+            ]
+            task = core.schedCoro(s_test.waitForBehold(core, events))
+
             opts = {'view': midfork.iden, 'user': visi.iden}
             await core.callStorm('return($lib.view.get().setMergeVote())', opts=opts)
 
             self.true(await midfork.waitfini(timeout=12))
 
+            await asyncio.wait_for(task, timeout=5)
+
             self.eq([], await core.callStorm(merging))
 
             leaffork = core.getView(fork01['iden'])

synapse/tests/test_lib_types.py

@@ -1087,6 +1087,7 @@ class TypesTest(s_t_utils.SynTest):
         self.eq('hehe', enums.norm('hehe')[0])
         self.eq('haha', enums.norm('haha')[0])
         self.eq('zork', enums.norm('zork')[0])
+        self.raises(s_exc.BadTypeValu, enums.norm, 1.23)
         self.raises(s_exc.BadTypeValu, enums.norm, 'zing')
 
         strsubs = model.type('str').clone({'regex': r'(?P<first>[ab]+)(?P<last>[zx]+)'})

synapse/tests/test_lib_view.py

@@ -769,21 +769,15 @@ class ViewTest(s_t_utils.SynTest):
 
             with self.raises(s_exc.AuthDeny) as cm:
                 await core.nodes('$lib.view.get().merge()', opts=viewopts)
-            self.eq('node.add.test:str', cm.exception.errinfo['perm'])
-
-            await core.addUserRule(useriden, (True, ('node', 'add')), gateiden=baselayr)
-
-            with self.raises(s_exc.AuthDeny) as cm:
-                await core.nodes('$lib.view.get().merge()', opts=viewopts)
-            self.eq('node.prop.set.test:str:.created', cm.exception.errinfo['perm'])
+            self.eq('node.prop.set.syn:tag.base', cm.exception.errinfo['perm'])
 
             await core.addUserRule(useriden, (True, ('node', 'prop', 'set')), gateiden=baselayr)
 
             with self.raises(s_exc.AuthDeny) as cm:
                 await core.nodes('$lib.view.get().merge()', opts=viewopts)
-            self.eq('node.edge.add.refs', cm.exception.errinfo['perm'])
+            self.eq('node.add.syn:tag', cm.exception.errinfo['perm'])
 
-            await core.addUserRule(useriden, (True, ('node', 'edge', 'add')), gateiden=baselayr)
+            await core.addUserRule(useriden, (True, ('node', 'add')), gateiden=baselayr)
 
             with self.raises(s_exc.AuthDeny) as cm:
                 await core.nodes('$lib.view.get().merge()', opts=viewopts)
@@ -797,6 +791,12 @@ class ViewTest(s_t_utils.SynTest):
 
             await core.addUserRule(useriden, (True, ('node', 'data', 'set')), gateiden=baselayr)
 
+            with self.raises(s_exc.AuthDeny) as cm:
+                await core.nodes('$lib.view.get().merge()', opts=viewopts)
+            self.eq('node.edge.add.refs', cm.exception.errinfo['perm'])
+
+            await core.addUserRule(useriden, (True, ('node', 'edge', 'add')), gateiden=baselayr)
+
             await core.nodes('$lib.view.get().merge()', opts=viewopts)
 
             nodes = await core.nodes('test:str=foo $node.data.load(foo)')

synapse/tests/test_model_base.py

@@ -12,9 +12,10 @@ class BaseTest(s_t_utils.SynTest):
             nodes = await core.nodes('[ meta:timeline=* :title=Woot :summary=4LOLZ :type=lol.cats ]')
             self.len(1, nodes)
             nodes = await core.nodes('''
-                [ meta:event=* :title=Zip :duration=1:30:00
+                [ meta:event=* :title=Zip :duration=1:30:00 :index=0
                     :summary=Zop :time=20220321 :type=zip.zop :timeline={meta:timeline:title=Woot} ]''')
             self.len(1, nodes)
+            self.eq(0, nodes[0].get('index'))
             nodes = await core.nodes('''[ meta:event=* :title=Hehe :duration=2:00
                     :summary=Haha :time=20220322 :type=hehe.haha :timeline={meta:timeline:title=Woot} ]''')
             self.len(1, nodes)
@@ -68,13 +69,14 @@ class BaseTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].get('text'), 'yieldnote')
 
-            nodes = await core.nodes('note.add --yield "nonodes"')
+            nodes = await core.nodes('note.add --yield "nonodes" | [ :replyto=* ]')
             self.len(1, nodes)
             self.eq(nodes[0].get('text'), 'nonodes')
             self.nn(nodes[0].get('created'))
             self.nn(nodes[0].get('updated'))
 
             self.len(0, await core.nodes('meta:note:text=nonodes -(about)> *'))
+            self.len(1, await core.nodes('meta:note:text=nonodes -> meta:note'))
 
     async def test_model_base_node(self):
 
@@ -348,7 +350,7 @@ class BaseTest(s_t_utils.SynTest):
 
                 keep.append(node)
 
-            self.len(0, keep)
+            self.len(0, keep, msg=[node.ndef[1] for node in keep])
             self.len(len(SYN_6315), skip)
 
             for edge in core.model.edges.values():

synapse/tests/test_model_economic.py

@@ -36,13 +36,17 @@ class EconTest(s_utils.SynTest):
                     :paid:time=20180202
 
                     :settled=20180205
+                    :listing = *
             ]'''
 
             perc = (await core.nodes(text))[0]
 
+            self.nn(perc.get('listing'))
             self.eq('13.37', perc.get('price'))
             self.eq('usd', perc.get('currency'))
 
+            self.len(1, await core.nodes('econ:purchase -> biz:listing'))
+
             self.len(1, await core.nodes('econ:purchase:price=13.37'))
             self.len(1, await core.nodes('econ:purchase:price=13.370'))
             self.len(0, await core.nodes('econ:purchase:price=13.372'))

synapse/tests/test_model_files.py

@@ -26,6 +26,7 @@ class FileTest(s_t_utils.SynTest):
             self.raises(s_exc.BadTypeValu, fbyts.norm, 'guid:0101')
             self.raises(s_exc.BadTypeValu, fbyts.norm, 'helo:moto')
             self.raises(s_exc.BadTypeValu, fbyts.norm, f'sha256:{s_common.guid()}')
+            self.raises(s_exc.BadTypeValu, fbyts.norm, 1.23)
 
             nodes = await core.nodes('''
                 [ file:bytes=$byts