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

synapse/tests/test_lib_cell.py

@@ -25,6 +25,7 @@ import synapse.lib.base as s_base
 import synapse.lib.cell as s_cell
 import synapse.lib.coro as s_coro
 import synapse.lib.link as s_link
+import synapse.lib.nexus as s_nexus
 import synapse.lib.certdir as s_certdir
 import synapse.lib.msgpack as s_msgpack
 import synapse.lib.version as s_version
@@ -2088,15 +2089,23 @@ class CellTest(s_t_utils.SynTest):
             return _ntuple_diskusage(100, 96, 4)
 
         revt = asyncio.Event()
-        orig = s_cortex.Cortex._setReadOnly
-        async def wrapReadOnly(self, valu, reason=None):
-            await orig(self, valu, reason=reason)
+        addWriteHold = s_nexus.NexsRoot.addWriteHold
+        delWriteHold = s_nexus.NexsRoot.delWriteHold
+        async def wrapAddWriteHold(root, reason):
+            retn = await addWriteHold(root, reason)
             revt.set()
+            return retn
+
+        async def wrapDelWriteHold(root, reason):
+            retn = await delWriteHold(root, reason)
+            revt.set()
+            return retn
 
         errmsg = 'Insufficient free space on disk.'
 
         with mock.patch.object(s_cell.Cell, 'FREE_SPACE_CHECK_FREQ', 0.1), \
-             mock.patch.object(s_cortex.Cortex, '_setReadOnly', wrapReadOnly):
+             mock.patch.object(s_nexus.NexsRoot, 'addWriteHold', wrapAddWriteHold), \
+             mock.patch.object(s_nexus.NexsRoot, 'delWriteHold', wrapDelWriteHold):
 
             async with self.getTestCore() as core:
 
@@ -2108,8 +2117,7 @@ class CellTest(s_t_utils.SynTest):
                     msgs = await core.stormlist('[inet:fqdn=newp.fail]')
                     self.stormIsInErr(errmsg, msgs)
 
-                    revt.clear()
-
+                revt.clear()
                 self.true(await asyncio.wait_for(revt.wait(), 1))
 
                 self.len(1, await core.nodes('[inet:fqdn=foo.com]'))
@@ -2150,6 +2158,7 @@ class CellTest(s_t_utils.SynTest):
                             self.len(0, await core01.nodes('inet:ipv4=2.3.4.5'))
                             revt.clear()
 
+                        revt.clear()
                         self.true(await asyncio.wait_for(revt.wait(), 1))
                         await core01.sync()
 
@@ -2194,10 +2203,17 @@ class CellTest(s_t_utils.SynTest):
 
         async with self.getTestCore() as core:
 
-            core.nexsroot.setReadOnly(True)
+            await core.nexsroot.addWriteHold('LOLWRITE TESTING')
 
             msgs = await core.stormlist('[inet:fqdn=newp.fail]')
-            self.stormIsInErr('Unable to issue Nexus events when readonly is set.', msgs)
+
+            self.stormIsInErr('LOLWRITE TESTING', msgs)
+
+            await core.nexsroot.delWriteHold('LOLWRITE TESTING')
+
+            core.nexsroot.readonly = True
+            with self.raises(s_exc.IsReadOnly):
+                core.nexsroot.reqNotReadOnly()
 
     async def test_cell_onboot_optimize(self):
 

synapse/tests/test_lib_certdir.py

@@ -340,6 +340,22 @@ class CertDirTest(s_t_utils.SynTest):
             inter_cakey = cdir.getCaKey(inter_name)
             self.basic_assertions(cdir, inter_cacert, inter_cakey, cacert=cacert)
 
+            # Per RFC5280 common-name has a length of 1 to 64 characters
+            # https://datatracker.ietf.org/doc/html/rfc5280#appendix-A.1
+            c64 = 'V' * 64
+            cakey64, cacert64 = cdir.genCaCert(c64)
+            self.basic_assertions(cdir, cacert64, cakey64)
+
+            c1 = 'V' * 1
+            cakey1, cacert1 = cdir.genCaCert(c1)
+            self.basic_assertions(cdir, cacert1, cakey1)
+
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genCaCert('V' * 65)
+
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genCaCert('')
+
     def test_certdir_hosts(self):
         with self.getCertDir() as cdir:
             caname = 'syntest'
@@ -557,6 +573,14 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getHostKey(hostname)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            # 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:
+                cdir.genHostCsr('V' * 65)
+
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genHostCsr('')
+
     def test_certdir_users_csr(self):
         with self.getCertDir() as cdir:
             caname = 'syntest'
@@ -580,6 +604,14 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getUserKey(username)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            # 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:
+                cdir.genUserCsr('V' * 65)
+
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genUserCsr('')
+
     def test_certdir_importfile(self):
         with self.getCertDir() as cdir:
             with self.getTestDir() as testpath:

synapse/tests/test_lib_grammar.py

@@ -717,7 +717,11 @@ Queries = [
     'inet:ipv4 <+(*)- media:news',
     'media:news -(*)+> inet:fqdn',
     'inet:ipv4 <+(*)- *',
-    'media:news -(*)+> *'
+    'media:news -(*)+> *',
+    '$foo=(null)',
+    '$foo=({"bar": null})',
+    '$p="names" ps:contact:name=foo [ :$p?+=bar ]',
+    '$p="names" ps:contact:name=foo [ :$p?-=bar ]',
 ]
 
 # Generated with print_parse_list below
@@ -1340,6 +1344,10 @@ _ParseResults = [
     'Query: [LiftProp: [Const: media:news], N1Walk: [Const: *, Const: inet:fqdn], isjoin=True]',
     'Query: [LiftProp: [Const: inet:ipv4], N2Walk: [Const: *, Const: *], isjoin=True]',
     'Query: [LiftProp: [Const: media:news], N1Walk: [Const: *, Const: *], isjoin=True]',
+    'Query: [SetVarOper: [Const: foo, DollarExpr: [Const: None]]]',
+    'Query: [SetVarOper: [Const: foo, DollarExpr: [ExprDict: [Const: bar, Const: None]]]]',
+    'Query: [SetVarOper: [Const: p, Const: names], LiftPropBy: [Const: ps:contact:name, Const: =, Const: foo], EditPropSet: [RelProp: [VarValue: [Const: p]], Const: ?+=, Const: bar]]',
+    'Query: [SetVarOper: [Const: p, Const: names], LiftPropBy: [Const: ps:contact:name, Const: =, Const: foo], EditPropSet: [RelProp: [VarValue: [Const: p]], Const: ?-=, Const: bar]]',
 ]
 
 class GrammarTest(s_t_utils.SynTest):

synapse/tests/test_lib_httpapi.py

@@ -840,7 +840,6 @@ class HttpApiTest(s_tests.SynTest):
                 spkg = {
                     'name': 'testy',
                     'version': (0, 0, 1),
-                    'synapse_minversion': [2, 144, 0],
                     'synapse_version': '>=2.50.0,<3.0.0',
                     'modules': (
                         {'name': 'testy.ingest', 'storm': 'function punch(x, y) { return (($x + $y)) }'},

synapse/tests/test_lib_jupyter.py

@@ -16,7 +16,6 @@ class TstsvcApi(s_cell.CellApi, s_stormsvc.StormSvc):
         {
             'name': 'testsvc',
             'version': (0, 0, 1),
-            'synapse_minversion': [2, 144, 0],
             'synapse_version': '>=2.8.0,<3.0.0',
             'commands': (
                 {

synapse/tests/test_lib_modelrev.py

@@ -432,3 +432,44 @@ class ModelRevTest(s_tests.SynTest):
     async def test_modelrev_0_2_23(self):
         async with self.getRegrCore('model-0.2.23') as core:
             self.len(1, await core.nodes('inet:ipv6="ff01::1" +:type=multicast +:scope=interface-local'))
+
+    async def test_modelrev_0_2_24(self):
+        async with self.getRegrCore('model-0.2.24') as core:
+
+            self.len(2, await core.nodes('transport:sea:telem:speed'))
+
+            self.len(1, await core.nodes('transport:air:telem:speed'))
+            self.len(1, await core.nodes('transport:air:telem:airspeed'))
+            self.len(1, await core.nodes('transport:air:telem:verticalspeed'))
+
+            self.len(2, await core.nodes('mat:item:_multispeed'))
+            nodes = await core.nodes('mat:item:_multispeed*[=5]')
+            self.len(1, nodes)
+            self.eq((5, 6), nodes[0].get('_multispeed'))
+
+            nodes = await core.nodes('transport:sea:telem:speed=4')
+            self.len(1, nodes)
+            self.eq(4, nodes[0].get('speed'))
+
+            nodes = await core.nodes('transport:air:telem')
+            node = nodes[0]
+            self.eq(1, node.get('speed'))
+            self.eq(2, node.get('airspeed'))
+            self.eq(3, node.get('verticalspeed'))
+
+            q = 'transport:sea:telem=(badvalu,) $node.data.load(_migrated:transport:sea:telem:speed)'
+            nodes = await core.nodes(q)
+            self.eq(-1.0, await nodes[0].getData('_migrated:transport:sea:telem:speed'))
+
+            nodes = await core.nodes('risk:mitigation=(foo,)')
+            self.len(1, nodes)
+            self.eq('foo bar', nodes[0].get('name'))
+            self.len(1, await core.nodes('risk:mitigation:name="  Foo Bar  "'))
+
+            nodes = await core.nodes('it:mitre:attack:mitigation=M0100')
+            self.len(1, nodes)
+            self.eq('patchstuff', nodes[0].get('name'))
+
+            nodes = await core.nodes('it:mitre:attack:technique=T0100')
+            self.len(1, nodes)
+            self.eq('lockpicking', nodes[0].get('name'))

synapse/tests/test_lib_nexus.py

@@ -264,3 +264,41 @@ class NexusTest(s_t_utils.SynTest):
 
             async with self.getTestCore(dirn=dirn) as core:
                 self.len(vcnt + viewadds, core.views)
+
+    async def test_mirror_version(self):
+
+        with self.getTestDir() as dirn:
+
+            s_common.yamlsave({'nexslog:en': True}, dirn, 'cell.yaml')
+            async with await s_cell.Cell.anit(dirn=dirn) as cell00:
+
+                getCellInfo = cell00.getCellInfo
+                async def getCrazyVersion():
+                    info = await getCellInfo()
+                    info['cell']['version'] = (9999, 0, 0)
+                    return info
+
+                await cell00.runBackup(name='cell01')
+
+                path = s_common.genpath(dirn, 'backups', 'cell01')
+
+                conf = s_common.yamlload(path, 'cell.yaml')
+                conf['mirror'] = f'cell://{dirn}'
+                s_common.yamlsave(conf, path, 'cell.yaml')
+
+                evnt = asyncio.Event()
+                cell00.getCellInfo = getCrazyVersion
+
+                async with await s_cell.Cell.anit(dirn=path) as cell01:
+                    addWriteHold = cell01.nexsroot.addWriteHold
+                    def wrapAddWriteHold(reason):
+                        retn = addWriteHold(reason)
+                        evnt.set()
+                        return retn
+
+                    cell01.nexsroot.addWriteHold = wrapAddWriteHold
+                    await asyncio.wait_for(evnt.wait(), timeout=3)
+
+                    with self.raises(s_exc.IsReadOnly):
+                        await cell01.sync()
+                    self.isin(s_nexus.leaderversion, cell01.nexsroot.writeholds)

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
@@ -3331,7 +3422,6 @@ class StormTest(s_t_utils.SynTest):
             otherpkg = {
                 'name': 'foosball',
                 'version': '0.0.1',
-                'synapse_minversion': [2, 144, 0],
                 'synapse_version': '>=2.8.0,<3.0.0',
                 'commands': ({
                                  'name': 'testcmd',

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))'))