synapse 2.165.0__py311-none-any.whl → 2.167.0__py311-none-any.whl

synapse/tests/test_lib_stormlib_macro.py

@@ -53,6 +53,27 @@ class MacroTest(s_test.SynTest):
             with self.raises(s_exc.AuthDeny):
                 await core.nodes('$lib.macro.del(hehe)', opts=asvisi)
 
+            with self.raises(s_exc.BadArg):
+                await core.nodes('$lib.macro.set("", ${ inet:ipv4 })')
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes('$lib.macro.get("")')
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes('$lib.macro.del("")')
+
+            with self.raises(s_exc.BadArg):
+                await core.delStormMacro('', user=None)
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes('$lib.macro.grant("", users, hehe, 3)')
+
+            with self.raises(s_exc.SchemaViolation):
+                await core.nodes('$lib.macro.mod("hehe", ({"name": ""}))')
+
+            with self.raises(s_exc.BadArg):
+                await core.nodes('$lib.macro.mod("", ({"name": "foobar"}))')
+
             with self.raises(s_exc.AuthDeny):
                 await core.nodes('$lib.macro.set(hehe, ${ inet:ipv6 })', opts=asvisi)
 
@@ -118,6 +139,14 @@ class MacroTest(s_test.SynTest):
             msgs = await core.stormlist('macro.del print', opts={'readonly': True})
             self.stormIsInErr('not marked readonly safe', msgs)
 
+            msgs = await core.stormlist('macro.set blorpblorp "+#foo"', opts=asvisi)
+            self.stormHasNoWarnErr(msgs)
+
+            await core.auth.delUser(visi.iden)
+            msgs = await core.stormlist('macro.list')
+            self.stormIsInPrint("User not found", msgs)
+            self.stormIsInPrint(visi.iden, msgs)
+
     async def test_stormlib_macro_vars(self):
 
         async with self.getTestCore() as core:
@@ -319,3 +348,68 @@ class MacroTest(s_test.SynTest):
             await visi.addRule((True, ('storm', 'macro', 'admin')))
             msgs = await core.stormlist('macro.del asdf', opts={'user': visi.iden})
             self.stormHasNoWarnErr(msgs)
+
+    async def test_stormlib_behold_macro(self):
+        self.skipIfNexusReplay()
+        async with self.getTestCore() as core:
+            host, port = await core.addHttpsPort(0, host='127.0.0.1')
+
+            visi = await core.auth.addUser('visi')
+            await visi.setPasswd('secret')
+            await visi.setAdmin(True)
+
+            async with self.getHttpSess() as sess:
+                async with sess.post(f'https://localhost:{port}/api/v1/login', json={'user': 'visi', 'passwd': 'secret'}) as resp:
+                    retn = await resp.json()
+                    self.eq('ok', retn.get('status'))
+                    self.eq('visi', retn['result']['name'])
+
+                async with sess.ws_connect(f'wss://localhost:{port}/api/v1/behold') as sock:
+                    await sock.send_json({'type': 'call:init'})
+                    mesg = await sock.receive_json()
+                    self.eq(mesg['type'], 'init')
+
+                    await core.callStorm('''
+                        $lib.macro.set('foobar', ${ file:bytes | [+#neato] })
+                        $lib.macro.set('foobar', ${ inet:ipv4 | [+#burrito] })
+                        $lib.macro.mod('foobar', ({'name': 'bizbaz'}))
+                        $lib.macro.grant('bizbaz', users, $visi, 3)
+                        $lib.macro.del('bizbaz')
+                    ''', opts={'vars': {'visi': visi.iden}})
+
+                    addmesg = await sock.receive_json()
+                    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.ne(visi.iden, macro['user'])
+                    self.ne(visi.iden, macro['creator'])
+                    self.nn(macro['iden'])
+
+                    setmesg = await sock.receive_json()
+                    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.nn(event['info']['updated'])
+
+                    modmesg = await sock.receive_json()
+                    self.eq('storm:macro:mod', modmesg['data']['event'])
+                    event = modmesg['data']['info']
+                    self.nn(event['macro'])
+                    self.eq(event['info']['name'], 'bizbaz')
+                    self.nn(event['info']['updated'])
+
+                    grantmesg = await sock.receive_json()
+                    self.eq('storm:macro:set:perm', grantmesg['data']['event'])
+                    event = grantmesg['data']['info']
+                    self.nn(event['macro'])
+                    self.eq(event['info']['level'], 3)
+                    self.eq(event['info']['scope'], 'users')
+                    self.eq(event['info']['iden'], visi.iden)
+
+                    delmesg = await sock.receive_json()
+                    self.eq('storm:macro:del', delmesg['data']['event'])
+                    event = delmesg['data']['info']
+                    self.nn(event['iden'])
+                    self.eq(event['name'], 'bizbaz')

synapse/tests/test_lib_stormlib_spooled.py

@@ -0,0 +1,190 @@
+import synapse.exc as s_exc
+import synapse.lib.stormtypes as s_stormtypes
+
+import synapse.tests.utils as s_test
+
+class StormlibSpooledTest(s_test.SynTest):
+    async def test_lib_spooled_set(self):
+        async with self.getTestCore() as core:
+            await core.nodes('[inet:ipv4=1.2.3.4 :asn=20]')
+            await core.nodes('[inet:ipv4=5.6.7.8 :asn=30]')
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add(1, 2, 3, 4)
+                return($set)
+            '''
+            valu = await core.callStorm(q)
+            self.eq({'1', '2', '3', '4'}, valu)
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.adds($lib.list(1, 2, 3, 4))
+                return($set)
+            '''
+            valu = await core.callStorm(q)
+            self.eq({'1', '2', '3', '4'}, valu)
+
+            q = '''
+                $set = $lib.spooled.set()
+                inet:ipv4 $set.add(:asn)
+                $set.rems((:asn,:asn))
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$set.list() ]
+            '''
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('data'), ())
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add($foo)
+                $set.add($bar)
+                $set.add($biz)
+                return(($set.has($foo), $set.has(lolnop)))
+            '''
+            valu = await core.callStorm(q, opts={'vars': {'foo': b'foo', 'bar': b'bar', 'biz': b'biz'}})
+            self.eq(True, valu[0])
+            self.eq(False, valu[1])
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.adds(('foo', 'bar', 'baz', 'biz', 'biz', 'biz', 'beep', 'boop'))
+                return($set.size())
+            '''
+            valu = await core.callStorm(q)
+            self.eq(6, valu)
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.adds(('foo', 'bar', 'baz', 'biz', 'biz', 'biz', 'beep', 'boop'))
+
+                $set.rems(('baz', 'beep', 'bar'))
+                return($set)
+
+            '''
+            valu = await core.callStorm(q)
+            self.eq({'foo', 'boop', 'biz'}, valu)
+
+            q = '''
+                $set = $lib.spooled.set(1, 2, 3, 4 ,5)
+                $set.add(1, 2, 3, 4)
+                return($set.list())
+            '''
+            valu = await core.callStorm(q)
+            self.isinstance(valu, tuple)
+            self.len(5, valu)
+            self.isin('1', valu)
+            self.isin('2', valu)
+            self.isin('3', valu)
+            self.isin('4', valu)
+            self.isin('5', valu)
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add($lib.true)
+                $set.add($lib.false)
+                $set.add($lib.true)
+                $set.add($lib.false)
+                $set.add('more stuff')
+
+                $dict = ({
+                    "foo": "bar",
+                    "biz": "baz",
+                })
+                $set.adds($dict)
+                return($set)
+            '''
+            valu = await core.callStorm(q)
+            self.len(5, valu)
+            self.isin(False, valu)
+            self.isin(True, valu)
+            self.isin('more stuff', valu)
+            self.isin(('biz', 'baz'), valu)
+            self.isin(('foo', 'bar'), valu)
+
+            q = '''
+                $set = $lib.spooled.set()
+                $set.adds($items)
+                for $x in $set {
+                    $lib.print(`{$x} exists in the set`)
+                }
+                return()
+            '''
+            msgs = await core.stormlist(q, opts={'vars': {'items': [True, 'neato', False, 9001]}})
+            self.len(7, msgs)
+            self.stormIsInPrint('false exists in the set', msgs)
+            self.stormIsInPrint('true exists in the set', msgs)
+            self.stormIsInPrint('neato exists in the set', msgs)
+            self.stormIsInPrint('9001 exists in the set', msgs)
+
+            q = '''
+                $set = $lib.spooled.set(neato, neato, neato, neato)
+                $lib.print(`The set is {$set}`)
+            '''
+            msgs = await core.stormlist(q, opts={'vars': {'items': [True, 'neato', False, 9001]}})
+            self.stormIsInPrint("The set is {'neato'}", msgs)
+
+            # force a fallback
+            q = '''
+                $set = $lib.spooled.set()
+                $set.adds($lib.range(1500))
+                return($set.size())
+            '''
+            valu = await core.callStorm(q)
+            self.eq(1500, valu)
+
+            # sad paths
+            # too complex
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add($stormnode)
+                return($set)
+            '''
+            stormnode = s_stormtypes.Node(nodes[0])
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q, {'vars': {'stormnode': stormnode}}))
+
+            # mutable failures
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add(({'neato': 'burrito'}))
+                return($set)
+            '''
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q))
+
+            q = '''
+                $set = $lib.spooled.set()
+                $dict = ({'neato': 'burrito'})
+                $set.adds(($dict, $dict))
+                return($set)
+            '''
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q))
+
+            q = '''
+                $set = $lib.spooled.set()
+                $form = $lib.model.form('inet:ipv4')
+                $set.adds(($stormnode, $form, $form))
+                return($set)
+            '''
+            # it'll blow up on the first
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q, {'vars': {'stormnode': stormnode}}))
+
+            q = '''
+                $dict = ({'foo': 'bar'})
+                $set = $lib.spooled.set($dict)
+                return($set)
+            '''
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q))
+
+            # type not msgpack-able
+            q = '''
+                $set = $lib.spooled.set()
+                $set.add($lib.model.form("inet:ipv4"))
+                return($set)
+            '''
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q))
+
+            q = '''
+                $set = $lib.spooled.set($stormnode)
+                return($set)
+            '''
+            await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q, {'vars': {'stormnode': stormnode}}))

synapse/tests/test_lib_stormtypes.py

@@ -20,7 +20,6 @@ import synapse.lib.storm as s_storm
 import synapse.lib.hashset as s_hashset
 import synapse.lib.httpapi as s_httpapi
 import synapse.lib.modelrev as s_modelrev
-import synapse.lib.provenance as s_provenance
 import synapse.lib.stormtypes as s_stormtypes
 
 import synapse.tests.utils as s_test
@@ -1344,34 +1343,34 @@ class StormTypesTest(s_test.SynTest):
             n2 = s_common.guid()
             n3 = s_common.guid()
 
-            nodes = await core.nodes('[graph:node="*" :data=$data]', opts={'vars': {'data': ghstr}})
+            nodes = await core.nodes('[tel:mob:telem="*" :data=$data]', opts={'vars': {'data': ghstr}})
             self.len(1, nodes)
             node1 = nodes[0]
 
-            nodes = await core.nodes('[graph:node="*" :data=$data]', opts={'vars': {'data': mstr}})
+            nodes = await core.nodes('[tel:mob:telem="*" :data=$data]', opts={'vars': {'data': mstr}})
             self.len(1, nodes)
             node2 = nodes[0]
-            q = '''graph:node=$n1 $gzthing = :data
+            q = '''tel:mob:telem=$n1 $gzthing = :data
                 $foo = $lib.base64.decode($gzthing).gunzip()
                 $lib.print($foo)
-                [( graph:node=$n2 :data=$foo.decode() )]'''
+                [( tel:mob:telem=$n2 :data=$foo.decode() )]'''
 
             msgs = await core.stormlist(q, opts={'vars': {'n1': node1.ndef[1], 'n2': n2}})
             self.stormHasNoWarnErr(msgs)
             self.stormIsInPrint('ohhai', msgs)
 
             # make sure we gunzip correctly
-            nodes = await core.nodes('graph:node=$valu', opts={'vars': {'valu': n2}})
+            nodes = await core.nodes('tel:mob:telem=$valu', opts={'vars': {'valu': n2}})
             self.len(1, nodes)
             self.eq(hstr, nodes[0].get('data'))
 
-            text = f'''graph:node=$n2 $bar = :data
-                    [( graph:node=$n3 :data=$lib.base64.encode($bar.encode().gzip()) )]'''
+            text = f'''tel:mob:telem=$n2 $bar = :data
+                    [( tel:mob:telem=$n3 :data=$lib.base64.encode($bar.encode().gzip()) )]'''
             msgs = await core.stormlist(text, opts={'vars': {'n2': node2.ndef[1], 'n3': n3}})
             self.stormHasNoWarnErr(msgs)
 
             # make sure we gzip correctly
-            nodes = await core.nodes('graph:node=$valu', opts={'vars': {'valu': n3}})
+            nodes = await core.nodes('tel:mob:telem=$valu', opts={'vars': {'valu': n3}})
             self.len(1, nodes)
             self.eq(mstr.encode(), gzip.decompress(base64.urlsafe_b64decode(nodes[0].props['data'])))
 
@@ -1384,30 +1383,30 @@ class StormTypesTest(s_test.SynTest):
             n2 = s_common.guid()
             n3 = s_common.guid()
 
-            nodes = await core.nodes('[graph:node="*" :data=$data]', opts={'vars': {'data': ghstr}})
+            nodes = await core.nodes('[tel:mob:telem="*" :data=$data]', opts={'vars': {'data': ghstr}})
             self.len(1, nodes)
             node1 = nodes[0]
-            nodes = await core.nodes('[graph:node="*" :data=$data]', opts={'vars': {'data': mstr}})
+            nodes = await core.nodes('[tel:mob:telem="*" :data=$data]', opts={'vars': {'data': mstr}})
             self.len(1, nodes)
             node2 = nodes[0]
 
-            q = '''graph:node=$valu $bzthing = :data $foo = $lib.base64.decode($bzthing).bunzip()
+            q = '''tel:mob:telem=$valu $bzthing = :data $foo = $lib.base64.decode($bzthing).bunzip()
             $lib.print($foo)
-            [( graph:node=$n2 :data=$foo.decode() )] -graph:node=$valu'''
+            [( tel:mob:telem=$n2 :data=$foo.decode() )] -tel:mob:telem=$valu'''
             msgs = await core.stormlist(q, opts={'vars': {'valu': node1.ndef[1], 'n2': n2}})
             self.stormHasNoWarnErr(msgs)
             self.stormIsInPrint('ohhai', msgs)
 
             # make sure we bunzip correctly
             opts = {'vars': {'iden': n2}}
-            nodes = await core.nodes('graph:node=$iden', opts=opts)
+            nodes = await core.nodes('tel:mob:telem=$iden', opts=opts)
             self.len(1, nodes)
             node = nodes[0]
             self.eq(node.get('data'), hstr)
 
             # bzip
-            q = '''graph:node=$valu $bar = :data
-                [( graph:node=$n3 :data=$lib.base64.encode($bar.encode().bzip()) )] -graph:node=$valu'''
+            q = '''tel:mob:telem=$valu $bar = :data
+                [( tel:mob:telem=$n3 :data=$lib.base64.encode($bar.encode().bzip()) )] -tel:mob:telem=$valu'''
             nodes = await core.nodes(q, opts={'vars': {'valu': node2.ndef[1], 'n3': n3}})
             self.len(1, nodes)
             node = nodes[0]
@@ -1421,13 +1420,13 @@ class StormTypesTest(s_test.SynTest):
             valu = s_common.guid()
             n2 = s_common.guid()
 
-            nodes = await core.nodes('[graph:node=$valu :data=$data]', opts={'vars': {'valu': valu, 'data': ghstr}})
+            nodes = await core.nodes('[tel:mob:telem=$valu :data=$data]', opts={'vars': {'valu': valu, 'data': ghstr}})
             self.len(1, nodes)
             node1 = nodes[0]
             self.eq(node1.get('data'), ghstr)
 
-            q = '''graph:node=$valu $jzthing=:data $foo=$jzthing.encode().json() [(graph:node=$n2 :data=$foo)]
-                  -graph:node=$valu'''
+            q = '''tel:mob:telem=$valu $jzthing=:data $foo=$jzthing.encode().json() [(tel:mob:telem=$n2 :data=$foo)]
+                  -tel:mob:telem=$valu'''
             nodes = await core.nodes(q, opts={'vars': {'valu': valu, 'n2': n2}})
             self.len(1, nodes)
             node2 = nodes[0]
@@ -1721,7 +1720,7 @@ class StormTypesTest(s_test.SynTest):
             q = '''
                 $set = $lib.set()
                 inet:ipv4 $set.add(:asn)
-                [ graph:node="*" ] +graph:node [ :data=$set.list() ]
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$set.list() ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
@@ -1730,7 +1729,7 @@ class StormTypesTest(s_test.SynTest):
             q = '''
                 $set = $lib.set()
                 inet:ipv4 $set.adds((:asn,:asn))
-                [ graph:node="*" ] +graph:node [ :data=$set.list() ]
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$set.list() ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
@@ -1740,7 +1739,7 @@ class StormTypesTest(s_test.SynTest):
                 $set = $lib.set()
                 inet:ipv4 $set.adds((:asn,:asn))
                 { +:asn=20 $set.rem(:asn) }
-                [ graph:node="*" ] +graph:node [ :data=$set.list() ]
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$set.list() ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
@@ -1750,7 +1749,7 @@ class StormTypesTest(s_test.SynTest):
                 $set = $lib.set()
                 inet:ipv4 $set.add(:asn)
                 $set.rems((:asn,:asn))
-                [ graph:node="*" ] +graph:node [ :data=$set.list() ]
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$set.list() ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
@@ -2152,7 +2151,7 @@ class StormTypesTest(s_test.SynTest):
             q = '''
                 inet:fqdn=vertex.link -> inet:dns:a -> inet:ipv4
                 $idens = $path.idens()
-                [ graph:node="*" ] +graph:node [ :data=$idens ]
+                [ tel:mob:telem="*" ] +tel:mob:telem [ :data=$idens ]
             '''
 
             idens = (
@@ -2700,6 +2699,17 @@ class StormTypesTest(s_test.SynTest):
             await core.addUserRule(user, (True, ('storm', 'lib', 'telepath', 'open', 'cell')))
             self.len(2, await core.callStorm('return ( $lib.telepath.open($url).ipv4s() )', opts=opts))
 
+            # SynErr exceptions are allowed through. They can be caught by storm.
+            with self.raises(s_exc.BadUrl):
+                await core.callStorm('$prox=$lib.telepath.open("weeeeeeeeeeeeee")')
+
+            # Python exceptions are caught and raised as StormRuntimeError exceptions.
+            with self.raises(s_exc.StormRuntimeError) as cm:
+                await core.callStorm('$prox=$lib.telepath.open("tcp://0.0.0.0:60000")')
+            emsg = cm.exception.get('mesg')
+            self.isin('Failed to connect to Telepath service: "tcp://0.0.0.0:60000" error:', emsg)
+            self.isin('Connect call failed', emsg)
+
     async def test_storm_lib_queue(self):
 
         async with self.getTestCore() as core:
@@ -4475,7 +4485,7 @@ class StormTypesTest(s_test.SynTest):
 
         async with self.getTestCore() as core:
 
-            cdef = await core.callStorm('return($lib.cron.add(query="{[graph:node=*]}", hourly=30).pack())')
+            cdef = await core.callStorm('return($lib.cron.add(query="{[tel:mob:telem=*]}", hourly=30).pack())')
             self.eq('', cdef.get('doc'))
             self.eq('', cdef.get('name'))
 
@@ -4491,7 +4501,7 @@ class StormTypesTest(s_test.SynTest):
             with self.raises(s_exc.BadArg):
                 await core.callStorm('return($lib.cron.get($iden).set(hehe, haha))', opts=opts)
 
-            mesgs = await core.stormlist('cron.add --hour +1 {[graph:node=*]} --name myname --doc mydoc')
+            mesgs = await core.stormlist('cron.add --hour +1 {[tel:mob:telem=*]} --name myname --doc mydoc')
             for mesg in mesgs:
                 if mesg[0] == 'print':
                     iden0 = mesg[1]['mesg'].split(' ')[-1]
@@ -4512,7 +4522,6 @@ class StormTypesTest(s_test.SynTest):
 
         MONO_DELT = 1543827303.0
         unixtime = datetime.datetime(year=2018, month=12, day=5, hour=7, minute=0, tzinfo=tz.utc).timestamp()
-        s_provenance.reset()
 
         def timetime():
             return unixtime
@@ -4597,7 +4606,7 @@ class StormTypesTest(s_test.SynTest):
                 nextlayroffs = await layr.getEditOffs() + 1
 
                 # Start simple: add a cron job that creates a node every minute
-                q = "cron.add --minute +1 {[graph:node='*' :type=m1]}"
+                q = "cron.add --minute +1 {[meta:note='*' :type=m1]}"
                 mesgs = await core.stormlist(q)
                 self.stormIsInPrint('Created cron job', mesgs)
                 for mesg in mesgs:
@@ -4639,24 +4648,24 @@ class StormTypesTest(s_test.SynTest):
 
                 # Make sure it ran
                 await layr.waitEditOffs(nextlayroffs, timeout=5)
-                self.eq(1, await prox.count('graph:node:type=m1'))
+                self.eq(1, await prox.count('meta:note:type=m1'))
 
-                q = "cron.mod $guid { [graph:node='*' :type=m2] }"
+                q = "cron.mod $guid { [meta:note='*' :type=m2] }"
                 mesgs = await core.stormlist(q, opts={'vars': {'guid': guid[:6]}})
                 self.stormIsInPrint(f'Modified cron job: {guid}', mesgs)
 
-                q = "cron.mod xxx { [graph:node='*' :type=m2] }"
+                q = "cron.mod xxx { [meta:note='*' :type=m2] }"
                 mesgs = await core.stormlist(q)
                 self.stormIsInErr('does not match', mesgs)
 
                 # Make sure the old one didn't run and the new query ran
                 unixtime += 60
                 await asyncio.sleep(0)
-                self.eq(1, await prox.count('graph:node:type=m1'))
+                self.eq(1, await prox.count('meta:note:type=m1'))
                 # UNG WTF
                 await asyncio.sleep(0)
                 await asyncio.sleep(0)
-                self.eq(1, await prox.count('graph:node:type=m2'))
+                self.eq(1, await prox.count('meta:note:type=m2'))
 
                 # Delete the job
                 q = f"cron.del {guid}"
@@ -4669,8 +4678,8 @@ class StormTypesTest(s_test.SynTest):
 
                 # Make sure deleted job didn't run
                 unixtime += 60
-                self.eq(1, await prox.count('graph:node:type=m1'))
-                self.eq(1, await prox.count('graph:node:type=m2'))
+                self.eq(1, await prox.count('meta:note:type=m1'))
+                self.eq(1, await prox.count('meta:note:type=m2'))
 
                 # Test fixed minute, i.e. every hour at 17 past
                 unixtime = datetime.datetime(year=2018, month=12, day=5, hour=7, minute=10,
@@ -4846,6 +4855,7 @@ class StormTypesTest(s_test.SynTest):
 
                     self.stormIsInPrint('last result:     finished successfully with 0 nodes', mesgs)
                     self.stormIsInPrint('entries:         <None>', mesgs)
+                    self.stormIsInPrint('pool:            false', mesgs)
 
                     # Test 'stat' command
                     mesgs = await core.stormlist('cron.stat xxx')
@@ -4919,7 +4929,7 @@ class StormTypesTest(s_test.SynTest):
                 self.stormIsInErr('data.iden must match pattern', msgs)
 
                 opts = {'vars': {'iden': 'cd263bd133a5dafa1e1c5e9a01d9d486'}}
-                q = "cron.add --iden $iden --day +1 --minute 14 {[test:guid=$lib.guid()]}"
+                q = "cron.add --pool --iden $iden --day +1 --minute 14 {[test:guid=$lib.guid()]}"
                 msgs = await core.stormlist(q, opts=opts)
                 self.stormIsInPrint('Created cron job: cd263bd133a5dafa1e1c5e9a01d9d486', msgs)
 
@@ -6465,6 +6475,10 @@ words\tword\twrd'''
             self.eq(merge['creator'], core.auth.rootuser.iden)
             self.none(merge.get('updated'))
 
+            merging = 'return($lib.view.get().getMergingViews()) '
+
+            self.eq([fork00], await core.callStorm(merging))
+
             with self.raises(s_exc.AuthDeny):
                 core.getView(fork00).reqValidVoter(root.iden)
 
@@ -6540,8 +6554,13 @@ words\tword\twrd'''
             self.none(core.getView(fork00))
             nodes = await core.nodes('inet:fqdn')
             self.len(2, nodes)
+
+            # previously successful merges
             self.len(1, await core.callStorm('$list = ([]) for $merge in $lib.view.get().getMerges() { $list.append($merge) } fini { return($list) }'))
 
+            # current open merge requests
+            self.eq([], await core.callStorm(merging))
+
             # test out the delMergeRequest logic / cleanup
             forkdef = await core.getView().fork()
 
@@ -6549,6 +6568,7 @@ words\tword\twrd'''
 
             opts = {'view': fork.iden}
             self.nn(await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts))
+            self.eq([fork.iden], await core.callStorm(merging))
 
             # confirm that you may not re-parent to a view with a merge request
             layr = await core.addLayer()
@@ -6564,6 +6584,8 @@ words\tword\twrd'''
             self.nn(await core.callStorm('return($lib.view.get().delMergeRequest())', opts=opts))
             self.len(0, [vote async for vote in fork.getMergeVotes()])
 
+            self.eq([], await core.callStorm(merging))
+
             # test coverage for beholder progress events...
             forkdef = await core.getView().fork()
             fork = core.getView(forkdef.get('iden'))
@@ -6572,10 +6594,12 @@ words\tword\twrd'''
             await core.stormlist('[ inet:ipv4=1.2.3.0/20 ]', opts=opts)
             await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
 
+            self.eq([fork.iden], await core.callStorm(merging))
+
             nevents = 8
             if s_common.envbool('SYNDEV_NEXUS_REPLAY'):
                 # view:merge:vote:set fires twice
-                nevents = nevents + 1
+                nevents += 1
             waiter = core.waiter(nevents, 'cell:beholder')
 
             opts = {'view': fork.iden, 'user': visi.iden}
@@ -6598,6 +6622,8 @@ words\tword\twrd'''
             self.eq(msgs[-1][1]['info']['merge']['creator'], core.auth.rootuser.iden)
             self.eq(msgs[-1][1]['info']['votes'][0]['user'], visi.iden)
 
+            self.eq([], await core.callStorm(merging))
+
             # test coverage for bad state for merge request
             fork00 = await core.getView().fork()
             fork01 = await core.getView(fork00['iden']).fork()
@@ -6606,8 +6632,11 @@ words\tword\twrd'''
             with self.raises(s_exc.BadState):
                 await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
 
+            self.eq([], await core.callStorm(merging))
+
             await core.delView(fork01['iden'])
             await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
+            self.eq([fork00['iden']], await core.callStorm(merging))
 
             core.getView().layers[0].readonly = True
             with self.raises(s_exc.BadState):
@@ -6626,6 +6655,8 @@ words\tword\twrd'''
             await core.stormlist('[ inet:ipv4=5.5.5.5 ]', opts=opts)
             await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
 
+            self.eq(set([fork.iden, fork00['iden']]), set(await core.callStorm(merging)))
+
             # hamstring the runViewMerge method on the new view
             async def fake():
                 return
@@ -6660,3 +6691,6 @@ words\tword\twrd'''
 
             msgs = await core.stormlist('$lib.view.get().set(quorum, $lib.null)')
             self.stormHasNoWarnErr(msgs)
+
+            with self.raises(s_exc.BadState):
+                await core.callStorm(merging)