synapse 2.161.0__py311-none-any.whl → 2.163.0__py311-none-any.whl

synapse/tests/test_lib_storm.py

@@ -735,9 +735,9 @@ class StormTest(s_t_utils.SynTest):
             # check that the feed API uses toprim
             email = await core.callStorm('''
                 $iden = $lib.guid()
-                $props = $lib.dict(email=visi@vertex.link)
+                $props = ({"email": "visi@vertex.link"})
                 $lib.feed.ingest(syn.nodes, (
-                    ( (ps:contact, $iden), $lib.dict(props=$props)),
+                    ( (ps:contact, $iden), ({"props": $props})),
                 ))
                 ps:contact=$iden
                 return(:email)
@@ -746,9 +746,9 @@ class StormTest(s_t_utils.SynTest):
 
             email = await core.callStorm('''
                 $iden = $lib.guid()
-                $props = $lib.dict(email=visi@vertex.link)
+                $props = ({"email": "visi@vertex.link"})
                 yield $lib.feed.genr(syn.nodes, (
-                    ( (ps:contact, $iden), $lib.dict(props=$props)),
+                    ( (ps:contact, $iden), ({"props": $props})),
                 ))
                 return(:email)
             ''')
@@ -777,7 +777,7 @@ class StormTest(s_t_utils.SynTest):
             # and again to test *not* creating it...
             self.eq(0, await core.callStorm('return($lib.queue.gen(woot).size())'))
 
-            self.eq({'foo': 'bar'}, await core.callStorm('return($lib.dict(    foo    =    bar   ))'))
+            self.eq({'foo': 'bar'}, await core.callStorm('return(({    "foo"    :    "bar"   }))'))
 
             ddef0 = await core.callStorm('return($lib.dmon.add(${ $lib.queue.gen(hehedmon).put(lolz) $lib.time.sleep(10) }, name=hehedmon))')
             ddef1 = await core.callStorm('return($lib.dmon.get($iden))', opts={'vars': {'iden': ddef0.get('iden')}})
@@ -1226,12 +1226,12 @@ class StormTest(s_t_utils.SynTest):
             await core.nodes('cron.list')
 
             self.eq({'foo': 'bar', 'baz': 'faz'}, await core.callStorm('''
-                return($lib.dict( // do foo thing
-                    foo /* hehe */ = /* haha */ bar, //lol
-                    baz // hehe
-                    = // haha
-                    faz // hehe
-                ))
+                return(({ // do foo thing
+                    "foo" /* hehe */ : /* haha */ "bar", //lol
+                    "baz" // hehe
+                    : // haha
+                    "faz" // hehe
+                }))
             '''))
 
             self.eq(('foo', 'bar', 'baz'), await core.callStorm('''
@@ -1805,7 +1805,7 @@ class StormTest(s_t_utils.SynTest):
 
             # Headers as list of tuples, params as dict
             q = '''
-            $params=$lib.dict(key=valu, foo=bar)
+            $params=({"key": "valu", "foo": "bar"})
             $hdr = (
                     ("User-Agent", "my fav ua"),
             )|
@@ -2045,7 +2045,7 @@ class StormTest(s_t_utils.SynTest):
             self.none(await core.callStorm('''
                 [ ps:contact = * ]
                 if $node {
-                    $foo = $lib.dict()
+                    $foo = ({})
                     $foo.bar = $lib.undef
                     return($foo.bar)
                 }
@@ -2064,7 +2064,7 @@ class StormTest(s_t_utils.SynTest):
             # runtsafe variants
             self.eq(('foo', 'baz'), await core.callStorm('$foo = (foo, bar, baz) $foo.1 = $lib.undef return($foo)'))
             self.eq(('foo', 'bar'), await core.callStorm('$foo = (foo, bar, baz) $foo."-1" = $lib.undef return($foo)'))
-            self.none(await core.callStorm('$foo = $lib.dict() $foo.bar = 10 $foo.bar = $lib.undef return($foo.bar)'))
+            self.none(await core.callStorm('$foo = ({}) $foo.bar = 10 $foo.bar = $lib.undef return($foo.bar)'))
             self.eq(('woot',), await core.callStorm('''
                 $foo = (foo, bar, baz)
                 $foo.0 = $lib.undef
@@ -4513,7 +4513,7 @@ class StormTest(s_t_utils.SynTest):
             visi = await core.auth.addUser('visi')
             await visi.addRule((True, ('node',)))
 
-            size, sha256 = await core.callStorm('return($lib.bytes.put($buf))', {'vars': {'buf': b'asdfasdf'}})
+            size, sha256 = await core.callStorm('return($lib.axon.put($buf))', {'vars': {'buf': b'asdfasdf'}})
 
             self.len(1, await core.nodes(f'[ file:bytes={sha256} ]'))
 

synapse/tests/test_lib_stormhttp.py

@@ -1,4 +1,5 @@
 import os
+import ssl
 import json
 import shutil
 
@@ -64,8 +65,8 @@ class StormHttpTest(s_test.SynTest):
 
             # Header and params as dict
             q = '''
-            $params=$lib.dict(key=valu, foo=bar, baz=$lib.false)
-            $hdr = $lib.dict(true=$lib.true)
+            $params=({"key": "valu", "foo": "bar", "baz": $lib.false})
+            $hdr = ({"true": $lib.true})
             $hdr."User-Agent"="Storm HTTP Stuff"
             $k = (0)
             $hdr.$k="Why"
@@ -240,7 +241,7 @@ class StormHttpTest(s_test.SynTest):
             opts = {'vars': {'url': url, 'noauth_url': noauth_url, 'newp_url': newp_url}}
 
             q = '''
-            $params=$lib.dict(key=valu, foo=bar)
+            $params=({"key": "valu", "foo": "bar"})
             $hdr = (
                     ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -256,7 +257,7 @@ class StormHttpTest(s_test.SynTest):
             self.eq('1', headers.get('Head'))
 
             q = '''
-            $params=$lib.dict(key=valu, redirect='http://test.newp/')
+            $params=({"key": "valu", "redirect": 'http://test.newp/'})
             $hdr = (
                     ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -273,7 +274,7 @@ class StormHttpTest(s_test.SynTest):
             self.eq('http://test.newp/', headers.get('Location'))
 
             q = '''
-            $params=$lib.dict(key=valu, redirect=$noauth_url)
+            $params=({"key": "valu", "redirect": $noauth_url})
             $hdr = (
                 ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -286,7 +287,7 @@ class StormHttpTest(s_test.SynTest):
             self.eq(b'', body)
 
             q = '''
-            $params=$lib.dict(key=valu, redirect=$newp_url)
+            $params=({"key": "valu", "redirect": $newp_url})
             $hdr = (
                 ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -299,7 +300,7 @@ class StormHttpTest(s_test.SynTest):
             self.eq(b'', body)
 
             q = '''
-            $params=$lib.dict(key=valu, redirect="http://127.0.0.1/newp")
+            $params=({"key": "valu", "redirect": "http://127.0.0.1/newp"})
             $hdr = (
                 ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -321,7 +322,7 @@ class StormHttpTest(s_test.SynTest):
             url = f'https://root:root@127.0.0.1:{port}/api/v0/test'
             opts = {'vars': {'url': url}}
             q = '''
-            $params=$lib.dict(key=valu, foo=bar)
+            $params=({"key": "valu", "foo": "bar"})
             $hdr = (
                     ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -337,7 +338,7 @@ class StormHttpTest(s_test.SynTest):
             url = f'https://root:root@127.0.0.1:{port}/api/v0/test'
             opts = {'vars': {'url': url, 'sleep': 1, 'timeout': 2}}
             q = '''
-            $params=$lib.dict(key=valu, foo=bar, sleep=$sleep)
+            $params=({"key": "valu", "foo": "bar", "sleep": $sleep})
             $hdr = (
                     ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -351,7 +352,7 @@ class StormHttpTest(s_test.SynTest):
             url = f'https://root:root@127.0.0.1:{port}/api/v0/test'
             opts = {'vars': {'url': url, 'sleep': 10, 'timeout': 1}}
             q = '''
-            $params=$lib.dict(key=valu, foo=bar, sleep=$sleep)
+            $params=({"key": "valu", "foo": "bar", "sleep": $sleep})
             $hdr = (
                     ("User-Agent", "Storm HTTP Stuff"),
             )
@@ -374,7 +375,7 @@ class StormHttpTest(s_test.SynTest):
 
             adduser = '''
                 $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/auth/adduser", port=$port)
-                $user = $lib.dict(name=$name, passwd=$passwd)
+                $user = ({"name": $name, "passwd": $passwd})
                 $post = $lib.inet.http.post($url, json=$user, ssl_verify=$(0)).json().result.name
                 $lib.print($post)
                 [ test:str=$post ]
@@ -387,7 +388,7 @@ class StormHttpTest(s_test.SynTest):
             adduser = '''
                 $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/auth/adduser", port=$port)
                 $user = $lib.str.format('{"name": "{name}", "passwd": "{passwd}"}', name=$name, passwd=$passwd)
-                $header = $lib.dict("Content-Type"="application/json")
+                $header = ({"Content-Type": "application/json"})
                 $post = $lib.inet.http.post($url, headers=$header, body=$user,  ssl_verify=$(0)).json().result.name
                 [ test:str=$post ]
             '''
@@ -400,7 +401,7 @@ class StormHttpTest(s_test.SynTest):
             url = f'https://root:root@127.0.0.1:{port}/api/v0/test'
             opts = {'vars': {'url': url, 'buf': b'1234'}}
             q = '''
-            $params=$lib.dict(key=valu, foo=bar)
+            $params=({"key": "valu", "foo": "bar"})
             $resp = $lib.inet.http.post($url, params=$params, body=$buf, ssl_verify=$lib.false)
             return ( $resp.json() )
             '''
@@ -411,9 +412,9 @@ class StormHttpTest(s_test.SynTest):
 
             q = '''
             $fields=$lib.list(
-                $lib.dict(name=foo, value=bar),
-                $lib.dict(name=foo, value=bar2),
-                $lib.dict(name=baz, value=cool)
+                ({"name": "foo", "value": "bar"}),
+                ({"name": "foo", "value": "bar2"}),
+                ({"name": "baz", "value": "cool"})
             )
             $resp = $lib.inet.http.post($url, fields=$fields, ssl_verify=$lib.false)
             return ( $resp.json() )
@@ -466,8 +467,8 @@ class StormHttpTest(s_test.SynTest):
             await root.setPasswd('root')
             text = '''
             $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/storm", port=$port)
-            $stormq = "($size, $sha2) = $lib.bytes.put($lib.base64.decode('dmVydGV4')) [ test:str = $sha2 ] [ test:int = $size ]"
-            $json = $lib.dict(query=$stormq)
+            $stormq = "($size, $sha2) = $lib.axon.put($lib.base64.decode('dmVydGV4')) [ test:str = $sha2 ] [ test:int = $size ]"
+            $json = ({"query": $stormq})
             $bytez = $lib.inet.http.post($url, json=$json, ssl_verify=$(0))
             '''
             opts = {'vars': {'port': port}}
@@ -482,7 +483,7 @@ class StormHttpTest(s_test.SynTest):
 
             text = '''
             $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/storm", port=$port)
-            $json = $lib.dict(query="test:str")
+            $json = ({"query": "test:str"})
             $body = $json
             $resp=$lib.inet.http.post($url, json=$json, body=$body, ssl_verify=$(0))
             return ( ($resp.code, $resp.err) )
@@ -672,3 +673,165 @@ class StormHttpTest(s_test.SynTest):
             with self.raises(s_stormctrl.StormExit) as cm:
                 await core.callStorm(query, opts=opts)
             self.isin('connect to proxy 127.0.0.1:1', str(cm.exception))
+
+    async def test_storm_http_mtls(self):
+
+        with self.getTestDir() as dirn:
+
+            cdir = s_common.gendir(dirn, 'certs')
+            cadir = s_common.gendir(cdir, 'cas')
+            tdir = s_certdir.CertDir(cdir)
+            tdir.genCaCert('somelocalca')
+            tdir.genHostCert('localhost', signas='somelocalca')
+
+            localkeyfp = tdir.getHostKeyPath('localhost')
+            localcertfp = tdir.getHostCertPath('localhost')
+            pkeypath = shutil.copyfile(localkeyfp, s_common.genpath(dirn, 'sslkey.pem'))
+            certpath = shutil.copyfile(localcertfp, s_common.genpath(dirn, 'sslcert.pem'))
+
+            tlscadir = s_common.gendir(dirn, 'cadir')
+            cacertpath = shutil.copyfile(os.path.join(cadir, 'somelocalca.crt'), os.path.join(tlscadir, 'somelocalca.crt'))
+
+            pkey, cert = tdir.genUserCert('someuser', signas='somelocalca')
+            user_pkey = tdir._pkeyToByts(pkey).decode()
+            user_cert = tdir._certToByts(cert).decode()
+
+            user_fullchain = user_cert + s_common.getbytes(cacertpath).decode()
+            user_fullchain_key = user_fullchain + user_pkey
+
+            conf = {'tls:ca:dir': tlscadir}
+            async with self.getTestCore(dirn=dirn, conf=conf) as core:
+
+                sslctx = core.initSslCtx(certpath, pkeypath)
+                sslctx.load_verify_locations(cafile=cacertpath)
+
+                addr, port = await core.addHttpsPort(0, sslctx=sslctx)
+                root = await core.auth.getUserByName('root')
+                await root.setPasswd('root')
+
+                core.addHttpApi('/api/v0/test', s_test.HttpReflector, {'cell': core})
+                core.addHttpApi('/test/ws', TstWebSock, {})
+
+                sslopts = {}
+
+                opts = {
+                    'vars': {
+                        'url': f'https://root:root@localhost:{port}/api/v0/test',
+                        'ws': f'https://localhost:{port}/test/ws',
+                        'verify': True,
+                        'sslopts': sslopts,
+                    },
+                }
+
+                q = 'return($lib.inet.http.get($url, ssl_verify=$verify, ssl_opts=$sslopts))'
+
+                size, sha256 = await core.callStorm('return($lib.bytes.put($lib.base64.decode(Zm9v)))')
+                opts['vars']['sha256'] = sha256
+
+                # mtls required
+
+                sslctx.verify_mode = ssl.CERT_REQUIRED
+
+                ## no client cert provided
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(-1, resp['code'])
+                self.isin('tlsv13 alert certificate required', resp['reason'])
+
+                ## full chain cert w/key
+                sslopts['client_cert'] = user_fullchain_key
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(200, resp['code'])
+
+                ## separate cert and key
+                sslopts['client_cert'] = user_fullchain
+                sslopts['client_key'] = user_pkey
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(200, resp['code'])
+
+                ## sslctx's are cached
+                self.len(3, core._sslctx_cache)
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(200, resp['code'])
+                self.len(3, core._sslctx_cache)
+
+                ## remaining methods
+                self.eq(200, await core.callStorm('return($lib.inet.http.post($url, ssl_opts=$sslopts).code)', opts=opts))
+                self.eq(200, await core.callStorm('return($lib.inet.http.head($url, ssl_opts=$sslopts).code)', opts=opts))
+                self.eq(200, await core.callStorm('return($lib.inet.http.request(get, $url, ssl_opts=$sslopts).code)', opts=opts))
+
+                ## connect
+                ret = await core.callStorm('''
+                    ($ok, $sock) = $lib.inet.http.connect($ws, ssl_opts=$sslopts)
+                    if (not $ok) { return(($ok, $sock)) }
+                    ($ok, $mesg) = $sock.rx()
+                    return(($ok, $mesg))
+                ''', opts=opts)
+                self.true(ret[0])
+                self.eq('woot', ret[1]['hi'])
+
+                # Axon APIs
+
+                axon_queries = {
+                    'postfile': '''
+                        $fields = ([{"name": "file", "sha256": $sha256}])
+                        return($lib.inet.http.post($url, fields=$fields, ssl_opts=$sslopts).code)
+                    ''',
+                    'wget': 'return($lib.axon.wget($url, ssl_opts=$sslopts).code)',
+                    'wput': 'return($lib.axon.wput($sha256, $url, method=POST, ssl_opts=$sslopts).code)',
+                    'urlfile': 'yield $lib.axon.urlfile($url, ssl_opts=$sslopts)',
+                }
+
+                ## version check fails
+                try:
+                    oldv = core.axoninfo['synapse']['version']
+                    core.axoninfo['synapse']['version'] = (2, 161, 0)
+                    await self.asyncraises(s_exc.BadVersion, core.callStorm(axon_queries['postfile'], opts=opts))
+                    await self.asyncraises(s_exc.BadVersion, core.callStorm(axon_queries['wget'], opts=opts))
+                    await self.asyncraises(s_exc.BadVersion, core.callStorm(axon_queries['wput'], opts=opts))
+                    await self.asyncraises(s_exc.BadVersion, core.nodes(axon_queries['urlfile'], opts=opts))
+                finally:
+                    core.axoninfo['synapse']['version'] = oldv
+
+                ## version check succeeds
+                # todo: setting the synapse version can be removed once ssl_opts is released
+                try:
+                    oldv = core.axoninfo['synapse']['version']
+                    core.axoninfo['synapse']['version'] = (oldv[0], oldv[1] + 1, oldv[2])
+                    self.eq(200, await core.callStorm(axon_queries['postfile'], opts=opts))
+                    self.eq(200, await core.callStorm(axon_queries['wget'], opts=opts))
+                    self.eq(200, await core.callStorm(axon_queries['wput'], opts=opts))
+                    self.len(1, await core.nodes(axon_queries['urlfile'], opts=opts))
+                finally:
+                    core.axoninfo['synapse']['version'] = oldv
+
+                # verify arg precedence
+
+                core.conf.pop('tls:ca:dir')
+                core._sslctx_cache.clear()
+
+                ## fail w/o ca
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(-1, resp['code'])
+                self.isin('self-signed certificate', resp['reason'])
+
+                ## verify arg wins
+                opts['vars']['verify'] = False
+                sslopts['verify'] = True
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(200, resp['code'])
+
+                # bad opts
+
+                ## schema violation
+                sslopts['newp'] = 'wut'
+                await self.asyncraises(s_exc.SchemaViolation, core.callStorm(q, opts=opts))
+                sslopts.pop('newp')
+
+                ## missing key
+                sslopts['client_cert'] = user_fullchain
+                sslopts['client_key'] = None
+                await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+                ## bad cert
+                sslopts['client_cert'] = 'not-gonna-work'
+                await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))

synapse/tests/test_lib_stormlib_auth.py

@@ -420,8 +420,8 @@ class StormLibAuthTest(s_test.SynTest):
         async with self.getTestCore() as core:
             self.none(await core.callStorm('return($lib.user.json.get(foo))'))
             self.none(await core.callStorm('return($lib.user.json.get(foo, prop=bar))'))
-            self.true(await core.callStorm('return($lib.user.json.set(hi, $lib.dict(foo=bar, baz=faz)))'))
-            self.true(await core.callStorm('return($lib.user.json.set(bye/bye, $lib.dict(zip=zop, bip=bop)))'))
+            self.true(await core.callStorm('return($lib.user.json.set(hi, ({"foo": "bar", "baz": "faz"})))'))
+            self.true(await core.callStorm('return($lib.user.json.set(bye/bye, ({"zip": "zop", "bip": "bop"})))'))
             self.eq('bar', await core.callStorm('return($lib.user.json.get(hi, prop=foo))'))
             self.eq({'foo': 'bar', 'baz': 'faz'}, await core.callStorm('return($lib.user.json.get(hi))'))
 
@@ -454,7 +454,7 @@ class StormLibAuthTest(s_test.SynTest):
                 await core.callStorm('return($lib.auth.users.byname(root).json.get(bye/bye, prop=zip))', opts=asvisi)
 
             self.none(await core.callStorm('return($lib.user.json.get(hi))', opts=asvisi))
-            await core.callStorm('if (not $lib.user.json.has(hehe)) { $lib.user.json.set(hehe, $lib.dict()) }', opts=asvisi)
+            await core.callStorm('if (not $lib.user.json.has(hehe)) { $lib.user.json.set(hehe, ({})) }', opts=asvisi)
 
             self.true(await core.callStorm('return($lib.user.json.set(hehe, haha, prop=foo))', opts=asvisi))
             self.true(await core.callStorm('return($lib.user.json.set(hehe, haha, prop=foo))', opts=asvisi))

synapse/tests/test_lib_stormlib_cell.py

@@ -187,7 +187,7 @@ class StormCellTest(s_test.SynTest):
                         }
                         $lib.exit('No view found for name={name}', name=$name)
                     }
-                    $ret = $lib.dict()
+                    $ret = ({})
                     $ret.baseview=$get_view(default)
                     $ret.fork1a=$get_view(base1a)
                     $ret.fork2a=$get_view(base2a)

synapse/tests/test_lib_stormlib_cortex.py

@@ -429,6 +429,44 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             '''
             iden3 = await core.callStorm(q)
 
+            # $lib.dict accessor methods
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.keys($api.vars))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.eq(valu, ('hehe', 'items'))
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.values($api.vars))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.eq(valu, ('wow', ('1', '2', 3)))
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.has($api.vars, anotherKey))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.false(valu)
+
+            q = '''$api=$lib.cortex.httpapi.get($iden)
+            return ($lib.dict.update($api.vars, ({"hehe": "haha", "anotherKey": "anotherValu"}) ))'''
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.none(valu)
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.has($api.vars, anotherKey))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.true(valu)
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.values($api.vars))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.eq(valu, ('haha', ('1', '2', 3), 'anotherValu'))
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.pop($api.vars, anotherKey))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.eq(valu, 'anotherValu')
+
+            q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.pop($api.vars, anotherKey, missingKey))'
+            valu = await core.callStorm(q, opts={'vars': {'iden': iden3}})
+            self.eq(valu, 'missingKey')
+
+            with self.raises(s_exc.BadArg):
+                q = '$api=$lib.cortex.httpapi.get($iden) return ($lib.dict.pop($api.vars, anotherKey))'
+                await core.callStorm(q, opts={'vars': {'iden': iden3}})
+
             msgs = await core.stormlist('cortex.httpapi.list')
             self.stormIsInPrint(f'0     {iden0}', msgs)
             self.stormIsInPrint(f'1     {iden1}', msgs)
@@ -569,7 +607,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             msgs = await core.stormlist('cortex.httpapi.stat $iden', opts={'vars': {'iden': iden3}})
             self.stormIsInPrint(f'Iden: {iden3}', msgs)
             self.stormIsInPrint('The handler has the following runtime variables set:', msgs)
-            self.stormIsInPrint('hehe             => wow', msgs)
+            self.stormIsInPrint('hehe             => haha', msgs)
             self.stormIsInPrint("items            => ('1', '2', 3)", msgs)
 
             # Remove a user + view and stat the handler
@@ -999,7 +1037,11 @@ for $i in $values {
             }
             // Cannot modify request headers
             $api.methods.post = ${
-                $request.headers.newp = haha
+                if $request.headers.dictmethod {
+                    $lib.dict.update($request.headers, ({"newp": "haha"}))
+                } else {
+                    $request.headers.newp = haha
+                }
             }
             return ( ($api.iden, $api.owner.name) )
             '''
@@ -1029,6 +1071,12 @@ for $i in $values {
                 self.eq(data.get('code'), 'StormRuntimeError')
                 self.eq(data.get('mesg'), 'http:api:request:headers may not be modified by the runtime.')
 
+                resp = await sess.post(f'https://localhost:{hport}/api/ext/testpath', headers={'dictmethod': '1'})
+                self.eq(resp.status, 500)
+                data = await resp.json()
+                self.eq(data.get('code'), 'StormRuntimeError')
+                self.eq(data.get('mesg'), 'http:api:request:headers may not be modified by the runtime.')
+
     async def test_libcortex_httpapi_vars(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_json.py

@@ -27,7 +27,7 @@ class JsonTest(s_test.SynTest):
 
             opts = {'vars': {'schema': s_test.test_schema}}
             q = '''$schemaObj = $lib.json.schema($schema)
-            $item=$lib.dict()
+            $item=({})
             $item."key:integer"=(4)
             return ( $schemaObj.validate($item) )
             '''
@@ -37,7 +37,7 @@ class JsonTest(s_test.SynTest):
             self.eq('Default string!', valu.get('key:string'))
 
             q = '''$schemaObj = $lib.json.schema($schema)
-            $item=$lib.dict()
+            $item=({})
             $item."key:integer"=4
             return ( $schemaObj.validate($item) )
             '''

synapse/tests/test_lib_stormlib_macro.py

@@ -152,7 +152,7 @@ class MacroTest(s_test.SynTest):
             self.eq([('test:str', 'cooler')], [n.ndef for n in nodes])
 
             # Inner vars win on conflict
-            q = 'macro.set data2 ${ $data=$lib.dict(value=beef) [test:str=$data.value +#cool.story] }'
+            q = 'macro.set data2 ${ $data=({"value": "beef"}) [test:str=$data.value +#cool.story] }'
             msgs = await core.stormlist(q)
             self.stormIsInPrint('Set macro: data2', msgs)