synapse 2.169.0__py311-none-any.whl → 2.170.0__py311-none-any.whl

synapse/tests/test_lib_stormtypes.py

@@ -3568,6 +3568,114 @@ class StormTypesTest(s_test.SynTest):
             self.eq(counts.get('test:int'), 2)
             self.eq(counts.get('test:guid'), 1)
 
+    async def test_storm_lib_layer_sodebyform(self):
+        async with self.getTestCore() as core:
+
+            await core.nodes('$lib.model.ext.addTagProp(score, (int, ({})), ({}))')
+
+            view_prop = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_tags = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_tagp = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_n1eg = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_n2eg = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_data = await core.callStorm('return($lib.view.get().fork().iden)')
+            view_noop = await core.callStorm('return($lib.view.get().fork().iden)')
+
+            self.len(1, await core.nodes('[ test:str=foo +#base ]'))
+            self.len(1, await core.nodes('test:str=foo [ :hehe=haha ]', opts={'view': view_prop}))
+            self.len(1, await core.nodes('test:str=foo [ +#bar ]', opts={'view': view_tags}))
+            self.len(1, await core.nodes('test:str=foo [ +#base:score=10 ]', opts={'view': view_tagp}))
+            self.len(1, await core.nodes('test:str=foo [ +(bam)> {[ test:int=2 ]} ]', opts={'view': view_n1eg}))
+            self.len(1, await core.nodes('test:str=foo [ <(bam)+ {[ test:int=1 ]} ]', opts={'view': view_n2eg}))
+            self.len(1, await core.nodes('test:str=foo $node.data.set(hehe, haha)', opts={'view': view_data}))
+
+            scmd = '''
+                $sodes = ([])
+                for $sode in $lib.layer.get().getStorNodesByForm($form) {
+                    $sodes.append($sode)
+                }
+                return($sodes)
+            '''
+            opts = {'vars': {'form': 'test:str'}}
+
+            self.len(1, await core.callStorm(scmd, opts=opts))
+            self.len(1, await core.callStorm(scmd, opts={**opts, 'view': view_prop}))
+            self.len(1, await core.callStorm(scmd, opts={**opts, 'view': view_tags}))
+            self.len(1, await core.callStorm(scmd, opts={**opts, 'view': view_tagp}))
+            self.len(1, await core.callStorm(scmd, opts={**opts, 'view': view_n1eg}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_n2eg})) # n2-only sode not added
+            self.len(1, await core.callStorm(scmd, opts={**opts, 'view': view_data}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_noop}))
+
+            self.len(1, await core.nodes('test:str=foo [ -:hehe ]', opts={'view': view_prop}))
+            self.len(1, await core.nodes('test:str=foo [ -#bar ]', opts={'view': view_tags}))
+            self.len(1, await core.nodes('test:str=foo [ -#base:score ]', opts={'view': view_tagp}))
+            self.len(1, await core.nodes('test:str=foo [ -(bam)> {[ test:int=2 ]} ]', opts={'view': view_n1eg}))
+            self.len(1, await core.nodes('test:str=foo [ <(bam)- {[ test:int=1 ]} ]', opts={'view': view_n2eg}))
+            self.len(1, await core.nodes('test:str=foo $node.data.pop(hehe)', opts={'view': view_data}))
+
+            self.len(1, await core.callStorm(scmd, opts=opts))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_prop}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_tags}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_tagp}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_n1eg}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_n2eg}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_data}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_noop}))
+
+            self.len(1, await core.nodes('''
+                test:str=foo [
+                    :hehe=lol
+                    +#baz
+                    +#base:score=11
+                    +(bar)> {[ test:int=2 ]}
+                    <(bar)+ {[ test:int=1 ]}
+                ]
+                $node.data.set(haha, lol)
+            '''))
+            self.len(1, await core.nodes('test:str=foo [ :hehe=lol ]', opts={'view': view_prop}))
+            self.len(1, await core.nodes('test:str=foo [ +#baz ]', opts={'view': view_tags}))
+            self.len(1, await core.nodes('test:str=foo [ +#base:score=11 ]', opts={'view': view_tagp}))
+            self.len(1, await core.nodes('test:str=foo [ +(bar)> {[ test:int=2 ]} ]', opts={'view': view_n1eg}))
+            self.len(1, await core.nodes('test:str=foo [ <(bar)+ {[ test:int=1 ]} ]', opts={'view': view_n2eg}))
+            self.len(1, await core.nodes('test:str=foo $node.data.set(haha, lol)', opts={'view': view_data}))
+
+            self.len(1, await core.callStorm(scmd, opts=opts))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_prop}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_tags}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_tagp}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_n1eg}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_n2eg}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_data}))
+            self.len(0, await core.callStorm(scmd, opts={**opts, 'view': view_noop}))
+
+            self.len(1, await core.nodes('''
+                test:str=foo [
+                    -:hehe
+                    -#baz
+                    -#base:score -#base
+                    -(bar)> { test:int=2 }
+                    <(bar)- { test:int=1 }
+                ]
+                $node.data.pop(haha)
+            '''))
+            self.len(1, await core.callStorm(scmd, opts=opts))
+
+            await core.nodes('test:str=foo delnode')
+            self.len(0, await core.callStorm(scmd, opts=opts))
+
+            # sad
+
+            await self.asyncraises(s_exc.NoSuchForm, core.callStorm(scmd, opts={'vars': {'form': 'newp:newp'}}))
+
+            lowuser = await core.auth.addUser('low')
+            lowopts = opts | {'user': lowuser.iden, 'view': view_prop}
+
+            await self.asyncraises(s_exc.AuthDeny, core.callStorm(scmd, opts=lowopts))
+
+            await lowuser.addRule((True, ('view', 'read')), gateiden=view_prop)
+            await core.callStorm(scmd, opts=lowopts)
+
     async def test_storm_lib_layer_upstream(self):
         async with self.getTestCore() as core:
             async with self.getTestCore() as core2:
@@ -6596,11 +6704,10 @@ words\tword\twrd'''
             self.nn(await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts))
             self.eq([fork.iden], await core.callStorm(merging))
 
-            # confirm that you may not re-parent to a view with a merge request
+            # confirm that you may re-parent to a view with a merge request
             layr = await core.addLayer()
             vdef = await core.addView({'layers': (layr['iden'],)})
-            with self.raises(s_exc.BadState):
-                await core.getView(vdef['iden']).setViewInfo('parent', fork.iden)
+            await core.getView(vdef['iden']).setViewInfo('parent', fork.iden)
 
             opts = {'view': fork.iden, 'user': visi.iden}
             self.nn(await core.callStorm('return($lib.view.get().setMergeVote(approved=(false)))', opts=opts))
@@ -6650,28 +6757,42 @@ words\tword\twrd'''
 
             self.eq([], await core.callStorm(merging))
 
-            # test coverage for bad state for merge request
+            # merge a view with a fork
             fork00 = await core.getView().fork()
-            fork01 = await core.getView(fork00['iden']).fork()
+            midfork = core.getView(fork00['iden'])
 
-            opts = {'view': fork00['iden']}
-            with self.raises(s_exc.BadState):
-                await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
+            fork01 = await midfork.fork()
+            self.true(midfork.hasKids())
+
+            opts = {'view': midfork.iden}
+            await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
+
+            self.eq([midfork.iden], await core.callStorm(merging))
+
+            opts = {'view': midfork.iden, 'user': visi.iden}
+            await core.callStorm('return($lib.view.get().setMergeVote())', opts=opts)
+
+            self.true(await midfork.waitfini(timeout=12))
 
             self.eq([], await core.callStorm(merging))
 
-            await core.delView(fork01['iden'])
+            leaffork = core.getView(fork01['iden'])
+            self.false(leaffork.hasKids())
+
+            self.len(2, leaffork.layers)
+            self.eq(leaffork.parent, core.getView())
+
+            # test coverage for bad state for merge request
+            opts = {'view': fork01['iden']}
             await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
-            self.eq([fork00['iden']], await core.callStorm(merging))
+            self.eq([fork01['iden']], await core.callStorm(merging))
 
             core.getView().layers[0].readonly = True
             with self.raises(s_exc.BadState):
                 await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
 
             core.getView().layers[0].readonly = False
-
-            with self.raises(s_exc.BadState):
-                await core.callStorm('return($lib.view.get().fork())', opts=opts)
+            await core.callStorm('return($lib.view.get().fork())', opts=opts)
 
             # setup a new merge and make a mirror...
             forkdef = await core.getView().fork()
@@ -6681,7 +6802,7 @@ words\tword\twrd'''
             await core.stormlist('[ inet:ipv4=5.5.5.5 ]', opts=opts)
             await core.callStorm('return($lib.view.get().setMergeRequest())', opts=opts)
 
-            self.eq(set([fork.iden, fork00['iden']]), set(await core.callStorm(merging)))
+            self.eq(set([fork.iden, fork01['iden']]), set(await core.callStorm(merging)))
 
             # hamstring the runViewMerge method on the new view
             async def fake():

synapse/tests/test_lib_types.py

@@ -939,6 +939,26 @@ class TypesTest(s_t_utils.SynTest):
             self.raises(s_exc.NoSuchForm, t.repr, ('test:newp', 'newp'))
             self.raises(s_exc.BadTypeValu, t.norm, ('newp',))
 
+            ndef = core.model.type('test:ndef:formfilter1')
+            ndef.norm(('inet:ipv4', '1.2.3.4'))
+            ndef.norm(('inet:ipv6', '::1'))
+
+            with self.raises(s_exc.BadTypeValu):
+                ndef.norm(('inet:fqdn', 'newp.com'))
+
+            ndef = core.model.type('test:ndef:formfilter2')
+            ndef.norm(('ou:orgtype', 'foo'))
+
+            with self.raises(s_exc.BadTypeValu):
+                ndef.norm(('inet:fqdn', 'newp.com'))
+
+            ndef = core.model.type('test:ndef:formfilter3')
+            ndef.norm(('inet:ipv4', '1.2.3.4'))
+            ndef.norm(('file:mime:msdoc', s_common.guid()))
+
+            with self.raises(s_exc.BadTypeValu):
+                ndef.norm(('inet:fqdn', 'newp.com'))
+
     async def test_nodeprop(self):
         async with self.getTestCore() as core:
             t = core.model.type('nodeprop')

synapse/tests/test_lib_view.py

@@ -828,3 +828,80 @@ class ViewTest(s_t_utils.SynTest):
 
             with self.raises(s_exc.AuthDeny) as cm:
                 await core.nodes('$lib.view.get().merge()', opts=viewopts)
+
+    async def test_view_insert_parent_fork(self):
+
+        async with self.getTestCore() as core:
+
+            role = await core.auth.addRole('ninjas')
+            visi = await core.auth.addUser('visi')
+            asvisi = {'user': visi.iden}
+
+            view00 = core.getView()
+            view02 = core.getView((await view00.fork())['iden'])
+            view03 = core.getView((await view02.fork())['iden'])
+
+            self.eq(view02.parent, view00)
+
+            self.len(2, view02.layers)
+            self.len(3, view03.layers)
+
+            await view00.nodes('[ inet:fqdn=vertex.link ]')
+            await view02.nodes('inet:fqdn=vertex.link [ +#foo ]')
+
+            await view02.nodes('auth.user.addrule visi node --gate $lib.view.get().iden')
+            await view02.nodes('auth.user.mod visi --admin $lib.true --gate $lib.view.get().iden')
+            userrules = visi.getRules(gateiden=view02.iden)
+
+            await view02.nodes('auth.role.addrule ninjas node.add --gate $lib.view.get().iden')
+            rolerules = role.getRules(gateiden=view02.iden)
+
+            msgs = await core.stormlist('auth.user.addrule visi node --gate $lib.view.get().layers.0.iden')
+            self.stormHasNoWarnErr(msgs)
+
+            opts = {'vars': {'role': role.iden}}
+            quorum = await core.callStorm('return($lib.view.get().set(quorum, ({"count": 1, "roles": [$role]})))', opts=opts)
+
+            forkopts = {'view': view02.iden}
+            await core.callStorm('return($lib.view.get().setMergeRequest(comment=woot))', opts=forkopts)
+
+            merging = 'return($lib.view.get().getMergingViews()) '
+            self.eq([view02.iden], await core.callStorm(merging))
+
+            q = 'return($lib.view.get().insertParentFork(name=staging).iden)'
+            newiden = await core.callStorm(q, opts=forkopts)
+
+            self.eq([], await core.callStorm(merging))
+
+            view01 = core.getView(newiden)
+
+            self.ne(view02.parent, view00)
+            self.eq(view03.parent, view02)
+            self.eq(view02.parent, view01)
+            self.eq(view01.parent, view00)
+
+            self.len(2, view01.layers)
+            self.len(3, view02.layers)
+            self.len(4, view03.layers)
+            self.isin(view01.layers[0], view02.layers)
+            self.isin(view01.layers[0], view03.layers)
+
+            self.eq(userrules, visi.getRules(gateiden=view01.iden))
+            self.eq(rolerules, role.getRules(gateiden=view01.iden))
+
+            nodes = await view01.nodes('inet:fqdn=vertex.link')
+            self.none(nodes[0].getTag('foo'))
+
+            await core.nodes('merge --diff --apply', opts=forkopts)
+
+            nodes = await core.nodes('inet:fqdn=vertex.link')
+            self.none(nodes[0].getTag('foo'))
+
+            nodes = await view01.nodes('inet:fqdn=vertex.link')
+            self.nn(nodes[0].getTag('foo'))
+
+            with self.raises(s_exc.BadState):
+                await view00.insertParentFork(visi.iden)
+
+            with self.raises(s_exc.BadState):
+                await core.callStorm('return($lib.view.get().insertParentFork().iden)')

synapse/tests/test_model_files.py

@@ -576,3 +576,54 @@ class FileTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('file:archive:entry :user -> inet:user'))
             self.len(1, await core.nodes('file:archive:entry :file -> file:bytes'))
             self.len(1, await core.nodes('file:archive:entry :parent -> file:bytes'))
+
+    async def test_model_file_lnk(self):
+
+        async with self.getTestCore() as core:
+            nodes = await core.nodes(r'''[
+                file:mime:lnk=*
+                    :entry:primary="c:\\some\\stuff\\prog~2\\cmd.exe"
+                    :entry:secondary="c:\\some\\stuff\program files\\cmd.exe"
+                    :entry:extended="c:\\some\\actual\\stuff\\I\\swear\\cmd.exe"
+                    :entry:localized="c:\\some\\actual\\stuff\\I\\swear\\cmd.exe"
+                    :entry:icon="%windir%\\system32\\notepad.exe"
+
+                    :environment:path="%windir%\\system32\\cmd.exe"
+                    :environment:icon="%some%%envvar%"
+                    :working="%HOMEDRIVE%%HOMEPATH%"
+                    :relative="..\\..\\..\\some\\foo.bar.txt"
+                    :arguments="/q /c copy %systemroot%\\system32\\msh*.exe"
+                    :desc="I've been here the whole time."
+
+                    :flags=0x40df
+                    :target:attrs=0x20
+                    :target:size=12345
+                    :target:created="2023/01/25 18:57:45.284"
+                    :target:accessed="2023/01/25 18:57:45.284"
+                    :target:written="2023/01/25 18:57:45.284"
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+
+            self.eq(node.get('entry:primary'), 'c:/some/stuff/prog~2/cmd.exe')
+            self.eq(node.get('entry:secondary'), 'c:/some/stuff/program files/cmd.exe')
+            self.eq(node.get('entry:extended'), 'c:/some/actual/stuff/i/swear/cmd.exe')
+            self.eq(node.get('entry:localized'), 'c:/some/actual/stuff/i/swear/cmd.exe')
+
+            self.eq(node.get('entry:icon'), '%windir%/system32/notepad.exe')
+            self.eq(node.get('environment:path'), '%windir%/system32/cmd.exe')
+            self.eq(node.get('environment:icon'), '%some%%envvar%')
+
+            self.eq(node.get('working'), '%homedrive%%homepath%')
+            self.eq(node.get('relative'), '..\\..\\..\\some\\foo.bar.txt')
+            self.eq(node.get('arguments'), '/q /c copy %systemroot%\\system32\\msh*.exe')
+            self.eq(node.get('desc'), "I've been here the whole time.")
+
+            self.eq(node.get('flags'), 0x40df)
+            self.eq(node.get('target:attrs'), 0x20)
+            self.eq(node.get('target:size'), 12345)
+
+            time = 1674673065284
+            self.eq(node.get('target:created'), time)
+            self.eq(node.get('target:accessed'), time)
+            self.eq(node.get('target:written'), time)

synapse/tests/test_model_inet.py

@@ -4,7 +4,6 @@ import logging
 import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.tests.utils as s_t_utils
-from synapse.tests.utils import alist
 
 logger = logging.getLogger(__name__)
 
@@ -166,6 +165,7 @@ class InetModelTest(s_t_utils.SynTest):
             # IPv6
             self.eq(t.norm('icmp://::1'), ('icmp://::1', {'subs': {'ipv6': '::1', 'proto': 'icmp'}}))
             self.eq(t.norm('tcp://[::1]:2'), ('tcp://[::1]:2', {'subs': {'ipv6': '::1', 'port': 2, 'proto': 'tcp'}}))
+            self.eq(t.norm('tcp://[::1]'), ('tcp://[::1]', {'subs': {'ipv6': '::1', 'proto': 'tcp'}}))
             self.eq(t.norm('tcp://[::fFfF:0102:0304]:2'),
                     ('tcp://[::ffff:1.2.3.4]:2', {'subs': {'ipv6': '::ffff:1.2.3.4',
                                                            'ipv4': 0x01020304,
@@ -1471,6 +1471,68 @@ class InetModelTest(s_t_utils.SynTest):
             self.none(nodes[0].get('ipv4'))
             self.none(nodes[0].get('fqdn'))
 
+            q = '''
+            [
+                inet:url="http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html"
+                inet:url="http://[1080:0:0:0:8:800:200C:417A]/index.html?foo=bar"
+                inet:url="http://[3ffe:2a00:100:7031::1]"
+                inet:url="http://[1080::8:800:200C:417A]/foo"
+                inet:url="http://[::192.9.5.5]/ipng"
+                inet:url="http://[::FFFF:129.144.52.38]:80/index.html"
+                inet:url="https://[2010:836B:4179::836B:4179]"
+            ]
+            '''
+            nodes = await core.nodes(q)
+            self.len(7, nodes)
+            self.eq(nodes[0].get('base'), 'http://[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:80/index.html')
+            self.eq(nodes[0].get('proto'), 'http')
+            self.eq(nodes[0].get('path'), '/index.html')
+            self.eq(nodes[0].get('params'), '')
+            self.eq(nodes[0].get('ipv6'), 'fedc:ba98:7654:3210:fedc:ba98:7654:3210')
+            self.eq(nodes[0].get('port'), 80)
+
+            self.eq(nodes[1].get('base'), 'http://[1080::8:800:200c:417a]/index.html')
+            self.eq(nodes[1].get('proto'), 'http')
+            self.eq(nodes[1].get('path'), '/index.html')
+            self.eq(nodes[1].get('params'), '?foo=bar')
+            self.eq(nodes[1].get('ipv6'), '1080::8:800:200c:417a')
+            self.eq(nodes[1].get('port'), 80)
+
+            self.eq(nodes[2].get('base'), 'http://[3ffe:2a00:100:7031::1]')
+            self.eq(nodes[2].get('proto'), 'http')
+            self.eq(nodes[2].get('path'), '')
+            self.eq(nodes[2].get('params'), '')
+            self.eq(nodes[2].get('ipv6'), '3ffe:2a00:100:7031::1')
+            self.eq(nodes[2].get('port'), 80)
+
+            self.eq(nodes[3].get('base'), 'http://[1080::8:800:200c:417a]/foo')
+            self.eq(nodes[3].get('proto'), 'http')
+            self.eq(nodes[3].get('path'), '/foo')
+            self.eq(nodes[3].get('params'), '')
+            self.eq(nodes[3].get('ipv6'), '1080::8:800:200c:417a')
+            self.eq(nodes[3].get('port'), 80)
+
+            self.eq(nodes[4].get('base'), 'http://[::c009:505]/ipng')
+            self.eq(nodes[4].get('proto'), 'http')
+            self.eq(nodes[4].get('path'), '/ipng')
+            self.eq(nodes[4].get('params'), '')
+            self.eq(nodes[4].get('ipv6'), '::c009:505')
+            self.eq(nodes[4].get('port'), 80)
+
+            self.eq(nodes[5].get('base'), 'http://[::ffff:129.144.52.38]:80/index.html')
+            self.eq(nodes[5].get('proto'), 'http')
+            self.eq(nodes[5].get('path'), '/index.html')
+            self.eq(nodes[5].get('params'), '')
+            self.eq(nodes[5].get('ipv6'), '::ffff:129.144.52.38')
+            self.eq(nodes[5].get('port'), 80)
+
+            self.eq(nodes[6].get('base'), 'https://[2010:836b:4179::836b:4179]')
+            self.eq(nodes[6].get('proto'), 'https')
+            self.eq(nodes[6].get('path'), '')
+            self.eq(nodes[6].get('params'), '')
+            self.eq(nodes[6].get('ipv6'), '2010:836b:4179::836b:4179')
+            self.eq(nodes[6].get('port'), 443)
+
     async def test_url_file(self):
 
         async with self.getTestCore() as core: