synapse 2.179.0__py311-none-any.whl → 2.180.1__py311-none-any.whl

synapse/tests/test_lib_ast.py

@@ -4100,3 +4100,234 @@ class AstTest(s_test.SynTest):
             q = 'media:news=(m0,) [-:published]'
             msgs = await core.stormlist(q, opts=aslow)
             self.stormIsInErr('must have permission node.prop.del.media:news.published', msgs)
+
+    async def test_ast_path_links(self):
+
+        async with self.getTestCore() as core:  # type: s_cortex.Cortex
+            guid = s_common.guid()
+            opts = {'vars': {'guid': guid}}
+
+            burr = (await core.nodes('[test:comp=(1234, burrito)]'))[0]
+            guid = (await core.nodes('[test:guid=$guid :size=176 :tick=now]', opts=opts))[0]
+            edge = (await core.nodes('[test:edge=(("test:guid", $guid), ("test:str", abcd))]', opts=opts))[0]
+            comp = (await core.nodes('[test:complexcomp=(1234, STUFF) +#foo.bar]'))[0]
+            tstr = (await core.nodes('[test:str=foobar :bar=(test:ro, "ackbar") :ndefs=((test:guid, $guid), (test:auto, "auto"))]', opts=opts))[0]
+            arry = (await core.nodes('[test:arrayprop=* :ints=(3245, 678) :strs=("foo", "bar", "foobar")]'))[0]
+            ostr = (await core.nodes('test:str=foo [ :bar=(test:ro, "ackbar") :ndefs=((test:int, 176), )]'))[0]
+            pstr = (await core.nodes('test:str=bar [ :ndefs=((test:guid, $guid), (test:auto, "auto"), (test:ro, "ackbar"))]', opts=opts))[0]
+            (await core.nodes('[test:arrayform=(1234, 176)]'))[0]
+            (await core.nodes('[test:arrayform=(3245, 678)]'))[0]
+
+            await core.nodes('test:int=176 [ <(seen)+ { test:guid } ]')
+            await core.nodes('test:int=176 [ <(someedge)+ { test:guid } ]')
+            await core.nodes('test:complexcomp [ <(refs)+ { test:arrayprop } ]')
+            await core.nodes('test:complexcomp [ +(concerns)> { test:ro } ]')
+            await core.nodes('test:edge [ <(seen)+ { test:guid } ]')
+
+            small = (await core.nodes('test:int=176'))[0]
+            large = (await core.nodes('test:int=1234'))[0]
+            auto = (await core.nodes('test:auto'))[0]
+            basetag = (await core.nodes('syn:tag=foo'))[0]
+            tag = (await core.nodes('syn:tag=foo.bar'))[0]
+            ro = (await core.nodes('test:ro'))[0]
+
+            def _assert_edge(msgs, src, edge, nidx=0, eidx=0):
+                nodes = [m[1] for m in msgs if m[0] == 'node']
+                links = nodes[nidx][1].get('links')
+                self.nn(links)
+                self.lt(eidx, len(links))
+                self.eq(links[eidx], (src.iden(), edge))
+
+            opts = {'links': True}
+
+            # non-runtsafe lift could be anything
+            msgs = await core.stormlist('test:str=foobar $newform=$node.props.bar.0 *$newform', opts={'links': True, 'vars': {'form': 'inet:ipv4'}})
+            _assert_edge(msgs, tstr, {'type': 'runtime'}, nidx=1)
+
+            # FormPivot
+            # -> baz:ndef
+            msgs = await core.stormlist('test:guid -> test:edge:n1', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'n1', 'reverse': True})
+
+            # plain old pivot
+            msgs = await core.stormlist('test:int=176 -> test:guid:size', opts=opts)
+            _assert_edge(msgs, small, {'type': 'prop', 'prop': 'size', 'reverse': True})
+
+            # graph edge dest form uses n1 automagically
+            msgs = await core.stormlist('test:guid -> test:edge', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'n1', 'reverse': True})
+
+            # <syn:tag> -> <form>
+            msgs = await core.stormlist('syn:tag=foo.bar -> test:complexcomp', opts=opts)
+            _assert_edge(msgs, tag, {'type': 'tag', 'tag': 'foo.bar', 'reverse': True})
+
+            # source node is a graph edge, use n2
+            msgs = await core.stormlist('test:edge -> test:str', opts=opts)
+            _assert_edge(msgs, edge, {'type': 'prop', 'prop': 'n2'})
+
+            # refs out - prop
+            msgs = await core.stormlist('test:complexcomp -> test:int', opts=opts)
+            _assert_edge(msgs, comp, {'type': 'prop', 'prop': 'foo'})
+
+            # refs out - array
+            msgs = await core.stormlist('test:arrayprop -> test:int', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'})
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'}, nidx=1)
+
+            # refs out - ndef
+            msgs = await core.stormlist('test:str -> test:ro', opts=opts)
+            _assert_edge(msgs, pstr, {'type': 'prop', 'prop': 'ndefs'})
+            _assert_edge(msgs, ostr, {'type': 'prop', 'prop': 'bar'}, nidx=1)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'bar'}, nidx=2)
+
+            # refs out - ndefarray
+            msgs = await core.stormlist('test:str -> test:auto', opts=opts)
+            _assert_edge(msgs, pstr, {'type': 'prop', 'prop': 'ndefs'})
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'}, nidx=1)
+
+            # reverse prop refs
+            msgs = await core.stormlist('test:int -> test:complexcomp', opts=opts)
+            _assert_edge(msgs, large, {'type': 'prop', 'prop': 'foo', 'reverse': True})
+
+            # reverse array refs
+            msgs = await core.stormlist('test:int -> test:arrayprop', opts=opts)
+            sixer = (await core.nodes('test:int=678'))[0]
+            thou = (await core.nodes('test:int=3245'))[0]
+            _assert_edge(msgs, sixer, {'type': 'prop', 'prop': 'ints', 'reverse': True})
+            _assert_edge(msgs, thou, {'type': 'prop', 'prop': 'ints', 'reverse': True}, nidx=1)
+
+            # reverse ndef refs
+            msgs = await core.stormlist('test:ro -> test:str', opts=opts)
+            _assert_edge(msgs, ro, {'type': 'prop', 'prop': 'bar', 'reverse': True})
+
+            # reverse ndefarray refs
+            msgs = await core.stormlist('test:auto -> test:str', opts=opts)
+            _assert_edge(msgs, auto, {'type': 'prop', 'prop': 'ndefs', 'reverse': True})
+
+            # PivotOut syn:tag
+            msgs = await core.stormlist('syn:tag -> *', opts=opts)
+            _assert_edge(msgs, basetag, {'type': 'tag', 'tag': 'foo', 'reverse': True})
+            _assert_edge(msgs, tag, {'type': 'tag', 'tag': 'foo.bar', 'reverse': True}, nidx=1)
+
+            # PivotOut edge uses n2 automatically
+            msgs = await core.stormlist('test:edge -> *', opts=opts)
+            _assert_edge(msgs, edge, {'type': 'prop', 'prop': 'n2'})
+
+            # PivotOut prop
+            msgs = await core.stormlist('test:guid -> *', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'size'})
+
+            # PivotOut prop array
+            msgs = await core.stormlist('test:arrayprop -> *', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'})
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'}, nidx=1)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'strs'}, nidx=2)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'strs'}, nidx=3)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'strs'}, nidx=4)
+
+            # PivotOut prop ndef and ndef array
+            msgs = await core.stormlist('test:str=foobar -> *', opts=opts)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'bar'})
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'}, nidx=1)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'}, nidx=2)
+
+            # PivotToTags
+            msgs = await core.stormlist('test:complexcomp -> #', opts=opts)
+            _assert_edge(msgs, comp, {'type': 'tag', 'tag': 'foo.bar'})
+
+            # PivotIn prop
+            msgs = await core.stormlist('test:int=176 <- *', opts=opts)
+            _assert_edge(msgs, small, {'type': 'prop', 'prop': 'size', 'reverse': True})
+
+            # PivotIn array prop
+            msgs = await core.stormlist('test:str=foobar <- *', opts=opts)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'strs', 'reverse': True})
+
+            # PivotIn edge uses n1 automatically
+            msgs = await core.stormlist('test:edge <- *', opts=opts)
+            _assert_edge(msgs, edge, {'type': 'prop', 'prop': 'n1', 'reverse': True})
+
+            # PivotIn ndef
+            msgs = await core.stormlist('test:ro <- *', opts=opts)
+            _assert_edge(msgs, ro, {'type': 'prop', 'prop': 'bar', 'reverse': True})
+
+            # PivotIn array ndef
+            msgs = await core.stormlist('test:auto <- *', opts=opts)
+            _assert_edge(msgs, auto, {'type': 'prop', 'prop': 'ndefs', 'reverse': True})
+
+            # PivotInFrom "<- edge"
+            abcd = (await core.nodes('test:str=abcd'))[0]
+            msgs = await core.stormlist('test:str <- test:edge', opts=opts)
+            _assert_edge(msgs, abcd, {'type': 'prop', 'prop': 'n2', 'reverse': True})
+
+            # PivotInFrom "edge <- form"
+            msgs = await core.stormlist('test:edge <- test:guid', opts=opts)
+            _assert_edge(msgs, edge, {'type': 'prop', 'prop': 'n1', 'reverse': True})
+
+            # PropPivotOut prop
+            msgs = await core.stormlist('test:guid :size -> *', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'size'})
+
+            # PropPivotOut ndef
+            msgs = await core.stormlist('test:str=foobar :bar -> *', opts=opts)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'bar'})
+
+            # PropPivotOut array
+            msgs = await core.stormlist('test:arrayprop :ints -> *', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'})
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'}, nidx=1)
+
+            # PropPivotOut array ndef
+            msgs = await core.stormlist('test:str=foobar :ndefs -> *', opts=opts)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'})
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'}, nidx=1)
+
+            # PropPivot prop to form
+            msgs = await core.stormlist('test:guid :size -> test:int', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'size'})
+
+            # PropPivot ndef prop
+            msgs = await core.stormlist('test:str :bar -> test:ro', opts=opts)
+            _assert_edge(msgs, ostr, {'type': 'prop', 'prop': 'bar'})
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'bar'}, nidx=1)
+
+            # PropPivot array
+            msgs = await core.stormlist('test:arrayprop :ints -> test:int', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'})
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'}, nidx=1)
+
+            # PropPivot dst array primary prop
+            msgs = await core.stormlist('test:guid :size -> test:arrayform', opts=opts)
+            _assert_edge(msgs, guid, {'type': 'prop', 'prop': 'size'})
+
+            # PropPivot oops all arrays
+            msgs = await core.stormlist('test:arrayprop :ints -> test:arrayform', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'prop', 'prop': 'ints'})
+
+            # PropPivot src ndef array
+            msgs = await core.stormlist('test:str=foobar :ndefs -> test:guid', opts=opts)
+            _assert_edge(msgs, tstr, {'type': 'prop', 'prop': 'ndefs'})
+
+            # prop to prop
+            msgs = await core.stormlist('test:comp :hehe -> test:complexcomp:foo', opts=opts)
+            _assert_edge(msgs, burr, {'type': 'prop', 'prop': 'hehe', 'dest': 'test:complexcomp:foo'})
+
+            # N1Walk
+            msgs = await core.stormlist('test:arrayprop -(*)> *', opts=opts)
+            _assert_edge(msgs, arry, {'type': 'edge', 'verb': 'refs'})
+
+            # N2Walk
+            msgs = await core.stormlist('test:edge <(*)- *', opts=opts)
+            _assert_edge(msgs, edge, {'type': 'edge', 'verb': 'seen', 'reverse': True})
+
+            # N1WalkNPivo
+            msgs = await core.stormlist('test:complexcomp --> *', opts=opts)
+            _assert_edge(msgs, comp, {'type': 'prop', 'prop': 'foo'})
+            _assert_edge(msgs, comp, {'type': 'edge', 'verb': 'concerns'}, nidx=1)
+
+            # N2WalNkPivo
+            msgs = await core.stormlist('test:int=176 <-- *', opts=opts)
+            _assert_edge(msgs, small, {'type': 'prop', 'prop': 'size', 'reverse': True})
+            _assert_edge(msgs, small, {'type': 'prop', 'prop': 'ndefs', 'reverse': True}, nidx=1)
+            _assert_edge(msgs, small, {'type': 'edge', 'verb': 'seen', 'reverse': True}, nidx=2)
+            _assert_edge(msgs, small, {'type': 'edge', 'verb': 'someedge', 'reverse': True}, nidx=3)

synapse/tests/test_lib_cell.py

@@ -1070,6 +1070,7 @@ class CellTest(s_t_utils.SynTest):
                 self.nn(slab['xactops'])
                 self.nn(slab['mapsize'])
                 self.nn(slab['readonly'])
+                self.nn(slab['readahead'])
                 self.nn(slab['lockmemory'])
                 self.nn(slab['recovering'])
 

synapse/tests/test_lib_certdir.py

@@ -356,6 +356,9 @@ class CertDirTest(s_t_utils.SynTest):
             with self.raises(s_exc.CryptoErr) as cm:
                 cdir.genCaCert('')
 
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genCaCert('V' * 63 + 'ॐ')
+
     def test_certdir_hosts(self):
         with self.getCertDir() as cdir:
             caname = 'syntest'
@@ -581,6 +584,9 @@ class CertDirTest(s_t_utils.SynTest):
             with self.raises(s_exc.CryptoErr) as cm:
                 cdir.genHostCsr('')
 
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genHostCsr('V' * 63 + 'ॐ')
+
     def test_certdir_users_csr(self):
         with self.getCertDir() as cdir:
             caname = 'syntest'
@@ -612,6 +618,9 @@ class CertDirTest(s_t_utils.SynTest):
             with self.raises(s_exc.CryptoErr) as cm:
                 cdir.genUserCsr('')
 
+            with self.raises(s_exc.CryptoErr) as cm:
+                cdir.genUserCsr('V' * 63 + 'ॐ')
+
     def test_certdir_importfile(self):
         with self.getCertDir() as cdir:
             with self.getTestDir() as testpath:

synapse/tests/test_lib_layer.py

@@ -2216,3 +2216,25 @@ class LayerTest(s_t_utils.SynTest):
 
             self.notin('pulls', dst_tree)
             self.notin('pushs', dst_tree)
+
+    async def test_layer_readahead(self):
+
+        async with self.getTestCore() as core:
+
+            layr = core.getLayer()
+            self.true(layr.layrslab.readahead)
+            self.true(layr.layrslab.lenv.flags()['readahead'])
+            self.false(layr.nodeeditslab.readahead)
+            self.false(layr.nodeeditslab.lenv.flags()['readahead'])
+            self.false(layr.dataslab.readahead)
+            self.false(layr.dataslab.lenv.flags()['readahead'])
+
+            with self.setTstEnvars(SYNDEV_CORTEX_LAYER_READAHEAD='false'):
+                iden = await core.callStorm('return($lib.layer.add().iden)')
+                layr = core.getLayer(iden)
+                self.false(layr.layrslab.readahead)
+                self.false(layr.layrslab.lenv.flags()['readahead'])
+                self.false(layr.nodeeditslab.readahead)
+                self.false(layr.nodeeditslab.lenv.flags()['readahead'])
+                self.false(layr.dataslab.readahead)
+                self.false(layr.dataslab.lenv.flags()['readahead'])

synapse/tests/test_lib_modelrev.py

@@ -559,3 +559,10 @@ class ModelRevTest(s_tests.SynTest):
             self.len(2, rnodes)
 
             self.eq([node.ndef[0] for node in nodes], [node.ndef[0] for node in reversed(rnodes)])
+
+    async def test_modelrev_0_2_27(self):
+
+        async with self.getRegrCore('model-0.2.27') as core:
+            nodes = await core.nodes('it:dev:repo:commit:id=" Foo "')
+            self.len(1, nodes)
+            self.eq('Foo', nodes[0].get('id'))

synapse/tests/test_lib_node.py

@@ -243,7 +243,8 @@ class NodeTest(s_t_utils.SynTest):
                     nodepaths = await alist(node.storm(runt, '-> test:int [:loc=$foo]', opts={'vars': {'foo': 'us'}}))
                     self.eq(nodepaths[0][0].props.get('loc'), 'us')
 
-                    path = nodepaths[0][1].fork(node)  # type: s_node.Path
+                    link = {'type': 'runtime'}
+                    path = nodepaths[0][1].fork(node, link)  # type: s_node.Path
                     path.vars['zed'] = 'ca'
 
                     # Path present, opts not present
@@ -251,12 +252,18 @@ class NodeTest(s_t_utils.SynTest):
                     self.eq(nodes[0][0].props.get('loc'), 'ca')
                     # path is not updated due to frame scope
                     self.none(path.vars.get('bar'), 'us')
+                    self.len(2, path.links)
+                    self.eq({'type': 'prop', 'prop': 'hehe'}, path.links[0][1])
+                    self.eq(link, path.links[1][1])
 
                     # Path present, opts present but no opts['vars']
                     nodes = await alist(node.storm(runt, '-> test:int [:loc=$zed] $bar=$foo', opts={}, path=path))
                     self.eq(nodes[0][0].props.get('loc'), 'ca')
                     # path is not updated due to frame scope
                     self.none(path.vars.get('bar'))
+                    self.len(2, path.links)
+                    self.eq({'type': 'prop', 'prop': 'hehe'}, path.links[0][1])
+                    self.eq(link, path.links[1][1])
 
                     # Path present, opts present with vars
                     nodes = await alist(node.storm(runt, '-> test:int [:loc=$zed] $bar=$baz',
@@ -294,6 +301,10 @@ class NodeTest(s_t_utils.SynTest):
                     self.eq(len(pcln.nodes), len(path.nodes))
                     pcln.nodes.pop(-1)
                     self.ne(len(pcln.nodes), len(path.nodes))
+                    # Ensure the link elements are independent
+                    pcln.links.append({'type': 'edge', 'verb': 'seen'})
+                    self.len(3, pcln.links)
+                    self.len(2, path.links)
 
                     # push a frame and clone it - ensure clone mods do not
                     # modify the original path

synapse/tests/test_lib_storm.py

@@ -3059,12 +3059,29 @@ class StormTest(s_t_utils.SynTest):
             self.len(4, nodes)
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * }'
-            nodes = await core.nodes(q)
+            msgs = await core.stormlist(q, opts={'links': True})
+            nodes = [m[1] for m in msgs if m[0] == 'node']
             self.len(4, nodes)
-            self.eq(nodes[0].ndef, ('inet:asn', 0))
-            self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('edge:refs'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+
+            self.eq(nodes[0][0], ('inet:asn', 0))
+            links = nodes[0][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'prop', 'prop': 'asn'}, links[0][1])
+
+            self.eq(nodes[1][0][0], ('inet:dns:a'))
+            links = nodes[1][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'prop', 'prop': 'ipv4', 'reverse': True}, links[0][1])
+
+            self.eq(nodes[2][0][0], ('edge:refs'))
+            links = nodes[2][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'prop', 'prop': 'n2', 'reverse': True}, links[0][1])
+
+            self.eq(nodes[3][0], ('inet:ipv4', 0x01020304))
+            links = nodes[2][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'prop', 'prop': 'n2', 'reverse': True}, links[0][1])
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * } { -> edge:refs:n2 :n1 -> * }'
             nodes = await core.nodes(q)
@@ -3834,10 +3851,18 @@ class StormTest(s_t_utils.SynTest):
             self.eq(sorted([n.ndef[1] for n in nodes]), ['test1', 'test2'])
 
             q = '[(test:str=refs) (test:str=foo)] $v=$node.value() | lift.byverb $v'
-            nodes = await core.nodes(q)
+            msgs = await core.stormlist(q, opts={'links': True})
+            nodes = [n[1] for n in msgs if n[0] == 'node']
             self.len(4, nodes)
-            self.eq({n.ndef[1] for n in nodes},
+            self.eq({n[0][1] for n in nodes},
                     {'test1', 'test2', 'refs', 'foo'})
+            links = nodes[1][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'runtime'}, links[0][1])
+
+            links = nodes[2][1]['links']
+            self.len(1, links)
+            self.eq({'type': 'runtime'}, links[0][1])
 
     async def test_storm_nested_root(self):
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_stix.py

@@ -423,7 +423,7 @@ class StormLibStixTest(s_test.SynTest):
             self.stormIsInErr('storm query must be a string', msgs)
 
             msgs = await core.stormlist('yield $lib.stix.import.ingest(({"objects": 3}), ({}))')
-            self.stormIsInErr('Error processing objects', msgs)
+            self.stormIsInErr('data.objects must be array', msgs)
 
     async def test_stix_export_custom(self):
 

synapse/tests/test_model_geopol.py

@@ -108,6 +108,7 @@ class GeoPolModelTest(s_t_utils.SynTest):
 
             nodes = await core.nodes('''
                 [ pol:candidate=*
+                    :id=" P00009423"
                     :race={pol:race}
                     :contact={[ps:contact=* :name=whippit]}
                     :winner=$lib.true
@@ -116,6 +117,7 @@ class GeoPolModelTest(s_t_utils.SynTest):
                 ]
             ''')
             self.eq(1, nodes[0].get('winner'))
+            self.eq('P00009423', nodes[0].get('id'))
             self.len(1, await core.nodes('pol:candidate -> pol:race'))
             self.len(1, await core.nodes('pol:candidate -> ou:org +:name=vertex'))
             self.len(1, await core.nodes('pol:candidate -> ps:contact +:name=whippit'))

synapse/tests/test_model_inet.py

@@ -2684,7 +2684,15 @@ class InetModelTest(s_t_utils.SynTest):
                 'acct': 'vertex.link/visi',
             }
 
-            q = '[inet:search:query=$valu :time=$p.time :text=$p.text :engine=$p.engine :acct=$p.acct :host=$p.host]'
+            q = '''[
+                inet:search:query=$valu
+                    :time=$p.time
+                    :text=$p.text
+                    :engine=$p.engine
+                    :acct=$p.acct
+                    :host=$p.host
+                    :account=*
+            ]'''
             nodes = await core.nodes(q, opts={'vars': {'valu': iden, 'p': props}})
             self.len(1, nodes)
             node = nodes[0]
@@ -2694,6 +2702,7 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(node.get('engine'), 'roofroof')
             self.eq(node.get('host'), host)
             self.eq(node.get('acct'), ('vertex.link', 'visi'))
+            self.len(1, await core.nodes('inet:search:query :account -> inet:service:account'))
 
             residen = s_common.guid()
             props = {

synapse/tests/test_model_person.py

@@ -165,6 +165,7 @@ class PsModelTest(s_t_utils.SynTest):
                     :birth:place:name=$p."birth:place:name"
                     :death:place=$p."death:place" :death:place:loc=$p."death:place:loc"
                     :death:place:name=$p."death:place:name"
+                    :service:accounts=(*, *)
                         )]'''
             nodes = await core.nodes(q, opts=opts)
             self.len(1, nodes)
@@ -208,6 +209,7 @@ class PsModelTest(s_t_utils.SynTest):
             self.eq(node.get('death:place:name'), 'reston, va, usa, earth, sol, milkyway')
             self.len(1, await core.nodes('ps:contact :birth:place -> geo:place'))
             self.len(1, await core.nodes('ps:contact :death:place -> geo:place'))
+            self.len(2, await core.nodes('ps:contact :service:accounts -> inet:service:account'))
 
             nodes = await core.nodes('''[
                 ps:achievement=*

synapse/tests/test_model_telco.py

@@ -112,7 +112,7 @@ class TelcoModelTest(s_t_utils.SynTest):
             q = '''[(tel:mob:telem=$valu :time=$p.time :latlong=$p.latlong :place=$p.place :host=$p.host
              :loc=$p.loc :accuracy=$p.accuracy :cell=$p.cell :imsi=$p.imsi :imei=$p.imei :phone=$p.phone
              :mac=$p.mac :ipv4=$p.ipv4 :ipv6=$p.ipv6 :wifi=$p.wifi :adid=$p.adid :aaid=$p.aaid :idfa=$p.idfa
-             :name=$p.name :email=$p.email :acct=$p.acct :app=$p.app :data=$p.data)]'''
+             :name=$p.name :email=$p.email :acct=$p.acct :app=$p.app :data=$p.data :account=*)]'''
             nodes = await core.nodes(q, opts={'vars': {'valu': guid, 'p': props}})
             self.len(1, nodes)
             node = nodes[0]
@@ -142,6 +142,7 @@ class TelcoModelTest(s_t_utils.SynTest):
             self.eq(node.get('acct'), ('vertex.link', 'clown'))
             self.eq(node.get('app'), softguid)
             self.eq(node.get('data'), {'some key': 'some valu', 'BEEP': 1})
+            self.len(1, await core.nodes('tel:mob:telem :account -> inet:service:account'))
 
     async def test_telco_imei(self):
         async with self.getTestCore() as core:

{synapse-2.179.0.dist-info → synapse-2.180.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synapse
-Version: 2.179.0
+Version: 2.180.1
 Summary: Synapse Intelligence Analysis Framework
 Author-email: The Vertex Project LLC <root@vertex.link>
 License: Apache License 2.0
@@ -20,7 +20,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: pyOpenSSL<25.0.0,>=24.0.0
-Requires-Dist: cryptography<43.0.0,>=42.0.4
+Requires-Dist: cryptography<44.0.0,>=43.0.1
 Requires-Dist: msgpack<1.1.0,>=1.0.5
 Requires-Dist: xxhash<3.5.0,>=1.4.4
 Requires-Dist: lmdb<1.5.0,>=1.2.1