synapse 2.202.0__py311-none-any.whl → 2.204.0__py311-none-any.whl

synapse/tests/test_lib_json.py

@@ -0,0 +1,219 @@
+import io
+import json
+
+import orjson
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+
+import synapse.lib.json as s_json
+
+import synapse.tests.utils as s_test
+
+class JsonTest(s_test.SynTest):
+
+    async def test_lib_json_loads(self):
+        self.eq({'a': 'b'}, s_json.loads('{"a": "b"}'))
+
+        with self.raises(s_exc.BadJsonText) as exc:
+            s_json.loads('newp')
+        self.eq(exc.exception.get('mesg'), 'Expecting value: line 1 column 1 (char 0)')
+
+    async def test_lib_json_load(self):
+        with self.getTestDir() as dirn:
+
+            with s_common.genfile(dirn, 'file00') as file00:
+                file00.write(b'{"a": "b"}')
+
+            with s_common.genfile(dirn, 'file00') as file00:
+                self.eq({'a': 'b'}, s_json.load(file00))
+
+            with s_common.genfile(dirn, 'empty') as empty:
+                with self.raises(s_exc.BadJsonText) as exc:
+                    s_json.load(empty)
+                self.eq(exc.exception.get('mesg'), 'Expecting value: line 1 column 1 (char 0)')
+
+            buf = io.BytesIO(b'{"a": "b"}')
+            self.eq({'a': 'b'}, s_json.load(buf))
+
+            buf = io.StringIO('{"a": "b"}')
+            self.eq({'a': 'b'}, s_json.load(buf))
+
+    async def test_lib_json_load_surrogates(self):
+
+        inval = '{"a": "😀\ud83d\ude47"}'
+        outval = {'a': '😀\ud83d\ude47'}
+
+        # orjson.dumps fails because of the surrogate pairs
+        with self.raises(orjson.JSONDecodeError):
+            orjson.loads(inval)
+
+        # stdlib json.loads passes because of voodoo magic
+        self.eq(outval, json.loads(inval))
+
+        self.eq(outval, s_json.loads(inval))
+
+        buf = io.StringIO(inval)
+        self.eq(outval, s_json.load(buf))
+
+        buf = io.BytesIO(inval.encode('utf8', errors='surrogatepass'))
+        self.eq(outval, s_json.load(buf))
+
+    async def test_lib_json_dump_surrogates(self):
+        inval = {'a': '😀\ud83d\ude47'}
+        outval = b'{"a": "\\ud83d\\ude00\\ud83d\\ude47"}'
+
+        # orjson.dumps fails because of the surrogate pairs
+        with self.raises(TypeError):
+            orjson.dumps(inval)
+
+        # stdlib json.dumps passes because of voodoo magic
+        self.eq(outval.decode(), json.dumps(inval))
+
+        self.eq(outval, s_json.dumps(inval))
+        self.eq(outval + b'\n', s_json.dumps(inval, newline=True))
+
+        buf = io.BytesIO()
+        s_json.dump(inval, buf)
+        self.eq(outval, buf.getvalue())
+
+    async def test_lib_json_dumps(self):
+        self.eq(b'{"c":"d","a":"b"}', s_json.dumps({'c': 'd', 'a': 'b'}))
+        self.eq(b'{"a":"b","c":"d"}', s_json.dumps({'c': 'd', 'a': 'b'}, sort_keys=True))
+        self.eq(b'{\n  "c": "d",\n  "a": "b"\n}', s_json.dumps({'c': 'd', 'a': 'b'}, indent=True))
+        self.eq(b'{"c":"d","a":"b"}\n', s_json.dumps({'c': 'd', 'a': 'b'}, newline=True))
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.dumps({}.items())
+        self.eq(exc.exception.get('mesg'), 'Type is not JSON serializable: dict_items')
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.dumps({1: 'foo'})
+        self.eq(exc.exception.get('mesg'), 'Dict key must be str')
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.dumps({'\ud83d\ude47': {}.items()})
+        self.eq(exc.exception.get('mesg'), 'Object of type dict_items is not JSON serializable')
+
+        self.eq(b'"dict_items([])"', s_json.dumps({}.items(), default=str))
+
+    async def test_lib_json_dump(self):
+        with self.getTestDir() as dirn:
+            binfn = s_common.genpath(dirn, 'bin.json')
+
+            with open(binfn, 'wb') as binfp:
+                s_json.dump({'c': 'd', 'a': 'b'}, binfp)
+
+            with open(binfn, 'rb') as binfp:
+                self.eq(b'{"c":"d","a":"b"}', binfp.read())
+
+        buf = io.BytesIO()
+        s_json.dump({'c': 'd', 'a': 'b'}, buf)
+        self.eq(b'{"c":"d","a":"b"}', buf.getvalue())
+
+    async def test_jsload(self):
+        with self.getTestDir() as dirn:
+            with s_common.genfile(dirn, 'jsload.json') as fp:
+                fp.write(b'{"a":"b"}')
+
+            obj = s_json.jsload(dirn, 'jsload.json')
+            self.eq({'a': 'b'}, obj)
+
+            s_common.genfile(dirn, 'empty.json').close()
+            self.none(s_json.jsload(dirn, 'empty.json'))
+
+    async def test_jslines(self):
+        with self.getTestDir() as dirn:
+            with s_common.genfile(dirn, 'jslines.json') as fp:
+                fp.write(b'{"a":"b"}\n{"c":"d"}')
+
+            objs = [k for k in s_json.jslines(dirn, 'jslines.json')]
+            self.len(2, objs)
+            self.eq([{'a': 'b'}, {'c': 'd'}], objs)
+
+    async def test_jssave(self):
+        with self.getTestDir() as dirn:
+            s_json.jssave({'a': 'b'}, dirn, 'jssave.json')
+
+            with s_common.genfile(dirn, 'jssave.json') as fd:
+                data = fd.read()
+
+            self.eq(data, b'{\n  "a": "b"\n}')
+
+    async def test_lib_json_reqjsonsafe(self):
+        self.none(s_json.reqjsonsafe('foo'))
+        self.none(s_json.reqjsonsafe({'foo': 'bar'}))
+        self.none(s_json.reqjsonsafe(['foo', 'bar']))
+
+        buf = io.BytesIO()
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe(buf)
+        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe({'foo': buf})
+        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe(['foo', buf])
+        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+
+        items = (
+            (None, None),
+            (1234, None),
+            ('1234', None),
+            ({'asdf': 'haha'}, None),
+            ({'a': (1,), 'b': [{'': 4}, 56, None, {'t': True, 'f': False}, 'oh my']}, None),
+            (b'1234', s_exc.MustBeJsonSafe),
+            ({'a': 'a', 2: 2}, s_exc.MustBeJsonSafe),
+            ({'a', 'b', 'c'}, s_exc.MustBeJsonSafe),
+            (s_common.novalu, s_exc.MustBeJsonSafe),
+        )
+        for (item, eret) in items:
+            if eret is None:
+                self.none(s_json.reqjsonsafe(item))
+            else:
+                with self.raises(eret):
+                    s_json.reqjsonsafe(item)
+
+        text = '😀\ud83d\ude47'
+        s_json.reqjsonsafe(text)
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe(text, strict=True)
+        self.eq(exc.exception.get('mesg'), 'str is not valid UTF-8: surrogates not allowed')
+
+    async def test_lib_json_data_at_rest(self):
+        async with self.getRegrCore('json-data') as core:
+            badjson = {
+                1: 'foo',
+                'foo': '😀\ud83d\ude47',
+            }
+
+            goodjson = {
+                '1': 'foo',
+                'foo': '😀',
+            }
+
+            # We can lift nodes with bad :data
+            nodes = await core.nodes('it:log:event')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('data'), badjson)
+
+            iden = nodes[0].iden()
+
+            # We can't lift nodes with bad data by querying the prop directly
+            opts = {'vars': {'data': badjson}}
+            with self.raises(s_exc.BadTypeValu):
+                await core.callStorm('it:log:event:data=$data', opts=opts)
+
+            # We can't set nodes with bad data
+            with self.raises(s_exc.BadTypeValu):
+                await core.callStorm('[ it:log:event=* :data=$data ]', opts=opts)
+
+            # We can overwrite bad :data props
+            opts = {'vars': {'data': goodjson}}
+            nodes = await core.nodes('it:log:event:data [ :data=$data ]', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].iden(), iden)
+            self.eq(nodes[0].get('data'), goodjson)

synapse/tests/test_lib_multislabseqn.py

@@ -5,6 +5,7 @@ import synapse.exc as s_exc
 import synapse.common as s_common
 
 import synapse.lib.coro as s_coro
+import synapse.lib.json as s_json
 import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.lib.multislabseqn as s_multislabseqn
 
@@ -314,7 +315,7 @@ class MultiSlabSeqn(s_t_utils.SynTest):
             # Make a slab a non-dir
             slab0dirn = s_common.genpath(baddirn, f'seqn{"0" * 16}.lmdb')
             shutil.rmtree(slab0dirn)
-            s_common.jssave('{}', slab0dirn)
+            s_json.jssave('{}', slab0dirn)
 
             with self.getAsyncLoggerStream('synapse.lib.multislabseqn', 'non-directory') as stream:
                 async with await s_multislabseqn.MultiSlabSeqn.anit(baddirn) as msqn:

synapse/tests/test_lib_node.py

@@ -1,9 +1,9 @@
-import json
 import collections
 
 import synapse.exc as s_exc
 import synapse.common as s_common
 
+import synapse.lib.json as s_json
 import synapse.lib.node as s_node
 
 import synapse.tests.utils as s_t_utils
@@ -220,7 +220,7 @@ class NodeTest(s_t_utils.SynTest):
                     async for byts, x in resp.content.iter_chunks():
                         if not byts:
                             break
-                        mesg = json.loads(byts)
+                        mesg = s_json.loads(byts)
                         if mesg[0] == 'node':
                             https_nodes.append(mesg[1])
 

synapse/tests/test_lib_scrape.py

@@ -1187,3 +1187,53 @@ class ScrapeTest(s_t_utils.SynTest):
         nodes.remove(('it:sec:cpe', 'cpe:2.3:*:*why*:*:*:*:*:*:*:*:*:*'))
 
         self.len(0, nodes)
+
+    def test_scrape_uris(self):
+
+        nodes = list(s_scrape.scrape('http://vertex.link https://woot.com'))
+        self.len(4, nodes)
+        self.isin(('inet:url', 'http://vertex.link'), nodes)
+        self.isin(('inet:url', 'https://woot.com'), nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)
+
+        nodes = list(s_scrape.scrape('ftps://files.vertex.link tcp://1.2.3.4:8080'))
+        self.len(5, nodes)
+        self.isin(('inet:url', 'ftps://files.vertex.link'), nodes)
+        self.isin(('inet:url', 'tcp://1.2.3.4:8080'), nodes)
+        self.isin(('inet:fqdn', 'files.vertex.link'), nodes)
+        self.isin(('inet:ipv4', '1.2.3.4'), nodes)
+        self.isin(('inet:server', '1.2.3.4:8080'), nodes)
+
+        nodes = list(s_scrape.scrape('invalidscheme://vertex.link newp://woot.com'))
+        self.len(2, nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)
+
+        nodes = list(s_scrape.scrape('[https://vertex.link] (http://woot.com)'))
+        self.len(4, nodes)
+        self.isin(('inet:url', 'https://vertex.link'), nodes)
+        self.isin(('inet:url', 'http://woot.com'), nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)
+
+        nodes = list(s_scrape.scrape('HTTP://vertex.link HTTPS://woot.com'))
+        self.len(4, nodes)
+        self.isin(('inet:url', 'HTTP://vertex.link'), nodes)
+        self.isin(('inet:url', 'HTTPS://woot.com'), nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)
+
+        nodes = list(s_scrape.scrape('hxxps://vertex[.]link hXXp://woot[.]com'))
+        self.len(4, nodes)
+        self.isin(('inet:url', 'https://vertex.link'), nodes)
+        self.isin(('inet:url', 'http://woot.com'), nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)
+
+        nodes = list(s_scrape.scrape('hxxp[:]//vertex(.)link hXXps[://]woot[.]com'))
+        self.len(4, nodes)
+        self.isin(('inet:url', 'http://vertex.link'), nodes)
+        self.isin(('inet:url', 'https://woot.com'), nodes)
+        self.isin(('inet:fqdn', 'vertex.link'), nodes)
+        self.isin(('inet:fqdn', 'woot.com'), nodes)

synapse/tests/test_lib_storm.py

@@ -1,5 +1,4 @@
 import copy
-import json
 import asyncio
 import datetime
 import itertools
@@ -13,6 +12,7 @@ import synapse.datamodel as s_datamodel
 
 import synapse.lib.base as s_base
 import synapse.lib.coro as s_coro
+import synapse.lib.json as s_json
 import synapse.lib.storm as s_storm
 import synapse.lib.httpapi as s_httpapi
 import synapse.lib.msgpack as s_msgpack
@@ -2388,7 +2388,7 @@ class StormTest(s_t_utils.SynTest):
             async for bytz in core.axon.get(s_common.uhex(sha)):
                 buf += bytz
 
-            resp = json.loads(buf.decode('utf8'))
+            resp = s_json.loads(buf)
             return resp
 
         async with self.getTestCore() as core:
@@ -3657,9 +3657,9 @@ class StormTest(s_t_utils.SynTest):
             orig = s_storm.ParallelCmd.pipeline
             tsks = {'cnt': 0}
 
-            async def pipecnt(self, runt, query, inq, outq):
+            async def pipecnt(self, runt, query, inq, outq, runtprims):
                 tsks['cnt'] += 1
-                await orig(self, runt, query, inq, outq)
+                await orig(self, runt, query, inq, outq, runtprims)
 
             with mock.patch('synapse.lib.storm.ParallelCmd.pipeline', pipecnt):
 
@@ -3689,6 +3689,34 @@ class StormTest(s_t_utils.SynTest):
                 self.len(4, nodes)
                 self.eq(4, tsks['cnt'])
 
+            self.len(20, await core.nodes('for $i in $lib.range(20) {[ test:str=$i ]}'))
+            q = '''
+            test:str
+            parallel --size 4 {
+                if (not $lib.vars.get(vals)) {
+                    $vals = ()
+                }
+                $vals.append($node.repr())
+                fini { $lib.fire(resu, vals=$vals) }
+            }
+            | spin
+            '''
+            vals = []
+            msgs = await core.stormlist(q)
+            for m in msgs:
+                if m[0] == 'storm:fire':
+                    vals.extend(m[1]['data']['vals'])
+
+            self.len(20, vals)
+
+            q = '''
+            $vals = ()
+            test:str
+            parallel --size 4 { $vals.append($node.repr()) }
+            fini { return($vals) }
+            '''
+            self.len(20, await core.callStorm(q))
+
     async def test_storm_yieldvalu(self):
 
         async with self.getTestCore() as core:
@@ -4223,15 +4251,15 @@ class StormTest(s_t_utils.SynTest):
             self.stormIsInPrint('$lib.auth                     : A Storm Library for interacting with Auth in the '
                                 'Cortex.',
                                 msgs)
-            self.stormIsInPrint('$lib.import(name, debug=$lib.false, reqvers=$lib.null)\nImport a Storm module.',
+            self.stormIsInPrint('$lib.import(name, debug=(false), reqvers=(null))\nImport a Storm module.',
                                 msgs)
             self.stormIsInPrint('$lib.debug\nTrue if the current runtime has debugging enabled.', msgs)
             self.stormNotInPrint('Examples', msgs)
 
             msgs = await core.stormlist('help -v $lib')
 
-            self.stormIsInPrint('$lib.import(name, debug=$lib.false, reqvers=$lib.null)\n'
-                                '======================================================\n'
+            self.stormIsInPrint('$lib.import(name, debug=(false), reqvers=(null))\n'
+                                '================================================\n'
                                 'Import a Storm module.', msgs)
 
             msgs = await core.stormlist('help $lib.macro')
@@ -4256,7 +4284,7 @@ class StormTest(s_t_utils.SynTest):
                                 'Regex flag to indicate that multiline matches are allowed.', msgs)
 
             msgs = await core.stormlist('help $lib.inet.http.get')
-            self.stormIsInPrint('$lib.inet.http.get(url, headers=$lib.null', msgs)
+            self.stormIsInPrint('$lib.inet.http.get(url, headers=(null)', msgs)
             self.stormIsInPrint('Get the contents of a given URL.', msgs)
 
             msgs = await core.stormlist('$str=hehe help $str.split')

synapse/tests/test_lib_stormhttp.py

@@ -1,11 +1,11 @@
 import os
 import ssl
-import json
 import shutil
 
 import synapse.exc as s_exc
 import synapse.common as s_common
 
+import synapse.lib.json as s_json
 import synapse.lib.certdir as s_certdir
 import synapse.lib.httpapi as s_httpapi
 import synapse.lib.stormctrl as s_stormctrl
@@ -32,11 +32,11 @@ class TstWebSock(s_httpapi.WebSocket):
         await self.sendJsonMesg(resp)
 
     async def on_message(self, byts):
-        mesg = json.loads(byts)
+        mesg = s_json.loads(byts)
         await self.sendJsonMesg(('echo', mesg), binary=True)
 
     async def sendJsonMesg(self, item, binary=False):
-        byts = json.dumps(item)
+        byts = s_json.dumps(item)
         await self.write_message(byts, binary=binary)
 
 class HttpNotJson(s_httpapi.Handler):
@@ -539,7 +539,7 @@ class StormHttpTest(s_test.SynTest):
             return($lib.inet.http.post($url, ssl_verify=$lib.false, fields=$fields))
             '''
             resp = await core.callStorm(q, opts=opts)
-            request = json.loads(resp.get('body'))
+            request = s_json.loads(resp.get('body'))
             request_headers = request.get('result').get('headers')
             self.isin('multipart/form-data; boundary=', request_headers.get('Content-Type', ''))
 

synapse/tests/test_lib_stormlib_auth.py

@@ -1,9 +1,10 @@
-import json
 import asyncio
 
 import synapse.exc as s_exc
 import synapse.common as s_common
 
+import synapse.lib.json as s_json
+
 import synapse.tests.utils as s_test
 
 visishow = '''
@@ -961,7 +962,7 @@ class StormLibAuthTest(s_test.SynTest):
             '''
             retn = await core.callStorm(q)
             self.eq(retn[0], retn[1])
-            self.eq(json.loads(retn[0]), {'hehe': 'haha', 'd': {'foo': 'bar'}})
+            self.eq(s_json.loads(retn[0]), {'hehe': 'haha', 'd': {'foo': 'bar'}})
 
             q = '''$u=$lib.auth.users.byname(puser) $profile=$u.profile
             for $valu in $profile {

synapse/tests/test_lib_stormlib_cortex.py

@@ -1,11 +1,9 @@
-import json
-
 import unittest.mock as mock
 
-import aiohttp
-
-import synapse.common as s_common
 import synapse.exc as s_exc
+import synapse.common as s_common
+
+import synapse.lib.json as s_json
 
 import synapse.tests.utils as s_test
 
@@ -141,7 +139,7 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                 resp = await sess.head(f'https://localhost:{hport}/api/ext/testpath00')
                 self.eq(resp.status, 206)
                 self.eq(resp.headers.get('Secret-Header'), 'Head')
-                self.eq(resp.headers.get('Content-Length'), '14')
+                self.eq(resp.headers.get('Content-Length'), '13')
                 # HEAD had no body in its response
                 self.eq(await resp.read(), b'')
 
@@ -804,12 +802,12 @@ $request.reply(200, headers=$headers, body=$body)
                 resp = await sess.get(f'https://localhost:{hport}/api/ext/raw')
                 self.eq(resp.status, 200)
                 self.eq(resp.headers.get('Content-Type'), 'application/json')
-                self.eq(resp.headers.get('Content-Length'), '12')
+                self.eq(resp.headers.get('Content-Length'), '11')
                 self.eq(resp.headers.get('Secret-Header'), 'OhBoy!')
 
                 buf = await resp.read()
-                self.len(12, buf)
-                self.eq(json.loads(buf), {'oh': 'my'})
+                self.len(11, buf)
+                self.eq(s_json.loads(buf), {'oh': 'my'})
 
     async def test_libcortex_httpapi_jsonlines(self):
         async with self.getTestCore() as core:
@@ -851,8 +849,8 @@ for $i in $values {
                             break
 
                         try:
-                            mesg = json.loads(byts)
-                        except json.JSONDecodeError:
+                            mesg = s_json.loads(byts)
+                        except s_exc.BadJsonText:
                             bufr = jstr
                             break
                         else:
@@ -1357,7 +1355,7 @@ for $i in $values {
                     self.eq(resp.status, 500)
                     data = await resp.json()
                     self.eq(data.get('code'), 'StormRuntimeError')
-                    self.isin('Failed to decode request body as JSON: Expecting value', data.get('mesg'))
+                    self.isin('Failed to decode request body as JSON', data.get('mesg'))
 
     async def test_cortex_httpapi_dynamic(self):
 

synapse/tests/test_lib_stormlib_infosec.py

@@ -1,7 +1,6 @@
-import json
-
 import synapse.exc as s_exc
 
+import synapse.lib.json as s_json
 import synapse.lib.time as s_time
 import synapse.lib.msgpack as s_msgpack
 
@@ -505,7 +504,7 @@ class InfoSecTest(s_test.SynTest):
 
     async def test_stormlib_infosec_attack_flow(self):
 
-        flow = json.loads(s_test_files.getAssetStr('attack_flow/CISA AA22-138B VMWare Workspace (Alt).json'))
+        flow = s_json.loads(s_test_files.getAssetStr('attack_flow/CISA AA22-138B VMWare Workspace (Alt).json'))
         async with self.getTestCore() as core:
             opts = {'vars': {'flow': flow}}
             msgs = await core.stormlist('$lib.infosec.mitre.attack.flow.ingest($flow)', opts=opts)

synapse/tests/test_lib_stormlib_json.py

@@ -1,3 +1,5 @@
+import textwrap
+
 import synapse.exc as s_exc
 
 import synapse.lib.stormlib.json as s_json
@@ -11,27 +13,22 @@ class JsonTest(s_test.SynTest):
         async with self.getTestCore() as core:
 
             self.eq(((1, 2, 3)), await core.callStorm('return($lib.json.load("[1, 2, 3]"))'))
-            self.eq(('["foo", "bar", "baz"]'), await core.callStorm('return($lib.json.save((foo, bar, baz)))'))
-            self.eq(('{"foo": 1, "bar": {"baz": "hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}})))'))
-            self.eq(('{"foo": 1, "bar": {"baz": "hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), (null)))'))
-            self.eq((
-'''{
-    "foo": 1,
-    "bar": {
-        "baz": "hello"
-    }
-}'''), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(4)))'))
-
-            self.eq((
-'''{
-  "foo": 1,
-  "bar": {
-    "baz": "hello"
-  }
-}'''), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=2))'))
-
-            with self.raises(s_exc.BadCast):
-                await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=x))')
+            self.eq(('["foo","bar","baz"]'), await core.callStorm('return($lib.json.save((foo, bar, baz)))'))
+            self.eq(('{"foo":1,"bar":{"baz":"hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}})))'))
+            self.eq(('{"foo":1,"bar":{"baz":"hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), (null)))'))
+
+            expected = textwrap.dedent('''\
+                {
+                  "foo": 1,
+                  "bar": {
+                    "baz": "hello"
+                  }
+                }'''
+            )
+            self.eq(expected, await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(1)))'))
+            self.eq(expected, await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(2)))'))
+            self.eq(expected, await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(4)))'))
+            self.eq(expected, await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(true)))'))
 
             with self.raises(s_exc.BadJsonText):
                 await core.callStorm('return($lib.json.load(foo))')

synapse/tests/test_lib_stormlib_log.py

@@ -43,7 +43,7 @@ class LogTest(s_test.SynTest):
                 await core.callStorm('$lib.log.debug("debug message", extra=(foo, bar, baz))')
 
             # structlog test
-            with self.getStructuredAsyncLoggerStream(logname, '"key": "valu"') as stream:
+            with self.getStructuredAsyncLoggerStream(logname, '"key":"valu"') as stream:
                 await core.callStorm('$lib.log.debug("struct1 message")')
                 await core.callStorm('$lib.log.debug("struct2 message", extra=({"key": "valu"}))')
                 self.true(await stream.wait(6))