synapse 2.153.0__py311-none-any.whl → 2.154.0__py311-none-any.whl

synapse/tests/files/stormpkg/badapidef.yaml

@@ -0,0 +1,13 @@
+name: testpkg
+version: 0.0.1
+
+modules:
+  - name: apimod
+    apidefs:
+      - name: status
+        desc: Get the status of the foo.
+        type:
+          type: function
+          returns:
+            type: 42
+            desc: A status dictionary.

synapse/tests/files/stormpkg/storm/modules/apimod

@@ -0,0 +1,10 @@
+
+function search(text, mintime="-30days") {
+    for $t in $text {
+        [ it:devstr=$t ]
+    }
+}
+
+function status() {
+    return(({"ok": true}))
+}

synapse/tests/files/stormpkg/testpkg.yaml

@@ -7,6 +7,29 @@ logo:
 
 modules:
     - name: testmod
+    - name: apimod
+      apidefs:
+        - name: search
+          desc: |
+            Execute a search
+            
+            This API will foo the bar.
+          type:
+            type: function
+            args:
+              - { name: text, type: str, desc: "The text." }
+              - { name: mintime, type: [str, int], desc: "The mintime.", default: "-30days" }
+            returns:
+              name: yields
+              type: node
+              desc: Yields it:dev:str nodes.
+        - name: status
+          desc: Get the status of the foo.
+          type:
+            type: function
+            returns:
+              type: dict
+              desc: A status dictionary.
 
 external_modules:
     - name: testext

synapse/tests/test_cortex.py

@@ -6117,55 +6117,71 @@ class CortexBasicTest(s_t_utils.SynTest):
             self.true(layr.lockmemory)
 
     async def test_cortex_storm_lib_dmon(self):
-        async with self.getTestCoreAndProxy() as (core, prox):
-            nodes = await core.nodes('''
 
-                $lib.print(hi)
+        with self.getTestDir() as dirn:
 
-                $tx = $lib.queue.add(tx)
-                $rx = $lib.queue.add(rx)
+            async with self.getTestCoreAndProxy(dirn=dirn) as (core, prox):
+                nodes = await core.nodes('''
 
-                $ddef = $lib.dmon.add(${
+                    $lib.print(hi)
 
-                    $rx = $lib.queue.get(tx)
-                    $tx = $lib.queue.get(rx)
+                    $tx = $lib.queue.add(tx)
+                    $rx = $lib.queue.add(rx)
 
-                    $ipv4 = nope
-                    for ($offs, $ipv4) in $rx.gets(wait=1) {
-                        [ inet:ipv4=$ipv4 ]
-                        $rx.cull($offs)
-                        $tx.put($ipv4)
-                    }
-                })
+                    $ddef = $lib.dmon.add(${
 
-                $tx.put(1.2.3.4)
+                        $rx = $lib.queue.get(tx)
+                        $tx = $lib.queue.get(rx)
 
-                for ($xoff, $xpv4) in $rx.gets(size=1, wait=1) { }
+                        $ipv4 = nope
+                        for ($offs, $ipv4) in $rx.gets(wait=1) {
+                            [ inet:ipv4=$ipv4 ]
+                            $rx.cull($offs)
+                            $tx.put($ipv4)
+                        }
+                    })
 
-                $lib.print(xed)
+                    $tx.put(1.2.3.4)
 
-                inet:ipv4=$xpv4
+                    for ($xoff, $xpv4) in $rx.gets(size=1, wait=1) { }
 
-                $lib.dmon.del($ddef.iden)
+                    $lib.print(xed)
 
-                $lib.queue.del(tx)
-                $lib.queue.del(rx)
-            ''')
-            self.len(1, nodes)
-            self.len(0, await prox.getStormDmons())
+                    inet:ipv4=$xpv4
 
-            with self.raises(s_exc.NoSuchIden):
-                await core.nodes('$lib.dmon.del(newp)')
+                    $lib.dmon.del($ddef.iden)
 
-            await core.stormlist('auth.user.add user')
-            user = await core.auth.getUserByName('user')
-            asuser = {'user': user.iden}
+                    $lib.queue.del(tx)
+                    $lib.queue.del(rx)
+                ''')
+                self.len(1, nodes)
+                self.len(0, await prox.getStormDmons())
 
-            ddef = await core.callStorm('return($lib.dmon.add(${$lib.print(foo)}))')
-            iden = ddef.get('iden')
+                with self.raises(s_exc.NoSuchIden):
+                    await core.nodes('$lib.dmon.del(newp)')
 
-            with self.raises(s_exc.AuthDeny):
-                await core.callStorm(f'$lib.dmon.del({iden})', opts=asuser)
+                await core.stormlist('auth.user.add user')
+                user = await core.auth.getUserByName('user')
+                asuser = {'user': user.iden}
+
+                ddef = await core.callStorm('return($lib.dmon.add(${$lib.print(foo)}))')
+                iden = ddef.get('iden')
+                asuser['vars'] = {'iden': iden}
+
+                with self.raises(s_exc.AuthDeny):
+                    await core.callStorm(f'$lib.dmon.del($iden)', opts=asuser)
+
+                # remove the dmon without a nexus entry to verify recover works
+                await core._delStormDmon(iden)
+                self.none(await core.callStorm('return($lib.dmon.get($iden))', opts=asuser))
+                self.eq('storm:dmon:add', (await core.nexsroot.nexslog.last())[1][1])
+
+            async with self.getTestCoreAndProxy(dirn=dirn) as (core, prox):
+
+                # nexus recover() previously failed on adding to the hive
+                # although the dmon would get successfully started
+                self.nn(await core.callStorm('return($lib.dmon.get($iden))', opts=asuser))
+                self.nn(core.stormdmonhive.get(iden))
 
     async def test_cortex_storm_dmon_view(self):
 

synapse/tests/test_lib_ast.py

@@ -2057,6 +2057,13 @@ class AstTest(s_test.SynTest):
             else { $lib.print(no) }
             '''
             msgs = await core.stormlist(q)
+            self.stormIsInPrint('yes', msgs)
+
+            q = '''test:str $data=$node.value()
+            if ($data ~= "(?-i:brown)") { $lib.print(yes) }
+            else { $lib.print(no) }
+            '''
+            msgs = await core.stormlist(q)
             self.stormIsInPrint('no', msgs)
 
             q = '''test:str $data=$node.value()

synapse/tests/test_lib_autodoc.py

@@ -62,7 +62,7 @@ shave'''
         self.eq(s_autodoc.getArgLines({}), [])
         lines = s_autodoc.getArgLines(rtype)
         self.eq(lines, ['\n', 'Args:', '    foo (str): The foos!', '\n',
-                        '    bar: The bar. The input type may one one of the following: ``str``, ``int``.',
+                        '    bar: The bar. The input type may be one of the following: ``str``, ``int``.',
                         '\n', '    \\*\\*kwargs (any): Extra foobars.', '\n'])
 
         lines = s_autodoc.getArgLines({'args': [{'name': 'cmplx', 'type': {}, 'desc': 'unsupported'}]})

synapse/tests/test_lib_modelrev.py

@@ -419,3 +419,12 @@ class ModelRevTest(s_tests.SynTest):
 
             self.len(1, await core.nodes('risk:vulnname="woot woot"'))
             self.len(1, await core.nodes('risk:vuln:name="woot woot"'))
+
+    async def test_modelrev_0_2_22(self):
+
+        async with self.getRegrCore('model-0.2.22') as core:
+            nodes = await core.nodes('inet:ipv4=100.64.0.0/10')
+            self.len(257, nodes)
+
+            for node in nodes:
+                self.eq(node.props.get('type'), 'shared')

synapse/tests/test_lib_node.py

@@ -517,3 +517,58 @@ class NodeTest(s_t_utils.SynTest):
 
             msgs = await core.stormlist(edgeq)
             self.len(1, [m for m in msgs if m[0] == 'print'])
+
+    async def test_node_remove_missing_basetag(self):
+
+        async with self.getTestCore() as core:
+
+            base = await core.callStorm('return($lib.view.get().iden)')
+            fork = await core.callStorm('return($lib.view.get().fork().iden)')
+
+            await core.nodes('[test:str=neato +#foo.one]', opts={'view': base})
+            await core.nodes('test:str=neato | [ +#foo.two ]', opts={'view': fork})
+
+            await core.nodes('test:str=neato | [ -#foo ]', opts={'view': base})
+
+            othr = await core.nodes('test:str=neato', opts={'view': fork})
+            self.len(1, othr)
+            self.isin('foo.two', othr[0].tags)
+            self.notin('foo', othr[0].tags)
+
+            msgs = await core.stormlist('test:str=neato | [ -#foo ]', opts={'view': fork})
+            edits = [m[1] for m in msgs if m[0] == 'node:edits']
+            nodes = [m[1] for m in msgs if m[0] == 'node']
+            self.len(1, edits)
+            self.len(1, edits[0]['edits'][0][2])
+
+            self.len(1, nodes)
+            self.len(0, nodes[0][1]['tags'])
+
+            await core.nodes('[test:int=12 +#ping.pong.neato.burrito]', opts={'view': base})
+            await core.nodes('test:int=12 | [ +#ping.pong.awesome.possum ]', opts={'view': fork})
+
+            await core.nodes('test:int=12 | [ -#ping.pong]', opts={'view': base})
+
+            othr = await core.nodes('test:int=12', opts={'view': fork})
+            self.len(1, othr)
+            self.isin('ping', othr[0].tags)
+            self.isin('ping.pong.awesome', othr[0].tags)
+            self.isin('ping.pong.awesome.possum', othr[0].tags)
+
+            self.notin('ping.pong', othr[0].tags)
+
+            msgs = await core.stormlist('test:int=12 | [ -#ping.pong ]', opts={'view': fork})
+            edits = [m[1] for m in msgs if m[0] == 'node:edits']
+            nodes = [m[1] for m in msgs if m[0] == 'node']
+
+            self.len(1, edits)
+            self.len(2, edits[0]['edits'][0][2])
+
+            self.len(1, nodes)
+            self.len(1, nodes[0][1]['tags'])
+            self.isin('ping', nodes[0][1]['tags'])
+
+            nodes = await core.nodes('test:int=12 | [ -#p ]')
+            self.len(1, nodes)
+            self.len(1, nodes[0].tags)
+            self.isin('ping', nodes[0].tags)

synapse/tests/test_lib_storm.py

@@ -1213,6 +1213,19 @@ class StormTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('test:str', 'pluto\udcbaneptune'))
 
+            nodes = await core.nodes('[ media:news=* :publisher:name=woot ] $name=:publisher:name [ :publisher={ gen.ou.org $name } ]')
+            self.len(1, nodes)
+            self.nn(nodes[0].get('publisher'))
+
+            # test regular expressions are case insensitive by default
+            self.len(1, await core.nodes('test:str~=Pluto'))
+            self.len(1, await core.nodes('test:str +test:str~=Pluto'))
+            self.true(await core.callStorm('return(("Foo" ~= "foo"))'))
+            self.len(0, await core.nodes('test:str~="(?-i:Pluto)"'))
+            self.len(0, await core.nodes('test:str +test:str~="(?-i:Pluto)"'))
+            self.false(await core.callStorm('return(("Foo" ~= "(?-i:foo)"))'))
+            self.true(await core.callStorm('return(("Foo" ~= "(?-i:Foo)"))'))
+
     async def test_storm_diff_merge(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_storm.py

@@ -28,3 +28,11 @@ class LibStormTest(s_test.SynTest):
 
             # for coverage of forked call...
             self.nn(s_parser.parseEval('woot'))
+
+            # Readonly functionality is sane
+            msgs = await core.stormlist('$lib.print($lib.storm.eval( "{$lib.print(wow)}" ))')
+            self.stormIsInPrint('wow', msgs)
+            self.stormIsInPrint('$lib.null', msgs)
+
+            with self.raises(s_exc.IsReadOnly):
+                await core.callStorm('$lib.storm.eval( "{$lib.auth.users.add(readonly)}" )', opts={'readonly': True})

synapse/tests/test_lib_stormsvc.py

@@ -317,7 +317,30 @@ class StormvarService(s_cell.CellApi, s_stormsvc.StormSvc):
                     $lib.print('my foo var is {f}', f=$fooz)
                     ''',
                 },
-            )
+            ),
+            'modules': (
+                {
+                    'name': 'testmod',
+                    'storm': '',
+                },
+                {
+                    'name': 'apimod',
+                    'storm': 'function status() { return($lib.true) }',
+                    'apidefs': (
+                        {
+                            'name': 'status',
+                            'desc': 'Status of the foo.',
+                            'type': {
+                                'type': 'function',
+                                'returns': {
+                                    'type': 'boolean',
+                                    'desc': 'Where foo is ok',
+                                },
+                            },
+                        },
+                    ),
+                },
+            ),
         },
     )
 

synapse/tests/test_lib_stormtypes.py

@@ -613,6 +613,14 @@ class StormTypesTest(s_test.SynTest):
                     'name': 'test',
                     'storm': '$valu=$modconf.valu function getvalu() { return($valu) }',
                     'modconf': {'valu': 'foo'},
+                },
+                {
+                    'name': 'test.danger',
+                    'storm': '''
+                        init { $src=$lib.null }
+                        function genSrc() { if $src { return ($src) } [meta:source=(s1,)] $src=$node return ($node) }
+                        $genSrc()
+                        '''
                 }
             ],
             'commands': [
@@ -735,9 +743,13 @@ class StormTypesTest(s_test.SynTest):
 
             await core.callStorm('$test = $lib.import(test) $test.modconf.valu=bar')
             self.eq('foo', await core.callStorm('return($lib.import(test).getvalu())'))
+            self.eq('foo', await core.callStorm('return($lib.import(test).getvalu())', opts={'readonly': True}))
+
+            with self.raises(s_exc.IsReadOnly):
+                await core.callStorm('return($lib.import(test.danger).src)', opts={'readonly': True})
 
             mods = await core.getStormMods()
-            self.len(1, mods)
+            self.len(2, mods)
             mods['test']['modconf']['valu'] = 'bar'
             mods = await core.getStormMods()
             self.eq('foo', mods['test']['modconf']['valu'])
@@ -1181,6 +1193,24 @@ class StormTypesTest(s_test.SynTest):
             '''
             self.eq(2, await core.callStorm(q))
 
+            q = '''
+            $q=${ return( $lib.auth.users.byname(root).name ) }
+            return ( $q.exec() )
+            '''
+            self.eq('root', await core.callStorm(q, opts={'readonly': True}))
+
+            q = '''
+            $q=${ test:int=1 }
+            return ( $q.size() )
+            '''
+            self.eq(1, await core.callStorm(q, opts={'readonly': True}))
+
+            with self.raises(s_exc.IsReadOnly):
+                await core.callStorm('$foo=${ [test:str=readonly] } return ( $foo.exec() )', opts={'readonly': True})
+
+            with self.raises(s_exc.IsReadOnly):
+                await core.callStorm('$foo=${ [test:str=readonly] } return( $foo.size() )', opts={'readonly': True})
+
     async def test_storm_lib_node(self):
         async with self.getTestCore() as core:
             nodes = await core.nodes('[ test:str=woot :tick=2001] [ test:int=$node.isform(test:str) ] +test:int')
@@ -1514,6 +1544,72 @@ class StormTypesTest(s_test.SynTest):
                 q = '$foo=$lib.text(foo) $bar=$lib.text(bar) $v=($foo, aString, $bar,) $v.sort() return ($v)'
                 await core.callStorm(q)
 
+            q = '$l = (1, 2, (3), 4, 1, (3), 3, asdf) return ( $l.unique() )'
+            self.eq(['1', '2', 3, '4', '3', 'asdf'], await core.callStorm(q))
+
+            q = '$a=$lib.text(hehe) $b=$lib.text(haha) $c=$lib.text(hehe) $foo=($a, $b, $c) return ($foo.unique())'
+            self.eq(['hehe', 'haha'], await core.callStorm(q))
+
+            await core.addUser('lowuser1')
+            await core.addUser('lowuser2')
+            q = '''
+            $a=$lib.auth.users.byname(lowuser1) $b=$lib.auth.users.byname(lowuser2) $r=$lib.auth.users.byname(root)
+            $l = ($a, $r, $b, $b, $a ) $l2 = $l.unique() $l3 = ()
+            for $user in $l2 {
+                $l3.append($user.name)
+            }
+            return ( $l3 )'''
+            self.eq(['lowuser1', 'root', 'lowuser2'], await core.callStorm(q))
+
+            q = '$l=(1, 2, 3, 3, $lib.queue) return ( $lib.len($l.unique()) )'
+            self.eq(4, await core.callStorm(q))
+
+            # funcs are different class instances here
+            q = '$l = (1, 2, 2, $lib.inet.http.get, $lib.inet.http.get) return ($lib.len($l.unique()))'
+            self.eq(4, await core.callStorm(q))
+
+            # funcs are the same class instance
+            q = '$hehe = $lib.inet.http $l = (1, 2, 2, $hehe.get, $hehe.get) return ($lib.len($l.unique()))'
+            self.eq(3, await core.callStorm(q))
+
+            q = '''
+            function foo() {}
+            function bar() {}
+            $l = ($foo, $bar)
+            return ($lib.len($l.unique()))
+            '''
+            self.eq(2, await core.callStorm(q))
+
+            q = '''
+            function foo() {}
+            function bar() {}
+            $l = ($bar, $foo, $bar)
+            return ($lib.len($l.unique()))
+            '''
+            self.eq(2, await core.callStorm(q))
+
+            q = '''
+            $q1 = $lib.queue.gen(hehe)
+            $q2 = $lib.queue.get(hehe)
+            $l = ($q1, $q2)
+            return ( $lib.len($l.unique()) ) '''
+            self.eq(1, await core.callStorm(q))
+
+            q = '''
+            $q1 = $lib.queue.gen(hehe)
+            $q2 = $lib.queue.get(hehe)
+            $l = ($q1, $q2, $q2)
+            return ( $lib.len($l.unique()) ) '''
+            self.eq(1, await core.callStorm(q))
+
+            q = '''
+            $q1 = $lib.queue.gen(hehe)
+            $q2 = $lib.queue.get(hehe)
+            $q3 = $lib.queue.get(hehe)
+            $l = ($q1, $q2, $q3)
+            return ( $lib.len($l.unique()) ) '''
+            self.eq(1, await core.callStorm(q))
+
             # Python Tuples can be treated like a List object for accessing via data inside of.
             q = '[ test:comp=(10,lol) ] $x=$node.ndef().index(1).index(1) [ test:str=$x ]'
             nodes = await core.nodes(q)
@@ -3465,10 +3561,18 @@ class StormTypesTest(s_test.SynTest):
             layrs0 = (layr0.iden, ldef1.get('iden'))
             layrs1 = (ldef1.get('iden'), layr0.iden)
 
+            # fork the default view to test editing the root view layers
+            fork00 = await core.callStorm('return($lib.view.get().fork().iden)')
+            self.eq(2, await core.callStorm('return($lib.view.get().layers.size())', opts={'view': fork00}))
+
             await core.callStorm('$lib.view.get().set(layers, $layers)', opts={'vars': {'layers': layrs0}})
             ldefs = await core.callStorm('return($lib.view.get().get(layers))')
             self.eq(layrs0, [x.get('iden') for x in ldefs])
 
+            layers = await core.callStorm('return($lib.view.get().layers)', opts={'view': fork00})
+            self.eq(layrs0, [layr['iden'] for layr in layers][-2:])
+            self.len(3, layers)
+
             await core.callStorm('$lib.view.get().set(layers, $layers)', opts={'vars': {'layers': layrs1}})
             ldefs = await core.callStorm('return($lib.view.get().get(layers))')
             self.eq(layrs1, [x.get('iden') for x in ldefs])