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

synapse/tests/test_lib_stormtypes.py

@@ -139,7 +139,7 @@ class StormTypesTest(s_test.SynTest):
             ''')
             self.stormNotInPrint(f'{visi.iden} says heya', msgs)
 
-            indx = await core.callStorm('return($lib.auth.users.byname(root).notify(hehe, $lib.dict(haha=hoho)))')
+            indx = await core.callStorm('return($lib.auth.users.byname(root).notify(hehe, ({"haha": "hoho"})))')
             opts = {'vars': {'indx': indx}}
             mesg = await core.callStorm('return($lib.notifications.get($indx))', opts=opts)
             self.eq(mesg[0], core.auth.rootuser.iden)
@@ -147,11 +147,11 @@ class StormTypesTest(s_test.SynTest):
             self.eq(mesg[3], {'haha': 'hoho'})
 
             opts = {'user': visi.iden}
-            q = 'return($lib.auth.users.byname(root).notify(newp, $lib.dict(key=valu)))'
+            q = 'return($lib.auth.users.byname(root).notify(newp, ({"key": "valu"})))'
             with self.raises(s_exc.AuthDeny):
                 await core.callStorm(q, opts=opts)
 
-            q = 'return($lib.auth.users.byname(root).notify(newp, $lib.dict(key=valu)))'
+            q = 'return($lib.auth.users.byname(root).notify(newp, ({"key": "valu"})))'
             with self.raises(s_exc.AuthDeny):
                 await core.callStorm(q, opts=opts)
 
@@ -189,8 +189,8 @@ class StormTypesTest(s_test.SynTest):
             self.none(await core.callStorm('return($lib.jsonstor.get(foo))'))
             self.false(await core.callStorm('return($lib.jsonstor.has(foo))'))
             self.none(await core.callStorm('return($lib.jsonstor.get(foo, prop=bar))'))
-            self.true(await core.callStorm('return($lib.jsonstor.set(hi, $lib.dict(foo=bar, baz=faz)))'))
-            self.true(await core.callStorm('return($lib.jsonstor.set(bye/bye, $lib.dict(zip=zop, bip=bop)))'))
+            self.true(await core.callStorm('return($lib.jsonstor.set(hi, ({"foo": "bar", "baz": "faz"})))'))
+            self.true(await core.callStorm('return($lib.jsonstor.set(bye/bye, ({"zip": "zop", "bip": "bop"})))'))
             self.true(await core.callStorm('return($lib.jsonstor.has(bye/bye))'))
             self.eq('bar', await core.callStorm('return($lib.jsonstor.get(hi, prop=foo))'))
             self.eq({'foo': 'bar', 'baz': 'faz'}, await core.callStorm('return($lib.jsonstor.get(hi))'))
@@ -587,6 +587,15 @@ class StormTypesTest(s_test.SynTest):
             self.true(s_common.isguid(nodes[1].ndef[1]))
             self.eq(nodes[0].ndef[1], nodes[1].ndef[1])
 
+            self.ne(s_common.guid('foo'), await core.callStorm('return($lib.guid(foo))'))
+            self.eq(s_common.guid('foo'), await core.callStorm('return($lib.guid(valu=foo))'))
+
+            with self.raises(s_exc.BadArg) as ectx:
+                await core.callStorm('return($lib.guid(foo, valu=bar))')
+            self.eq('Valu cannot be specified if positional arguments are provided', ectx.exception.errinfo['mesg'])
+
+            await self.asyncraises(s_exc.NoSuchType, core.callStorm('return($lib.guid(valu=$lib))'))
+
             async with core.getLocalProxy() as prox:
                 mesgs = [m async for m in prox.storm('$lib.print("hi there")') if m[0] == 'print']
                 self.len(1, mesgs)
@@ -680,12 +689,12 @@ class StormTypesTest(s_test.SynTest):
             self.stormIsInPrint("'2'", mesgs)
             self.stormIsInPrint("'3'", mesgs)
 
-            mesgs = await core.stormlist('$lib.print($lib.dict(foo=1, bar=2))')
+            mesgs = await core.stormlist('$lib.print(({"foo": "1", "bar": "2"}))')
             self.stormIsInPrint("'foo': '1'", mesgs)
             self.stormIsInPrint("'bar': '2'", mesgs)
 
             mesgs = await core.stormlist('$lib.print($lib.dict)')
-            self.stormIsInPrint("bound method LibBase._dict", mesgs)
+            self.stormIsInPrint("Library $lib.dict", mesgs)
 
             mesgs = await core.stormlist('$lib.print($lib)')
             self.stormIsInPrint("Library $lib", mesgs)
@@ -696,13 +705,10 @@ class StormTypesTest(s_test.SynTest):
             mesgs = await core.stormlist('$lib.pprint($lib.list(1,2,3))')
             self.stormIsInPrint("('1', '2', '3')", mesgs)
 
-            mesgs = await core.stormlist('$lib.pprint($lib.dict(foo=1, bar=2))')
+            mesgs = await core.stormlist('$lib.pprint(({"foo": "1", "bar": "2"}))')
             self.stormIsInPrint("'foo': '1'", mesgs)
             self.stormIsInPrint("'bar': '2'", mesgs)
 
-            mesgs = await core.stormlist('$lib.pprint($lib.dict)')
-            self.stormIsInPrint("bound method LibBase._dict", mesgs)
-
             mesgs = await core.stormlist('$lib.pprint($lib)')
             self.stormIsInPrint("LibBase object", mesgs)
 
@@ -716,7 +722,7 @@ class StormTypesTest(s_test.SynTest):
             # lib.guid()
             opts = {'vars': {'x': {'foo': 'bar'}, 'y': ['foo']}}
             guid00 = await core.callStorm('return($lib.guid($x, $y))', opts=opts)
-            guid01 = await core.callStorm('$x=$lib.dict(foo=bar) $y=$lib.list(foo) return($lib.guid($x, $y))')
+            guid01 = await core.callStorm('$x=({"foo": "bar"}) $y=$lib.list(foo) return($lib.guid($x, $y))')
             self.eq(guid00, guid01)
 
             guid00 = await core.callStorm('return($lib.guid(foo))')
@@ -729,7 +735,7 @@ class StormTypesTest(s_test.SynTest):
             guid = await core.callStorm('return($lib.guid(($lib.undef,)))')
             self.eq(s_common.guid(((),)), guid)
 
-            guid = await core.callStorm('return($lib.guid($lib.dict(foo=($lib.undef,))))')
+            guid = await core.callStorm('$foo = ($lib.undef,) return($lib.guid(({"foo": $foo})))')
             self.eq(s_common.guid(({'foo': ()},)), guid)
 
             mesgs = await core.stormlist('function foo() { test:str } $lib.guid($foo())')
@@ -1143,11 +1149,59 @@ class StormTypesTest(s_test.SynTest):
 
     async def test_storm_lib_dict(self):
         async with self.getTestCore() as core:
-            nodes = await core.nodes('$blah = $lib.dict(foo=vertex.link) [ inet:fqdn=$blah.foo ]')
+            nodes = await core.nodes('$blah = ({"foo": "vertex.link"}) [ inet:fqdn=$blah.foo ]')
             self.len(1, nodes)
             self.eq('vertex.link', nodes[0].ndef[1])
 
-            self.eq(2, await core.callStorm('$d=$lib.dict(k1=1, k2=2) return($lib.len($d))'))
+            self.eq(2, await core.callStorm('$d=({"k1": "1", "k2": "2"}) return($lib.len($d))'))
+
+            d = {'key1': 'val1', 'key2': None}
+            opts = {'vars': {'d': d}}
+            has = await core.callStorm('return($lib.dict.has($d, "key1"))', opts=opts)
+            self.true(has)
+
+            has = await core.callStorm('return($lib.dict.has($d, "key2"))', opts=opts)
+            self.true(has)
+
+            has = await core.callStorm('return($lib.dict.has($d, "key3"))', opts=opts)
+            self.false(has)
+
+            d = {'key1': 'val1', 'key2': 'val2'}
+            opts = {'vars': {'d': d}}
+            keys = await core.callStorm('return($lib.dict.keys($d))', opts=opts)
+            self.eq(keys, ['key1', 'key2'])
+
+            vals = await core.callStorm('return($lib.dict.values($d))', opts=opts)
+            self.eq(vals, ['val1', 'val2'])
+
+            val = await core.callStorm('return($lib.dict.pop($d, "key2"))', opts=opts)
+            self.eq(val, 'val2')
+            self.eq(d, {'key1': 'val1'})
+
+            val = await core.callStorm('return($lib.dict.pop($d, "newp", "w00t"))', opts=opts)
+            self.eq(val, 'w00t')
+            self.eq(d, {'key1': 'val1'})
+
+            with self.raises(s_exc.BadArg):
+                await core.callStorm('return($lib.dict.pop($d, "newp"))', opts=opts)
+
+            await core.callStorm('$lib.dict.update($d, ({"foo": "bar"}))', opts=opts)
+            self.eq(d, {'key1': 'val1', 'foo': 'bar'})
+
+            msgs = await core.stormlist('$d = $lib.dict(foo=bar, baz=woot)')
+            self.stormIsInWarn('$lib.dict() is deprecated. Use ({}) instead.', msgs)
+
+            msgs = await core.stormlist('$lib.dict.keys(([]))')
+            self.stormIsInErr('valu argument must be a dict, not list.', msgs)
+
+            msgs = await core.stormlist('$lib.dict.keys(1)')
+            self.stormIsInErr('valu argument must be a dict, not str.', msgs)
+
+            msgs = await core.stormlist('$lib.dict.keys((1))')
+            self.stormIsInErr('valu argument must be a dict, not int.', msgs)
+
+            msgs = await core.stormlist('$lib.dict.keys($lib.undef)')
+            self.stormIsInErr('valu argument must be a dict, not undef.', msgs)
 
     async def test_storm_lib_str(self):
         async with self.getTestCore() as core:
@@ -1269,6 +1323,11 @@ class StormTypesTest(s_test.SynTest):
 
             self.eq('foo bar baz faz', await core.callStorm('return($lib.regex.replace("[ ]{2,}", " ", "foo  bar   baz faz"))'))
 
+            self.eq(((1, 2, 3)), await core.callStorm('return(("[1, 2, 3]").json())'))
+
+            with self.raises(s_exc.BadJsonText):
+                await core.callStorm('return(("foo").json())')
+
     async def test_storm_lib_bytes_gzip(self):
         async with self.getTestCore() as core:
             hstr = 'ohhai'
@@ -1943,20 +2002,20 @@ class StormTypesTest(s_test.SynTest):
 
             # Dict
             q = '''
-                $dict = $lib.dict(
-                    "foo" = "bar",
-                    "biz" = "baz",
-                )
+                $dict = ({
+                    "foo": "bar",
+                    "biz": "baz",
+                })
                 $set = $lib.set($dict)
             '''
             msgs = await core.stormlist(q)
             self.stormIsInErr('is mutable and cannot be used in a set', msgs)
 
             q = '''
-                $dict = $lib.dict(
-                    "foo" = "bar",
-                    "biz" = "baz",
-                )
+                $dict = ({
+                    "foo": "bar",
+                    "biz": "baz",
+                })
                 $set = $lib.set()
                 $set.adds($dict)
                 $lib.print('There are {count} items in the set', count=$lib.len($set))
@@ -2162,7 +2221,7 @@ class StormTypesTest(s_test.SynTest):
 
                 q = '''
                 inet:fqdn=vertex.link
-                $path.meta.wat = $lib.dict(foo=bar, biz=baz, thing=$lib.dict(1=2, 2=(a, b, c), five=nine))
+                $path.meta.wat = ({"foo": "bar", "biz": "baz", "thing": ({"1": "2", "2": ["a", "b", "c"], "five": "nine"}) })
                 $path.meta.neato = (awesome, burrito)
                 '''
                 msgs = [mesg async for mesg in proxy.storm(q)]
@@ -2189,7 +2248,7 @@ class StormTypesTest(s_test.SynTest):
 
                 q = '''
                 inet:fqdn=vertex.link
-                $test = $lib.dict(foo=bar)
+                $test = ({"foo": "bar"})
                 $path.meta.data = $test
                 $test.biz = baz
                 '''
@@ -2251,7 +2310,7 @@ class StormTypesTest(s_test.SynTest):
                     mesgs = await s_test.alist(prox.storm(popq))
                     self.stormIsInPrint('pop valu is beep', mesgs)
 
-                    q = '''$x=$lib.dict(foo=1)
+                    q = '''$x=({"foo": "1"})
                     $lib.globals.set(bar, $x)
                     $y=$lib.globals.get(bar)
                     $lib.print("valu={v}", v=$y.foo)
@@ -2958,11 +3017,16 @@ class StormTypesTest(s_test.SynTest):
 
         async with self.getTestCore() as core:
 
+            opts = {'vars': {'bytes': 10}}
+
             with self.raises(s_exc.BadArg):
-                opts = {'vars': {'bytes': 10}}
                 text = '($size, $sha2) = $lib.bytes.put($bytes)'
                 nodes = await core.nodes(text, opts=opts)
 
+            with self.raises(s_exc.BadArg):
+                text = '($size, $sha2) = $lib.axon.put($bytes)'
+                nodes = await core.nodes(text, opts=opts)
+
             asdf = b'asdfasdf'
             asdfset = s_hashset.HashSet()
             asdfset.update(asdf)
@@ -2974,6 +3038,7 @@ class StormTypesTest(s_test.SynTest):
             ret = await core.callStorm('return($lib.bytes.has($hash))', {'vars': {'hash': asdfhash_h}})
             self.false(ret)
             self.false(await core.callStorm('return($lib.bytes.has($lib.null))'))
+            self.false(await core.callStorm('return($lib.axon.has($lib.null))'))
 
             opts = {'vars': {'bytes': asdf}}
             text = '($size, $sha2) = $lib.bytes.put($bytes) [ test:int=$size test:str=$sha2 ]'
@@ -2983,10 +3048,14 @@ class StormTypesTest(s_test.SynTest):
 
             opts = {'vars': {'sha256': asdfhash_h}}
             self.eq(8, await core.callStorm('return($lib.bytes.size($sha256))', opts=opts))
+            self.eq(8, await core.callStorm('return($lib.axon.size($sha256))', opts=opts))
 
             hashset = await core.callStorm('return($lib.bytes.hashset($sha256))', opts=opts)
             self.eq(hashset, hashes)
 
+            hashset = await core.callStorm('return($lib.axon.hashset($sha256))', opts=opts)
+            self.eq(hashset, hashes)
+
             self.eq(nodes[0].ndef, ('test:int', 8))
             self.eq(nodes[1].ndef, ('test:str', asdfhash_h))
 
@@ -2997,6 +3066,9 @@ class StormTypesTest(s_test.SynTest):
             ret = await core.callStorm('return($lib.bytes.has($hash))', {'vars': {'hash': asdfhash_h}})
             self.true(ret)
 
+            ret = await core.callStorm('return($lib.axon.has($hash))', {'vars': {'hash': asdfhash_h}})
+            self.true(ret)
+
             # Allow bytes to be directly decoded as a string
             opts = {'vars': {'buf': 'hehe'.encode()}}
             nodes = await core.nodes('$valu=$buf.decode() [test:str=$valu]', opts)
@@ -3046,6 +3118,32 @@ class StormTypesTest(s_test.SynTest):
             retn = await core.callStorm('return($lib.bytes.upload($chunks))', opts=opts)
             self.eq((8, '9ed8ffd0a11e337e6e461358195ebf8ea2e12a82db44561ae5d9e638f6f922c4'), retn)
 
+            retn = await core.callStorm('return($lib.axon.upload($chunks))', opts=opts)
+            self.eq((8, '9ed8ffd0a11e337e6e461358195ebf8ea2e12a82db44561ae5d9e638f6f922c4'), retn)
+
+            visi = await core.auth.addUser('visi')
+            await visi.addRule((False, ('axon', 'has')))
+
+            opts = {'user': visi.iden, 'vars': {'hash': asdfhash_h}}
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('return($lib.bytes.has($hash))', opts=opts)
+
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('return($lib.bytes.size($hash))', opts=opts)
+
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('return($lib.bytes.hashset($hash))', opts=opts)
+
+            await visi.addRule((False, ('axon', 'upload')))
+
+            opts = {'user': visi.iden, 'vars': {'byts': b'foo'}}
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('return($lib.bytes.put($byts))', opts=opts)
+
+            opts = {'user': visi.iden, 'vars': {'chunks': (b'visi', b'kewl')}}
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('return($lib.bytes.upload($chunks))', opts=opts)
+
     async def test_storm_lib_base64(self):
 
         async with self.getTestCore() as core:
@@ -3060,7 +3158,7 @@ class StormTypesTest(s_test.SynTest):
             self.eq(nodes[0].ndef, ('test:str', 'Zm9vYmE_'))
 
             opts = {'vars': {'bytes': nodes[0].ndef[1]}}
-            text = '$lib.bytes.put($lib.base64.decode($bytes))'
+            text = '$lib.axon.put($lib.base64.decode($bytes))'
             nodes = await core.nodes(text, opts)
             key = binascii.unhexlify(hashlib.sha256(base64.urlsafe_b64decode(opts['vars']['bytes'])).hexdigest())
             byts = b''.join([b async for b in core.axon.get(key)])
@@ -3074,7 +3172,7 @@ class StormTypesTest(s_test.SynTest):
             self.eq(nodes[0].ndef, ('test:str', 'Zm9vYmE/'))
 
             opts = {'vars': {'bytes': nodes[0].ndef[1]}}
-            text = '$lib.bytes.put($lib.base64.decode($bytes, $(0)))'
+            text = '$lib.axon.put($lib.base64.decode($bytes, $(0)))'
             nodes = await core.nodes(text, opts)
             key = binascii.unhexlify(hashlib.sha256(base64.urlsafe_b64decode(opts['vars']['bytes'])).hexdigest())
             byts = b''.join([b async for b in core.axon.get(key)])
@@ -3317,7 +3415,7 @@ class StormTypesTest(s_test.SynTest):
             self.sorteq(idens, core.layers)
 
             # Create a new layer with a name
-            q = f'$lib.print($lib.layer.add($lib.dict(name=foo)).iden)'
+            q = f'$lib.print($lib.layer.add(({{"name": "foo"}})).iden)'
             for mesg in await core.stormlist(q):
                 if mesg[0] == 'print':
                     namedlayer = mesg[1]['mesg']
@@ -4157,12 +4255,12 @@ class StormTypesTest(s_test.SynTest):
 
             # Move a trigger to a different view
             q = '''
-                $tdef = $lib.dict(
-                    condition='node:add',
-                    form='test:str',
-                    storm='{[ +#tagged ]}',
-                    doc='some trigger'
-                )
+                $tdef = ({
+                    "condition": 'node:add',
+                    "form": 'test:str',
+                    "storm": '{[ +#tagged ]}',
+                    "doc": 'some trigger'
+                })
                 $trig = $lib.trigger.add($tdef)
                 return($trig.pack())
             '''
@@ -4249,12 +4347,12 @@ class StormTypesTest(s_test.SynTest):
                 await core.nodes(f'$lib.trigger.get({trig}).move(newp)')
 
             q = '''
-                $tdef = $lib.dict(
-                    condition='node:add',
-                    form='test:str',
-                    storm='{[ +#tagged ]}',
-                    iden=$trig
-                )
+                $tdef = ({
+                    "condition": 'node:add',
+                    "form": 'test:str',
+                    "storm": '{[ +#tagged ]}',
+                    "iden": $trig
+                })
                 $trig = $lib.trigger.add($tdef)
                 return($trig.iden)
             '''
@@ -5062,7 +5160,7 @@ class StormTypesTest(s_test.SynTest):
             nodes = await core.nodes('[test:guid=(beep,)] $node.props.".seen"=2020')
             self.eq((1577836800000, 1577836800001), nodes[0].get('.seen'))
 
-            text = '$d=$lib.dict() test:guid=(beep,) { for ($name, $valu) in $node.props { $d.$name=$valu } } return ($d)'
+            text = '$d=({}) test:guid=(beep,) { for ($name, $valu) in $node.props { $d.$name=$valu } } return ($d)'
             props = await core.callStorm(text)
             self.eq(12, props.get('size'))
             self.eq((1577836800000, 1577836800001), props.get('.seen'))
@@ -5104,7 +5202,7 @@ class StormTypesTest(s_test.SynTest):
 
             q = '$list = $lib.list() $list.append(foo) $list.append(bar) return($list)'
             self.eq(('foo', 'bar'), await core.callStorm(q))
-            self.eq({'foo': 'bar'}, await core.callStorm('$dict = $lib.dict() $dict.foo = bar return($dict)'))
+            self.eq({'foo': 'bar'}, await core.callStorm('$dict = ({}) $dict.foo = bar return($dict)'))
             q = '$tally = $lib.stats.tally() $tally.inc(foo) $tally.inc(foo) return($tally)'
             self.eq({'foo': 2}, await core.callStorm(q))
 
@@ -5526,7 +5624,7 @@ class StormTypesTest(s_test.SynTest):
             ret = await core.callStorm('$x=$lib.set() $y=$lib.list(1,2,3) $x.adds($y) return($x)')
             self.eq({'1', '2', '3'}, ret)
 
-            ret = await core.callStorm('$x=$lib.set() $y=$lib.dict(foo=1, bar=2) $x.adds($y) return($x)')
+            ret = await core.callStorm('$x=$lib.set() $y=({"foo": "1", "bar": "2"}) $x.adds($y) return($x)')
             self.eq({('foo', '1'), ('bar', '2')}, ret)
 
             ret = await core.nodes('$x=$lib.set() $x.adds(${inet:ipv4}) for $n in $x { yield $n.iden() }')
@@ -5544,16 +5642,16 @@ class StormTypesTest(s_test.SynTest):
 
             scmd = '''
                 $x=$lib.set()
-                $y=$lib.dict(foo=1, bar=2)
+                $y=({"foo": "1", "bar": "2"})
                 $x.adds($y)
-                $z=$lib.dict(foo=1)
+                $z=({"foo": "1"})
                 $x.rems($z)
                 return($x)
             '''
             ret = await core.callStorm(scmd)
             self.eq({('bar', '2')}, ret)
 
-            ret = await core.callStorm('$x=$lib.set() $y=$lib.dict(foo=1, bar=2) $x.adds($y) return($x)')
+            ret = await core.callStorm('$x=$lib.set() $y=({"foo": "1", "bar": "2"}) $x.adds($y) return($x)')
             self.eq({('foo', '1'), ('bar', '2')}, ret)
 
             ret = await core.callStorm('$x=$lib.set(1,2,3) $x.rems((1,2)) return($x)')
@@ -5636,7 +5734,7 @@ class StormTypesTest(s_test.SynTest):
 
             self.len(1, await core.callStorm('$x=$lib.list() for $i in $lib.axon.list() { $x.append($i) } return($x)'))
 
-            size, sha256 = await core.callStorm('return($lib.bytes.put($buf))', opts={'vars': {'buf': b'foo'}})
+            size, sha256 = await core.callStorm('return($lib.axon.put($buf))', opts={'vars': {'buf': b'foo'}})
 
             items = await core.callStorm('$x=$lib.list() for $i in $lib.axon.list() { $x.append($i) } return($x)')
             self.len(2, items)
@@ -5658,9 +5756,9 @@ class StormTypesTest(s_test.SynTest):
             self.true(resp['ok'])
 
             opts = {'vars': {'linesbuf': linesbuf, 'jsonsbuf': jsonsbuf, 'asdfbuf': b'asdf'}}
-            asdfitem = await core.callStorm('return($lib.bytes.put($asdfbuf))', opts=opts)
-            linesitem = await core.callStorm('return($lib.bytes.put($linesbuf))', opts=opts)
-            jsonsitem = await core.callStorm('return($lib.bytes.put($jsonsbuf))', opts=opts)
+            asdfitem = await core.callStorm('return($lib.axon.put($asdfbuf))', opts=opts)
+            linesitem = await core.callStorm('return($lib.axon.put($linesbuf))', opts=opts)
+            jsonsitem = await core.callStorm('return($lib.axon.put($jsonsbuf))', opts=opts)
 
             opts = {'vars': {'sha256': asdfitem[1]}}
             self.eq(('asdf',), await core.callStorm('''
@@ -6343,6 +6441,9 @@ words\tword\twrd'''
             with self.raises(s_exc.SynErr):
                 await core.callStorm('$lib.view.get().merge()', opts={'view': fork00})
 
+            with self.raises(s_exc.BadState):
+                core.getView(fork00).reqValidVoter(visi.iden)
+
             with self.raises(s_exc.AuthDeny):
                 await core.callStorm('$lib.view.get().setMergeRequest()', opts={'user': visi.iden, 'view': fork00})
 
@@ -6352,12 +6453,18 @@ words\tword\twrd'''
             self.eq(merge['comment'], 'woot')
             self.eq(merge['creator'], core.auth.rootuser.iden)
 
+            with self.raises(s_exc.AuthDeny):
+                core.getView(fork00).reqValidVoter(root.iden)
+
             merge = await core.callStorm('return($lib.view.get().getMergeRequest())', opts={'view': fork00})
             self.nn(merge['iden'])
             self.nn(merge['created'])
             self.eq(merge['comment'], 'woot')
             self.eq(merge['creator'], core.auth.rootuser.iden)
 
+            with self.raises(s_exc.AuthDeny):
+                await core.callStorm('$lib.view.get().setMergeVote()', opts={'view': fork00})
+
             with self.raises(s_exc.AuthDeny):
                 await core.callStorm('$lib.view.get().setMergeVote()', opts={'user': visi.iden, 'view': fork00})
 

synapse/tests/test_lib_stormwhois.py

@@ -26,7 +26,7 @@ class StormWhoisTest(s_test.SynTest):
             guid_exp = s_common.guid(sorted((props['net4'], str(props['asof']), props['id'])))
             self.len(1, await core.nodes(f'inet:whois:iprec={guid_exp}'))
 
-            stormcmd = '''$props=$lib.dict(net4="10.0.0.0/28", asof=(2554869000000), id='NET-10-0-0-0-1', status=validated)
+            stormcmd = '''$props=({'net4':'10.0.0.0/28', 'asof':(2554869000000), 'id':'NET-10-0-0-0-1', 'status':'validated'})
             return ($lib.inet.whois.guid($props, 'iprec'))
             '''
             guid = await core.callStorm(stormcmd)

synapse/tests/test_lib_trigger.py

@@ -558,21 +558,21 @@ class TrigTest(s_t_utils.SynTest):
             view = await core.callStorm('return ($lib.view.get().fork().iden)')
 
             await self.asyncraises(s_exc.SchemaViolation, core.nodes('''
-                $tdef = $lib.dict(
-                    cond="edge:add",
-                    form="test:int",
-                    storm="[+#asdfasdf]"
-                )
+                $tdef = ({
+                    'cond':'edge:add',
+                    'form':'test:int',
+                    'storm':'[+#asdfasdf]'
+                })
                 $lib.trigger.add($tdef)
             '''))
 
             await self.asyncraises(s_exc.SchemaViolation, core.nodes('''
-                $tdef = $lib.dict(
-                    cond="edge:add",
-                    form="test:int",
-                    storm="[+#asdfasdf]",
-                    verb=$lib.null
-                )
+                $tdef = ({
+                    'cond':'edge:add',
+                    'form':'test:int',
+                    'storm':'[+#asdfasdf]',
+                    'verb':$lib.null
+                })
                 $lib.trigger.add($tdef)
             '''))
 

synapse/tests/test_lib_view.py

@@ -670,7 +670,7 @@ class ViewTest(s_t_utils.SynTest):
 
                 mirror_catchup = await core2.getNexsIndx() - 1 + 2 + layr.nodeeditlog.size
                 mirror_view, mirror_layr = await core2.callStorm('''
-                    $ldef = $lib.dict(mirror=$lib.str.concat($baseurl, "/", $baseiden))
+                    $ldef = ({'mirror':$lib.str.concat($baseurl, "/", $baseiden)})
                     $lyr = $lib.layer.add(ldef=$ldef)
                     $view = $lib.view.add(($lyr.iden,))
                     return(($view.iden, $lyr.iden))
@@ -759,3 +759,25 @@ class ViewTest(s_t_utils.SynTest):
             self.nn(nodes[0].tagprops.get('seen'))
             self.nn(nodes[0].tagprops['seen'].get('score'))
             self.nn(nodes[0].nodedata.get('foo'))
+
+            await core.delUserRule(useriden, (True, ('node', 'tag', 'add')), gateiden=baselayr)
+
+            await core.addUserRule(useriden, (True, ('node', 'tag', 'add', 'rep', 'foo')), gateiden=baselayr)
+
+            await core.nodes('test:str=foo [ -#seen +#rep.foo ]', opts=viewopts)
+
+            await core.nodes('$lib.view.get().merge()', opts=viewopts)
+            nodes = await core.nodes('test:str=foo')
+            self.nn(nodes[0].get('#rep.foo'))
+
+            await core.nodes('test:str=foo [ -#rep ]')
+
+            await core.nodes('test:str=foo | merge --apply', opts=viewopts)
+            nodes = await core.nodes('test:str=foo')
+            self.nn(nodes[0].get('#rep.foo'))
+
+            await core.nodes('test:str=foo [ -#rep ]')
+            await core.nodes('test:str=foo [ +#rep=now ]', opts=viewopts)
+
+            with self.raises(s_exc.AuthDeny) as cm:
+                await core.nodes('$lib.view.get().merge()', opts=viewopts)

synapse/tests/test_model_crypto.py

@@ -344,7 +344,7 @@ class CryptoModelTest(s_t_utils.SynTest):
                     crypto:smart:token=(2bdea834252a220b61aadf592cc0de66, 30)
                         :owner=eth/aaaa
                         :nft:url = https://coin.vertex.link/nfts/30
-                        :nft:meta = $lib.dict(name=WootWoot)
+                        :nft:meta = ({'name':'WootWoot'})
                         :nft:meta:name = WootWoot
                         :nft:meta:description = LoLoL
                         :nft:meta:image = https://vertex.link/favicon.ico

synapse/tests/test_model_inet.py

@@ -2662,6 +2662,9 @@ class InetModelTest(s_t_utils.SynTest):
                 :headers=(('to', 'Visi Stark <visi@vertex.link>'),)
                 :cc=(baz@faz.org, foo@bar.com, baz@faz.org)
                 :bytes="*"
+                :received:from:ipv4=1.2.3.4
+                :received:from:ipv6="::1"
+                :received:from:fqdn=smtp.vertex.link
             ]
 
             {[( inet:email:message:link=($node, https://www.vertex.link) :text=Vertex )]}
@@ -2671,6 +2674,9 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(1, nodes)
 
             self.eq(nodes[0].get('cc'), ('baz@faz.org', 'foo@bar.com'))
+            self.eq(nodes[0].get('received:from:ipv6'), '::1')
+            self.eq(nodes[0].get('received:from:ipv4'), 0x01020304)
+            self.eq(nodes[0].get('received:from:fqdn'), 'smtp.vertex.link')
 
             self.len(1, await core.nodes('inet:email:message:to=woot@woot.com'))
             self.len(1, await core.nodes('inet:email:message:date=2015'))

synapse/tests/test_model_orgs.py

@@ -450,10 +450,11 @@ class OuModelTest(s_t_utils.SynTest):
             self.eq(node.get('departed'), 1519945200000)
             self.eq(node.get('roles'), ('speaker', 'staff'))
 
-            nodes = await core.nodes('[ ou:id:type=* :org=* :name=foobar ]')
+            nodes = await core.nodes('[ ou:id:type=* :org=* :name=foobar :url="http://foobar.com/ids"]')
             self.len(1, nodes)
             self.nn(nodes[0].get('org'))
             self.eq('foobar', nodes[0].get('name'))
+            self.eq('http://foobar.com/ids', nodes[0].get('url'))
 
             iden = await core.callStorm('ou:id:type return($node.value())')
 

synapse/tests/test_model_proj.py

@@ -19,6 +19,12 @@ class ProjModelTest(s_test.SynTest):
             self.nn(proj)
             self.len(1, await core.nodes('proj:project:desc=bar'))
 
+            nodes = await core.nodes('proj:project [ :type=foo.bar ]')
+            self.len(1, nodes)
+            self.eq('foo.bar.', nodes[0].get('type'))
+
+            self.len(1, await core.nodes('proj:project -> proj:project:type:taxonomy'))
+
             opts = {'user': visi.iden, 'vars': {'proj': proj}}
             with self.raises(s_exc.AuthDeny):
                 await core.callStorm('return($lib.projects.get($proj).epics.add(bar))', opts=opts)

synapse/tests/test_model_risk.py

@@ -285,6 +285,9 @@ class RiskModelTest(s_t_utils.SynTest):
                     :detected=20501217
                     :attack=*
                     :vuln=*
+                    :status=todo
+                    :assignee=$lib.user.iden
+                    :ext:assignee = {[ ps:contact=* :email=visi@vertex.link ]}
                     :url=https://vertex.link/alerts/WOOT-20
                     :ext:id=WOOT-20
                     :engine={[ it:prod:softver=* :name=visiware ]}
@@ -294,6 +297,7 @@ class RiskModelTest(s_t_utils.SynTest):
                 ]
             ''')
             self.len(1, nodes)
+            self.eq(20, nodes[0].get('status'))
             self.eq(40, nodes[0].get('priority'))
             self.eq(50, nodes[0].get('severity'))
             self.eq('bazfaz.', nodes[0].get('type'))
@@ -302,7 +306,9 @@ class RiskModelTest(s_t_utils.SynTest):
             self.eq(2554848000000, nodes[0].get('detected'))
             self.eq('WOOT-20', nodes[0].get('ext:id'))
             self.eq('https://vertex.link/alerts/WOOT-20', nodes[0].get('url'))
+            self.eq(core.auth.rootuser.iden, nodes[0].get('assignee'))
             self.nn(nodes[0].get('host'))
+            self.nn(nodes[0].get('ext:assignee'))
             self.len(1, await core.nodes('risk:alert -> it:host'))
             self.len(1, await core.nodes('risk:alert -> risk:vuln'))
             self.len(1, await core.nodes('risk:alert -> risk:attack'))
@@ -504,9 +510,13 @@ class RiskModelTest(s_t_utils.SynTest):
                     :desc=BazFaz
                     :hardware=*
                     :software=*
+                    :reporter:name=vertex
+                    :reporter = { gen.ou.org vertex }
             ]''')
             self.eq('FooBar', nodes[0].props['name'])
             self.eq('BazFaz', nodes[0].props['desc'])
+            self.eq('vertex', nodes[0].get('reporter:name'))
+            self.nn(nodes[0].get('reporter'))
             self.len(1, await core.nodes('risk:mitigation -> risk:vuln'))
             self.len(1, await core.nodes('risk:mitigation -> it:prod:softver'))
             self.len(1, await core.nodes('risk:mitigation -> it:prod:hardware'))