synapse 2.189.0__py311-none-any.whl → 2.191.0__py311-none-any.whl

synapse/tests/test_lib_cell.py

@@ -115,6 +115,14 @@ class EchoAuthApi(s_cell.CellApi):
         await self._reqUserAllowed(path)
         return True
 
+    @s_cell.adminapi()
+    async def adminOnly(self):
+        return True
+
+    @s_cell.adminapi(log=True)
+    async def adminOnlyLog(self, arg1, arg2, **kwargs):
+        return arg1, arg2, kwargs
+
 class EchoAuth(s_cell.Cell):
     cellapi = EchoAuthApi
 
@@ -428,6 +436,16 @@ class CellTest(s_t_utils.SynTest):
                     self.eq(info.get('user').get('name'), 'root')
                     self.eq(info.get('user').get('iden'), root.iden)
 
+                    # @adminApi methods are allowed
+                    self.true(await proxy.adminOnly())
+                    mesg = "Executing [EchoAuthApi.adminOnlyLog] as [root] with args [(1, 2)[{'three': 4}]"
+                    with self.getStructuredAsyncLoggerStream('synapse.lib.cell', mesg) as stream:
+                        self.eq(await proxy.adminOnlyLog(1, 2, three=4), (1, 2, {'three': 4}))
+                        self.true(await stream.wait(timeout=10))
+                    msgs = stream.jsonlines()
+                    self.len(1, msgs)
+                    self.eq('EchoAuthApi.adminOnlyLog', msgs[0].get('wrapped_func'))
+
                 visi = await echo.auth.addUser('visi')
                 await visi.setPasswd('foo')
                 await visi.addRule((True, ('foo', 'bar')))
@@ -454,6 +472,15 @@ class CellTest(s_t_utils.SynTest):
                     with self.raises(s_exc.NoSuchUser):
                         await proxy.getUserInfo('newp')
 
+                    # @adminApi methods are not allowed
+                    with self.raises(s_exc.AuthDeny) as cm:
+                        await proxy.adminOnly()
+                    self.eq(cm.exception.get('mesg'), 'User is not an admin [visi]')
+                    self.eq(cm.exception.get('user'), visi.iden)
+                    self.eq(cm.exception.get('username'), visi.name)
+                    with self.raises(s_exc.AuthDeny) as cm:
+                        await proxy.adminOnlyLog(1, 2, three=4)
+
                     # User cannot get authinfo for other items since they are
                     # not an admin or do not have those roles.
                     await self.asyncraises(s_exc.AuthDeny, proxy.getUserInfo('root'))
@@ -3064,10 +3091,7 @@ class CellTest(s_t_utils.SynTest):
                 async with self.getTestCore(conf={'health:sysctl:checks': True}):
                     pass
 
-        stream.seek(0)
-        data = stream.getvalue()
-        raw_mesgs = [m for m in data.split('\n') if m]
-        msgs = [json.loads(m) for m in raw_mesgs]
+        msgs = stream.jsonlines()
 
         self.len(1, msgs)
 

synapse/tests/test_lib_httpapi.py

@@ -1722,10 +1722,8 @@ class HttpApiTest(s_tests.SynTest):
 
     async def test_request_logging(self):
 
-        def get_mesg(stream):
-            data = stream.getvalue()
-            raw_mesgs = [m for m in data.split('\n') if m]
-            msgs = [json.loads(m) for m in raw_mesgs]
+        def get_mesg(stream: s_tests.AsyncStreamEvent) -> dict:
+            msgs = stream.jsonlines()
             self.len(1, msgs)
             return msgs[0]
 

synapse/tests/test_lib_lmdbslab.py

@@ -1,5 +1,4 @@
 import os
-import json
 import asyncio
 import pathlib
 import multiprocessing
@@ -15,7 +14,6 @@ import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.lib.thisplat as s_thisplat
 
 import synapse.tests.utils as s_t_utils
-from synapse.tests.utils import alist
 
 def getFileMapCount(filename):
     filename = str(filename)
@@ -360,8 +358,7 @@ class LmdbSlabTest(s_t_utils.SynTest):
                         slab.put(b'\xff\xff\xff\xff' + s_common.guid(i).encode('utf8'), byts, db=foo)
                 self.true(await stream.wait(timeout=1))
 
-            data = stream.getvalue()
-            msgs = [json.loads(m) for m in data.split('\\n') if m]
+            msgs = stream.jsonlines()
             self.gt(len(msgs), 0)
             self.nn(msgs[0].get('delta'))
             self.nn(msgs[0].get('path'))

synapse/tests/test_lib_stormhttp.py

@@ -464,6 +464,15 @@ class StormHttpTest(s_test.SynTest):
             self.isin('mesg', errinfo)
             self.eq('', errinfo.get('mesg'))  # timeouterror has no mesg
 
+            q = '''
+            $params=({"foo": ["bar", "baz"], "key": [["valu"]]})
+            $resp = $lib.inet.http.request(GET, $url, params=$params, ssl_verify=$lib.false)
+            return ( $resp.json() )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            data = resp.get('result')
+            self.eq(data.get('params'), {'foo': ['bar', 'baz'], 'key': ["('valu',)"]})
+
     async def test_storm_http_post(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_cortex.py

@@ -304,9 +304,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                     resp = await sess.get(url)
                     self.eq(resp.status, 200)
                     self.true(await stream.wait(timeout=12))
-                data = stream.getvalue()
-                raw_mesgs = [m for m in data.split('\n') if m]
-                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = stream.jsonlines()
                 self.eq(msgs[0].get('httpapi'), echoiden)
                 core.stormlog = False
 

synapse/tests/test_lib_stormlib_log.py

@@ -1,5 +1,3 @@
-import json
-
 import synapse.exc as s_exc
 
 import synapse.tests.utils as s_test
@@ -49,10 +47,7 @@ class LogTest(s_test.SynTest):
                 await core.callStorm('$lib.log.debug("struct1 message")')
                 await core.callStorm('$lib.log.debug("struct2 message", extra=({"key": "valu"}))')
                 self.true(await stream.wait(6))
-
-            data = stream.getvalue()
-            raw_mesgs = [m for m in data.split('\n') if m]
-            msgs = [json.loads(m) for m in raw_mesgs]
+            msgs = stream.jsonlines()
             self.len(2, msgs)
             mesg = msgs[0]
             self.eq(mesg.get('logger').get('name'), 'synapse.storm.log')

synapse/tests/test_lib_stormlib_model.py

@@ -704,3 +704,31 @@ class StormlibModelTest(s_test.SynTest):
             self.eq(nodes[0].get('cert'), cert3.ndef[1])
             self.isin('ssl.migration.three', nodes[0].tags)
             self.eq(nodes[0].nodedata, {'foo': None})
+
+    async def test_stormlib_model_migrations_inet_service_message_client(self):
+
+        async with self.getTestCore() as core:
+
+            await core.nodes('''[
+                (inet:service:message=* :client:address=1.2.3.4 :client=2.3.4.5)
+                (inet:service:message=* :client:address=3.4.5.6)
+                (inet:service:message=* :client=4.5.6.7)
+            ]''')
+
+            nodes = await core.nodes('''
+                inet:service:message
+                $lib.model.migration.s.inetServiceMessageClientAddress($node)
+            ''')
+
+            self.len(3, nodes)
+
+            for node in nodes:
+                self.none(node.get('client:address'))
+
+            exp = ['tcp://2.3.4.5', 'tcp://3.4.5.6', 'tcp://4.5.6.7']
+            self.sorteq(exp, [n.get('client') for n in nodes])
+
+            ndata = [n for n in nodes if await n.getData('migration:inet:service:message:client:address')]
+            self.len(1, ndata)
+            self.eq(ndata[0].get('client'), 'tcp://2.3.4.5')
+            self.eq(await ndata[0].getData('migration:inet:service:message:client:address'), 'tcp://1.2.3.4')

synapse/tests/test_lib_stormtypes.py

@@ -1665,8 +1665,23 @@ class StormTypesTest(s_test.SynTest):
             self.eq('bar', await core.callStorm('$foo = (foo, bar) return($foo.1)'))
             self.eq('foo', await core.callStorm('$foo = (foo, bar) return($foo."-2")'))
             self.eq('bar', await core.callStorm('$foo = (foo, bar) return($foo.pop())'))
-            with self.raises(s_exc.StormRuntimeError):
+
+            self.eq(3, await core.callStorm('$list = ([1, 2, 3, 4]) return($list.pop(2))'))
+            self.eq(2, await core.callStorm('$list = ([1, 2, 3, 4]) return($list.pop(-3))'))
+            self.eq(4, await core.callStorm('$list = ([1, 2, 3, 4]) $list.pop(2) return($list.pop(2))'))
+            self.eq([1, 3, 4], await core.callStorm('$list = ([1, 2, 3, 4]) $list.pop(1) return($list)'))
+
+            with self.raises(s_exc.StormRuntimeError) as exc:
                 await core.callStorm('$lib.list().pop()')
+            self.eq(exc.exception.get('mesg'), 'pop from empty list')
+
+            with self.raises(s_exc.StormRuntimeError) as exc:
+                await core.callStorm('$list = ([1, 2, 3, 4]) return($list.pop(13))')
+            self.eq(exc.exception.get('mesg'), 'pop index out of range')
+
+            with self.raises(s_exc.StormRuntimeError) as exc:
+                await core.callStorm('$list = ([1, 2, 3, 4]) return($list.pop(-5))')
+            self.eq(exc.exception.get('mesg'), 'pop index out of range')
 
             somelist = ["foo", "bar", "baz", "bar"]
             q = '''
@@ -4905,8 +4920,7 @@ class StormTypesTest(s_test.SynTest):
                         unixtime += 7 * MINSECS
                         self.eq('m3', await getNextFoo())
                         self.true(await stream.wait(6))
-                    buf = stream.getvalue()
-                    mesg = json.loads(buf.split('\n')[0])
+                    mesg = stream.jsonlines()[0]
                     self.eq(mesg['message'], f'm3 cron {guid}')
                     self.eq(mesg['iden'], guid)
 

synapse/tests/test_lib_trigger.py

@@ -1,5 +1,4 @@
 import os
-import json
 import synapse.exc as s_exc
 import synapse.common as s_common
 
@@ -253,8 +252,8 @@ class TrigTest(s_t_utils.SynTest):
             with self.getStructuredAsyncLoggerStream('synapse.storm.log', 'test trigger') as stream:
                 await core.nodes('[ test:str=logit ]')
                 self.true(await stream.wait(6))
-            buf = stream.getvalue()
-            mesg = json.loads(buf.split('\n')[-2])
+            msgs = stream.jsonlines()
+            mesg = [m for m in msgs if m.get('iden') == tdef.get('iden')][0]
             self.eq(mesg['message'], f'test trigger {tdef.get("iden")}')
             self.eq(mesg['iden'], tdef.get('iden'))
 

synapse/tests/test_model_base.py

@@ -222,13 +222,23 @@ class BaseTest(s_t_utils.SynTest):
 
         async with self.getTestCore() as core:
 
-            nodes = await core.nodes('[meta:source="*" :name="FOO Bar" :type=osint :url="https://foo.bar/index.html"]')
+            nodes = await core.nodes('''
+                [meta:source="*"
+                    :name="FOO Bar"
+                    :type=osint
+                    :url="https://foo.bar/index.html"
+                    :ingest:latest=20241205
+                    :ingest:offset=17
+                ]
+            ''')
             self.len(1, nodes)
             sorc = nodes[0]
 
             self.eq(sorc.get('type'), 'osint')
             self.eq(sorc.get('name'), 'foo bar')
             self.eq(sorc.get('url'), 'https://foo.bar/index.html')
+            self.eq(sorc.get('ingest:offset'), 17)
+            self.eq(sorc.get('ingest:latest'), 1733356800000)
 
             valu = (sorc.ndef[1], ('inet:fqdn', 'woot.com'))
             nodes = await core.nodes('[meta:seen=$valu]', opts={'vars': {'valu': valu}})
@@ -330,7 +340,7 @@ class BaseTest(s_t_utils.SynTest):
                 'tel:mob:telem:ipv6', 'tel:mob:telem:wifi', 'tel:mob:telem:wifi:ssid',
                 'tel:mob:telem:wifi:bssid', 'tel:mob:telem:adid', 'tel:mob:telem:aaid',
                 'tel:mob:telem:idfa', 'tel:mob:telem:name', 'tel:mob:telem:email',
-                'tel:mob:telem:acct', 'tel:mob:telem:app', 'tel:mob:telem:data',
+                'tel:mob:telem:app', 'tel:mob:telem:data',
                 'inet:http:request:response:time', 'inet:http:request:response:code',
                 'inet:http:request:response:reason', 'inet:http:request:response:body',
                 'gov:us:cage:street', 'gov:us:cage:city', 'gov:us:cage:state', 'gov:us:cage:zip',

synapse/tests/test_model_inet.py

@@ -2958,10 +2958,12 @@ class InetModelTest(s_t_utils.SynTest):
                 :platform={ inet:service:platform=(slack,) }
                 :url="https://v.vtx.lk/slack"
                 :name="Synapse users slack"
+                :tenant={[ inet:service:tenant=({"id": "VS-31337"}) ]}
             ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
+            self.nn(nodes[0].get('tenant'))
             self.eq(nodes[0].ndef, ('inet:service:instance', s_common.guid(('vertex', 'slack'))))
             self.eq(nodes[0].get('id'), 'T2XK1223Y')
             self.eq(nodes[0].get('platform'), platform.ndef[1])
@@ -2976,6 +2978,7 @@ class InetModelTest(s_t_utils.SynTest):
                     :user=blackout
                     :email=blackout@vertex.link
                     :profile={ gen.ps.contact.email vertex.employee blackout@vertex.link }
+                    :tenant={[ inet:service:tenant=({"id": "VS-31337"}) ]}
                 )
 
                 (inet:service:account=(visi, account, vertex, slack)
@@ -2989,6 +2992,8 @@ class InetModelTest(s_t_utils.SynTest):
             accounts = await core.nodes(q)
             self.len(2, accounts)
 
+            self.nn(accounts[0].get('tenant'))
+
             profiles = await core.nodes('ps:contact')
             self.len(2, profiles)
             self.eq(profiles[0].get('email'), 'blackout@vertex.link')
@@ -3068,14 +3073,17 @@ class InetModelTest(s_t_utils.SynTest):
             [ inet:service:session=*
                 :creator=$blckiden
                 :period=(202405160900, 202405161055)
+                :http:session=*
             ]
             '''
             opts = {'vars': {'blckiden': blckacct.ndef[1]}}
             nodes = await core.nodes(q, opts=opts)
             self.len(1, nodes)
+            self.nn(nodes[0].get('http:session'))
             self.eq(nodes[0].get('creator'), blckacct.ndef[1])
             self.eq(nodes[0].get('period'), (1715850000000, 1715856900000))
             blcksess = nodes[0]
+            self.len(1, await core.nodes('inet:service:session -> inet:http:session'))
 
             q = '''
             [ inet:service:login=*
@@ -3407,3 +3415,18 @@ class InetModelTest(s_t_utils.SynTest):
 
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ inet:service:relationship=* :source={[it:dev:str=foo]} ]')
+
+            nodes = await core.nodes('''
+                [ inet:service:subscription=*
+                    :level=vertex.synapse.enterprise
+                    :pay:instrument={[ econ:bank:account=* :contact={[ ps:contact=* :name=visi]} ]}
+                    :subscriber={[ inet:service:tenant=({"id": "VS-31337"}) ]}
+                ]
+            ''')
+            self.len(1, nodes)
+            self.eq('vertex.synapse.enterprise.', nodes[0].get('level'))
+            self.eq('econ:bank:account', nodes[0].get('pay:instrument')[0])
+            self.eq('inet:service:tenant', nodes[0].get('subscriber')[0])
+            self.len(1, await core.nodes('inet:service:subscription -> inet:service:subscription:level:taxonomy'))
+            self.len(1, await core.nodes('inet:service:subscription :pay:instrument -> econ:bank:account'))
+            self.len(1, await core.nodes('inet:service:subscription :subscriber -> inet:service:tenant'))

synapse/tests/test_model_person.py

@@ -278,12 +278,14 @@ class PsModelTest(s_t_utils.SynTest):
                     :source:host=*
                     :source:file=*
                     :source:acct=(twitter.com, invisig0th)
+                    :source:account=(twitter.com, invisig0th)
             ]''')
             self.len(1, nodes)
             self.len(1, await core.nodes('ps:contactlist -> it:host'))
             self.len(1, await core.nodes('ps:contactlist -> file:bytes'))
             self.len(2, await core.nodes('ps:contactlist -> ps:contact'))
             self.len(1, await core.nodes('ps:contactlist -> inet:web:acct'))
+            self.len(1, await core.nodes('ps:contactlist -> inet:service:account'))
 
             nodes = await core.nodes('''[
                 ps:workhist = *

synapse/tests/test_model_risk.py

@@ -379,6 +379,7 @@ class RiskModelTest(s_t_utils.SynTest):
                     :desc=VTX-APT1
                     :tag=cno.threat.apt1
                     :active=(2012,2023)
+                    :activity=high
                     :reporter=*
                     :reporter:name=mandiant
                     :reporter:discovered=202202
@@ -400,6 +401,7 @@ class RiskModelTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq('vtx-apt1', nodes[0].get('name'))
             self.eq('VTX-APT1', nodes[0].get('desc'))
+            self.eq(40, nodes[0].get('activity'))
             self.eq('apt1', nodes[0].get('org:name'))
             self.eq('ua', nodes[0].get('country:code'))
             self.eq('cn.shanghai', nodes[0].get('org:loc'))
@@ -546,11 +548,13 @@ class RiskModelTest(s_t_utils.SynTest):
                     :cause=nature.earthquake
                     :provider={[ ou:org=* :name="desert power" ]}
                     :provider:name="desert power"
+                    :attack={[ risk:attack=* ]}
                     :reporter={ ou:org:name=vertex }
                     :reporter:name=vertex
                 ]
             ''')
             self.len(1, nodes)
+            self.nn(nodes[0].get('attack'))
             self.nn(nodes[0].get('reporter'))
             self.eq('the big one', nodes[0].get('name'))
             self.eq('vertex', nodes[0].get('reporter:name'))
@@ -559,6 +563,7 @@ class RiskModelTest(s_t_utils.SynTest):
             self.eq('nature.earthquake.', nodes[0].get('cause'))
             self.eq((1672531200000, 1704067200000), nodes[0].get('period'))
 
+            self.len(1, await core.nodes('risk:outage -> risk:attack'))
             self.len(1, await core.nodes('risk:outage -> risk:outage:cause:taxonomy'))
             self.len(1, await core.nodes('risk:outage :reporter -> ou:org +:name=vertex'))
             self.len(1, await core.nodes('risk:outage :provider -> ou:org +:name="desert power"'))

synapse/tests/test_model_syn.py

@@ -362,6 +362,93 @@ class SynModelTest(s_t_utils.SynTest):
                 nodes = await core.nodes('syn:tagprop')
                 self.len(0, nodes)
 
+        async with self.getTestCore() as core:
+                # Check we can iterate runt nodes while changing the underlying dictionary
+
+                numforms = len(core.model.forms)
+
+                q = '''
+                init {
+                    $forms = ()
+                    $count = (0)
+                }
+
+                syn:form
+
+                $forms.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    $info = ({"doc": "test taxonomy", "interfaces": ["meta:taxonomy"]})
+                    $lib.model.ext.addForm(_test:taxonomy, taxonomy, ({}), $info)
+                }
+
+                spin |
+
+                fini { return($forms) }
+                '''
+
+                forms = await core.callStorm(q)
+                self.len(numforms, forms)
+                self.len(numforms + 1, core.model.forms)
+
+                numtypes = len(core.model.types)
+                q = '''
+                init {
+                    $types = ()
+                    $count = (0)
+                }
+
+                syn:type
+
+                $types.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    $typeopts = ({"lower": true, "onespace": true})
+                    $typeinfo = ({"doc": "A test type doc."})
+                    $lib.model.ext.addType(_test:type, str, $typeopts, $typeinfo)
+                }
+
+                spin |
+
+                fini { return($types) }
+                '''
+
+                types = await core.callStorm(q)
+                self.len(numtypes, types)
+                self.len(numtypes + 1, core.model.types)
+
+                q = '''
+                init {
+                    $tagprops = ()
+                    $count = (0)
+                    $lib.model.ext.addTagProp(cypher, (str, ({})), ({}))
+                    $lib.model.ext.addTagProp(trinity, (str, ({})), ({}))
+                    $lib.model.ext.addTagProp(morpheus, (str, ({})), ({}))
+                }
+
+                syn:tagprop
+
+                $tagprops.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    $lib.model.ext.addTagProp(neo, (str, ({})), ({}))
+                }
+
+                spin |
+
+                fini { return($tagprops) }
+                '''
+
+                tagprops = await core.callStorm(q)
+                self.len(3, tagprops)
+                self.len(4, core.model.tagprops)
+
     async def test_syn_trigger_runts(self):
         async with self.getTestCore() as core:
             nodes = await core.nodes('syn:trigger')
@@ -465,6 +552,42 @@ class SynModelTest(s_t_utils.SynTest):
             pode = nodes[0].pack()
             self.eq(pode[0][1], iden)
 
+        async with self.getTestCore() as core:
+                # Check we can iterate runt nodes while changing the underlying dictionary
+
+                tdef = {'cond': 'node:add', 'form': 'it:dev:str', 'storm': '[inet:user=1] | testcmd'}
+                await core.view.addTrigger(tdef)
+
+                tdef = {'cond': 'node:add', 'form': 'it:dev:str', 'storm': '[inet:user=2] | testcmd'}
+                await core.view.addTrigger(tdef)
+
+                q = '''
+                init {
+                    $trigs = ()
+                    $count = (0)
+                }
+
+                syn:trigger
+
+                $trigs.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    $lib.trigger.add($tdef)
+                }
+
+                spin |
+
+                fini { return($trigs) }
+                '''
+
+                tdef = {'cond': 'node:add', 'form': 'it:dev:str', 'storm': '[inet:user=3] | testcmd'}
+                opts = {'vars': {'tdef': tdef}}
+                triggers = await core.callStorm(q, opts=opts)
+                self.len(2, triggers)
+                self.len(3, core.view.triggers.triggers)
+
     async def test_syn_cmd_runts(self):
 
         async with self.getTestDmon() as dmon:
@@ -554,6 +677,49 @@ class SynModelTest(s_t_utils.SynTest):
                 self.eq(nodes[0].get('output'), ('inet:fqdn',))
                 self.eq(nodes[0].get('nodedata'), (('foo', 'inet:ipv4'), ('bar', 'inet:fqdn')))
 
+        async with self.getTestCore() as core:
+                # Check we can iterate runt nodes while changing the underlying dictionary
+
+                numcmds = len(core.stormcmds)
+
+                stormpkg = {
+                    'name': 'stormpkg',
+                    'version': '1.2.3',
+                    'synapse_version': '>=2.8.0,<3.0.0',
+                    'commands': (
+                        {
+                         'name': 'pkgcmd.old',
+                         'storm': '$lib.print(hi)',
+                        },
+                    ),
+                }
+
+                q = '''
+                init {
+                    $cmds = ()
+                    $count = (0)
+                }
+
+                syn:cmd
+
+                $cmds.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    $lib.pkg.add($pkgdef)
+                }
+
+                spin |
+
+                fini { return($cmds) }
+                '''
+
+                opts = {'vars': {'pkgdef': stormpkg}}
+                cmds = await core.callStorm(q, opts=opts)
+                self.len(numcmds, cmds)
+                self.len(numcmds + 1, core.stormcmds)
+
     async def test_syn_cron_runts(self):
 
         async with self.getTestCore() as core:
@@ -582,3 +748,35 @@ class SynModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].ndef, ('syn:cron', iden))
             self.eq(nodes[0].get('doc'), 'hehe')
             self.eq(nodes[0].get('name'), 'haha')
+
+        async with self.getTestCore() as core:
+                # Check we can iterate runt nodes while changing the underlying dictionary
+
+                q = '''
+                init {
+                    $appts = ()
+                    $count = (0)
+
+                    cron.add --hour 1 --day 1 {#foo} |
+                    cron.add --hour 2 --day 1 {#foo} |
+                    cron.add --hour 3 --day 1 {#foo}
+                }
+
+                syn:cron
+
+                $appts.append(({'name': $node.repr(), 'doc': :doc }))
+
+                $count = ($count + 1)
+
+                if ($count = (2)) {
+                    cron.add  --hour 4 --day 1 {#foo}
+                }
+
+                spin |
+
+                fini { return($appts) }
+                '''
+
+                appts = await core.callStorm(q)
+                self.len(3, appts)
+                self.len(4, core.agenda.appts)

synapse/tests/test_utils.py

@@ -1,5 +1,6 @@
 import os
 import time
+import json
 import logging
 import unittest
 
@@ -109,13 +110,13 @@ class TestUtils(s_t_utils.SynTest):
     def test_syntest_logstream_event(self):
 
         @s_common.firethread
-        def logathing():
+        def logathing(mesg):
             time.sleep(0.01)
-            logger.error('StreamEvent Test Message')
+            logger.error(mesg)
 
         logger.error('notthere')
         with self.getLoggerStream('synapse.tests.test_utils', 'Test Message') as stream:
-            thr = logathing()
+            thr = logathing('StreamEvent Test Message')
             self.true(stream.wait(10))
             thr.join()
 
@@ -124,16 +125,34 @@ class TestUtils(s_t_utils.SynTest):
         self.isin('StreamEvent Test Message', mesgs)
         self.notin('notthere', mesgs)
 
+        with self.getLoggerStream('synapse.tests.test_utils', 'Test Message') as stream:
+            thr = logathing(json.dumps({'mesg': 'Test Message'}))
+            self.true(stream.wait(10))
+            thr.join()
+
+        msgs = stream.jsonlines()
+        self.len(1, msgs)
+        self.eq(msgs[0], {'mesg': 'Test Message'})
+
     def test_syntest_envars(self):
         os.environ['foo'] = '1'
         os.environ['bar'] = '2'
 
-        with self.setTstEnvars(foo=1, bar='joke', baz=1234) as cm:
+        with self.setTstEnvars(foo=1, bar='joke', baz=1234, FOO_THING=1, BAR_THING=0) as cm:
             self.none(cm)
             self.eq(os.environ.get('foo'), '1')
             self.eq(os.environ.get('bar'), 'joke')
             self.eq(os.environ.get('baz'), '1234')
 
+            self.thisEnvMust('FOO_THING', 'baz')
+            self.thisEnvMustNot('BAR_THING', 'NEWP_THING')
+            with self.raises(unittest.SkipTest):
+                self.thisEnvMust('MEWP_THING')
+            with self.raises(unittest.SkipTest):
+                self.thisEnvMust('BAR_THING')
+            with self.raises(unittest.SkipTest):
+                self.thisEnvMustNot('FOO_THING')
+
         self.eq(os.environ.get('foo'), '1')
         self.eq(os.environ.get('bar'), '2')
         self.none(os.environ.get('baz'))