synapse 2.180.0__py311-none-any.whl → 2.181.0__py311-none-any.whl

synapse/tests/test_lib_slabseqn.py

@@ -27,12 +27,13 @@ class SlabSeqn(s_t_utils.SynTest):
 
             self.eq(seqn.nextindx(), 0)
             items = ('foo', 10, 20)
-            seqn.save(items)
+            await seqn.save(items)
             retn = tuple(seqn.iter(0))
             self.eq(retn, ((0, 'foo'), (1, 10), (2, 20)))
             self.chk_size(seqn)
 
-            self.raises(s_exc.NotMsgpackSafe, seqn.save, ({'set'},))
+            with self.raises(s_exc.NotMsgpackSafe):
+                await seqn.save(({'set'},))
             retn = tuple(seqn.iter(0))
             self.eq(retn, ((0, 'foo'), (1, 10), (2, 20)))
 
@@ -48,7 +49,7 @@ class SlabSeqn(s_t_utils.SynTest):
             self.chk_size(seqn)
 
             self.eq(seqn.nextindx(), 3)
-            seqn.save(items)
+            await seqn.save(items)
 
             retn = tuple(seqn.iter(0))
             self.eq(retn, ((0, 'foo'), (1, 10), (2, 20),
@@ -70,7 +71,7 @@ class SlabSeqn(s_t_utils.SynTest):
             evnt2 = seqn.getOffsetEvent(9)
             evnt3 = seqn.getOffsetEvent(8)
 
-            seqn.save(items)
+            await seqn.save(items)
             retn = tuple(seqn.iter(0))
             self.len(9, retn)
             self.chk_size(seqn)

synapse/tests/test_lib_snap.py

@@ -438,6 +438,10 @@ class SnapTest(s_t_utils.SynTest):
 
             self.len(1, await view0.nodes('[ test:int=10 +#woot:score=40 ]'))
 
+            self.len(1, await view0.nodes('[ test:int=20 +#woot:score=10 ]'))
+            self.len(1, await view1.nodes('[ test:int=20 +#foo:score=10 ]'))
+            self.len(2, await view1.nodes('#woot:score'))
+
     async def test_cortex_lift_layers_ordering(self):
 
         async with self._getTestCoreMultiLayer() as (view0, view1):

synapse/tests/test_lib_storm.py

@@ -23,6 +23,77 @@ import synapse.tools.backup as s_tools_backup
 
 class StormTest(s_t_utils.SynTest):
 
+    async def test_lib_storm_guidctor(self):
+        async with self.getTestCore() as core:
+
+            nodes00 = await core.nodes('[ ou:org=({"name": "vertex"}) ]')
+            self.len(1, nodes00)
+            self.eq('vertex', nodes00[0].get('name'))
+
+            nodes01 = await core.nodes('[ ou:org=({"name": "vertex"}) :names+="the vertex project"]')
+            self.len(1, nodes01)
+            self.eq('vertex', nodes01[0].get('name'))
+            self.eq(nodes00[0].ndef, nodes01[0].ndef)
+
+            nodes02 = await core.nodes('[ ou:org=({"name": "the vertex project"}) ]')
+            self.len(1, nodes02)
+            self.eq('vertex', nodes02[0].get('name'))
+            self.eq(nodes01[0].ndef, nodes02[0].ndef)
+
+            nodes03 = await core.nodes('[ ou:org=({"name": "vertex", "type": "woot"}) :names+="the vertex project" ]')
+            self.len(1, nodes03)
+            self.ne(nodes02[0].ndef, nodes03[0].ndef)
+
+            nodes04 = await core.nodes('[ ou:org=({"name": "the vertex project", "type": "woot"}) ]')
+            self.len(1, nodes04)
+            self.eq(nodes03[0].ndef, nodes04[0].ndef)
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('[ ou:org=({"hq": "woot"}) ]')
+
+            msgs = await core.stormlist('[ ou:org=({"hq": "woot", "$try": true}) ]')
+            self.len(0, [m for m in msgs if m[0] == 'node'])
+            self.stormIsInWarn('Bad value for prop hq: valu is not a guid', msgs)
+
+            nodes05 = await core.nodes('[ ou:org=({"name": "vertex", "$props": {"motto": "for the people"}}) ]')
+            self.len(1, nodes05)
+            self.eq('vertex', nodes05[0].get('name'))
+            self.eq('for the people', nodes05[0].get('motto'))
+            self.eq(nodes00[0].ndef, nodes05[0].ndef)
+
+            nodes06 = await core.nodes('[ ou:org=({"name": "acme", "$props": {"motto": "HURR DURR"}}) ]')
+            self.len(1, nodes06)
+            self.eq('acme', nodes06[0].get('name'))
+            self.eq('hurr durr', nodes06[0].get('motto'))
+            self.ne(nodes00[0].ndef, nodes06[0].ndef)
+
+            goals = [s_common.guid(), s_common.guid()]
+            goals.sort()
+
+            nodes07 = await core.nodes('[ ou:org=({"name": "goal driven", "goals": $goals}) ]', opts={'vars': {'goals': goals}})
+            self.len(1, nodes07)
+            self.eq(goals, nodes07[0].get('goals'))
+
+            nodes08 = await core.nodes('[ ou:org=({"name": "goal driven", "goals": $goals}) ]', opts={'vars': {'goals': goals}})
+            self.len(1, nodes08)
+            self.eq(goals, nodes08[0].get('goals'))
+            self.eq(nodes07[0].ndef, nodes08[0].ndef)
+
+            nodes09 = await core.nodes('[ ou:org=({"name": "vertex"}) :name=foobar :names=() ]')
+            nodes10 = await core.nodes('[ ou:org=({"name": "vertex"}) :type=lulz ]')
+            self.len(1, nodes09)
+            self.len(1, nodes10)
+            self.ne(nodes09[0].ndef, nodes10[0].ndef)
+
+            await core.nodes('[ ou:org=* :type=lulz ]')
+            await core.nodes('[ ou:org=* :type=hehe ]')
+            nodes11 = await core.nodes('[ ou:org=({"name": "vertex", "$props": {"type": "lulz"}}) ]')
+            self.len(1, nodes11)
+
+            nodes12 = await core.nodes('[ ou:org=({"name": "vertex", "type": "hehe"}) ]')
+            self.len(1, nodes12)
+            self.ne(nodes11[0].ndef, nodes12[0].ndef)
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 
@@ -3700,7 +3771,7 @@ class StormTest(s_t_utils.SynTest):
             msgs = await core.stormlist('help view')
             self.stormIsInPrint('Storm api for a View instance', msgs)
             self.stormIsInPrint('view.merge', msgs)
-            self.stormNotInPrint('uniq', msgs)
+            self.stormNotInPrint('tee', msgs)
 
             msgs = await core.stormlist('help newp')
             self.stormIsInPrint('No commands found matching "newp"', msgs)

synapse/tests/test_lib_stormhttp.py

@@ -61,7 +61,36 @@ class StormHttpTest(s_test.SynTest):
             core.addHttpApi('/api/v0/notjson', HttpNotJson, {'cell': core})
             core.addHttpApi('/api/v0/badjson', HttpBadJson, {'cell': core})
             url = f'https://root:root@127.0.0.1:{port}/api/v0/test'
-            opts = {'vars': {'url': url}}
+            status_url = f'https://127.0.0.1:{port}/api/v1/status'
+            opts = {'vars': {'url': url, 'port': port, 'status_url': status_url}}
+
+            # Request URL is exposed
+            q = '''
+            $resp = $lib.inet.http.get($url, ssl_verify=$lib.false)
+            return ( $resp.url )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            # The password is omitted
+            self.eq(resp, f'https://127.0.0.1:{port}/api/v0/test')
+
+            # Redirects expose the final URL
+            q = '''
+            $params = ({'redirect': $status_url})
+            $resp = $lib.inet.http.get($url, params=$params, ssl_verify=$lib.false)
+            return ( $resp.url )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            self.eq(resp, f'https://127.0.0.1:{port}/api/v1/status')
+
+            q = '''
+            $_url = `https://root:root@127.0.0.1:{($port + (1))}/api/v0/newp`
+            $resp = $lib.inet.http.get($_url, ssl_verify=$lib.false)
+            if ( $resp.code != (-1) ) { $lib.exit(mesg='Test fail!') }
+            return ( $resp.url )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            # The password is present
+            self.eq(resp, f'https://root:root@127.0.0.1:{port + 1}/api/v0/newp')
 
             # Header and params as dict
             q = '''
@@ -106,6 +135,17 @@ class StormHttpTest(s_test.SynTest):
             resp = await core.callStorm(q, opts=opts)
             self.eq(resp, 'application/json; charset=UTF-8')
 
+            # Request headers
+            q = '''
+            $headers = ({"Wow": "OhMy"})
+            $resp = $lib.inet.http.get($url, headers=$headers, ssl_verify=$lib.false)
+            return ( $resp.request_headers )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            self.eq(resp.get('Wow'), 'OhMy')
+            # Authorization header derived from the basic auth in $url
+            self.isin('Authorization', resp)
+
             badurl = f'https://root:root@127.0.0.1:{port}/api/v0/notjson'
             badopts = {'vars': {'url': badurl}}
             q = '''
@@ -175,6 +215,64 @@ class StormHttpTest(s_test.SynTest):
             retn = await core.callStorm('return($lib.inet.http.codereason(123))')
             self.eq(retn, 'Unknown HTTP status code 123')
 
+            # Request history is preserved across multiple redirects.
+            q = '''$api = $lib.cortex.httpapi.add(dyn00)
+            $api.methods.get =  ${
+                $api = $request.api
+                if $n {
+                    $part = `redir0{$n}`
+                    $redir = `/api/ext/{$part}`
+                    $headers = ({"Location": $redir})
+                    $api.vars.n = ($n - (1) )
+                    $api.path = $part
+                    $request.reply(301, headers=$headers)
+                } else {
+                    $api.vars.n = $initial_n
+                    $api.path = dyn00
+                    $request.reply(200, body=({"end": "youMadeIt"}) )
+                }
+            }
+            $api.authenticated = (false)
+            $api.vars.initial_n = (3)
+            $api.vars.n = (3)
+            return ( ($api.iden) )'''
+            iden00 = await core.callStorm(q)
+
+            q = '''
+            $url = `https://127.0.0.1:{$port}/api/ext/dyn00`
+            $resp = $lib.inet.http.get($url, ssl_verify=$lib.false)
+            return ( $resp )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            self.eq(resp.get('url'), f'https://127.0.0.1:{port}/api/ext/redir01')
+            self.eq([hnfo.get('url') for hnfo in resp.get('history')],
+                    [f'https://127.0.0.1:{port}/api/ext/dyn00',
+                     f'https://127.0.0.1:{port}/api/ext/redir03',
+                     f'https://127.0.0.1:{port}/api/ext/redir02',
+                     ])
+
+            # The gtor returns a list of objects
+            q = '''
+            $url = `https://127.0.0.1:{$port}/api/ext/dyn00`
+            $resp = $lib.inet.http.get($url, ssl_verify=$lib.false)
+            return ( $resp.history.0 )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            self.eq(resp.get('url'), f'https://127.0.0.1:{port}/api/ext/dyn00')
+
+            # The history is not available if there is a fatal error when
+            # following redirects.
+            q = '''
+            $_url = `https://127.0.0.1:{($port + (1))}/api/v0/newp`
+            $params = ({'redirect': $_url})
+            $resp = $lib.inet.http.get($url, params=$params, ssl_verify=$lib.false)
+            if ( $resp.code != (-1) ) { $lib.exit(mesg='Test fail!') }
+            return ( $resp.history )
+            '''
+            resp = await core.callStorm(q, opts=opts)
+            self.isinstance(resp, tuple)
+            self.len(0, resp)
+
     async def test_storm_http_inject_ca(self):
 
         with self.getTestDir() as dirn:

synapse/tests/test_lib_stormlib_cortex.py

@@ -9,8 +9,6 @@ import synapse.exc as s_exc
 
 import synapse.tests.utils as s_test
 
-from pprint import pprint
-
 class CortexLibTest(s_test.SynTest):
 
     async def test_libcortex_httpapi_methods(self):
@@ -63,11 +61,16 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             '''
             testpath00 = await core.callStorm(q)
 
+            iden = s_common.guid()
             q = '''
-            $api = $lib.cortex.httpapi.add(nomeths)
+            $api = $lib.cortex.httpapi.add(nomeths, iden=$iden)
             return ( $api.iden )
             '''
-            nomeths = await core.callStorm(q)
+            nomeths = await core.callStorm(q, opts={'vars': {'iden': iden}})
+            self.eq(iden, nomeths)
+
+            adef = await core.getHttpExtApi(iden)
+            self.nn(adef)
 
             info = await core.callStorm('return( $lib.cortex.httpapi.get($iden).pack() )',
                                         opts={'vars': {'iden': testpath00}})
@@ -89,6 +92,20 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                 q = '$api = $lib.cortex.httpapi.get($iden) $api.methods.wildycustomverb = ${}'
                 await core.callStorm(q, opts={'vars': {'iden': testpath00}})
 
+            with self.raises(s_exc.DupIden):
+                q = '''
+                $api = $lib.cortex.httpapi.add(duplicate, iden=$iden)
+                return ( $api.iden )
+                '''
+                await core.callStorm(q, opts={'vars': {'iden': iden}})
+
+            with self.raises(s_exc.SchemaViolation):
+                q = '''
+                $api = $lib.cortex.httpapi.add(duplicate, iden="trollolololol")
+                return ( $api.iden )
+                '''
+                await core.callStorm(q, opts={'vars': {'iden': iden}})
+
             async with self.getHttpSess(auth=('root', 'root'), port=hport) as sess:  # type: aiohttp.ClientSession
                 resp = await sess.get(f'https://localhost:{hport}/api/ext/testpath00')
                 self.eq(resp.status, 200)

synapse/tests/test_lib_stormlib_iters.py

@@ -109,8 +109,11 @@ class StormLibItersTest(s_test.SynTest):
                     }
                     '''
                     msgs = await core.stormlist(q)
-                    err = "$lib.iters.zip() encountered errors in 3 iterators during iteration: " \
-                          "(foo: bar), " \
-                          "(NoSuchVar: Missing variable: newp), " \
-                          "(NameError: name 'newp' is not defined)"
-                    self.stormIsInErr(err, msgs)
+                    errs = (
+                        "$lib.iters.zip() encountered errors in 3 iterators during iteration: ",
+                        "(foo: bar)",
+                        "(NoSuchVar: Missing variable: newp)",
+                        "(NameError: name 'newp' is not defined)",
+                    )
+                    for errchunk in errs:
+                        self.stormIsInErr(errchunk, msgs)

synapse/tests/test_lib_stormlib_model.py

@@ -403,9 +403,48 @@ class StormlibModelTest(s_test.SynTest):
             q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyTags($n, $node) }'
             await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))
 
+            with self.raises(s_exc.NoSuchProp) as exc:
+                await core.callStorm('$lib.model.migration.liftByPropValuNoNorm(formname, propname, valu)')
+            self.eq(exc.exception.get('mesg'), 'Could not find prop: formname:propname')
+
+            with self.raises(s_exc.AuthDeny) as exc:
+                await core.callStorm('$lib.model.migration.liftByPropValuNoNorm(it:prod:soft, cpe, valu)')
+            self.eq(exc.exception.get('mesg'), '$lib.model.migration.liftByPropValuNoNorm() is restricted to model migrations only.')
+
+            with self.raises(s_exc.BadArg) as exc:
+                await core.callStorm('$lib.model.migration.setNodePropValuNoNorm(notanode, propname, valu)')
+            self.eq(exc.exception.get('mesg'), '$lib.model.migration.setNodePropValuNoNorm() argument must be a node.')
+
+            with self.raises(s_exc.AuthDeny) as exc:
+                await core.callStorm('test:str $lib.model.migration.setNodePropValuNoNorm($node, propname, valu)')
+            self.eq(exc.exception.get('mesg'), '$lib.model.migration.setNodePropValuNoNorm() is restricted to model migrations only.')
+
+            # copy extended properties
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyExtProps($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyExtProps(newp, $node)'))
+
+            await core.addFormProp('test:str', '_foo', ('str', {}), {})
+
+            srciden = s_common.guid()
+            dstiden = s_common.guid()
+
+            opts = {'vars': {'srciden': srciden, 'dstiden': dstiden}}
+            await core.callStorm('''
+                [ test:str=$srciden :_foo=foobarbaz ]
+                $n=$node -> {
+                    [ test:str=$dstiden ]
+                    $lib.model.migration.copyExtProps($n, $node)
+                }
+            ''', opts=opts)
+
+            nodes = await core.nodes('test:str=$dstiden', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('_foo'), 'foobarbaz')
+
     async def test_model_migration_s_itSecCpe_2_170_0(self):
 
-        async with self.getRegrCore('itSecCpe_2_170_0') as core:
+        async with self.getRegrCore('itSecCpe_2_170_0', maxvers=(0, 2, 27)) as core:
             # Migrate it:sec:cpe nodes with a valid CPE2.3, valid CPE2.2
             q = 'it:sec:cpe +#test.cpe.23valid +#test.cpe.22valid'
             nodes = await core.nodes(q)
@@ -436,7 +475,7 @@ class StormlibModelTest(s_test.SynTest):
             self.eq(data['status'], 'success')
             self.none(data.get('reason'))
 
-        async with self.getRegrCore('itSecCpe_2_170_0') as core:
+        async with self.getRegrCore('itSecCpe_2_170_0', maxvers=(0, 2, 27)) as core:
             # Migrate it:sec:cpe nodes with a valid CPE2.3, invalid CPE2.2
             q = '''
             it:sec:cpe +#test.cpe.23valid +#test.cpe.22invalid
@@ -512,7 +551,7 @@ class StormlibModelTest(s_test.SynTest):
             self.eq(nodes[0].get('v2_2'), 'cpe:/o:zyxel:nas542_firmware:5.21%28aazf.15%29co')
             self.eq(nodes[0].get('version'), '5.21(aazf.15)co')
 
-        async with self.getRegrCore('itSecCpe_2_170_0') as core:
+        async with self.getRegrCore('itSecCpe_2_170_0', maxvers=(0, 2, 27)) as core:
             # Migrate it:sec:cpe nodes with a invalid CPE2.3, valid CPE2.2
             q = '''
             it:sec:cpe +#test.cpe.23invalid +#test.cpe.22valid
@@ -573,7 +612,7 @@ class StormlibModelTest(s_test.SynTest):
             self.eq(data['valu'], 'cpe:2.3:o:zyxel:nas326_firmware:5.21\\(aazf.14\\)c0:*:*:*:*:*:*:*')
             self.eq(nodes[3].get('version'), '5.21(aazf.14)c0')
 
-        async with self.getRegrCore('itSecCpe_2_170_0') as core:
+        async with self.getRegrCore('itSecCpe_2_170_0', maxvers=(0, 2, 27)) as core:
             # Migrate it:sec:cpe nodes with a invalid CPE2.3, invalid CPE2.2
             q = '''
             it:sec:cpe +#test.cpe.23invalid +#test.cpe.22invalid
@@ -639,7 +678,7 @@ class StormlibModelTest(s_test.SynTest):
             $lib.model.migration.s.itSecCpe_2_170_0($node)
             '''
             msgs = await core.stormlist(q)
-            self.stormIsInPrint(f'DEBUG: itSecCpe_2_170_0(it:sec:cpe=cpe:2.3:a:openbsd:openssh:8.2p1 ubuntu-4ubuntu0.2:*:*:*:*:*:*:*): Node already migrated.', msgs)
+            self.stormIsInPrint('DEBUG: itSecCpe_2_170_0(it:sec:cpe=cpe:2.3:a:openbsd:openssh:8.2p1 ubuntu-4ubuntu0.2:*:*:*:*:*:*:*): Node already migrated.', msgs)
 
             q = '''
             it:sec:cpe:version^=8.2p1
@@ -647,7 +686,7 @@ class StormlibModelTest(s_test.SynTest):
             $lib.model.migration.s.itSecCpe_2_170_0($node, force=$lib.true)
             '''
             msgs = await core.stormlist(q)
-            self.stormIsInPrint(f'DEBUG: itSecCpe_2_170_0(it:sec:cpe=cpe:2.3:a:openbsd:openssh:8.2p1 ubuntu-4ubuntu0.2:*:*:*:*:*:*:*): No property updates required.', msgs)
+            self.stormIsInPrint('DEBUG: itSecCpe_2_170_0(it:sec:cpe=cpe:2.3:a:openbsd:openssh:8.2p1 ubuntu-4ubuntu0.2:*:*:*:*:*:*:*): No property updates required.', msgs)
 
         async with self.getTestCore() as core:
             with self.raises(s_exc.BadArg):

synapse/tests/test_lib_stormtypes.py

@@ -1657,6 +1657,25 @@ class StormTypesTest(s_test.SynTest):
             with self.raises(s_exc.StormRuntimeError):
                 await core.callStorm('$lib.list().pop()')
 
+            somelist = ["foo", "bar", "baz", "bar"]
+            q = '''
+                $l.rem("bar")
+                $l.rem("newp")
+                return($l)
+            '''
+            opts = {'vars': {'l': somelist.copy()}}
+            out = await core.callStorm(q, opts=opts)
+            self.eq(out, ["foo", "baz", "bar"])
+
+            somelist = ["foo", "bar", "baz", "bar"]
+            q = '''
+                $l.rem("bar", all=$lib.true)
+                return($l)
+            '''
+            opts = {'vars': {'l': somelist.copy()}}
+            out = await core.callStorm(q, opts=opts)
+            self.eq(out, ["foo", "baz"])
+
     async def test_storm_layer_getstornode(self):
 
         async with self.getTestCore() as core:
@@ -5638,6 +5657,143 @@ class StormTypesTest(s_test.SynTest):
                 q = 'return($lib.layer.get().getTagPropCount(foo, newp, valu=2))'
                 await core.callStorm(q)
 
+    async def test_stormtypes_prop_uniq_values(self):
+        async with self.getTestCore() as core:
+
+            layr1vals = [
+                'a' * 512 + 'a',
+                'a' * 512 + 'a',
+                'a' * 512 + 'c',
+                'a' * 512 + 'c',
+                'c' * 512,
+                'c' * 512,
+                'c',
+                'c'
+            ]
+            opts = {'vars': {'vals': layr1vals}}
+            await core.nodes('for $val in $vals {[ it:dev:str=$val .seen=2020 ]}', opts=opts)
+            await core.nodes('for $val in $vals {[ ou:org=* :name=$val .seen=2021]}', opts=opts)
+
+            layr2vals = [
+                'a' * 512 + 'a',
+                'a' * 512 + 'a',
+                'a' * 512 + 'b',
+                'a' * 512 + 'b',
+                'b' * 512,
+                'b' * 512,
+                'b',
+                'b'
+            ]
+            forkview = await core.callStorm('return($lib.view.get().fork().iden)')
+            opts = {'view': forkview, 'vars': {'vals': layr2vals}}
+            await core.nodes('for $val in $vals {[ it:dev:str=$val .seen=2020]}', opts=opts)
+            await core.nodes('for $val in $vals {[ ou:org=* :name=$val .seen=2023]}', opts=opts)
+
+            viewq = '''
+            $vals = ([])
+            for $valu in $lib.view.get().getPropValues($prop) {
+                $vals.append($valu)
+            }
+            return($vals)
+            '''
+
+            layrq = '''
+            $vals = ([])
+            for $valu in $lib.layer.get().getPropValues($prop) {
+                $vals.append($valu)
+            }
+            return($vals)
+            '''
+
+            # Values come out in index order which is not necessarily value order
+            opts = {'vars': {'prop': 'it:dev:str'}}
+            uniqvals = list(set(layr1vals))
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            opts['view'] = forkview
+            uniqvals = list(set(layr2vals) - set(layr1vals))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            uniqvals = list(set(layr1vals) | set(layr2vals))
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+
+            opts = {'vars': {'prop': 'ou:org:name'}}
+            uniqvals = list(set(layr1vals))
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            opts['view'] = forkview
+            uniqvals = list(set(layr2vals))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            uniqvals = list(set(layr1vals) | set(layr2vals))
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+
+            opts = {'vars': {'prop': '.seen'}}
+
+            ival = core.model.type('ival')
+            uniqvals = [ival.norm('2020')[0], ival.norm('2021')[0]]
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            opts['view'] = forkview
+            uniqvals = [ival.norm('2020')[0], ival.norm('2023')[0]]
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            uniqvals = [ival.norm('2020')[0], ival.norm('2021')[0], ival.norm('2023')[0]]
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+
+            opts['vars']['prop'] = 'ps:contact:name'
+            self.eq([], await core.callStorm(viewq, opts=opts))
+
+            opts['vars']['prop'] = 'newp:newp'
+            with self.raises(s_exc.NoSuchProp):
+                await core.callStorm(layrq, opts=opts)
+
+            with self.raises(s_exc.NoSuchProp):
+                await core.callStorm(viewq, opts=opts)
+
+            arryvals = [
+                ('foo', 'bar'),
+                ('foo', 'bar'),
+                ('foo', 'baz'),
+                ('bar', 'baz'),
+                ('bar', 'foo')
+            ]
+            opts = {'vars': {'vals': arryvals}}
+            await core.nodes('for $val in $vals {[ transport:air:flight=* :stops=$val ]}', opts=opts)
+
+            opts = {'vars': {'prop': 'transport:air:flight:stops'}}
+            uniqvals = list(set(arryvals))
+            self.sorteq(uniqvals, await core.callStorm(viewq, opts=opts))
+            self.sorteq(uniqvals, await core.callStorm(layrq, opts=opts))
+
+            await core.nodes('[ media:news=(bar,) :title=foo ]')
+            await core.nodes('[ media:news=(baz,) :title=bar ]')
+            await core.nodes('[ media:news=(faz,) :title=faz ]')
+
+            forkopts = {'view': forkview}
+            await core.nodes('[ media:news=(baz,) :title=faz ]', opts=forkopts)
+
+            opts = {'vars': {'prop': 'media:news:title'}}
+            self.eq(['bar', 'faz', 'foo'], await core.callStorm(viewq, opts=opts))
+
+            opts = {'view': forkview, 'vars': {'prop': 'media:news:title'}}
+            self.eq(['faz', 'foo'], await core.callStorm(viewq, opts=opts))
+
+            forkview2 = await core.callStorm('return($lib.view.get().fork().iden)', opts=forkopts)
+            forkopts2 = {'view': forkview2}
+
+            await core.nodes('[ ps:contact=(foo,) :name=foo ]', opts=forkopts2)
+            await core.nodes('[ ps:contact=(foo,) :name=bar ]', opts=forkopts)
+            await core.nodes('[ ps:contact=(bar,) :name=bar ]')
+
+            opts = {'view': forkview2, 'vars': {'prop': 'ps:contact:name'}}
+            self.eq(['bar', 'foo'], await core.callStorm(viewq, opts=opts))
+
+            self.eq([], await alist(core.getLayer().iterPropIndxBuids('newp', 'newp', 'newp')))
+
     async def test_lib_stormtypes_cmdopts(self):
         pdef = {
             'name': 'foo',
@@ -6389,9 +6545,9 @@ words\tword\twrd'''
             self.eq(2, await core.callStorm('return($lib.math.number(1.23).toint(rounding=ROUND_UP))'))
 
             with self.raises(s_exc.BadCast):
-                    await core.callStorm('return($lib.math.number((null)))')
+                await core.callStorm('return($lib.math.number((null)))')
             with self.raises(s_exc.BadCast):
-                    await core.callStorm('return($lib.math.number(newp))')
+                await core.callStorm('return($lib.math.number(newp))')
 
             with self.raises(s_exc.StormRuntimeError):
                 await core.callStorm('return($lib.math.number(1.23).toint(rounding=NEWP))')

synapse/tests/test_lib_types.py

@@ -22,6 +22,12 @@ class TypesTest(s_t_utils.SynTest):
         self.none(t.getCompOffs('newp'))
         self.raises(s_exc.NoSuchCmpr, t.cmpr, val1=1, name='newp', val2=0)
 
+        str00 = model.type('str').clone({})
+        str01 = model.type('str').clone({})
+        str02 = model.type('str').clone({'lower': True})
+        self.eq(str00, str01)
+        self.ne(str01, str02)
+
     async def test_mass(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_model_inet.py

@@ -985,6 +985,12 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(0, await core.nodes('[test:str="foo"] [inet:ipv4?=$node.value()] -test:str'))
             self.len(0, await core.nodes('[test:str="foo-bar.com"] [inet:ipv4?=$node.value()] -test:str'))
 
+            q = '''init { $l = () }
+            [inet:ipv4=192.0.0.9 inet:ipv4=192.0.0.0 inet:ipv4=192.0.0.255] $l.append(:type)
+            fini { return ( $l ) }'''
+            resp = await core.callStorm(q)
+            self.eq(resp, ['unicast', 'private', 'private'])
+
     async def test_ipv6(self):
         formname = 'inet:ipv6'
         async with self.getTestCore() as core:
@@ -1290,6 +1296,10 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(2, await core.nodes('inet:rfc2822:addr^=unittest1'))
             self.len(1, await core.nodes('inet:rfc2822:addr^=unittest12'))
 
+            # CVE-2023-27043 related behavior
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('[inet:rfc2822:addr="alice@example.org]<bob@example.org>"]')
+
     async def test_server(self):
         formname = 'inet:server'
         data = (

synapse/tests/test_model_language.py

@@ -27,6 +27,10 @@ class LangModuleTest(s_t_utils.SynTest):
             with self.raises(s_exc.BadTypeValu):
                 await core.callStorm('return($lib.gen.langByCode(neeeeewp))')
 
+            nodes = await core.nodes('[ lang:phrase="For   The  People" ]')
+            self.len(1, nodes)
+            self.eq('for the people', nodes[0].repr())
+
     async def test_forms_idiom(self):
         async with self.getTestCore() as core:
             valu = 'arbitrary text 123'