synapse 2.207.0__py311-none-any.whl → 2.209.0__py311-none-any.whl

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_rstorm.py

@@ -119,7 +119,7 @@ clear_storm_opts = '''
 .. storm-cortex:: default
 .. storm-opts:: {"vars": {"foobar": "bar"}}
 .. storm-clear-http:: true
-.. storm:: $lib.print($lib.str.concat($foobar, "bizboz"))
+.. storm:: $lib.print(`{$foobar}bizboz`)
 '''
 
 stormenv = '''
@@ -381,8 +381,9 @@ class RStormLibTest(s_test.SynTest):
             path = s_common.genpath(dirn, 'clear_storm_opts.rst')
             with s_common.genfile(path) as fd:
                 fd.write(clear_storm_opts.encode())
-            with self.raises(s_exc.StormRuntimeError):
-                text = await get_rst_text(path)
+            with self.raises(s_exc.StormRuntimeError) as cm:
+                await get_rst_text(path)
+            self.eq('Missing variable: foobar', cm.exception.get('mesg'))
 
             # boom1 test
             path = s_common.genpath(dirn, 'boom1.rst')

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

@@ -494,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)
@@ -506,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 ]
@@ -586,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))
@@ -602,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))
@@ -780,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) }
@@ -796,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) }
@@ -810,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("-", ".") ]')
@@ -1760,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
         '''
@@ -2462,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)
                     }
                     '''
@@ -2506,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)
                     }
                     '''
@@ -2579,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)
                     }
                     '''
@@ -2734,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:
@@ -3785,7 +3802,6 @@ class StormTypesTest(s_test.SynTest):
         async with self.getTestCore() as core:
             async with self.getTestCore() as core2:
 
-                await core2.nodes('[ inet:ipv4=1.2.3.4 ]')
                 url = core2.getLocalUrl('*/layer')
 
                 layriden = core2.view.layers[0].iden
@@ -3802,8 +3818,141 @@ class StormTypesTest(s_test.SynTest):
 
                 layr = core.getLayer(uplayr)
 
-                evnt = await layr.waitUpstreamOffs(layriden, offs)
-                self.true(await asyncio.wait_for(evnt.wait(), timeout=6))
+                async def query(q):
+                    '''
+                    Run a query on core2 and wait for it to sync to layr from core
+                    '''
+                    nodes = await core2.nodes(q)
+                    offs = await core2.view.layers[0].getEditIndx()
+                    evnt = await layr.waitUpstreamOffs(layriden, offs)
+                    self.true(await asyncio.wait_for(evnt.wait(), timeout=6))
+                    return nodes
+
+                vdef = {
+                    'layers': [layr.iden]
+                }
+
+                view00 = await core.addView(vdef)
+                self.nn(view00)
+
+                # No foobar in core
+                opts = {'view': view00.get('iden')}
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(0, nodes)
+
+                # Add foobar in core2
+                nodes = await query('[ it:dev:str=foobar ]')
+                self.len(1, nodes)
+
+                # foobar shows up in core
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(1, nodes)
+
+                self.len(1, layr.activetasks)
+
+                # The upstream key only accepts null
+                q = f'layer.set {uplayr} upstream (true)'
+                msgs = await core.stormlist(q)
+                self.stormIsInErr('Layer only supports setting "mirror" and "upstream" to null.', msgs)
+
+                with self.raises(s_exc.BadOptValu) as exc:
+                    await layr.setLayerInfo('upstream', False)
+                self.eq(exc.exception.get('mesg'), 'Layer only supports setting "mirror" and "upstream" to None.', msgs)
+
+                # Now remove the upstream configuration
+                q = f'layer.set {uplayr} upstream (null)'
+                msgs = await core.stormlist(q)
+                self.stormHasNoWarnErr(msgs)
+
+                layr = core.getLayer(uplayr)
+                self.len(0, layr.activetasks)
+                self.none(layr.layrinfo.get('upstream'))
+
+                with self.raises(TimeoutError):
+                    await query('[ it:dev:str=newp ]')
+
+                # No newp in core because layer upstream is disabled
+                nodes = await core.nodes('it:dev:str=newp', opts=opts)
+                self.len(0, nodes)
+
+    async def test_storm_lib_layer_mirror(self):
+        async with self.getTestCore() as core:
+            async with self.getTestCore() as core2:
+
+                url = core2.getLocalUrl('*/layer')
+
+                layers = set(core.layers.keys())
+                q = f'layer.add --mirror {url}'
+                mesgs = await core.stormlist(q)
+                uplayr = list(set(core.layers.keys()) - layers)[0]
+
+                q = f'layer.set {uplayr} name "woot woot"'
+                mesgs = await core.stormlist(q)
+                self.stormIsInPrint('(name: woot woot)', mesgs)
+
+                layr = core.getLayer(uplayr)
+
+                async def query(q):
+                    '''
+                    Run a query on core2 and wait for it to sync to layr from core
+                    '''
+                    nodes = await core2.nodes(q)
+                    offs = await core2.view.layers[0].getEditOffs()
+                    self.true(await layr.waitEditOffs(offs, timeout=10))
+                    return nodes
+
+                vdef = {
+                    'layers': [layr.iden]
+                }
+
+                view00 = await core.addView(vdef)
+                self.nn(view00)
+
+                # No foobar in core
+                opts = {'view': view00.get('iden')}
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(0, nodes)
+
+                # Add foobar in core2
+                nodes = await query('[ it:dev:str=foobar ]')
+                self.len(1, nodes)
+
+                # foobar shows up in core
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(1, nodes)
+
+                self.true(layr.ismirror)
+                self.nn(layr.leadtask)
+                self.nn(layr.leader)
+                self.len(0, layr.activetasks)
+
+                # The mirror key only accepts null
+                q = f'layer.set {uplayr} mirror (true)'
+                msgs = await core.stormlist(q)
+                self.stormIsInErr('Layer only supports setting "mirror" and "upstream" to null.', msgs)
+
+                with self.raises(s_exc.BadOptValu) as exc:
+                    await layr.setLayerInfo('mirror', False)
+                self.eq(exc.exception.get('mesg'), 'Layer only supports setting "mirror" and "upstream" to None.', msgs)
+
+                # Now remove the mirror configuration
+                q = f'layer.set {uplayr} mirror (null)'
+                msgs = await core.stormlist(q)
+                self.stormHasNoWarnErr(msgs)
+
+                layr = core.getLayer(uplayr)
+                self.none(layr.layrinfo.get('mirror'))
+                self.none(layr.leadtask)
+                self.none(layr.leader)
+                self.false(layr.ismirror)
+
+                # Add newp in core2
+                nodes = await query('[ it:dev:str=newp ]')
+                self.len(1, nodes)
+
+                # No newp in core because layer mirroring is disabled
+                nodes = await core.nodes('it:dev:str=newp', opts=opts)
+                self.len(0, nodes)
 
     async def test_storm_lib_view(self):
 
@@ -4927,7 +5076,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:
@@ -6057,6 +6206,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)
 
@@ -6077,7 +6236,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):