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

synapse/tests/test_lib_agenda.py

@@ -361,10 +361,13 @@ class AgendaTest(s_t_utils.SynTest):
 
                 # schedule a query to run every Wednesday and Friday at 10:15am
                 cdef = {'creator': visi.iden, 'iden': s_common.guid(), 'storm': '$lib.queue.gen(visi).put(bar)',
+                        'pool': True,
                         'reqs': {s_tu.HOUR: 10, s_tu.MINUTE: 15},
                         'incunit': s_agenda.TimeUnit.DAYOFWEEK,
                         'incvals': (2, 4)}
                 adef = await agenda.add(cdef)
+
+                self.true(adef['pool'])
                 guid = adef.get('iden')
 
                 self.len(1, agenda.apptheap)
@@ -634,7 +637,7 @@ class AgendaTest(s_t_utils.SynTest):
             nodes = await core.nodes('test:int=97', opts={'view': newview})
             self.len(0, nodes)
 
-    async def test_agenda_edit_creator(self):
+    async def test_agenda_edit(self):
 
         async with self.getTestCore() as core:
 
@@ -645,8 +648,12 @@ class AgendaTest(s_t_utils.SynTest):
             self.stormHasNoWarnErr(msgs)
 
             cdef = await core.callStorm('for $cron in $lib.cron.list() { return($cron) }')
+            self.false(cdef['pool'])
             self.eq(cdef['creator'], core.auth.rootuser.iden)
 
+            cdef = await core.callStorm('for $cron in $lib.cron.list() { $cron.set(pool, (true)) return($cron) }')
+            self.true(cdef['pool'])
+
             opts = {'vars': {'lowuser': lowuser}}
             cdef = await core.callStorm('for $cron in $lib.cron.list() { return($cron.set(creator, $lowuser)) }',
                                         opts=opts)

synapse/tests/test_lib_aha.py

@@ -186,8 +186,8 @@ class AhaTest(s_test.SynTest):
                     self.nn(await proxy.getCellIden())
 
                 with self.raises(s_exc.BadArg):
-                    await cryo.ahaclient.waitready(timeout=2)
-                    await cryo.ahaclient.modAhaSvcInfo('cryo.mynet', {'newp': 'newp'})
+                    _proxy = await cryo.ahaclient.proxy(timeout=2)
+                    await _proxy.modAhaSvcInfo('cryo.mynet', {'newp': 'newp'})
 
                 async with await s_telepath.openurl('aha://root:secret@0.cryo.mynet') as proxy:
                     self.nn(await proxy.getCellIden())
@@ -1169,13 +1169,24 @@ class AhaTest(s_test.SynTest):
                     self.stormHasNoWarnErr(msgs)
                     self.stormIsInPrint('Created AHA service pool: pool00.loop.vertex.link', msgs)
 
-                    with self.raises(s_exc.BadArg):
-                        await s_telepath.open('aha://pool00...')
+                    # Pool has no members....
+                    pool = await s_telepath.open('aha://pool00...')
+                    self.eq(0, pool.size())
+                    waiter = pool.waiter(0, 'svc:add')
 
                     msgs = await core00.stormlist('aha.pool.svc.add pool00... 00...')
                     self.stormHasNoWarnErr(msgs)
                     self.stormIsInPrint('AHA service (00...) added to service pool (pool00.loop.vertex.link)', msgs)
 
+                    self.len(1, await waiter.wait(timeout=12))
+                    prox = await pool.proxy(timeout=12)
+                    info = await prox.getCellInfo()
+                    self.eq('00', info.get('cell').get('aha').get('name'))
+                    self.eq(1, pool.size())
+                    await pool.fini()
+                    self.eq(0, pool.size())
+                    self.true(prox.isfini)
+
                     poolinfo = await aha.getAhaPool('pool00...')
                     self.len(1, poolinfo['services'])
 
@@ -1184,6 +1195,9 @@ class AhaTest(s_test.SynTest):
                     self.stormIsInPrint('    00.loop.vertex.link', msgs)
                     self.stormIsInPrint('1 pools', msgs)
 
+                    msgs = await core00.stormlist('$lib.print($lib.aha.pool.get(pool00.loop.vertex.link))')
+                    self.stormIsInPrint('aha:pool: pool00.loop.vertex.link', msgs)
+
                     async with await s_telepath.open('aha://pool00...') as pool:
 
                         replay = s_common.envbool('SYNDEV_NEXUS_REPLAY')

synapse/tests/test_lib_storm.py

@@ -1262,7 +1262,7 @@ class StormTest(s_t_utils.SynTest):
                 query = await core.getStormQuery('')
                 async with snap.getStormRuntime(query) as runt:
                     with self.raises(s_exc.AuthDeny):
-                        runt.reqAdmin(gateiden='cortex')
+                        runt.reqAdmin(gateiden=layr)
 
             await core.stormlist('[ inet:fqdn=vertex.link ]')
             fork = await core.callStorm('return($lib.view.get().fork().iden)')
@@ -1772,13 +1772,92 @@ class StormTest(s_t_utils.SynTest):
             self.eq('796d67b92a6ffe9b88fa19d115b46ab6712d673a06ae602d41de84b1464782f2', node[1]['embeds']['asn']['*'])
 
             opts = {'embeds': {'ou:org': {'hq::email': ('user',)}}}
-            msgs = await core.stormlist('[ ou:org=* :hq=* ] { -> ps:contact [ :email=visi@vertex.link ] }', opts=opts)
+            msgs = await core.stormlist('[ ou:org=* :country=* :hq=* ] { -> ps:contact [ :email=visi@vertex.link ] }', opts=opts)
             nodes = [m[1] for m in msgs if m[0] == 'node']
-
             node = nodes[0]
+
             self.eq('visi', node[1]['embeds']['hq::email']['user'])
             self.eq('2346d7bed4b0fae05e00a413bbf8716c9e08857eb71a1ecf303b8972823f2899', node[1]['embeds']['hq::email']['*'])
 
+            fork = await core.callStorm('return($lib.view.get().fork().iden)')
+
+            opts['vars'] = {
+                'md5': '12345a5758eea935f817dd1490a322a5',
+                'sha1': '40b8e76cff472e593bd0ba148c09fec66ae72362'
+            }
+            opts['view'] = fork
+            opts['show:storage'] = True
+            opts['embeds']['ou:org']['lol::nope'] = ('notreal',)
+            opts['embeds']['ou:org']['country::flag'] = ('md5', 'sha1')
+            opts['embeds']['ou:org']['country::tld'] = ('domain',)
+
+            await core.stormlist('pol:country [ :flag={[ file:bytes=* :md5=fa818a259cbed7ce8bc2a22d35a464fc ]} ]')
+
+            msgs = await core.stormlist('''
+                ou:org {
+                    -> pol:country
+                    [ :tld=co.uk ]
+                    {
+                        :flag -> file:bytes [ :md5=$md5 :sha1=$sha1 ]
+                    }
+                }
+            ''', opts=opts)
+            nodes = [m[1] for m in msgs if m[0] == 'node']
+            node = nodes[0]
+
+            storage = node[1]['storage']
+            self.len(2, storage)
+            top = storage[0].get('embeds')
+            bot = storage[1].get('embeds')
+            self.nn(top)
+            self.nn(bot)
+
+            self.nn(top.get('country::flag::md5'))
+            self.eq(top['country::flag::md5'][0], '12345a5758eea935f817dd1490a322a5')
+
+            self.nn(top.get('country::flag::sha1'))
+            self.eq(top['country::flag::sha1'][0], '40b8e76cff472e593bd0ba148c09fec66ae72362')
+
+            self.nn(top.get('country::tld::domain'))
+            self.eq(top['country::tld::domain'][0], 'uk')
+
+            self.nn(bot.get('hq::email::user'))
+            self.eq(bot['hq::email::user'][0], 'visi')
+
+            self.nn(bot.get('country::flag::md5'))
+            self.eq(bot['country::flag::md5'][0], 'fa818a259cbed7ce8bc2a22d35a464fc')
+
+            empty = await core.callStorm('return($lib.view.get().fork().iden)', opts=opts)
+            opts['view'] = empty
+
+            msgs = await core.stormlist('ou:org', opts=opts)
+            nodes = [m[1] for m in msgs if m[0] == 'node']
+            node = nodes[0]
+            storage = node[1]['storage']
+            self.len(3, storage)
+            top = storage[0].get('embeds')
+            mid = storage[1].get('embeds')
+            bot = storage[2].get('embeds')
+            self.none(top)
+
+            self.nn(mid)
+            self.nn(bot)
+
+            self.nn(mid.get('country::flag::md5'))
+            self.eq(mid['country::flag::md5'][0], '12345a5758eea935f817dd1490a322a5')
+
+            self.nn(mid.get('country::flag::sha1'))
+            self.eq(mid['country::flag::sha1'][0], '40b8e76cff472e593bd0ba148c09fec66ae72362')
+
+            self.nn(mid.get('country::tld::domain'))
+            self.eq(mid['country::tld::domain'][0], 'uk')
+
+            self.nn(bot.get('hq::email::user'))
+            self.eq(bot['hq::email::user'][0], 'visi')
+
+            self.nn(bot.get('country::flag::md5'))
+            self.eq(bot['country::flag::md5'][0], 'fa818a259cbed7ce8bc2a22d35a464fc')
+
     async def test_storm_wget(self):
 
         async def _getRespFromSha(core, mesgs):
@@ -2151,7 +2230,7 @@ class StormTest(s_t_utils.SynTest):
 
             # Max recursion fail
             q = '[ inet:fqdn=www.vertex.link ] | tree { inet:fqdn=www.vertex.link }'
-            await self.asyncraises(s_exc.StormRuntimeError, core.nodes(q))
+            await self.asyncraises(s_exc.RecursionLimitHit, core.nodes(q))
 
             # Runtsafety test
             q = '[ inet:fqdn=www.vertex.link ] $q=:domain | tree $q'
@@ -2359,6 +2438,18 @@ class StormTest(s_t_utils.SynTest):
             with self.raises(s_exc.BadOperArg):
                 await core.nodes('movetag this is')
 
+        async with self.getTestCore() as core:
+            await core.nodes('[ syn:tag=hehe :isnow=haha ]')
+            nodes = await core.nodes('[ ou:org=* +#hehe.qwer ]')
+            self.len(1, nodes)
+            self.nn(nodes[0].getTag('haha.qwer'))
+            self.none(nodes[0].getTag('hehe.qwer'))
+            self.len(1, await core.nodes('syn:tag=haha.qwer'))
+
+            # this should hit the already existing redirected tag now...
+            nodes = await core.nodes('[ ou:org=* +#hehe.qwer ]')
+            self.len(1, nodes)
+
         # Sad path
         async with self.getTestCore() as core:
             # Test moving a tag to itself

synapse/tests/test_lib_stormlib_cache.py

@@ -0,0 +1,272 @@
+import synapse.exc as s_exc
+
+import synapse.tests.utils as s_test
+
+class StormlibCacheTest(s_test.SynTest):
+
+    async def test_storm_lib_cache_fixed(self):
+
+        async with self.getTestCore() as core:
+
+            # basics
+
+            rets = await core.callStorm('''
+                $rets = ([])
+                $cache = $lib.cache.fixed("return(`{$cache_key}-ret`)")
+
+                $cache.clear()
+
+                $rets.append($lib.len($cache))
+
+                $rets.append($cache.get(key))
+                $rets.append($lib.len($cache))
+
+                $cache.put(key, key-put)
+                $rets.append($cache.get(key))
+
+                $cache.clear()
+                $rets.append($cache.get(key))
+
+                $cache.put(key, key-put)
+                $rets.append($cache.get(key))
+                $rets.append($cache.pop(key))
+                $rets.append($cache.get(key))
+
+                $rets.append($cache.pop(newp))
+
+                $rets.append($cache.query)
+
+                return($rets)
+            ''')
+            self.eq([
+                0,
+                'key-ret', 1,
+                'key-put',
+                'key-ret',
+                'key-put', 'key-put', 'key-ret',
+                None,
+                'return(`{$cache_key}-ret`)'
+            ], rets)
+
+            # exhaust size
+
+            rets = await core.callStorm('''
+                $rets = ([])
+                $cache = $lib.cache.fixed("return(`{$cache_key}-ret`)", size=2)
+
+                $cache.put(one, one-put)
+                $cache.put(two, two-put)
+                $rets.append($cache.get(one))
+                $rets.append($cache.get(two))
+
+                $rets.append($cache.get(three))
+                $rets.append($cache.get(one))
+
+                return($rets)
+            ''')
+            self.eq(['one-put', 'two-put', 'three-ret', 'one-ret'], rets)
+
+            # also accept a storm query object
+
+            ret = await core.callStorm('''
+                $cache = $lib.cache.fixed(${ $suf=ret return(`{$cache_key}-{$suf}`)})
+                return($cache.get(foo))
+            ''')
+            self.eq('foo-ret', ret)
+
+            # callback runtime scoping
+
+            ## a function still has the outer scope as its root
+            rets = await core.callStorm('''
+                $val = zero
+                $sent = $lib.null
+
+                function cb(key) {
+                    $sent = $val
+                    return(`{$key}-{$val}`)
+                }
+
+                $cache = $lib.cache.fixed("return($cb($cache_key))")
+
+                $rets = ([])
+
+                $rets.append($cache.get(foo))
+                $rets.append($sent)
+
+                $val = one
+                $rets.append($cache.get(bar))
+                $rets.append($sent)
+
+                return($rets)
+            ''')
+            self.eq([
+                'foo-zero', 'zero',
+                'bar-one', 'one'
+            ], rets)
+
+            ## runtime also can modify refs to the outer scope
+            rets = await core.callStorm('''
+                $val = zero
+                $vals = ([])
+                $sent = $lib.null
+
+                $cache = $lib.cache.fixed(${
+                    $sent = $val
+                    $vals.append($cache_key)
+                    return(`{$cache_key}-{$val}`)
+                })
+
+                $rets = ([])
+
+                $rets.append($cache.get(foo))
+                $rets.append($sent)
+                $rets.append($lib.str.join(",", $vals))
+
+                $val = one
+                $rets.append($cache.get(bar))
+                $rets.append($sent)
+                $rets.append($lib.str.join(",", $vals))
+
+                return($rets)
+            ''')
+            self.eq([
+                'foo-zero', None, 'foo',
+                'bar-one', None, 'foo,bar',
+            ], rets)
+
+            ## default to null w/o a return
+            self.none(await core.callStorm('return($lib.cache.fixed("if (0) { return(yup) }").get(foo))'))
+
+            ## control flow exceptions don't propagate up
+            rets = await core.callStorm('''
+                $cache = $lib.cache.fixed( ${ if ($cache_key < (2)) { return (`key={$cache_key}`) } else { break } } )
+
+                $rets = ([])
+
+                for $i in $lib.range(4) {
+                    $rets.append($cache.get($i))
+                }
+
+                $rets.append(`i={$i}`)
+                return($rets)
+            ''')
+            self.eq(['key=0', 'key=1', None, None, 'i=3'], rets)
+
+            ## control flow scoped inside the callback
+            rets = await core.callStorm("""
+                $cache = $lib.cache.fixed('''
+                    $vals = ([])
+                    for $i in $lib.range(3) {
+                        $vals.append(`key={$cache_key} i={$i}`)
+                        break
+                    }
+                    return($vals)
+                ''')
+
+                $rets = ([])
+
+                for $k in (foo, bar, baz) {
+                    $rets.append($cache.get($k))
+                }
+
+                return($rets)
+            """)
+            self.eq([('key=foo i=0',), ('key=bar i=0',), ('key=baz i=0',),], rets)
+
+            ## coverage for the cb runtime emiting nodes
+            rets = await core.callStorm('''
+                $rets = ([])
+                $cache = $lib.cache.fixed(${ if (0) { return(yup) } [ inet:ipv4=$cache_key ] })
+
+                for $i in (0, 1) {
+                    $rets.append($cache.get($i))
+                }
+                return($rets)
+            ''')
+            self.eq([None, None], rets)
+
+            # stormrepr
+
+            msgs = await core.stormlist('''
+                $lib.print($lib.cache.fixed(${return(cool)}))
+                $lib.print($lib.cache.fixed($longq))
+            ''', opts={'vars': {'longq': f'return({"a" * 150})'}})
+            self.stormIsInPrint('cache:fixed: size=10000 query="return(cool)"', msgs)
+            self.stormIsInPrint('aaaaa...', msgs)
+
+            # sad
+
+            ## bad storm query
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("function x -> newp")')
+            self.isin('Invalid callback query', ectx.exception.errinfo.get('mesg'))
+
+            ## no return
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("$x=1")')
+            self.eq('Callback query must return a value', ectx.exception.errinfo.get('mesg'))
+
+            ## bad size
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("return()", size=(-1))')
+            self.eq('Cache size must be between 1-10000', ectx.exception.errinfo.get('mesg'))
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("return()", size=(1000000))')
+            self.eq('Cache size must be between 1-10000', ectx.exception.errinfo.get('mesg'))
+
+            ## callback raises an exception
+
+            rets = await core.callStorm('''
+                function cb(key) {
+                    if ($key = "sad") {
+                        $lib.raise(Bad, Time)
+                    }
+                    return(`{$key}-happy`)
+                }
+                $cache = $lib.cache.fixed("return($cb($cache_key))")
+
+                $rets = ([])
+
+                try {
+                    $rets.append($cache.get(sad))
+                } catch Bad as e {
+                    $rets.append(badtime)
+                }
+
+                $rets.append($cache.get(foo))
+
+                return($rets)
+            ''')
+            self.eq(['badtime', 'foo-happy'], rets)
+
+            with self.raises(s_exc.BadCast) as ectx:
+                await core.nodes('$lib.cache.fixed(${ return(($cache_key * 3)) }).get(foo)')
+            self.eq('Failed to make an integer from \'foo\'.', ectx.exception.errinfo.get('mesg'))
+
+            ## mutable key
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("return()").get((foo,))')
+            self.eq('Mutable values are not allowed as cache keys', ectx.exception.errinfo.get('mesg'))
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("return()").put((foo,), bar)')
+            self.eq('Mutable values are not allowed as cache keys', ectx.exception.errinfo.get('mesg'))
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.nodes('$lib.cache.fixed("return()").pop((foo,))')
+            self.eq('Mutable values are not allowed as cache keys', ectx.exception.errinfo.get('mesg'))
+
+            ## non-primable key
+
+            with self.raises(s_exc.NoSuchType) as ectx:
+                await core.nodes('$cache = $lib.cache.fixed("return()") $cache.get($cache)')
+            self.eq('Unable to convert object to Storm primitive.', ectx.exception.errinfo.get('mesg'))
+
+            ## missing use of $cache_key - no error
+
+            self.eq('newp', await core.callStorm('return($lib.cache.fixed("return(newp)").get(foo))'))

synapse/tests/test_lib_stormlib_cortex.py

@@ -1,5 +1,7 @@
 import json
 
+import unittest.mock as mock
+
 import aiohttp
 
 import synapse.common as s_common
@@ -393,6 +395,9 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             return ( $api.iden )
             '''
             iden0 = await core.callStorm(q)
+            msgs = await core.stormlist('$lib.print($lib.cortex.httpapi.get($iden))', opts={'vars': {'iden': iden0}})
+            mesg = 'http:api: the hehe wildcard handler (********************************), path=hehe/([a-z0-9]*)'
+            self.stormIsInPrint(mesg, msgs, deguid=True)
 
             q = '''
             $api = $lib.cortex.httpapi.add('hehe/haha')
@@ -401,6 +406,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             $api.name = 'the hehe/haha handler'
             $api.desc = 'beep boop zoop robot captain'
             $api.runas = user
+            $api.pool = (true)
             $api.perms = (
                 ({"perm": ["hehe", "haha"]}),
                 ({"perm": ["some", "thing"], "default": $lib.true}),
@@ -428,6 +434,9 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             return ( $api.iden )
             '''
             iden3 = await core.callStorm(q)
+            msgs = await core.stormlist('$lib.print($lib.cortex.httpapi.get($iden))', opts={'vars': {'iden': iden3}})
+            mesg = 'http:api: <no name> (********************************), path=wow'
+            self.stormIsInPrint(mesg, msgs, deguid=True)
 
             # $lib.dict accessor methods
             q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.keys($api.vars))'
@@ -473,6 +482,15 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             self.stormIsInPrint(f'2     {iden2}', msgs)
             self.stormIsInPrint(f'3     {iden3}', msgs)
 
+            q = '''
+            $ret = $lib.null $api = $lib.cortex.httpapi.getByPath($path)
+            if $api { $ret = $api.iden}
+            return ( $ret )
+            '''
+            self.eq(iden0, await core.callStorm(q, opts={'vars': {'path': 'hehe/haha'}}))
+            self.eq(iden0, await core.callStorm(q, opts={'vars': {'path': 'hehe/ohmy'}}))
+            self.none(await core.callStorm(q, opts={'vars': {'path': 'newpnewpnewp'}}))
+
             # Order matters. The hehe/haha path occurs after the wildcard.
             async with self.getHttpSess(auth=('root', 'root'), port=hport) as sess:
                 resp = await sess.get(f'https://localhost:{hport}/api/ext/hehe/haha')
@@ -494,6 +512,9 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             msgs = await core.stormlist('cortex.httpapi.index $iden 1', opts={'vars': {'iden': iden0}})
             self.stormIsInPrint(f'Set HTTP API {iden0} to index 1', msgs)
 
+            self.eq(iden1, await core.callStorm(q, opts={'vars': {'path': 'hehe/haha'}}))
+            self.eq(iden0, await core.callStorm(q, opts={'vars': {'path': 'hehe/ohmy'}}))
+
             msgs = await core.stormlist('cortex.httpapi.list')
             self.stormIsInPrint(f'0     {iden1}', msgs)
             self.stormIsInPrint(f'1     {iden0}', msgs)
@@ -562,6 +583,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             self.stormIsInPrint('Owner: root', msgs)
             self.stormIsInPrint('Runas: owner', msgs)
             self.stormIsInPrint('Readonly: false', msgs)
+            self.stormIsInPrint('Pool enabled: false', msgs)
             self.stormIsInPrint('Authenticated: true', msgs)
             self.stormIsInPrint('Name: the hehe wildcard handler', msgs)
             self.stormIsInPrint('Description: wildcard words', msgs)
@@ -596,6 +618,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             self.stormIsInPrint('Owner: root', msgs)
             self.stormIsInPrint('Runas: user', msgs)
             self.stormIsInPrint('Readonly: false', msgs)
+            self.stormIsInPrint('Pool enabled: true', msgs)
             self.stormIsInPrint('Authenticated: true', msgs)
             self.stormIsInPrint('Name: the hehe/haha handler', msgs)
             self.stormIsInPrint('Description: beep boop zoop robot captain', msgs)
@@ -1373,3 +1396,51 @@ for $i in $values {
                 self.none(resp.headers.get('X-Content-Type-Options'))
                 # Server is still omitted though
                 self.none(resp.headers.get('Server'))
+
+    async def test_cortex_httpapi_pool(self):
+
+        # Test if we pass the mirror value in opts or not.
+        async with self.getTestCore(conf={'https:headers': {'Key1': 'Valu1'}}) as core:
+            await core.setUserPasswd(core.auth.rootuser.iden, 'root')
+            addr, hport = await core.addHttpsPort(0)
+
+            q = '''$api = $lib.cortex.httpapi.add(stuff)
+            $api.methods.get =  ${
+                $request.reply(200, headers=({"Weee": "valu"}) )
+            }
+            return ( ($api.iden) )'''
+            iden00 = await core.callStorm(q)
+            opts_iden00 = {'vars': {'iden': iden00}}
+
+            data = {}
+
+            oldstorm = core.storm
+            async def storm(self, text, opts=None):
+                data['opts'] = opts
+                async for mesg in oldstorm(text, opts=opts):
+                    yield mesg
+
+            with mock.patch('synapse.cortex.Cortex.storm', new=storm) as patch:
+                async with self.getHttpSess(auth=('root', 'root'), port=hport) as sess:
+                    resp = await sess.get(f'https://localhost:{hport}/api/ext/stuff')  # type: aiohttp.ClientResponse
+                    self.eq(resp.status, 200)
+                    self.false(data['opts'].get('mirror'))
+                    data.clear()
+
+                    q = '$api=$lib.cortex.httpapi.get($iden) $api.pool = (true) return ( $api.pack() ) '
+                    adef = await core.callStorm(q, opts=opts_iden00)
+                    self.true(adef.get('pool'))
+
+                    resp = await sess.get(f'https://localhost:{hport}/api/ext/stuff')  # type: aiohttp.ClientResponse
+                    self.eq(resp.status, 200)
+                    self.true(data['opts'].get('mirror'))
+                    data.clear()
+
+                    q = '$api=$lib.cortex.httpapi.get($iden) $api.pool = (false) return ( $api.pack() ) '
+                    adef = await core.callStorm(q, opts=opts_iden00)
+                    self.false(adef.get('pool'))
+
+                    resp = await sess.get(f'https://localhost:{hport}/api/ext/stuff')  # type: aiohttp.ClientResponse
+                    self.eq(resp.status, 200)
+                    self.false(data['opts'].get('mirror'))
+                    data.clear()