synapse 2.175.0__py311-none-any.whl → 2.177.0__py311-none-any.whl

synapse/tests/test_lib_storm.py

@@ -955,6 +955,42 @@ class StormTest(s_t_utils.SynTest):
                 | merge --apply
             ''', opts=opts)
 
+            # make a few more edits and merge some of them to test --wipe
+            await core.stormlist('[ inet:fqdn=hehehaha.com inet:fqdn=woottoow.com ]')
+
+            layrcount = len(core.layers.values())
+            await core.stormlist('[ inet:fqdn=hehehaha.com inet:fqdn=woottoow.com ]', opts=opts)
+            oldlayr = await core.callStorm('return($lib.view.get().layers.0.iden)', opts=opts)
+            msgs = await core.stormlist('inet:fqdn=hehehaha.com | merge --apply --wipe', opts=opts)
+            self.stormHasNoWarnErr(msgs)
+            newlayr = await core.callStorm('return($lib.view.get().layers.0.iden)', opts=opts)
+            self.ne(oldlayr, newlayr)
+            msgs = await core.stormlist('''
+                $layr = $lib.view.get().layers.0.iden
+                $user = $lib.auth.users.byname(visi)
+                $role = $lib.auth.roles.add(ninjas)
+
+                $user.grant($role.iden)
+
+                $user.setAdmin((true), gateiden=$layr)
+                $user.addRule(([true, ["foo", "bar"]]), gateiden=$layr)
+                $role.addRule(([true, ["baz", "faz"]]), gateiden=$layr)
+            ''', opts=opts)
+            self.stormHasNoWarnErr(msgs)
+            await core.callStorm('$lib.view.get().swapLayer()', opts=opts)
+            self.ne(newlayr, await core.callStorm('return($lib.view.get().layers.0.iden)', opts=opts))
+
+            self.true(await core.callStorm('''
+                $layr = $lib.view.get().layers.0.iden
+                return($lib.auth.users.byname(visi).allowed(foo.bar, gateiden=$layr))
+            ''', opts=opts))
+            self.true(await core.callStorm('''
+                $layr = $lib.view.get().layers.0.iden
+                return($lib.auth.users.byname(visi).allowed(baz.faz, gateiden=$layr))
+            ''', opts=opts))
+
+            self.len(0, await core.nodes('diff', opts=opts))
+
             self.len(0, await core.callStorm('''
                 $list = $lib.list()
                 for ($buid, $sode) in $lib.view.get().layers.0.getStorNodes() {
@@ -4235,6 +4271,15 @@ class StormTest(s_t_utils.SynTest):
                 msgs = await core.stormlist(pushq, opts={'user': visi.iden, 'vars': varz})
                 self.stormHasNoWarnErr(msgs)
 
+                l1iden = l1.get('iden')
+                pdef = list(core.getLayer(l1iden).layrinfo['pushs'].values())[0]
+                self.none(await core.addLayrPush(l1iden, pdef))
+                self.len(1, list(core.getLayer(l1iden).layrinfo['pushs'].values()))
+
+                pdef = list(core.getLayer(l1iden).layrinfo['pulls'].values())[0]
+                self.none(await core.addLayrPull(l1iden, pdef))
+                self.len(1, list(core.getLayer(l1iden).layrinfo['pulls'].values()))
+
     async def test_storm_tagprune(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_aha.py

@@ -146,8 +146,7 @@ Member:     00.cell.loop.vertex.link'''
                                     network='loop.vertex.link')
 
                 msgs = await core00.stormlist('aha.svc.list --nexus')
-                emsg = '00.newp.loop.vertex.link                      null   false  null  0.0.0.0         3030  ' \
-                       'Service is not online. Will not attempt to retrieve its nexus offset.'
+                emsg = '00.newp.loop.vertex.link                      null   false  null  0.0.0.0         3030  <offline>'
                 self.stormIsInPrint(emsg, msgs)
 
                 self.none(await core00.callStorm('return($lib.aha.del(00.newp...))'))

synapse/tests/test_lib_stormlib_auth.py

@@ -480,6 +480,9 @@ class StormLibAuthTest(s_test.SynTest):
 
             await core.callStorm('$lib.user.vars.set(foo, foovalu)', opts=asvisi)
 
+            msgs = await core.stormlist('for $valu in $lib.user.vars { $lib.print($valu) }', opts=asvisi)
+            self.stormIsInPrint("('foo', 'foovalu')", msgs)
+
             q = 'return($lib.auth.users.byname(visi).vars.foo)'
             self.eq('foovalu', await core.callStorm(q, opts=asvisi))
 
@@ -494,6 +497,24 @@ class StormLibAuthTest(s_test.SynTest):
             await core.callStorm('$lib.auth.users.byname(visi).vars.foo=$lib.undef')
             self.none(await core.callStorm('return($lib.auth.users.byname(visi).vars.foo)'))
 
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.user.vars.set((1), newp)')
+
+            await core.callStorm('$lib.user.profile.set(bar, foovalu)', opts=asvisi)
+
+            self.eq('foovalu', await core.callStorm('return($lib.user.profile.get(bar))', opts=asvisi))
+
+            self.eq((('bar', 'foovalu'),), await core.callStorm('return($lib.user.profile.list())', opts=asvisi))
+
+            msgs = await core.stormlist('for $valu in $lib.user.profile { $lib.print($valu) }', opts=asvisi)
+            self.stormIsInPrint("('bar', 'foovalu')", msgs)
+
+            await core.callStorm('$lib.user.profile.pop(bar)', opts=asvisi)
+            self.none(await core.callStorm('return($lib.user.profile.get(bar))', opts=asvisi))
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.user.profile.set((1), newp)')
+
     async def test_stormlib_auth_base(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_cortex.py

@@ -489,10 +489,10 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                 await core.callStorm(q, opts={'vars': {'iden': iden3}})
 
             msgs = await core.stormlist('cortex.httpapi.list')
-            self.stormIsInPrint(f'0     {iden0}', msgs)
-            self.stormIsInPrint(f'1     {iden1}', msgs)
-            self.stormIsInPrint(f'2     {iden2}', msgs)
-            self.stormIsInPrint(f'3     {iden3}', msgs)
+            self.stormIsInPrint(f'0     | {iden0}', msgs)
+            self.stormIsInPrint(f'1     | {iden1}', msgs)
+            self.stormIsInPrint(f'2     | {iden2}', msgs)
+            self.stormIsInPrint(f'3     | {iden3}', msgs)
 
             q = '''
             $ret = $lib.null $api = $lib.cortex.httpapi.getByPath($path)
@@ -528,10 +528,10 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             self.eq(iden0, await core.callStorm(q, opts={'vars': {'path': 'hehe/ohmy'}}))
 
             msgs = await core.stormlist('cortex.httpapi.list')
-            self.stormIsInPrint(f'0     {iden1}', msgs)
-            self.stormIsInPrint(f'1     {iden0}', msgs)
-            self.stormIsInPrint(f'2     {iden2}', msgs)
-            self.stormIsInPrint(f'3     {iden3}', msgs)
+            self.stormIsInPrint(f'0     | {iden1}', msgs)
+            self.stormIsInPrint(f'1     | {iden0}', msgs)
+            self.stormIsInPrint(f'2     | {iden2}', msgs)
+            self.stormIsInPrint(f'3     | {iden3}', msgs)
 
             # The wildcard handler does not match the more specific request as a result of the new order
             async with self.getHttpSess(auth=('root', 'root'), port=hport) as sess:
@@ -569,10 +569,10 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
             self.stormIsInPrint(f'Set HTTP API {iden0} to index 3', msgs)
 
             msgs = await core.stormlist('cortex.httpapi.list')
-            self.stormIsInPrint(f'0     {iden1}', msgs)
-            self.stormIsInPrint(f'1     {iden2}', msgs)
-            self.stormIsInPrint(f'2     {iden3}', msgs)
-            self.stormIsInPrint(f'3     {iden0}', msgs)
+            self.stormIsInPrint(f'0     | {iden1}', msgs)
+            self.stormIsInPrint(f'1     | {iden2}', msgs)
+            self.stormIsInPrint(f'2     | {iden3}', msgs)
+            self.stormIsInPrint(f'3     | {iden0}', msgs)
 
             # iden Prefix + name matching
             msgs = await core.stormlist('cortex.httpapi.index $iden 0', opts={'vars': {'iden': iden1[:6]}})

synapse/tests/test_lib_stormlib_gen.py

@@ -1,4 +1,5 @@
 import synapse.exc as s_exc
+import synapse.common as s_common
 
 import synapse.tests.utils as s_test
 
@@ -245,3 +246,101 @@ class StormLibGenTest(s_test.SynTest):
             names = nodes[0].get('names')
             self.len(1, names)
             self.isin('rhodesia', names)
+
+    async def test_stormlib_gen_fileBytes(self):
+
+        async with self.getTestCore() as core:
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+
+            nodes = await core.nodes('yield $lib.gen.fileBytesBySha256($sha256)', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('sha256'), sha256)
+
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+
+            q = '''
+                [ file:bytes=(file1,) :sha256=$sha256 ]
+                spin |
+                yield $lib.gen.fileBytesBySha256($sha256)
+            '''
+            nodes = await core.nodes(q, opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), 'guid:' + s_common.guid(('file1',)))
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.callStorm('$lib.gen.fileBytesBySha256(newp)', opts=opts)
+
+            q = 'return($lib.gen.fileBytesBySha256(newp, try=$lib.true))'
+            self.none(await core.callStorm(q, opts=opts))
+
+    async def test_stormlib_gen_inetTlsServerCert(self):
+
+        async with self.getTestCore() as core:
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+
+            q = '''
+                $server = {[ inet:server="1.2.3.4:443" ]}
+                yield $lib.gen.inetTlsServerCertByServerAndSha256($server, $sha256)
+            '''
+            nodes = await core.nodes(q, opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('server'), 'tcp://1.2.3.4:443')
+            cert = nodes[0].get('cert')
+            self.nn(cert)
+
+            nodes = await core.nodes('crypto:x509:cert:sha256=$sha256', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), cert)
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.callStorm('$lib.gen.inetTlsServerCertByServerAndSha256(newp, $sha256)', opts=opts)
+
+            q = 'return($lib.gen.inetTlsServerCertByServerAndSha256(newp, $sha256, try=$lib.true))'
+            self.none(await core.callStorm(q, opts=opts))
+
+    async def test_stormlib_gen_cryptoX509Cert(self):
+
+        async with self.getTestCore() as core:
+
+            # Check guid generation
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+            nodes = await core.nodes('yield $lib.gen.cryptoX509CertBySha256($sha256)', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('sha256'), sha256)
+            self.eq(nodes[0].repr(), s_common.guid(sha256))
+
+            # Check invalid values, no try
+            with self.raises(s_exc.BadTypeValu):
+                await core.callStorm('$lib.gen.cryptoX509CertBySha256(newp)')
+
+            # Check invalid values, with try
+            self.none(await core.callStorm('return($lib.gen.cryptoX509CertBySha256(newp, try=$lib.true))'))
+
+            # Check node matching with same sha256 values
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+            nodes = await core.nodes('[crypto:x509:cert=* :sha256=$sha256]', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('sha256'), sha256)
+            self.ne(nodes[0].repr(), s_common.guid(sha256))
+            crypto = nodes[0].repr()
+
+            nodes = await core.nodes('yield $lib.gen.cryptoX509CertBySha256($sha256)', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), crypto)
+
+            # Check node matching, crypto:x509:cert -> file with matching sha256
+            sha256 = s_common.buid().hex()
+            opts = {'vars': {'sha256': sha256}}
+            nodes = await core.nodes('[crypto:x509:cert=* :file={[ file:bytes=$sha256 ]} ]', opts=opts)
+            self.len(1, nodes)
+            self.none(nodes[0].get('sha256'))
+            crypto = nodes[0].repr()
+
+            nodes = await core.nodes('yield $lib.gen.cryptoX509CertBySha256($sha256)', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), crypto)

synapse/tests/test_lib_stormlib_model.py

@@ -1,4 +1,6 @@
 import synapse.exc as s_exc
+import synapse.common as s_common
+
 import synapse.lib.time as s_time
 import synapse.lib.layer as s_layer
 
@@ -827,3 +829,109 @@ class StormlibModelTest(s_test.SynTest):
             with self.raises(s_exc.BadArg) as ectx:
                 await core.nodes('$lib.model.migration.s.riskHasVulnToVulnerable(newp)')
             self.isin('must be a node', ectx.exception.errinfo['mesg'])
+
+    async def test_stormlib_model_migration_s_inet_ssl_to_tls_servercert(self):
+        async with self.getRegrCore('inet_ssl_to_tls_servercert') as core:
+            nodes = await core.nodes('meta:source')
+            self.len(1, nodes)
+
+            nodes = await core.nodes('meta:source -(seen)> *')
+            self.len(3, nodes)
+            for node in nodes:
+                self.eq(node.ndef[0], 'inet:ssl:cert')
+
+            nodes = await core.nodes('inet:ssl:cert')
+            self.len(3, nodes)
+
+            nodes = await core.nodes('file:bytes')
+            self.len(3, nodes)
+
+            nodes = await core.nodes('crypto:x509:cert')
+            self.len(2, nodes)
+
+            nodes = await core.nodes('inet:tls:servercert')
+            self.len(0, nodes)
+
+            q = 'inet:ssl:cert | $lib.model.migration.s.inetSslCertToTlsServerCert($node)'
+            await core.nodes(q)
+
+            nodes = await core.nodes('file:bytes')
+            self.len(3, nodes)
+
+            nodes = await core.nodes('crypto:x509:cert')
+            self.len(3, nodes)
+
+            nodes = await core.nodes('inet:tls:servercert')
+            self.len(3, nodes)
+
+            nodes = await core.nodes('crypto:x509:cert=(cert1,)')
+            self.len(1, nodes)
+            cert1 = nodes[0]
+
+            nodes = await core.nodes('inet:tls:servercert:server="tcp://1.2.3.4:443"')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('.seen'), (1688947200000, 1688947200001))
+            self.eq(nodes[0].get('server'), 'tcp://1.2.3.4:443')
+            self.eq(nodes[0].get('cert'), cert1.ndef[1])
+            self.isin('ssl.migration.one', nodes[0].tags)
+
+            nodes = await core.nodes('crypto:x509:cert=(cert2,)')
+            self.len(1, nodes)
+            cert2 = nodes[0]
+
+            nodes = await core.nodes('inet:tls:servercert:server="tcp://[fe80::1]:8080"')
+            self.len(1, nodes)
+            self.none(nodes[0].get('.seen'))
+            self.eq(nodes[0].get('server'), 'tcp://[fe80::1]:8080')
+            self.eq(nodes[0].get('cert'), cert2.ndef[1])
+            self.isin('ssl.migration.two', nodes[0].tags)
+
+            sha256 = 'aa0366ffb013ba2053e45cd7e4bcc8acd6a6c1bafc82eddb4e155876734c5e25'
+            opts = {'vars': {'sha256': sha256}}
+
+            nodes = await core.nodes('file:bytes=$sha256', opts=opts)
+            self.len(1, nodes)
+            file = nodes[0]
+
+            # This cert was created by the migration code so do a little extra
+            # checking
+            nodes = await core.nodes('crypto:x509:cert:file=$sha256', opts=opts)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('file'), file.ndef[1])
+            self.eq(nodes[0].ndef, ('crypto:x509:cert', s_common.guid(sha256)))
+            cert3 = nodes[0]
+
+            nodes = await core.nodes('inet:tls:servercert:server="tcp://8.8.8.8:53" $node.data.load(foo)')
+            self.len(1, nodes)
+            self.none(nodes[0].get('.seen'))
+            self.eq(nodes[0].get('server'), 'tcp://8.8.8.8:53')
+            self.eq(nodes[0].get('cert'), cert3.ndef[1])
+            self.isin('ssl.migration.three', nodes[0].tags)
+            self.eq(nodes[0].nodedata, {'foo': 'bar'})
+
+            # Check that edges were migrated
+            nodes = await core.nodes('meta:source -(seen)> *')
+            self.len(6, nodes)
+            self.sorteq(
+                [k.ndef[0] for k in nodes],
+                (
+                    'inet:ssl:cert', 'inet:ssl:cert', 'inet:ssl:cert',
+                    'inet:tls:servercert', 'inet:tls:servercert', 'inet:tls:servercert',
+                )
+            )
+
+            with self.raises(s_exc.BadArg) as exc:
+                await core.callStorm('inet:server | $lib.model.migration.s.inetSslCertToTlsServerCert($node)')
+            self.isin(', not inet:server', exc.exception.get('mesg'))
+
+        async with self.getRegrCore('inet_ssl_to_tls_servercert') as core:
+            q = 'inet:ssl:cert | $lib.model.migration.s.inetSslCertToTlsServerCert($node, nodata=$lib.true)'
+            await core.nodes(q)
+
+            nodes = await core.nodes('inet:tls:servercert:server="tcp://8.8.8.8:53" $node.data.load(foo)')
+            self.len(1, nodes)
+            self.none(nodes[0].get('.seen'))
+            self.eq(nodes[0].get('server'), 'tcp://8.8.8.8:53')
+            self.eq(nodes[0].get('cert'), cert3.ndef[1])
+            self.isin('ssl.migration.three', nodes[0].tags)
+            self.eq(nodes[0].nodedata, {'foo': None})

synapse/tests/test_lib_stormlib_modelext.py

@@ -22,6 +22,9 @@ class StormtypesModelextTest(s_test.SynTest):
 
                 $pinfo = ({"doc": "Extended a core model."})
                 $lib.model.ext.addFormProp(test:int, _tick, (time, ({})), $propinfo)
+
+                $edgeinfo = ({"doc": "A test edge."})
+                $lib.model.ext.addEdge(inet:user, _copies, *, $edgeinfo)
             ''')
 
             nodes = await core.nodes('[ _visi:int=10 :tick=20210101 ._woot=30 +#lol:score=99 ]')
@@ -44,6 +47,12 @@ class StormtypesModelextTest(s_test.SynTest):
                 q = '''$lib.model.ext.addUnivProp(_woot, (time, ({})), ({}))'''
                 await core.callStorm(q)
 
+            with self.raises(s_exc.DupEdgeType):
+                q = '''$lib.model.ext.addEdge(inet:user, _copies, *, ({}))'''
+                await core.callStorm(q)
+
+            self.nn(core.model.edge(('inet:user', '_copies', None)))
+
             # Grab the extended model definitions
             model_defs = await core.callStorm('return ( $lib.model.ext.getExtModel() )')
             self.isinstance(model_defs, dict)
@@ -55,6 +64,7 @@ class StormtypesModelextTest(s_test.SynTest):
                 $lib.model.ext.delFormProp(_visi:int, tick)
                 $lib.model.ext.delFormProp(test:int, _tick)
                 $lib.model.ext.delForm(_visi:int)
+                $lib.model.ext.delEdge(inet:user, _copies, *)
             ''')
 
             self.none(core.model.form('_visi:int'))
@@ -62,6 +72,7 @@ class StormtypesModelextTest(s_test.SynTest):
             self.none(core.model.prop('_visi:int:tick'))
             self.none(core.model.prop('test:int:_tick'))
             self.none(core.model.tagprop('score'))
+            self.none(core.model.edge(('inet:user', '_copies', None)))
 
             # Underscores can exist in extended names but only at specific locations
             q = '''$l =$lib.list('str', ({})) $d=({"doc": "Foo"})
@@ -105,6 +116,26 @@ class StormtypesModelextTest(s_test.SynTest):
                 q = '''$lib.model.ext.addTagProp(_someones:_score^value, (int, ({})), ({}))'''
                 await core.callStorm(q)
 
+            with self.raises(s_exc.BadEdgeDef):
+                q = '''$lib.model.ext.addEdge(*, does, *, ({}))'''
+                await core.callStorm(q)
+
+            with self.raises(s_exc.BadEdgeDef):
+                q = '''$lib.model.ext.addEdge(*, _NEWP, *, ({}))'''
+                await core.callStorm(q)
+
+            with self.raises(s_exc.BadEdgeDef):
+                q = '''$lib.model.ext.addEdge(*, "_ne wp", *, ({}))'''
+                await core.callStorm(q)
+
+            with self.raises(s_exc.BadEdgeDef):
+                q = f'''$lib.model.ext.addEdge(*, "_{'a'*201}", *, ({{}}))'''
+                await core.callStorm(q)
+
+            with self.raises(s_exc.BadEdgeDef):
+                q = '''$lib.model.ext.delEdge(*, "_ne wp", *)'''
+                await core.callStorm(q)
+
             # Permission errors
             visi = await core.auth.addUser('visi')
             opts = {'user': visi.iden}
@@ -133,6 +164,10 @@ class StormtypesModelextTest(s_test.SynTest):
                     $lib.model.ext.addTagProp(score, (int, ({})), $tagpropinfo)
                 ''', opts=opts)
 
+            with self.raises(s_exc.AuthDeny):
+                q = '''$lib.model.ext.addEdge(*, _does, *, ({}))'''
+                await core.callStorm(q, opts=opts)
+
         # Reload the model extensions automatically
         async with self.getTestCore() as core:
             opts = {'vars': {'model_defs': model_defs}}
@@ -174,6 +209,9 @@ class StormtypesModelextTest(s_test.SynTest):
 
                 $pinfo = ({"doc": "NEWP"})
                 $lib.model.ext.addFormProp(test:int, _tick, (time, ({})), $propinfo)
+
+                $edgeinfo = ({"doc": "NEWP"})
+                $lib.model.ext.addEdge(inet:user, _copies, *, $edgeinfo)
             ''')
 
             q = '''return ($lib.model.ext.addExtModel($model_defs))'''
@@ -196,6 +234,11 @@ class StormtypesModelextTest(s_test.SynTest):
                 opts = {'vars': {'model_defs': {'univs': model_defs['univs']}}}
                 await core.callStorm(q, opts)
 
+            q = '''return ($lib.model.ext.addExtModel($model_defs))'''
+            with self.raises(s_exc.BadEdgeDef) as cm:
+                opts = {'vars': {'model_defs': {'edges': model_defs['edges']}}}
+                await core.callStorm(q, opts)
+
         # Reload the model extensions from the dump by hand
         async with self.getTestCore() as core:
             opts = {'vars': {'model_defs': model_defs}}
@@ -212,6 +255,10 @@ class StormtypesModelextTest(s_test.SynTest):
             for ($prop, $def, $info) in $model_defs.univs {
                 $lib.model.ext.addUnivProp($prop, $def, $info)
             }
+            for ($edge, $info) in $model_defs.edges {
+                ($n1form, $verb, $n2form) = $edge
+                $lib.model.ext.addEdge($n1form, $verb, $n2form, $info)
+            }
             '''
             await core.nodes(q, opts)
 
@@ -227,6 +274,8 @@ class StormtypesModelextTest(s_test.SynTest):
             self.eq(nodes[0].ndef, ('test:int', 1234))
             self.eq(nodes[0].get('_tick'), 1609459200000)
 
+            self.nn(core.model.edge(('inet:user', '_copies', None)))
+
     async def test_lib_stormlib_behold_modelext(self):
         self.skipIfNexusReplay()
         async with self.getTestCore() as core:
@@ -252,6 +301,7 @@ class StormtypesModelextTest(s_test.SynTest):
                         $lib.model.ext.addFormProp(_behold:score, rank, (int, ({})), ({"doc": "second string"}))
                         $lib.model.ext.addUnivProp(_beep, (int, ({})), ({"doc": "third string"}))
                         $lib.model.ext.addTagProp(thingy, (int, ({})), ({"doc": "fourth string"}))
+                        $lib.model.ext.addEdge(*, _goes, geo:place, ({"doc": "fifth string"}))
                     ''')
 
                     formmesg = await sock.receive_json()
@@ -279,11 +329,17 @@ class StormtypesModelextTest(s_test.SynTest):
                     self.eq(tagpmesg['data']['info']['name'], 'thingy')
                     self.eq(tagpmesg['data']['info']['info'], {'doc': 'fourth string'})
 
+                    edgemesg = await sock.receive_json()
+                    self.eq(edgemesg['data']['event'], 'model:edge:add')
+                    self.eq(edgemesg['data']['info']['edge'], (None, '_goes', 'geo:place'))
+                    self.eq(edgemesg['data']['info']['info'], {'doc': 'fifth string'})
+
                     await core.callStorm('''
                         $lib.model.ext.delTagProp(thingy)
                         $lib.model.ext.delUnivProp(_beep)
                         $lib.model.ext.delFormProp(_behold:score, rank)
                         $lib.model.ext.delForm(_behold:score)
+                        $lib.model.ext.delEdge(*, _goes, geo:place)
                     ''')
                     deltagp = await sock.receive_json()
                     self.eq(deltagp['data']['event'], 'model:tagprop:del')
@@ -302,6 +358,10 @@ class StormtypesModelextTest(s_test.SynTest):
                     self.eq(delform['data']['event'], 'model:form:del')
                     self.eq(delform['data']['info']['form'], '_behold:score')
 
+                    deledge = await sock.receive_json()
+                    self.eq(deledge['data']['event'], 'model:edge:del')
+                    self.eq(deledge['data']['info']['edge'], (None, '_goes', 'geo:place'))
+
     async def test_lib_stormlib_modelext_delform(self):
         '''
         Verify extended forms can't be deleted if they have associated extended props
@@ -385,6 +445,10 @@ class StormtypesModelextTest(s_test.SynTest):
                 '$lib.model.ext.addTagProp(_foo:bar, (), ())',
                 'Tag property definitions should be a dict.'
             ),
+            (
+                '$lib.model.ext.addEdge(*, _foo, *, ())',
+                'Edge info should be a dict.'
+            ),
         )
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_storm.py

@@ -5,7 +5,7 @@ import synapse.tests.utils as s_test
 
 class LibStormTest(s_test.SynTest):
 
-    async def test_lib_stormlib_storm(self):
+    async def test_lib_stormlib_storm_eval(self):
         async with self.getTestCore() as core:
 
             opts = {'vars': {'text': '(10)'}}
@@ -61,3 +61,84 @@ class LibStormTest(s_test.SynTest):
 
                 mesg = f'Executing storm query via $lib.storm.eval() {{{q}}} as [root]'
                 self.isin(mesg, data)
+
+    async def test_lib_stormlib_storm(self):
+
+        async with self.getTestCore() as core:
+
+            q = '''
+            $query = '[ inet:fqdn=foo.com inet:fqdn=bar.com ]'
+            storm.exec $query
+            '''
+            self.len(2, await core.nodes(q))
+
+            q = '''[
+            (inet:ipv4=1.2.3.4 :asn=4)
+            (inet:ipv4=1.2.3.5 :asn=5)
+            (inet:ipv4=1.2.3.6 :asn=10)
+            ]'''
+            await core.nodes(q)
+
+            q = '''
+            $filter = '-:asn=10'
+            inet:ipv4:asn
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            q = '''
+            $pivot = ${ -> inet:asn }
+            inet:ipv4:asn
+            storm.exec $pivot
+            '''
+            nodes = await core.nodes(q)
+            self.len(3, nodes)
+            for node in nodes:
+                self.eq(node.form.name, 'inet:asn')
+
+            # Exec a non-runtsafe query
+            q = '''
+            inet:ipv4:asn
+            $filter = `+:asn={$node.repr().split('.').'-1'}`
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            iden = await core.callStorm('return($lib.view.get().fork().iden)')
+            msgs = await core.stormlist('''
+                $query = "[inet:fqdn=vertex.link +#haha] $lib.print(woot)"
+                $opts = ({"view": $view})
+                for $mesg in $lib.storm.run($query, opts=$opts) {
+                    if ($mesg.0 = "print") { $lib.print($mesg.1.mesg) }
+                }
+            ''', opts={'vars': {'view': iden}})
+            self.stormIsInPrint('woot', msgs)
+            self.len(1, await core.nodes('inet:fqdn#haha', opts={'view': iden}))
+
+            visi = await core.auth.addUser('visi')
+            msgs = await core.stormlist('''
+                $opts=({"user": $lib.auth.users.byname(root).iden})
+                for $mesg in $lib.storm.run("$lib.print(lolz)", opts=$opts) {
+                    if ($mesg.0 = "err") { $lib.print($mesg) }
+                    if ($mesg.0 = "print") { $lib.print($mesg) }
+                }
+            ''', opts={'user': visi.iden})
+            self.stormIsInErr('must have permission impersonate', msgs)
+            self.stormNotInPrint('lolz', msgs)
+
+            # no opts provided
+            msgs = await core.stormlist('''
+                $q = ${ $lib.print('hello') }
+                for $mesg in $lib.storm.run($q) {
+                    if ( $mesg.0 = 'print' ) {
+                        $lib.print(`mesg={$mesg.1.mesg}`)
+                    }
+                }
+            ''')
+            self.stormIsInPrint('mesg=hello', msgs)