synapse 2.213.0__py311-none-any.whl → 2.215.0__py311-none-any.whl

synapse/tests/test_daemon.py

@@ -98,7 +98,7 @@ class DaemonTest(s_t_utils.SynTest):
 
                 # Invalid data casues a link to fail on rx
                 async with await prox.getPoolLink() as link:
-                    with self.getAsyncLoggerStream('synapse.lib.link', 'rx error') as stream:
+                    with self.getAsyncLoggerStream('synapse.lib.link', 'rx closed unexpectedly') as stream:
                         byts = b'\x16\x03\x01\x02\x00\x01\x00\x01\xfc\x03\x03\xa6\xa3D\xd5\xdf%\xac\xa9\x92\xc3'
                         await link.send(byts)
                         self.true(await stream.wait(timeout=6))

synapse/tests/test_exc.py

@@ -54,3 +54,9 @@ class ExcTest(s_t_utils.SynTest):
 
         with self.raises(s_exc.BadArg):
             s_exc.StormRaise(mesg='newp')
+
+    async def test_reprexc(self):
+        exc = s_exc.SynErr(mesg='woot')
+        self.eq('woot', s_exc.reprexc(exc))
+        self.eq('ValueError()', s_exc.reprexc(ValueError()))
+        self.eq("ValueError('woot')", s_exc.reprexc(ValueError('woot')))

synapse/tests/test_lib_ast.py

@@ -2192,17 +2192,24 @@ class AstTest(s_test.SynTest):
             self.eq(nodes[1].ndef, ('test:str', 'init2'))
             self.eq(nodes[1].get('hehe'), 'hi')
 
-            # Non-runtsafe init fails to execute
+            # Non-runtsafe values allowed in init
+            q = '''
+            init {
+                [test:str=cool :hehe=runtsafety]
+                $lib.print(:hehe)
+            }
+            '''
+            msgs = await core.stormlist(q)
+            self.stormIsInPrint('runtsafety', msgs)
+
+            # Non-runtsafe init doesn't create the node
             q = '''
             test:str^=init +:hehe $hehe=:hehe
             init {
                 [test:str=$hehe]
             }
             '''
-            msgs = await core.stormlist(q)
-            erfo = [m for m in msgs if m[0] == 'err'][0]
-            self.eq(erfo[1][0], 'StormRuntimeError')
-            self.eq(erfo[1][1].get('mesg'), 'Init block query must be runtsafe')
+            self.len(2, await core.nodes(q))
 
             # Runtsafe init works and can yield nodes, this has inbound nodes as well
             q = '''
@@ -2231,7 +2238,7 @@ class AstTest(s_test.SynTest):
             self.eq(nodes[1].ndef, ('test:str', 'fini2'))
             self.eq(nodes[1].get('hehe'), 'hehe')
 
-            # Non-runtsafe fini example which fails
+            # Non-runtsafe fini example
             q = '''
             [test:str=fini3 :hehe="number3"]
             $hehe=:hehe
@@ -2239,10 +2246,10 @@ class AstTest(s_test.SynTest):
                 [(test:str=fini4 :hehe=$hehe)]
             }
             '''
-            msgs = await core.stormlist(q)
-            erfo = [m for m in msgs if m[0] == 'err'][0]
-            self.eq(erfo[1][0], 'StormRuntimeError')
-            self.eq(erfo[1][1].get('mesg'), 'Fini block query must be runtsafe')
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.eq('number3', node.get('hehe'))
 
             # Tally use - case example for counting
             q = '''
@@ -2413,12 +2420,21 @@ class AstTest(s_test.SynTest):
             self.stormIsInPrint('blorp', msgs)
 
             q = '''
-            [test:str=latte :hehe=milk] $beep=:hehe | spin | empty { $lib.print($beep) }
+            [test:str=latte :hehe=milk] $beep=:hehe | spin | empty { $lib.print($beep) $lib.print(ok) }
             '''
             msgs = await core.stormlist(q)
             nodes = [m[1] for m in msgs if m[0] == 'node']
             self.len(0, nodes)
-            self.stormIsInErr('Empty block query must be runtsafe', msgs)
+            self.stormIsInPrint('ok', msgs)
+            self.stormNotInPrint('milk', msgs)
+
+            q = '''
+            empty { [test:str=runtsafety :hehe=optional] $beep=:hehe $lib.print($beep) }
+            '''
+            msgs = await core.stormlist(q)
+            nodes = [m[1] for m in msgs if m[0] == 'node']
+            self.len(1, nodes)
+            self.stormIsInPrint('optional', msgs)
 
             q = '''
             function foo() {
@@ -3224,11 +3240,11 @@ class AstTest(s_test.SynTest):
             off, end = errm[1][1]['highlight']['offsets']
             self.eq(':foo:bar', text[off:end])
 
-            text = 'init { $foo = :bar }'
+            text = 'init { $foo = $bar }'
             msgs = await core.stormlist(text)
             errm = [m for m in msgs if m[0] == 'err'][0]
             off, end = errm[1][1]['highlight']['offsets']
-            self.eq(':bar', text[off:end])
+            self.eq('bar', text[off:end])
 
             text = 'inet:ipv5'
             msgs = await core.stormlist(text)
@@ -3554,6 +3570,45 @@ class AstTest(s_test.SynTest):
 
             self.len(1, nodes)
 
+    async def test_ast_subgraph_multipivot(self):
+        async with self.getTestCore() as core:
+            guid = s_common.guid()
+            await core.nodes('''[
+                (test:guid=$guid :size=1234 :tick=now) +(refs)> {[test:str=blorp]}
+            ]''', opts={'vars': {'guid': guid}})
+
+            opts = {
+                'graph': {
+                    'pivots': ('-> *', '-(refs)> *'),
+                    'refs': True,
+                    'degrees': 1
+                }
+            }
+
+            nodes = []
+            async with await core.snap() as snap:
+                async for node, path in snap.storm('test:guid', opts=opts):
+                    nodes.append(node)
+
+            opts = {
+                'graph': {
+                    'pivots': ('-(refs)> *', '-> *'),
+                    'refs': True,
+                    'degrees': 1
+                }
+            }
+            nodes2 = []
+            async with await core.snap() as snap:
+                async for node, path in snap.storm('test:guid', opts=opts):
+                    nodes2.append(node)
+
+            self.eq(set(n.iden() for n in nodes), set(n.iden() for n in nodes2))
+            self.len(3, nodes)
+            ndefs = [n.ndef for n in nodes]
+            self.isin(('test:guid', guid), ndefs)
+            self.isin(('test:str', 'blorp'), ndefs)
+            self.isin(('test:int', 1234), ndefs)
+
     async def test_ast_double_init_fini(self):
         async with self.getTestCore() as core:
             q = '''

synapse/tests/test_lib_boss.py

@@ -62,3 +62,11 @@ class BossTest(s_test.SynTest):
                 coro = boss.schedCoro(double_promote())
                 self.true(await stream.wait(timeout=6))
                 await coro
+
+            async with boss.shutdown_lock:
+                with self.raises(s_exc.ShuttingDown):
+                    boss.reqNotShut()
+
+            boss.is_shutdown = True
+            with self.raises(s_exc.ShuttingDown):
+                boss.reqNotShut()

synapse/tests/test_lib_cell.py

@@ -187,6 +187,20 @@ testDataSchema_v1 = {
         'size': {'type': 'number'},
         'stuff': {'type': ['number', 'null'], 'default': None},
         'woot': {'type': 'string'},
+        'blorp': {
+            'type': 'object',
+            'properties': {
+                'bleep': {
+                    'type': 'array',
+                    'items': {
+                        'type': 'object',
+                        'properties': {
+                            'neato': {'type': 'string'}
+                        }
+                    }
+                }
+            }
+        }
     },
     'required': ['type', 'size', 'woot'],
     'additionalProperties': False,
@@ -244,13 +258,21 @@ class CellTest(s_t_utils.SynTest):
                 with self.raises(s_exc.BadVersion):
                     await cell.drive.setTypeSchema('woot', testDataSchema_v0, vers=0)
 
-                info = {'name': 'win32k.sys', 'type': 'woot'}
+                info = {'name': 'win32k.sys', 'type': 'woot', 'perm': {'users': {}}}
                 info = await cell.addDriveItem(info, reldir=rootdir)
+                self.notin('perm', info)
+                self.eq(info[0]['permissions'], {
+                    'users': {},
+                    'roles': {}
+                })
 
                 iden = info[-1].get('iden')
 
                 tick = s_common.now()
                 rootuser = cell.auth.rootuser.iden
+                fooser = await cell.auth.addUser('foo')
+                neatrole = await cell.auth.addRole('neatrole')
+                await fooser.grant(neatrole.iden)
 
                 with self.raises(s_exc.SchemaViolation):
                     versinfo = {'version': (1, 0, 0), 'updated': tick, 'updater': rootuser}
@@ -305,6 +327,10 @@ class CellTest(s_t_utils.SynTest):
                 info, versinfo = await cell.setDriveData(iden, versinfo, {'type': 'haha', 'size': 17, 'stuff': 15})
                 self.eq(versinfo, (await cell.getDriveData(iden))[0])
 
+                await cell.setDriveItemProp(iden, versinfo, ('stuff',), 1234)
+                data = await cell.getDriveData(iden)
+                self.eq(data[1]['stuff'], 1234)
+
                 # This will be done by the cell in a cell storage version migration...
                 async def migrate_v1(info, versinfo, data):
                     data['woot'] = 'woot'
@@ -312,6 +338,37 @@ class CellTest(s_t_utils.SynTest):
 
                 await cell.drive.setTypeSchema('woot', testDataSchema_v1, migrate_v1)
 
+                versinfo['version'] = (1, 1, 1)
+                await cell.setDriveItemProp(iden, versinfo, 'stuff', 3829)
+                data = await cell.getDriveData(iden)
+                self.eq(data[0]['version'], (1, 1, 1))
+                self.eq(data[1]['stuff'], 3829)
+
+                await self.asyncraises(s_exc.NoSuchIden, cell.setDriveItemProp(s_common.guid(), versinfo, ('lolnope',), 'not real'))
+
+                await self.asyncraises(s_exc.BadArg, cell.setDriveItemProp(iden, versinfo, ('blorp', 0, 'neato'), 'my special string'))
+                data[1]['blorp'] = {
+                    'bleep': [{'neato': 'thing'}]
+                }
+                info, versinfo = await cell.setDriveData(iden, versinfo, data[1])
+                now = s_common.now()
+                versinfo['updated'] = now
+                await cell.setDriveItemProp(iden, versinfo, ('blorp', 'bleep', 0, 'neato'), 'my special string')
+                data = await cell.getDriveData(iden)
+                self.eq(now, data[0]['updated'])
+                self.eq('my special string', data[1]['blorp']['bleep'][0]['neato'])
+
+                versinfo['version'] = (1, 2, 1)
+                await cell.delDriveItemProp(iden, versinfo, ('blorp', 'bleep', 0, 'neato'))
+                vers, data = await cell.getDriveData(iden)
+                self.eq((1, 2, 1), vers['version'])
+                self.nn(data['blorp']['bleep'][0])
+                self.notin('neato', data['blorp']['bleep'][0])
+
+                await self.asyncraises(s_exc.NoSuchIden, cell.delDriveItemProp(s_common.guid(), versinfo, 'blorp'))
+
+                self.none(await cell.delDriveItemProp(iden, versinfo, ('lolnope', 'nopath')))
+
                 versinfo, data = await cell.getDriveData(iden, vers=(1, 0, 0))
                 self.eq('woot', data.get('woot'))
 
@@ -325,10 +382,10 @@ class CellTest(s_t_utils.SynTest):
                     await cell.getDriveInfo(iden, typename='newp')
 
                 self.nn(await cell.getDriveInfo(iden))
-                self.len(2, [vers async for vers in cell.getDriveDataVersions(iden)])
+                self.len(4, [vers async for vers in cell.getDriveDataVersions(iden)])
 
                 await cell.delDriveData(iden)
-                self.len(1, [vers async for vers in cell.getDriveDataVersions(iden)])
+                self.len(3, [vers async for vers in cell.getDriveDataVersions(iden)])
 
                 await cell.delDriveInfo(iden)
 
@@ -352,8 +409,12 @@ class CellTest(s_t_utils.SynTest):
                 baziden = pathinfo[2].get('iden')
                 self.eq(pathinfo, await cell.drive.getItemPath(baziden))
 
-                info = await cell.setDriveInfoPerm(baziden, {'users': {rootuser: 3}, 'roles': {}})
-                self.eq(3, info['perm']['users'][rootuser])
+                info = await cell.setDriveInfoPerm(baziden, {'users': {rootuser: s_cell.PERM_ADMIN}, 'roles': {}})
+                # make sure drive perms work with easy perms
+                self.true(cell._hasEasyPerm(info, cell.auth.rootuser, s_cell.PERM_ADMIN))
+                # defaults to READ
+                self.true(cell._hasEasyPerm(info, fooser, s_cell.PERM_READ))
+                self.false(cell._hasEasyPerm(info, fooser, s_cell.PERM_EDIT))
 
                 with self.raises(s_exc.NoSuchIden):
                     # s_drive.rootdir is all 00s... ;)
@@ -648,6 +709,44 @@ class CellTest(s_t_utils.SynTest):
                 with self.raises(s_exc.NeedConfValu):
                     await echo.reqAhaProxy()
 
+    async def test_cell_drive_perm_migration(self):
+        async with self.getRegrCore('drive-perm-migr') as core:
+            item = await core.getDrivePath('driveitemdefaultperms')
+            self.len(1, item)
+            self.notin('perm', item)
+            self.eq(item[0]['permissions'], {'users': {}, 'roles': {}})
+
+            ldog = await core.auth.getRoleByName('littledog')
+            bdog = await core.auth.getRoleByName('bigdog')
+
+            louis = await core.auth.getUserByName('lewis')
+            tim = await core.auth.getUserByName('tim')
+            mj = await core.auth.getUserByName('mj')
+
+            item = await core.getDrivePath('permfolder/driveitemwithperms')
+            self.len(2, item)
+            self.notin('perm', item[0])
+            self.notin('perm', item[1])
+            self.eq(item[0]['permissions'], {'users': {tim.iden: s_cell.PERM_ADMIN}, 'roles': {}})
+            self.eq(item[1]['permissions'], {
+                'users': {
+                    mj.iden: s_cell.PERM_ADMIN
+                },
+                'roles': {
+                    ldog.iden: s_cell.PERM_READ,
+                    bdog.iden: s_cell.PERM_EDIT,
+                },
+                'default': s_cell.PERM_DENY
+            })
+
+            # make sure it's all good with easy perms
+            self.true(core._hasEasyPerm(item[0], tim, s_cell.PERM_ADMIN))
+            self.false(core._hasEasyPerm(item[0], mj, s_cell.PERM_EDIT))
+
+            self.true(core._hasEasyPerm(item[1], mj, s_cell.PERM_ADMIN))
+            self.true(core._hasEasyPerm(item[1], tim, s_cell.PERM_READ))
+            self.true(core._hasEasyPerm(item[1], louis, s_cell.PERM_EDIT))
+
     async def test_cell_unix_sock(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_certdir.py

@@ -576,6 +576,10 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getHostKey(hostname)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            self.true(cdir.delHostCsr(hostname))
+            self.false(os.path.isfile(path))
+            self.false(cdir.delHostCsr(hostname))
+
             # Per RFC5280 common-name has a length of 1 to 64 characters
             # Do not generate CSRs which exceed that name range.
             with self.raises(s_exc.CryptoErr) as cm:
@@ -610,6 +614,10 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getUserKey(username)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            self.true(cdir.delUserCsr(username))
+            self.false(os.path.isfile(path))
+            self.false(cdir.delUserCsr(username))
+
             # Per RFC5280 common-name has a length of 1 to 64 characters
             # Do not generate CSRs which exceed that name range.
             with self.raises(s_exc.CryptoErr) as cm:

synapse/tests/test_lib_coro.py

@@ -235,3 +235,8 @@ class CoroTest(s_t_utils.SynTest):
         results = await s_coro.await_bg_tasks()
         self.len(1, results)
         self.isinstance(results[0], ZeroDivisionError)
+
+        task = s_coro.create_task(sleep(10))
+        self.eq([], await s_coro.await_bg_tasks(timeout=0.001))
+        task.cancel()
+        self.eq([], await s_coro.await_bg_tasks())

synapse/tests/test_lib_httpapi.py

@@ -807,8 +807,8 @@ class HttpApiTest(s_tests.SynTest):
                 opts['user'] = newpuser
                 async with sess.get(f'https://localhost:{port}/api/v1/storm', json=data) as resp:
                     self.eq(resp.status, http.HTTPStatus.BAD_REQUEST)
-                    data = await resp.json()
-                    self.eq(data, {'status': 'err', 'code': 'NoSuchUser',
+                    info = await resp.json()
+                    self.eq(info, {'status': 'err', 'code': 'NoSuchUser',
                                    'mesg': f'No user found with iden: {newpuser}'})
 
     async def test_http_coreinfo(self):
@@ -1615,6 +1615,14 @@ class HttpApiTest(s_tests.SynTest):
                                     json={'query': '.created', 'opts': {'user': lowuser.iden, 'view': fork}}) as resp:
                     self.eq(resp.status, http.HTTPStatus.FORBIDDEN)
 
+                # ShuttingDown precondition failure
+                core.boss.is_shutdown = True
+                async with sess.get(f'https://localhost:{port}/api/v1/storm', json={'query': '.created'}) as resp:
+                    self.eq(resp.status, http.HTTPStatus.BAD_REQUEST)
+                    info = await resp.json()
+                    self.eq(info.get('code'), 'ShuttingDown')
+                core.boss.is_shutdown = False
+
                 # check reqvalidstorm with various queries
                 tvs = (
                     ('test:str=test', {}, 'ok'),

synapse/tests/test_lib_jsonstor.py

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

synapse/tests/test_lib_layer.py

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

synapse/tests/test_lib_link.py

@@ -121,7 +121,7 @@ class LinkTest(s_test.SynTest):
         self.eq(msg0, ('what', {'k': 1}))
         evt.set()
         await asyncio.sleep(0)
-        with self.getAsyncLoggerStream('synapse.lib.link', 'rx error') as stream:
+        with self.getAsyncLoggerStream('synapse.lib.link', 'rx closed unexpectedly') as stream:
             msg1 = await link.rx()
             self.true(await stream.wait(6))
         self.none(msg1)

synapse/tests/test_lib_storm.py

@@ -130,7 +130,6 @@ class StormTest(s_t_utils.SynTest):
             self.none(props.get('phone'))
             self.eq(props.get('name'), 'burrito corp')
             self.eq(props.get('desc'), 'burritos man')
-            self.stormIsInWarn('Skipping bad value for prop ou:org:phone: requires a digit string', msgs)
 
             await self.asyncraises(s_exc.BadTypeValu, core.addNode(core.auth.rootuser, 'ou:org', {'name': 'org name 77', 'phone': 'lolnope'}, props={'desc': 'an org desc'}))
 
@@ -173,6 +172,127 @@ class StormTest(s_t_utils.SynTest):
             nodes = await core.nodes('[ it:exec:proc=(nulltime,) ]')
             self.len(1, nodes)
 
+            # Recursive gutors
+            nodes = await core.nodes('''[
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'fooplatform',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'foomesg')
+            self.nn(node.get('channel'))
+
+            nodes = await core.nodes('inet:service:message -> inet:service:channel')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('id'), 'foochannel')
+            self.nn(node.get('platform'))
+
+            nodes = await core.nodes('inet:service:message -> inet:service:channel -> inet:service:platform')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'fooplatform')
+            self.eq(node.get('url'), 'http://foo.com')
+
+            nodes = await core.nodes('''
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'fooplatform',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            ''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'foomesg')
+
+            nodes = await core.nodes('''[
+                inet:service:message=({
+                    'id': 'barmesg',
+                    'channel': {
+                        'id': 'barchannel',
+                        'platform': {
+                            'name': 'barplatform',
+                            'url': 'http://bar.com'
+                        }
+                    },
+                    '$props': {
+                        'platform': {
+                            'name': 'barplatform',
+                            'url': 'http://bar.com'
+                        }
+                    }
+                })
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'barmesg')
+            self.nn(node.get('channel'))
+
+            platguid = node.get('platform')
+            self.nn(platguid)
+            nodes = await core.nodes('inet:service:message:id=barmesg -> inet:service:channel -> inet:service:platform')
+            self.len(1, nodes)
+            self.eq(platguid, nodes[0].ndef[1])
+
+            # No node lifted if no matching node for inner gutor
+            self.len(0, await core.nodes('''
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'newp',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            '''))
+
+            # BadTypeValu comes through from inner gutor
+            with self.raises(s_exc.BadTypeValu) as cm:
+                await core.nodes('''
+                    inet:service:message=({
+                        'id': 'foomesg',
+                        'channel': {
+                            'id': 'foochannel',
+                            'platform': {
+                                'name': 'newp',
+                                'url': 'newp'
+                            }
+                        }
+                    })
+                ''')
+
+            self.eq(cm.exception.get('form'), 'inet:service:platform')
+            self.eq(cm.exception.get('prop'), 'url')
+            self.eq(cm.exception.get('mesg'), 'Bad value for prop inet:service:platform:url: Invalid/Missing protocol')
+
+            # Ensure inner nodes are not created unless the entire gutor is valid.
+            self.len(0, await core.nodes('''[
+                inet:service:account?=({
+                    "id": "bar",
+                    "platform": {"name": "barplat"},
+                    "url": "newp"})
+            ]'''))
+
+            self.len(0, await core.nodes('inet:service:platform:name=barplat'))
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 

synapse/tests/test_lib_stormlib_iters.py

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

synapse/tests/test_lib_stormlib_spooled.py

@@ -1,3 +1,4 @@
+import os
 import synapse.exc as s_exc
 import synapse.lib.stormtypes as s_stormtypes
 
@@ -144,6 +145,20 @@ class StormlibSpooledTest(s_test.SynTest):
             valu = await core.callStorm(q)
             self.eq(1500, valu)
 
+            subq = '''{
+                $sset = $lib.spooled.set()
+                $sset.adds($lib.range(1500))
+                return($sset)
+            }'''
+
+            q = '''
+                $subset = $lib.storm.eval($text)
+                $subset.add(2345)
+                return($subset.size())
+            '''
+            valu = await core.callStorm(q, opts={'vars': {'text': subq}})
+            self.eq(1501, valu)
+
             # sad paths
             # too complex
             q = '''
@@ -199,3 +214,8 @@ class StormlibSpooledTest(s_test.SynTest):
                 return($set)
             '''
             await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q, {'vars': {'stormnode': stormnode}}))
+
+            # make sure the various spools got trashed
+            path = os.path.join(core.dirn, 'tmp')
+            files = [f for f in os.listdir(os.path.join(path))]
+            self.len(0, files)