synapse 2.206.0__py311-none-any.whl → 2.208.0__py311-none-any.whl

synapse/tests/test_axon.py

@@ -19,6 +19,7 @@ import synapse.common as s_common
 import synapse.telepath as s_telepath
 
 import synapse.lib.coro as s_coro
+import synapse.lib.json as s_json
 import synapse.lib.certdir as s_certdir
 import synapse.lib.httpapi as s_httpapi
 import synapse.lib.msgpack as s_msgpack
@@ -1005,6 +1006,15 @@ bar baz",vv
             self.eq(True, resp['ok'])
             self.eq(200, resp['code'])
 
+            jsonq = f'''$resp = $lib.axon.wput($sha256, "https://127.0.0.1:{port}/api/v1/pushfile", ssl=(0))
+            return ( $lib.json.save($resp) )
+            '''
+            resp = await core.callStorm(jsonq, opts=opts)
+            self.isinstance(resp, str)
+            resp = s_json.loads(resp)
+            self.eq(True, resp['ok'])
+            self.eq(200, resp['code'])
+
             opts = {'vars': {'sha256': s_common.ehex(s_common.buid())}}
             resp = await core.callStorm(q, opts=opts)
             self.eq(False, resp['ok'])

synapse/tests/test_cortex.py

@@ -1240,7 +1240,7 @@ class CortexTest(s_t_utils.SynTest):
                     $ddef = $lib.dmon.add(${
                         $lib.print(hi)
                         $lib.warn(omg)
-                        $s = $lib.str.format('Running {t} {i}', t=$auto.type, i=$auto.iden)
+                        $s = `Running {$auto.type} {$auto.iden}`
                         $lib.log.info($s, ({"iden": $auto.iden}))
                         $que = $lib.queue.get(foo)
                         $que.put(done)
@@ -5224,7 +5224,7 @@ class CortexBasicTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.nn(nodes[0].getTag('bar'))
 
-            q = '[test:str=yop +#$lib.str.format("{first}.{last}", first=foo, last=bar)]'
+            q = '$t="{first}.{last}" [test:str=yop +#$t.format(first=foo, last=bar)]'
             nodes = await core.nodes(q)
             self.len(1, nodes)
             self.nn(nodes[0].getTag('foo.bar'))
@@ -5695,7 +5695,7 @@ class CortexBasicTest(s_t_utils.SynTest):
             self.len(1, nodes)
 
     async def test_storm_order(self):
-        q = '''[test:str=foo :hehe=bar] $tvar=() $tvar.append(1) $tvar.append(:hehe) $lib.print($lib.str.join('', $tvar)) '''
+        q = '''[test:str=foo :hehe=bar] $tvar=() $tvar.append(1) $tvar.append(:hehe) $lib.print(('').join($tvar)) '''
         async with self.getTestCore() as core:
             mesgs = await core.stormlist(q)
             self.stormIsInPrint('1bar', mesgs)
@@ -7731,7 +7731,7 @@ class CortexBasicTest(s_t_utils.SynTest):
                     $ddef = $lib.dmon.add(${
                         $lib.print(hi)
                         $lib.warn(omg)
-                        $s = $lib.str.format('Running {t} {i}', t=$auto.type, i=$auto.iden)
+                        $s = `Running {$auto.type} {$auto.iden}`
                         $lib.log.info($s, ({"iden": $auto.iden}))
                     })
                 ''')

synapse/tests/test_datamodel.py

@@ -299,7 +299,7 @@ class DataModelTest(s_t_utils.SynTest):
             syn:type:subof=comp $opts=:opts
             -> syn:form:type $valu=$node.value()
             for ($name, $thing) in $opts.fields {
-                $v=$lib.str.format('{v}:{t}', v=$valu, t=$name)  syn:prop=$v
+                $v=`{$valu}:{$name}`  syn:prop=$v
             }
             +syn:prop
             -:ro=1

synapse/tests/test_lib_ast.py

@@ -74,9 +74,9 @@ foo_stormpkg = {
             }
 
             function outer(arg1, add) {
-                $strbase = $lib.str.format("(Run: {c}) we got back ", c=$counter)
+                $strbase = `(Run: {$counter}) we got back `
                 $reti = $inner($arg1, $add)
-                $mesg = $lib.str.concat($strbase, $reti)
+                $mesg = `{$strbase}{$reti}`
                 $counter = $( $counter + $add )
                 $lib.print("foobar is {foobar}", foobar=$foobar)
                 return ($mesg)
@@ -296,7 +296,7 @@ class AstTest(s_test.SynTest):
                 $newvar=:hehe
                 -.created
                 $s.append("yar {x}", x=$newvar)
-                $lib.print($lib.str.join('', $s))
+                $lib.print(('').join($s))
             '''
             mesgs = await core.stormlist(q)
             prints = [m[1]['mesg'] for m in mesgs if m[0] == 'print']
@@ -2029,7 +2029,7 @@ class AstTest(s_test.SynTest):
             q = '$val=$lib.base64.decode("dmlzaQ==") function x(parm1=$val) { return($parm1) }'
             self.len(0, await core.nodes(q))
 
-            self.eq('foo', await core.callStorm('return($lib.str.format("{func}", func=foo))'))
+            self.eq('foo', await core.callStorm('$template="{func}" return($template.format(func=foo))'))
 
             msgs = await core.stormlist('$lib.null()')
             erfo = [m for m in msgs if m[0] == 'err'][0]
@@ -3580,7 +3580,7 @@ class AstTest(s_test.SynTest):
 
             q = '''
             init { $foo = bar }
-            init { $baz = $lib.str.format('foo={foo}', foo=$foo) }
+            init { $baz = `foo={$foo}` }
             $lib.print($baz)
             '''
             msgs = await core.stormlist(q)

synapse/tests/test_lib_boss.py

@@ -56,8 +56,8 @@ class BossTest(s_test.SynTest):
                 iden = s_common.guid()
 
                 async def double_promote():
-                    await boss.promote(f'double', root, taskiden=iden)
-                    await boss.promote(f'double', root, taskiden=iden + iden)
+                    await boss.promote('double', root, taskiden=iden)
+                    await boss.promote('double', root, taskiden=iden + iden)
 
                 coro = boss.schedCoro(double_promote())
                 self.true(await stream.wait(timeout=6))

synapse/tests/test_lib_nexus.py

@@ -385,19 +385,13 @@ class NexusTest(s_t_utils.SynTest):
         evnt = asyncio.Event()
 
         async with self.getTestCore() as core:
-            orig = core._nexshands['view:delwithlayer'][0]
-
-            async def holdlock(self, viewiden, layriden, nexsitem, newparent=None):
-                evnt.set()
-                await asyncio.sleep(1)
-                await orig(self, viewiden, layriden, nexsitem, newparent=newparent)
-
-            core._nexshands['view:delwithlayer'] = (holdlock, True)
-
             forkiden = await core.callStorm('return($lib.view.get().fork().iden)')
 
-            core.schedCoro(core.delViewWithLayer(forkiden))
-            await asyncio.wait_for(evnt.wait(), timeout=10)
+            # Remove the nexus handler for the fork's write layer to simulate a view delete/edit race
+            layriden = core.getView(forkiden).layers[0].iden
+            layr = core.nexsroot._nexskids.pop(layriden)
 
             with self.raises(s_exc.NoSuchIden):
                 await core.nodes('[ it:dev:str=foo ]', opts={'view': forkiden})
+
+            core.nexsroot._nexskids[layriden] = layr

synapse/tests/test_lib_storm.py

@@ -308,7 +308,7 @@ class StormTest(s_t_utils.SynTest):
             ''')
             self.eq('valu=12', retn)
 
-            q = "$hehe=({'k': 'v'}) $fs=$lib.str.format('{v}56', v=$hehe) return((`{$hehe}56`, $fs))"
+            q = "$hehe=({'k': 'v'}) $fs=`{$hehe}56` return((`{$hehe}56`, $fs))"
             retn = await core.callStorm(q)
             self.eq("{'k': 'v'}56", retn[0])
             self.eq(retn[0], retn[1])
@@ -322,6 +322,14 @@ class StormTest(s_t_utils.SynTest):
 
             self.eq("foo 'bar'", await core.callStorm("$foo=bar return(`foo '{$foo}'`)"))
             self.eq(r"\'''''bar'''", await core.callStorm(r"$foo=bar return(`\\'\''''{$foo}'''`)"))
+            self.eq(r"\bar", await core.callStorm(r"$foo=bar return(`\\{$foo}`)"))
+            self.eq(r"\`bar", await core.callStorm(r"$foo=bar return(`\\\`{$foo}`)"))
+            self.eq(r"\{bar", await core.callStorm(r"$foo=bar return(`\\\{{$foo}`)"))
+            self.eq(r"foo\bar", await core.callStorm(r"$foo=foo $bar=bar return(`{$foo}\\{$bar}`)"))
+            self.eq(r"foo \bar", await core.callStorm(r"$foo=foo $bar=bar return(`{$foo} \\{$bar}`)"))
+
+            with self.raises(s_exc.BadSyntax):
+                await core.callStorm(r"$foo=bar return(`\\{{$foo}`)")
 
     async def test_lib_storm_emit(self):
         async with self.getTestCore() as core:
@@ -2179,7 +2187,7 @@ class StormTest(s_t_utils.SynTest):
             [ ou:org=(cov,) ]
 
             { for $i in $lib.range(1001) {
-                $prop = $lib.str.format('_test{i}', i=$i)
+                $prop = `_test{$i}`
                 [ :$prop = $i
                   +#$prop:score = $i
                   +($i)> { ou:org=(cov,) }
@@ -2826,6 +2834,75 @@ class StormTest(s_t_utils.SynTest):
             ]
             self.eq(exp, evnts)
 
+    async def test_storm_pkg_onload_active(self):
+        pkg = {
+            'name': 'testload',
+            'version': '0.3.0',
+            'modules': (
+                {
+                    'name': 'testload',
+                    'storm': 'function x() { return((0)) }',
+                },
+            ),
+            'onload': '''
+                $lib.print(testprint)
+                $lib.warn(testwarn)
+
+                $queue = $lib.queue.gen(onload:test)
+
+                $vers = $lib.globals.get(testload:version, (0))
+                $vers = ($vers + 1)
+                $lib.globals.set(testload:version, $vers)
+                $queue.put($vers)
+            '''
+        }
+
+        with self.getTestDir() as dirn:
+            dirn00 = s_common.gendir(dirn, 'core00')
+            dirn01 = s_common.gendir(dirn, 'core01')
+
+            async with self.getTestCore(dirn=dirn00) as core00:
+
+                waiter = core00.waiter(2, 'core:pkg:onload:start', 'core:pkg:onload:complete')
+
+                await core00.addStormPkg(pkg)
+
+                events = await waiter.wait(timeout=10)
+                self.eq(events, [
+                    ('core:pkg:onload:start', {'pkg': 'testload'}),
+                    ('core:pkg:onload:complete', {'pkg': 'testload'}),
+                ])
+
+                self.eq((0, 1), await core00.callStorm('return($lib.queue.gen(onload:test).get((0), cull=(false)))'))
+
+            s_tools_backup.backup(dirn00, dirn01)
+
+            async with self.getTestCore(dirn=dirn00) as core00:
+
+                self.eq((1, 2), await core00.callStorm('return($lib.queue.gen(onload:test).get((1), cull=(false)))'))
+
+                conf01 = {'mirror': core00.getLocalUrl()}
+
+                async with self.getTestCore(dirn=dirn01, conf=conf01) as core01:
+
+                    await core01.sync()
+
+                    waiter = core01.waiter(2, 'core:pkg:onload:start', 'core:pkg:onload:complete')
+
+                    await core01.promote()
+
+                    events = await waiter.wait(timeout=10)
+                    self.eq(events, [
+                        ('core:pkg:onload:start', {'pkg': 'testload'}),
+                        ('core:pkg:onload:complete', {'pkg': 'testload'}),
+                    ])
+
+                    self.eq((2, 3), await core01.callStorm('return($lib.queue.gen(onload:test).get((2), cull=(false)))'))
+
+                await core01.waitfini()
+
+            await core00.waitfini()
+
     async def test_storm_tree(self):
 
         async with self.getTestCore() as core:
@@ -5083,7 +5160,7 @@ class StormTest(s_t_utils.SynTest):
                 batch $lib.true --size 5 ${
                     $vals=([])
                     for $n in $nodes { $vals.append($n.repr()) }
-                    $lib.print($lib.str.join(',', $vals))
+                    $lib.print((',').join($vals))
                 }
             '''
             msgs = await core.stormlist(q)
@@ -5098,7 +5175,7 @@ class StormTest(s_t_utils.SynTest):
                 batch $lib.false --size 5 {
                     $vals=([])
                     for $n in $nodes { $vals.append($n.repr()) }
-                    $lib.print($lib.str.join(',', $vals))
+                    $lib.print((',').join($vals))
                 }
             '''
             msgs = await core.stormlist(q)
@@ -5204,7 +5281,7 @@ class StormTest(s_t_utils.SynTest):
             msgs = await core.stormlist(q)
             self.stormHasNoErr(msgs)
 
-            await core.nodes('''$token=foo $lib.print(({"Authorization":$lib.str.format("Bearer {token}", token=$token)}))''')
+            await core.nodes('''$token=foo $lib.print(({"Authorization":`Bearer {$token}`}))''')
 
             q = '#rep.clearsky.dreamjob -># +syn:tag^=rep |uniq -syn:tag~=rep.clearsky'
             msgs = await core.stormlist(q)
@@ -5218,7 +5295,7 @@ class StormTest(s_t_utils.SynTest):
             msgs = await core.stormlist(q)
             self.stormIsInWarn('Failed to decode iden: [ssl://svcrs:27492?certname=root=bar]', msgs)
 
-            q = "$foo=one $bar=two $lib.print($lib.str.concat($foo, '=', $bar))"
+            q = "$foo=one $bar=two $lib.print(`{$foo}={$bar}`)"
             msgs = await core.stormlist(q)
             self.stormIsInPrint("one=two", msgs)
 

synapse/tests/test_lib_stormhttp.py

@@ -473,6 +473,19 @@ class StormHttpTest(s_test.SynTest):
             data = resp.get('result')
             self.eq(data.get('params'), {'foo': ['bar', 'baz'], 'key': ["('valu',)"]})
 
+            # headers are safe to serialize
+            q = '''
+            $headers = ({'Foo': 'Bar'})
+            $resp = $lib.inet.http.request(GET, $url, headers=$headers, ssl_verify=$lib.false)
+            return ( ($lib.json.save($resp.headers), $lib.json.save($resp.request_headers)) )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            (headers, req_headers) = resp
+            headers = s_json.loads(headers)
+            self.eq(headers.get('Content-Type'), 'application/json; charset=UTF-8')
+            req_headers = s_json.loads(req_headers)
+            self.eq(req_headers.get('Foo'), 'Bar')
+
     async def test_storm_http_post(self):
 
         async with self.getTestCore() as core:
@@ -481,7 +494,7 @@ class StormHttpTest(s_test.SynTest):
             await root.setPasswd('root')
 
             adduser = '''
-                $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/auth/adduser", port=$port)
+                $url = `https://root:root@127.0.0.1:{$port}/api/v1/auth/adduser`
                 $user = ({"name": $name, "passwd": $passwd})
                 $post = $lib.inet.http.post($url, json=$user, ssl_verify=$(0)).json().result.name
                 $lib.print($post)
@@ -493,8 +506,8 @@ class StormHttpTest(s_test.SynTest):
             self.assertIn('foo', [u.name for u in core.auth.users()])
 
             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)
+                $url = `https://root:root@127.0.0.1:{$port}/api/v1/auth/adduser`
+                $user = $lib.json.save( ({"name": $name, "passwd": $passwd}) )
                 $header = ({"Content-Type": "application/json"})
                 $post = $lib.inet.http.post($url, headers=$header, body=$user,  ssl_verify=$(0)).json().result.name
                 [ test:str=$post ]
@@ -573,7 +586,7 @@ class StormHttpTest(s_test.SynTest):
             root = await core.auth.getUserByName('root')
             await root.setPasswd('root')
             text = '''
-            $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/storm", port=$port)
+            $url = `https://root:root@127.0.0.1:{$port}/api/v1/storm`
             $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))
@@ -589,7 +602,7 @@ class StormHttpTest(s_test.SynTest):
             self.eq(nodes[0].ndef, ('test:int', 6))
 
             text = '''
-            $url = $lib.str.format("https://root:root@127.0.0.1:{port}/api/v1/storm", port=$port)
+            $url = `https://root:root@127.0.0.1:{$port}/api/v1/storm`
             $json = ({"query": "test:str"})
             $body = $json
             $resp=$lib.inet.http.post($url, json=$json, body=$body, ssl_verify=$(0))
@@ -767,7 +780,7 @@ class StormHttpTest(s_test.SynTest):
             mesg = await core.callStorm('''
                 $params = ( { "param1": "somevalu" } )
                 $hdr = ( { "key": $lib.false } )
-                $url = $lib.str.format('https://127.0.0.1:{port}/test/ws', port=$port)
+                $url = `https://127.0.0.1:{$port}/test/ws`
 
                 ($ok, $sock) = $lib.inet.http.connect($url, headers=$hdr, params=$params, ssl_verify=$lib.false)
                 if (not $ok) { $lib.exit($sock) }
@@ -783,7 +796,7 @@ class StormHttpTest(s_test.SynTest):
 
             mesg = await core.callStorm('''
                 $hdr = ( { "key": $lib.false } )
-                $url = $lib.str.format('https://127.0.0.1:{port}/test/ws', port=$port)
+                $url = `https://127.0.0.1:{$port}/test/ws`
 
                 ($ok, $sock) = $lib.inet.http.connect($url, headers=$hdr, ssl_verify=$lib.false)
                 if (not $ok) { $lib.exit($sock) }
@@ -797,7 +810,7 @@ class StormHttpTest(s_test.SynTest):
             self.none(mesg.get('params'))
 
             query = '''
-            $url = $lib.str.format('https://127.0.0.1:{port}/test/ws', port=$port)
+            $url = `https://127.0.0.1:{$port}/test/ws`
 
             ($ok, $sock) = $lib.inet.http.connect($url, proxy=$proxy, ssl_verify=$lib.false)
             if (not $ok) { $lib.exit($sock) }

synapse/tests/test_lib_stormlib_cache.py

@@ -120,12 +120,12 @@ class StormlibCacheTest(s_test.SynTest):
 
                 $rets.append($cache.get(foo))
                 $rets.append($sent)
-                $rets.append($lib.str.join(",", $vals))
+                $rets.append((',').join($vals))
 
                 $val = one
                 $rets.append($cache.get(bar))
                 $rets.append($sent)
-                $rets.append($lib.str.join(",", $vals))
+                $rets.append((',').join($vals))
 
                 return($rets)
             ''')

synapse/tests/test_lib_stormlib_scrape.py

@@ -172,7 +172,7 @@ class StormScrapeTest(s_test.SynTest):
 
             text = text + ' and then there was another 1.2.3.4 that happened at woot.com '
             query = '''$tally = $lib.stats.tally() for ($form, $ndef) in $lib.scrape.ndefs($text)
-            { $valu=$lib.str.format('{f}={n}', f=$form, n=$ndef) $tally.inc($valu) }
+            { $valu=`{$form}={$ndef}` $tally.inc($valu) }
             fini { return ( $tally ) }
             '''
             varz = {'text': text}

synapse/tests/test_lib_stormlib_storm.py

@@ -1,3 +1,5 @@
+import asyncio
+
 import synapse.exc as s_exc
 import synapse.lib.parser as s_parser
 
@@ -142,3 +144,64 @@ class LibStormTest(s_test.SynTest):
                 }
             ''')
             self.stormIsInPrint('mesg=hello', msgs)
+
+    async def test_lib_stormlib_storm_tasks(self):
+
+        with self.getStructuredAsyncLoggerStream('synapse') as stream:
+
+            async with self.getTestCore() as core:
+
+                async with core.getLocalProxy() as prox:
+
+                    event = asyncio.Event()
+
+                    q = 'for $mesg in $lib.storm.run("$lib.time.sleep(120)") { $lib.fire(storm, mesg=$mesg) }'
+
+                    async def doit():
+                        async for mesg in prox.storm(q):
+                            if mesg[0] == 'storm:fire':
+                                event.set()
+
+                    task00 = core.schedCoro(doit())
+                    await asyncio.wait_for(event.wait(), timeout=10)
+
+                    viewiden = core.getView().iden
+
+                    # One task for the main query
+                    tasks = core.boss.ps()
+                    self.len(1, tasks)
+                    self.eq(tasks[0].name, 'storm')
+                    self.eq(tasks[0].info, {'query': q, 'view': viewiden})
+                    self.len(1, tasks[0].kids)
+
+                    # The main query has one kid, the worker
+                    kid = list(tasks[0].kids.values())[0]
+                    self.nn(kid.iden)
+                    self.nn(kid.user)
+                    self.eq(kid.name, 'runstorm')
+                    self.eq(kid.info, {})
+
+                    # The worker has a kid which is the $lib.storm.run() worker
+                    self.len(1, kid.kids)
+                    gkid = list(kid.kids.values())[0]
+                    self.eq(gkid.name, 'runstorm')
+                    self.eq(gkid.info, {})
+
+                    # Kill the main task
+                    tasks = core.boss.ps()
+                    self.len(1, tasks)
+                    await tasks[0].kill()
+
+                    # No tasks running
+                    tasks = core.boss.ps()
+                    self.len(0, tasks)
+
+                    task00.cancel('oh bye')
+
+        # Verify we saw two storm runtime cancellations
+        msgs = stream.jsonlines()
+        self.gt(len(msgs), 0)
+
+        msgs = [(k.get('message'), k.get('text')) for k in msgs]
+        self.isin(('Storm runtime cancelled.', '$lib.time.sleep(120)'), msgs)
+        self.isin(('Storm runtime cancelled.', q), msgs)

synapse/tests/test_lib_stormsvc.py

@@ -347,6 +347,9 @@ class StormvarServiceCell(s_cell.Cell):
                 'bar': {
                     'type': 'string',
                 },
+                'name': {
+                    'type': 'string',
+                },
             },
             'required': ['name', ],
             'additionalProperties': False,

synapse/tests/test_lib_stormtypes.py

@@ -156,7 +156,7 @@ class StormTypesTest(s_test.SynTest):
                 await core.callStorm(q, opts=opts)
 
             # Push a handful of notifications and list a subset of them
-            q = '''$m=$lib.str.format('hello {i}', i=$i) return($lib.auth.users.byname(root).tell($m))'''
+            q = '''$m=`hello {$i}` return($lib.auth.users.byname(root).tell($m))'''
             for i in range(5):
                 opts = {'user': visi.iden, 'vars': {'i': i}}
                 await core.callStorm(q, opts=opts)
@@ -1071,7 +1071,7 @@ class StormTypesTest(s_test.SynTest):
             # exec vars do not populate upwards
             q = '''
             $foo = "that is one neato burrito"
-            $baz = ${ $bar=$lib.str.concat(wompwomp, $lib.guid()) $lib.print("in exec") }
+            $baz = ${ $bar=`wompwomp{$lib.guid()}` $lib.print("in exec") }
             $baz.exec()
             $lib.print("post exec {bar}", bar=$bar)
             [ test:str=$foo ]
@@ -1283,6 +1283,8 @@ class StormTypesTest(s_test.SynTest):
 
     async def test_storm_lib_str(self):
         async with self.getTestCore() as core:
+
+            # TODO $lib.str.concat and rmat are deprecated should be removed in 3.0.0
             q = '$v=vertex $l=link $fqdn=$lib.str.concat($v, ".", $l)' \
                 ' [ inet:email=$lib.str.format("visi@{domain}", domain=$fqdn) ]'
             nodes = await core.nodes(q)
@@ -1310,7 +1312,7 @@ class StormTypesTest(s_test.SynTest):
             sobj = s_stormtypes.Str('beepbeep')
             self.len(8, sobj)
 
-            nodes = await core.nodes('$s = (foo, bar, baz) [ test:str=$lib.str.join(".", $s) ]')
+            nodes = await core.nodes("$s = (foo, bar, baz) [ test:str=('.').join($s) ]")
             self.eq('foo.bar.baz', nodes[0].ndef[1])
 
             nodes = await core.nodes('$s = foo-bar-baz [ test:str=$s.replace("-", ".") ]')
@@ -1406,6 +1408,14 @@ class StormTypesTest(s_test.SynTest):
 
             self.eq(((1, 2, 3)), await core.callStorm('return(("[1, 2, 3]").json())'))
 
+            self.eq('hehe,haha', await core.callStorm("$sepr=',' $l=(hehe, haha) return( $sepr.join($l) )"))
+            self.eq('hehehaha', await core.callStorm("$sepr='' $l=(hehe, haha) return( $sepr.join($l) )"))
+            self.eq('a|++|b|++|c', await core.callStorm("$sepr='|++|' $l=(a, b, c) return( $sepr.join($l) )"))
+            self.eq('hehe,haha', await core.callStorm("$l=(hehe, haha) return( (',').join($l) )"))
+            self.eq('hehehaha', await core.callStorm("$l=(hehe, haha) return( ('').join($l) )"))
+            self.eq('', await core.callStorm("$sepr=',' $l=() return( $sepr.join($l) )"))
+            self.eq('', await core.callStorm("$sepr='' $l=() return( $sepr.join($l) )"))
+
             with self.raises(s_exc.BadJsonText):
                 await core.callStorm('return(("foo").json())')
 
@@ -1752,7 +1762,7 @@ class StormTypesTest(s_test.SynTest):
             $ipv4 = $node.repr()
             $loc = $node.repr(loc)
             $latlong = $node.repr(latlong, defv="??")
-            $valu = $lib.str.format("{ipv4} in {loc} at {latlong}", ipv4=$ipv4, loc=$loc, latlong=$latlong)
+            $valu = `{$ipv4} in {$loc} at {$latlong}`
             [ test:str=$valu ]
             +test:str
         '''
@@ -2454,7 +2464,7 @@ class StormTypesTest(s_test.SynTest):
                     self.stormIsInPrint('pop valu is 0', mesgs)
 
                     listq = '''for ($key, $valu) in $lib.globals.list() {
-                    $string = $lib.str.format("{key} is {valu}", key=$key, valu=$valu)
+                    $string = `{$key} is {$valu}`
                     $lib.print($string)
                     }
                     '''
@@ -2498,7 +2508,7 @@ class StormTypesTest(s_test.SynTest):
                     self.len(1, await core.nodes('test:str=hehe'))
 
                     listq = '''for ($key, $valu) in $lib.user.vars.list() {
-                        $string = $lib.str.format("{key} is {valu}", key=$key, valu=$valu)
+                        $string = `{$key} is {$valu}`
                         $lib.print($string)
                     }
                     '''
@@ -2571,7 +2581,7 @@ class StormTypesTest(s_test.SynTest):
                     # core.vars, they only get the values they can read.
                     corelistq = '''
                     for ($key, $valu) in $lib.globals.list() {
-                        $string = $lib.str.format("{key} is {valu}", key=$key, valu=$valu)
+                        $string = `{$key} is {$valu}`
                         $lib.print($string)
                     }
                     '''
@@ -2726,6 +2736,21 @@ class StormTypesTest(s_test.SynTest):
             self.false(valu[0])
             self.eq(valu[1]['err'], 'BadArg')
 
+            query = '''$valu="2020-10-01 01:30:00"
+            $parsed=$lib.time.parse($valu, "%Y-%m-%d %H:%M:%S")
+            $lib.print($lib.time.toUTC($parsed, US/Eastern))
+            '''
+            mesgs = await core.stormlist(query)
+            self.stormIsInPrint('1601530200000', mesgs)
+
+            query = '''$valu="2020-11-01 01:30:00"
+            $parsed=$lib.time.parse($valu, "%Y-%m-%d %H:%M:%S")
+            return($lib.time.toUTC($parsed, America/New_York))
+            '''
+            mesgs = await core.callStorm(query)
+            self.false(mesgs[0])
+            self.isin('Ambiguous time', mesgs[1]['errinfo']['mesg'])
+
     async def test_storm_lib_time_ticker(self):
 
         async with self.getTestCore() as core:
@@ -4919,7 +4944,7 @@ class StormTypesTest(s_test.SynTest):
                 unixtime = datetime.datetime(year=2018, month=12, day=5, hour=7, minute=10,
                                              tzinfo=tz.utc).timestamp()
 
-                q = '{$lib.queue.get(foo).put(m3) $s=$lib.str.format("m3 {t} {i}", t=$auto.type, i=$auto.iden) $lib.log.info($s, ({"iden": $auto.iden})) }'
+                q = '{$lib.queue.get(foo).put(m3) $s=`m3 {$auto.type} {$auto.iden}` $lib.log.info($s, ({"iden": $auto.iden})) }'
                 text = f'cron.add --minute 17 {q}'
                 async with getCronJob(text) as guid:
                     with self.getStructuredAsyncLoggerStream('synapse.storm.log', 'm3 cron') as stream:
@@ -6049,6 +6074,16 @@ class StormTypesTest(s_test.SynTest):
             self.eq({'d', 'c'}, ret)
 
             # str join
+            ret = await core.callStorm('$x=(foo,bar,baz) $y=("-").join($x) return($y)')
+            self.eq('foo-bar-baz', ret)
+
+            ret = await core.callStorm('$y=("-").join((foo, bar, baz)) return($y)')
+            self.eq('foo-bar-baz', ret)
+
+            ret = await core.callStorm('$x=abcd $y=("-").join($x) return($y)')
+            self.eq('a-b-c-d', ret)
+
+            # TODO $lib.str.join is deprecated and will be removed in 3.0.0
             ret = await core.callStorm('$x=(foo,bar,baz) $y=$lib.str.join("-", $x) return($y)')
             self.eq('foo-bar-baz', ret)
 
@@ -6069,7 +6104,7 @@ class StormTypesTest(s_test.SynTest):
 
             opts = {'user': visi.iden, 'vars': {'port': port}}
             wget = '''
-               $url = $lib.str.format("https://visi:secret@127.0.0.1:{port}/api/v1/healthcheck", port=$port)
+               $url = `https://visi:secret@127.0.0.1:{$port}/api/v1/healthcheck`
                return($lib.axon.wget($url, ssl=$lib.false))
            '''
             with self.raises(s_exc.AuthDeny):

synapse/tests/test_lib_trigger.py

@@ -141,8 +141,7 @@ class TrigTest(s_t_utils.SynTest):
             view = core.view
 
             # node:add case
-            q = '''$s=$lib.str.format("f={f} v={v}", f=$auto.opts.form, v=$auto.opts.valu) $lib.log.info($s)
-                    [ test:guid="*" +#nodeadd]'''
+            q = '$s=`f={$auto.opts.form} v={$auto.opts.valu}` $lib.log.info($s) [ test:guid="*" +#nodeadd]'
             tdef = {'cond': 'node:add', 'form': 'test:str', 'storm': q}
             await view.addTrigger(tdef)
             with self.getAsyncLoggerStream('synapse.storm.log', 'f=') as stream:
@@ -206,7 +205,7 @@ class TrigTest(s_t_utils.SynTest):
             self.len(0, await core.nodes('test:int=5'))
 
             # Prop set
-            q = '''$s=$lib.str.format("pf={f} pn={n}", f=$auto.opts.propfull, n=$auto.opts.propname) $lib.log.info($s)
+            q = '''$s=`pf={$auto.opts.propfull} pn={$auto.opts.propname}` $lib.log.info($s)
             [ test:guid="*" +#propset ]'''
             tdef = {'cond': 'prop:set',
                     'storm': q,
@@ -246,7 +245,7 @@ class TrigTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('test:int#withiden'))
 
             # iden embedded in vars
-            q = '+test:str~=log $s=$lib.str.format("test {t} {i}", t=$auto.type, i=$auto.iden) $lib.log.info($s, ({"iden": $auto.iden}))'
+            q = '+test:str~=log $s=`test {$auto.type} {$auto.iden}` $lib.log.info($s, ({"iden": $auto.iden}))'
             tdef = {'cond': 'node:add', 'form': 'test:str', 'storm': q}
             await view.addTrigger(tdef)
             with self.getStructuredAsyncLoggerStream('synapse.storm.log', 'test trigger') as stream: