synapse 2.195.1__py311-none-any.whl → 2.196.0__py311-none-any.whl

synapse/tests/test_lib_cell.py

@@ -784,6 +784,10 @@ class CellTest(s_t_utils.SynTest):
             cell.VERSION = (1, 2, 3)
             cell.VERSTRING = '1.2.3'
 
+            cell.features.update({
+                'testvalu': 2
+            })
+
             http_info = []
             host, port = await cell.addHttpsPort(0)
             http_info.append({'host': host, 'port': port})
@@ -807,6 +811,9 @@ class CellTest(s_t_utils.SynTest):
                 # A Cortex populated cellvers
                 self.isin('cortex:defaults', cnfo.get('cellvers', {}))
 
+                self.eq(info.get('features'), cell.features)
+                self.eq(info.get('features', {}).get('testvalu'), 2)
+
                 # Defaults aha data is
                 self.eq(cnfo.get('aha'), {'name': None, 'leader': None, 'network': None})
 
@@ -3294,6 +3301,51 @@ class CellTest(s_t_utils.SynTest):
                         await cell00.promote(graceful=True)
                     self.isin('02.cell is not the current leader', cm.exception.get('mesg'))
 
+    async def test_cell_get_aha_proxy(self):
+
+        async with self.getTestCell() as cell:
+
+            self.none(await cell.getAhaProxy())
+
+            class MockAhaClient:
+                def __init__(self, proxy=None):
+                    self._proxy = proxy
+
+                async def proxy(self, timeout=None):
+                    return self._proxy
+
+            with self.getAsyncLoggerStream('synapse.lib.cell', 'AHA client connection failed.') as stream:
+                cell.ahaclient = MockAhaClient()
+                self.none(await cell.getAhaProxy())
+                self.true(await stream.wait(timeout=1))
+
+            class MockProxyHasNot:
+                def _hasTeleFeat(self, name, vers):
+                    return False
+
+            cell.ahaclient = MockAhaClient(proxy=MockProxyHasNot())
+            self.none(await cell.getAhaProxy(feats=(('test', 1),)))
+
+            class MockProxyHas:
+                def _hasTeleFeat(self, name, vers):
+                    return True
+
+            mock_proxy = MockProxyHas()
+            cell.ahaclient = MockAhaClient(proxy=mock_proxy)
+            self.eq(await cell.getAhaProxy(), mock_proxy)
+            self.eq(await cell.getAhaProxy(feats=(('test', 1),)), mock_proxy)
+
+    async def test_lib_cell_sadaha(self):
+
+        async with self.getTestCell() as cell:
+
+            self.none(await cell.getAhaProxy())
+            cell.ahaclient = await s_telepath.Client.anit('cell:///tmp/newp')
+
+            # coverage for failure of aha client to connect
+            with self.raises(TimeoutError):
+                self.none(await cell.getAhaProxy(timeout=0.1))
+
     async def test_stream_backup_exception(self):
 
         with self.getTestDir() as dirn:
@@ -3356,3 +3408,12 @@ class CellTest(s_t_utils.SynTest):
                     with self.raises(s_exc.BackupAlreadyRunning):
                         async for _ in proxy.iterNewBackupArchive('newbackup', remove=True):
                             pass
+
+    async def test_cell_peer_noaha(self):
+
+        todo = s_common.todo('newp')
+        async with self.getTestCell() as cell:
+            async for item in cell.callPeerApi(todo):
+                pass
+            async for item in cell.callPeerGenr(todo):
+                pass

synapse/tests/test_lib_jsonstor.py

@@ -116,6 +116,7 @@ class JsonStorTest(s_test.SynTest):
                     self.eq({'hehe': 'haha', 'zip': {}}, await prox.getPathObj('foo/bar'))
 
                     self.false(await prox.delPathObjProp('newp/newp', 'newp'))
+                    self.false(await prox.delPathObjProp('foo/bar', 'nested/newp'))
 
                     await prox.delPathObj('foo/bar')
                     self.none(await prox.getPathObj('foo/bar'))

synapse/tests/test_lib_modelrev.py

@@ -1766,3 +1766,9 @@ class ModelRevTest(s_tests.SynTest):
             self.eq('foo bar', nodes[0].get('model'))
             nodes = await core.nodes('transport:sea:vessel')
             self.eq('foo bar', nodes[0].get('model'))
+
+    async def test_modelrev_0_2_33(self):
+        async with self.getRegrCore('model-0.2.33') as core:
+            nodes = await core.nodes('entity:name')
+            self.len(1, nodes)
+            self.eq('foo bar', nodes[0].repr())

synapse/tests/test_lib_stormlib_aha.py

@@ -6,6 +6,8 @@ import synapse.lib.cell as s_cell
 
 import synapse.tests.utils as s_test
 
+import unittest.mock as mock
+
 class AhaLibTest(s_test.SynTest):
 
     async def test_stormlib_aha_basics(self):
@@ -193,3 +195,189 @@ Connection information:
 
                 with self.raises(s_exc.NoSuchName):
                     await core00.callStorm('$lib.aha.del(axon...)')
+
+    async def test_stormlib_aha_mirror(self):
+
+        async with self.getTestAha() as aha:
+
+            with self.getTestDir() as dirn:
+
+                dirn00 = s_common.genpath(dirn, 'cell00')
+                dirn01 = s_common.genpath(dirn, 'cell01')
+                dirn02 = s_common.genpath(dirn, 'cell02')
+
+                async with aha.waiter(3, 'aha:svcadd', timeout=10):
+
+                    cell00 = await aha.enter_context(self.addSvcToAha(aha, '00.cell', s_cell.Cell, dirn=dirn00))
+                    cell01 = await aha.enter_context(self.addSvcToAha(aha, '01.cell', s_cell.Cell, dirn=dirn01,
+                                                                      provinfo={'mirror': 'cell'}))
+                    core00 = await aha.enter_context(self.addSvcToAha(aha, 'core', s_cortex.Cortex, dirn=dirn02))
+                    await cell01.sync()
+
+                # PeerGenr
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo('getTasks')
+                    for ($name, $info) in $lib.aha.callPeerGenr(cell..., $todo) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''')
+                self.len(0, resp)
+
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo('getNexusChanges', (0), wait=(false))
+                    for ($name, $info) in $lib.aha.callPeerGenr(cell..., $todo) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''')
+                self.len(4, resp)
+
+                cell00_rid = (await cell00.getCellInfo())['cell']['run']
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo('getNexusChanges', (0), wait=(false))
+                    for $info in $lib.aha.callPeerGenr(cell..., $todo, skiprun=$skiprun) {
+                        $resps.append($info)
+                    }
+                    return($resps)
+                ''', opts={'vars': {'skiprun': cell00_rid}})
+                self.len(2, resp)
+
+                await self.asyncraises(s_exc.NoSuchName, core00.callStorm('''
+                    $todo = $lib.utils.todo('getTasks')
+                    $lib.aha.callPeerGenr(null, $todo)
+                '''))
+
+                # PeerApi
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo('getCellInfo')
+                    for ($name, $info) in $lib.aha.callPeerApi(cell..., $todo) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''')
+                self.len(2, resp)
+                self.eq(resp[0][0], '00.cell.synapse')
+                self.eq(resp[0][1][0], True)
+                self.isinstance(resp[0][1][1], dict)
+
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo(getCellInfo)
+                    for ($name, $info) in $lib.aha.callPeerApi(cell..., $todo) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''')
+                self.len(2, resp)
+
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo(getCellInfo)
+                    for ($name, $info) in $lib.aha.callPeerApi(cell..., $todo, skiprun=$skiprun) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''', opts={'vars': {'skiprun': cell00_rid}})
+                self.len(1, resp)
+
+                resp = await core00.callStorm('''
+                    $resps = $lib.list()
+                    $todo = $lib.utils.todo('getCellInfo')
+                    for ($name, $info) in $lib.aha.callPeerApi(cell..., $todo, timeout=(10)) {
+                        $resps.append(($name, $info))
+                    }
+                    return($resps)
+                ''')
+                self.len(2, resp)
+
+                await self.asyncraises(s_exc.NoSuchName, core00.callStorm('''
+                    $todo = $lib.utils.todo('getCellInfo')
+                    $lib.aha.callPeerApi(newp..., $todo)
+                '''))
+
+                await self.asyncraises(s_exc.NoSuchName, core00.callStorm('''
+                    $todo = $lib.utils.todo('getCellInfo')
+                    $lib.aha.callPeerApi(null, $todo)
+                '''))
+
+                await self.asyncraises(s_exc.NoSuchMeth, core00.callStorm('''
+                    $todo = $lib.utils.todo('bogusMethod')
+                    for $info in $lib.aha.callPeerApi(cell..., $todo) {
+                        ($ok, $info) = $info.1
+                        if (not $ok) {
+                            $lib.raise($info.err, $info.errmsg)
+                        }
+                    }
+                '''))
+
+                await aha.addAhaSvc('noiden.cell', info={'urlinfo': {'scheme': 'tcp',
+                                                                     'host': '0.0.0.0',
+                                                                     'port': '3030'}},
+                                  network='synapse')
+                await self.asyncraises(s_exc.NoSuchName, core00.callStorm('''
+                    $todo = $lib.utils.todo('getTasks')
+                    $lib.aha.callPeerGenr(noiden.cell..., $todo)
+                '''))
+                await self.asyncraises(s_exc.NoSuchName, core00.callStorm('''
+                    $todo = $lib.utils.todo('getCellInfo')
+                    $lib.aha.callPeerApi(noiden.cell..., $todo)
+                '''))
+
+                msgs = await core00.stormlist('aha.svc.mirror')
+                self.stormIsInPrint('Service Mirror Groups:', msgs)
+                self.stormIsInPrint('cell.synapse', msgs)
+                self.stormIsInPrint('00.cell.synapse', msgs)
+                self.stormIsInPrint('01.cell.synapse', msgs)
+                self.stormIsInPrint('Group Status: In Sync', msgs)
+
+                msgs = await core00.stormlist('aha.svc.mirror --timeout 30')
+                self.stormIsInPrint('Service Mirror Groups:', msgs)
+                self.stormIsInPrint('Group Status: In Sync', msgs)
+
+                async def mockCellInfo():
+                    return {
+                        'cell': {'ready': True, 'nexsindx': 10, 'uplink': None},
+                        'synapse': {'verstring': '2.190.0'},
+                    }
+
+                async def mockOutOfSyncCellInfo():
+                    return {
+                        'cell': {'ready': True, 'nexsindx': 5, 'uplink': cell00.iden},
+                        'synapse': {'verstring': '2.190.0'},
+                    }
+
+                with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                    with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                        async def mock_call_aha(*args, **kwargs):
+                            todo = args[1]
+                            if todo[0] == 'waitNexsOffs':
+                                yield ('00.cell.synapse', (True, True))
+                                yield ('01.cell.synapse', (True, True))
+                            elif todo[0] == 'getCellInfo':
+                                if not hasattr(mock_call_aha, 'called'):
+                                    mock_call_aha.called = True
+                                    yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                    yield ('01.cell.synapse', (True, await mockOutOfSyncCellInfo()))
+                                else:
+                                    yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                    yield ('01.cell.synapse', (True, await mockCellInfo()))
+
+                        with mock.patch.object(aha, 'callAhaPeerApi', mock_call_aha):
+                            msgs = await core00.stormlist('aha.svc.mirror --wait')
+                            self.stormIsInPrint('Group Status: Out of Sync', msgs)
+                            self.stormIsInPrint('Updated status:', msgs)
+                            self.stormIsInPrint('Group Status: In Sync', msgs)
+
+                with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                    with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                        msgs = await core00.stormlist('aha.svc.mirror --timeout 1')
+                        self.stormIsInPrint('Group Status: Out of Sync', msgs)
+
+                await aha.delAhaSvc('00.cell', network='synapse')
+                msgs = await core00.stormlist('aha.svc.mirror')
+                self.stormNotInPrint('Service Mirror Groups:', msgs)

synapse/tests/test_lib_stormlib_utils.py

@@ -0,0 +1,14 @@
+import synapse.exc as s_exc
+import synapse.tests.utils as s_test
+
+class UtilsTest(s_test.SynTest):
+
+    async def test_lib_stormlib_utils_todo(self):
+
+        async with self.getTestCore() as core:
+
+            valu = await core.callStorm('return($lib.utils.todo(foo))')
+            self.eq(valu, ('foo', (), {}))
+
+            valu = await core.callStorm('return($lib.utils.todo(fooName, arg1, arg2, keyword=bar, anotherkeyword=hehe))')
+            self.eq(valu, ('fooName', ('arg1', 'arg2'), {'keyword': 'bar', 'anotherkeyword': 'hehe'}))

synapse/tests/test_lib_stormtypes.py

@@ -3,6 +3,7 @@ import bz2
 import gzip
 import json
 import base64
+import struct
 import asyncio
 import hashlib
 import binascii
@@ -6467,13 +6468,29 @@ words\tword\twrd'''
         async with self.getTestCore() as core:
 
             viewiden = await core.callStorm('return($lib.view.get().fork().iden)')
-            await core.nodes('[ ou:org=* :name=foobar +#hehe ]')
+            q = '[ ou:org=* :name=foobar +#hehe ] $node.data.set(foo, bar) return($node.iden())'
+            basenode = await core.callStorm(q)
 
             opts = {'view': viewiden}
-            nodeiden = await core.callStorm('[ ou:org=* :name=foobar +#hehe ] return($node.iden())', opts=opts)
+            nodeiden = await core.callStorm('''
+                [ ou:org=* :name=foobar +#hehe ]
+                $node.data.set(foo, bar)
+                return($node.iden())
+            ''', opts=opts)
+
+            nodeiden2 = await core.callStorm('[test:str=yup] $node.data.set(foo, yup) return ($node.iden())',
+                                             opts=opts)
 
             self.len(2, await core.nodes('ou:org +:name=foobar +#hehe', opts=opts))
 
+            nodes = await core.nodes('yield $lib.layer.get().liftByNodeData(foo)', opts=opts)
+            self.len(2, nodes)
+            self.eq(set((nodeiden, nodeiden2)), {node.iden() for node in nodes})
+
+            nodes = await core.nodes('yield $lib.layer.get().liftByNodeData(foo)')
+            self.len(1, nodes)
+            self.eq(nodes[0].iden(), basenode)
+
             nodes = await core.nodes('yield $lib.layer.get().liftByProp(ou:org)', opts=opts)
             self.len(1, nodes)
             self.eq(nodes[0].iden(), nodeiden)
@@ -6487,7 +6504,7 @@ words\tword\twrd'''
             self.eq(nodes[0].iden(), nodeiden)
 
             nodes = await core.nodes('yield $lib.layer.get().liftByProp(".created")', opts=opts)
-            self.len(1, nodes)
+            self.len(2, nodes)
             self.eq(nodes[0].iden(), nodeiden)
 
             nodes = await core.nodes('yield $lib.layer.get().liftByTag(hehe)', opts=opts)
@@ -7084,3 +7101,73 @@ words\tword\twrd'''
 
             with self.raises(s_exc.BadState):
                 await core.callStorm(merging)
+
+    async def test_storm_lib_axon_read_unpack(self):
+
+        async with self.getTestCore() as core:
+
+            visi = await core.auth.addUser('visi')
+
+            orig_axoninfo = core.axoninfo
+            core.axoninfo = {'features': {}}
+            data = struct.pack('>Q', 1)
+            size, sha256 = await core.axon.put(data)
+            sha256_s = s_common.ehex(sha256)
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            await self.asyncraises(s_exc.FeatureNotSupported,
+                                   core.callStorm(q, opts={'vars': {'sha256': sha256_s}}))
+            core.axoninfo = orig_axoninfo
+
+            data = b'vertex.link'
+            size, sha256 = await core.axon.put(data)
+            sha256_s = s_common.ehex(sha256)
+
+            _, emptyhash = await core.axon.put(b'')
+            emptyhash = s_common.ehex(emptyhash)
+
+            opts = {'user': visi.iden, 'vars': {'sha256': sha256_s, 'emptyhash': emptyhash}}
+            await self.asyncraises(s_exc.AuthDeny,
+                core.callStorm('return($lib.axon.read($sha256, offs=3, size=3))', opts=opts))
+            await visi.addRule((True, ('storm', 'lib', 'axon', 'get')))
+
+            q = 'return($lib.axon.read($sha256, offs=3, size=3))'
+            self.eq(b'tex', await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=7, size=4))'
+            self.eq(b'link', await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=11, size=1))'
+            self.eq(b'', await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.read($emptyhash))'
+            self.eq(b'', await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.read($sha256, size=0))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=-1, size=1))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, size=2097152))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+            intdata = struct.pack('>QQQ', 1, 2, 3)
+            size, sha256 = await core.axon.put(intdata)
+            sha256_s = s_common.ehex(sha256)
+            opts = {'user': visi.iden, 'vars': {'sha256': sha256_s}}
+
+            await visi.delRule((True, ('storm', 'lib', 'axon', 'get')))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            await self.asyncraises(s_exc.AuthDeny, core.callStorm(q, opts=opts))
+            await visi.addRule((True, ('storm', 'lib', 'axon', 'get')))
+
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            self.eq((1,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=8))'
+            self.eq((2,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=16))'
+            self.eq((3,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">QQ", offs=8))'
+            self.eq((2, 3), await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.unpack($sha256, fmt="not a valid format"))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=24))'
+            await self.asyncraises(s_exc.BadDataValu, core.callStorm(q, opts=opts))

synapse/tests/test_model_base.py

@@ -227,6 +227,7 @@ class BaseTest(s_t_utils.SynTest):
                     :name="FOO Bar"
                     :type=osint
                     :url="https://foo.bar/index.html"
+                    :ingest:cursor="Woot Woot "
                     :ingest:latest=20241205
                     :ingest:offset=17
                 ]
@@ -238,6 +239,7 @@ class BaseTest(s_t_utils.SynTest):
             self.eq(sorc.get('name'), 'foo bar')
             self.eq(sorc.get('url'), 'https://foo.bar/index.html')
             self.eq(sorc.get('ingest:offset'), 17)
+            self.eq(sorc.get('ingest:cursor'), 'Woot Woot ')
             self.eq(sorc.get('ingest:latest'), 1733356800000)
 
             valu = (sorc.ndef[1], ('inet:fqdn', 'woot.com'))

synapse/tests/test_model_infotech.py

@@ -342,6 +342,7 @@ class InfotechModelTest(s_t_utils.SynTest):
                     :verdict=suspicious
                     :scanner={[ it:prod:softver=* :name="visi scan" ]}
                     :scanner:name="visi scan"
+                    :categories=("Foo  Bar", "baz faz")
                     :signame=omgwtfbbq
                     :target:file=*
                     :target:proc={[ it:exec:proc=* :cmd="foo.exe --bar" ]}
@@ -367,6 +368,7 @@ class InfotechModelTest(s_t_utils.SynTest):
             self.eq(0x01020304, nodes[0].get('target:ipv4'))
             self.eq('::1', nodes[0].get('target:ipv6'))
             self.eq('omgwtfbbq', nodes[0].get('signame'))
+            self.eq(('baz faz', 'foo bar'), nodes[0].get('categories'))
 
             self.len(1, await core.nodes('it:av:scan:result:scanner:name="visi scan" -> it:host'))
             self.len(1, await core.nodes('it:av:scan:result:scanner:name="visi scan" -> inet:url'))
@@ -617,11 +619,36 @@ class InfotechModelTest(s_t_utils.SynTest):
             node = nodes[0]
             self.eq(node.ndef, ('it:dev:int', 1640531528))
 
-            nodes = await core.nodes('[it:sec:cve=CVE-2013-9999 :desc="Some words."]')
+            nodes = await core.nodes('''[
+                it:sec:cve=CVE-2013-9999
+                    :desc="Some words."
+
+                    :nist:nvd:source=NistSource
+                    :nist:nvd:published=2021-10-11
+                    :nist:nvd:modified=2021-10-11
+
+                    :cisa:kev:name=KevName
+                    :cisa:kev:desc=KevDesc
+                    :cisa:kev:action=KevAction
+                    :cisa:kev:vendor=KevVendor
+                    :cisa:kev:product=KevProduct
+                    :cisa:kev:added=2022-01-02
+                    :cisa:kev:duedate=2022-01-02
+            ]''')
             self.len(1, nodes)
             node = nodes[0]
             self.eq(node.ndef, ('it:sec:cve', 'cve-2013-9999'))
             self.eq(node.get('desc'), 'Some words.')
+            self.eq(node.get('nist:nvd:source'), 'nistsource')
+            self.eq(node.get('nist:nvd:published'), 1633910400000)
+            self.eq(node.get('nist:nvd:modified'), 1633910400000)
+            self.eq(node.get('cisa:kev:name'), 'KevName')
+            self.eq(node.get('cisa:kev:desc'), 'KevDesc')
+            self.eq(node.get('cisa:kev:action'), 'KevAction')
+            self.eq(node.get('cisa:kev:vendor'), 'kevvendor')
+            self.eq(node.get('cisa:kev:product'), 'kevproduct')
+            self.eq(node.get('cisa:kev:added'), 1641081600000)
+            self.eq(node.get('cisa:kev:duedate'), 1641081600000)
 
             nodes = await core.nodes('[it:sec:cve=$valu]', opts={'vars': {'valu': 'CVE\u20122013\u20131138'}})
             self.len(1, nodes)

synapse/tests/test_model_orgs.py

@@ -640,6 +640,7 @@ class OuModelTest(s_t_utils.SynTest):
                 ou:contest:result=(*, *)
                     :rank=1
                     :score=20
+                    :period=(20250101, 20250102)
                     :url=http://vertex.link/contest/result
             ]''')
             self.len(1, nodes)
@@ -647,6 +648,7 @@ class OuModelTest(s_t_utils.SynTest):
             self.nn(nodes[0].get('participant'))
             self.eq(1, nodes[0].get('rank'))
             self.eq(20, nodes[0].get('score'))
+            self.eq((1735689600000, 1735776000000), nodes[0].get('period'))
             self.eq('http://vertex.link/contest/result', nodes[0].get('url'))
             self.len(1, await core.nodes('ou:contest:result -> ps:contact'))
             self.len(1, await core.nodes('ou:contest:result -> ou:contest'))

synapse/tests/test_model_risk.py

@@ -111,12 +111,14 @@ class RiskModelTest(s_t_utils.SynTest):
                 :cvss:v3 ?= "newp3.1"
                 :priority=high
                 :severity=high
+                :tag=cno.vuln.woot
             ]''')
 
             self.none(node.get('cvss:v2'))
             self.none(node.get('cvss:v3'))
             self.eq(40, node.get('severity'))
             self.eq(40, node.get('priority'))
+            self.eq('cno.vuln.woot', node.get('tag'))
 
             with self.raises(s_exc.BadTypeValu):
                 node = await addNode(f'''[

synapse/tests/test_model_transport.py

@@ -110,6 +110,7 @@ class TransportTest(s_test.SynTest):
             self.nn(vessel.get('operator'))
 
             self.len(1, await core.nodes('transport:sea:vessel:imo^="IMO 123"'))
+            self.len(1, await core.nodes('transport:sea:vessel :name -> entity:name'))
             self.len(1, await core.nodes('transport:sea:vessel -> transport:sea:vessel:type:taxonomy'))
 
             seatelem = (await core.nodes('''[

synapse/tests/test_telepath.py

@@ -54,6 +54,9 @@ class Beep:
     def beep(self):
         return f'{self.path}: beep'
 
+    def genbeep(self):
+        yield self.beep()
+
 class Foo:
 
     def __init__(self):
@@ -138,6 +141,9 @@ class TeleApi:
     def getFooBar(self, x, y):
         return x - y
 
+    def genGetFooBar(self, x, y):
+        yield self.getFooBar(x, y)
+
     async def customshare(self):
         return await CustomShare.anit(self.link, 42)
 
@@ -160,6 +166,11 @@ class TeleAware(s_telepath.Aware):
 
         return self._initBeep(path[0])
 
+    async def getTeleFeats(self):
+        return {
+            'aware': 1,
+        }
+
 class TeleAuth(s_telepath.Aware):
 
     def getTeleApi(self, link, mesg, path):
@@ -632,7 +643,15 @@ class TeleTest(s_t_utils.SynTest):
                 self.len(1, snfo)
                 self.eq(snfo[0].get('items'), {None: 'synapse.tests.test_telepath.TeleApi'})
 
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
+
+                self.true(proxy._hasTeleMeth('getFooBar'))
+                self.false(proxy._hasTeleMeth('getBarBaz'))
+
                 self.eq(10, await proxy.getFooBar(20, 10))
+                self.eq([10], [m async for m in await proxy.genGetFooBar(20, 10)])
 
                 # check a custom share works
                 obj = await proxy.customshare()
@@ -674,7 +693,14 @@ class TeleTest(s_t_utils.SynTest):
 
             # check that a dynamic share works
             async with await self.getTestProxy(dmon, 'woke/up') as proxy:
+                self.isin('synapse.tests.test_telepath.Beep', proxy._getClasses())
+                self.notin('synapse.tests.test_telepath.TeleApi', proxy._getClasses())
                 self.eq('up: beep', await proxy.beep())
+                self.eq(['up: beep'], [m async for m in await proxy.genbeep()])
+                # Telepath features are a function of the base object, not the result of getTeleApi
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
 
     async def test_telepath_auth(self):