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

synapse/tests/test_cortex.py

@@ -41,6 +41,50 @@ class CortexTest(s_t_utils.SynTest):
     '''
     The tests that should be run with different types of layers
     '''
+    async def test_cortex_basics(self):
+
+        with self.getTestDir() as dirn:
+
+            async with self.getTestCore(dirn=dirn) as core:
+
+                with self.raises(s_exc.NoSuchProp):
+                    await core.setPropLocked('newp', True)
+
+                with self.raises(s_exc.NoSuchUniv):
+                    await core.setUnivLocked('newp', True)
+
+                with self.raises(s_exc.NoSuchTagProp):
+                    await core.setTagPropLocked('newp', True)
+
+                await core.addTagProp('score', ('int', {}), {})
+
+                await core.setPropLocked('inet:ipv4:asn', True)
+                await core.setUnivLocked('.seen', True)
+                await core.setTagPropLocked('score', True)
+
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 :asn=99 ]')
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 .seen=now ]')
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 +#foo:score=10 ]')
+
+            # test persistence...
+            async with self.getTestCore(dirn=dirn) as core:
+
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 :asn=99 ]')
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 .seen=now ]')
+                with self.raises(s_exc.IsDeprLocked):
+                    await core.nodes('[ inet:ipv4=1.2.3.4 +#foo:score=10 ]')
+
+                await core.setPropLocked('inet:ipv4:asn', False)
+                await core.setUnivLocked('.seen', False)
+                await core.setTagPropLocked('score', False)
+
+                await core.nodes('[ inet:ipv4=1.2.3.4 :asn=99 .seen=now +#foo:score=10 ]')
+
     async def test_cortex_cellguid(self):
         iden = s_common.guid()
         conf = {'cell:guid': iden}
@@ -1302,7 +1346,7 @@ class CortexTest(s_t_utils.SynTest):
 
                 await core.delTagProp('score')
 
-                with self.raises(s_exc.NoSuchProp):
+                with self.raises(s_exc.NoSuchTagProp):
                     await core.delTagProp('score')
 
                 modl = await core.getModelDict()

synapse/tests/test_lib_aha.py

@@ -1292,3 +1292,20 @@ class AhaTest(s_test.SynTest):
                 async with await s_cell.Cell.anit(dirn=clldir, conf=cllconf) as cell:
                     self.none(await cell.ahaclient.waitready(timeout=12))
                     self.eq(cell.conf.get('aha:registry'), ahaurl)
+
+    async def test_aha_provision_listen_dns_name(self):
+        # Ensure that we use the dns:name for the provisioning listener when
+        # the provision:listen value is not provided.
+        conf = {
+            'aha:network': 'synapse',
+            'dns:name': 'here.loop.vertex.link',
+        }
+        mesg = 'provision listening: ssl://0.0.0.0:27272?hostname=here.loop.vertex.link'
+        with self.getAsyncLoggerStream('synapse.lib.aha', mesg) as stream:
+            async with self.getTestCell(s_aha.AhaCell, conf=conf) as aha:
+                self.true(await stream.wait(timeout=6))
+                # And the URL works with our listener :)
+                provurl = await aha.addAhaUserEnroll('bob.grey')
+                async with await s_telepath.openurl(provurl) as prox:
+                    info = await prox.getUserInfo()
+                    self.eq(info.get('aha:user'), 'bob.grey')

synapse/tests/test_lib_cell.py

@@ -28,6 +28,7 @@ import synapse.lib.base as s_base
 import synapse.lib.cell as s_cell
 import synapse.lib.coro as s_coro
 import synapse.lib.link as s_link
+import synapse.lib.drive as s_drive
 import synapse.lib.nexus as s_nexus
 import synapse.lib.certdir as s_certdir
 import synapse.lib.msgpack as s_msgpack
@@ -155,8 +156,217 @@ async def altAuthCtor(cell):
     cell.onfini(auth.fini)
     return auth
 
+testDataSchema_v0 = {
+    'type': 'object',
+    'properties': {
+        'type': {'type': 'string'},
+        'size': {'type': 'number'},
+    },
+    'required': ['type', 'size'],
+    'additionalProperties': False,
+}
+
+testDataSchema_v1 = {
+    'type': 'object',
+    'properties': {
+        'type': {'type': 'string'},
+        'size': {'type': 'number'},
+        'woot': {'type': 'string'},
+    },
+    'required': ['type', 'size', 'woot'],
+    'additionalProperties': False,
+}
+
 class CellTest(s_t_utils.SynTest):
 
+    async def test_cell_drive(self):
+
+        async with self.getTestCell() as cell:
+
+            with self.raises(s_exc.BadName):
+                s_drive.reqValidName('A' * 512)
+
+            info = {'name': 'users'}
+            pathinfo = await cell.addDriveItem(info)
+
+            info = {'name': 'root'}
+            pathinfo = await cell.addDriveItem(info, path='users')
+
+            with self.raises(s_exc.DupIden):
+                await cell.drive.addItemInfo(pathinfo[-1], path='users')
+
+            rootdir = pathinfo[-1].get('iden')
+            self.eq(0, pathinfo[-1].get('kids'))
+
+            info = {'name': 'win32k.sys', 'type': 'hehe'}
+            with self.raises(s_exc.NoSuchType):
+                info = await cell.addDriveItem(info, reldir=rootdir)
+
+            infos = [i async for i in cell.getDriveKids(s_drive.rootdir)]
+            self.len(1, infos)
+            self.eq(1, infos[0].get('kids'))
+            self.eq('users', infos[0].get('name'))
+
+            # TODO how to handle iden match with additional property mismatch
+
+            await cell.drive.setTypeSchema('woot', testDataSchema_v0)
+
+            info = {'name': 'win32k.sys', 'type': 'woot'}
+            info = await cell.addDriveItem(info, reldir=rootdir)
+
+            iden = info[-1].get('iden')
+
+            tick = s_common.now()
+            rootuser = cell.auth.rootuser.iden
+
+            with self.raises(s_exc.SchemaViolation):
+                versinfo = {'version': (1, 0, 0), 'updated': tick, 'updater': rootuser}
+                await cell.setDriveData(iden, versinfo, {'newp': 'newp'})
+
+            versinfo = {'version': (1, 1, 0), 'updated': tick + 10, 'updater': rootuser}
+            info, versinfo = await cell.setDriveData(iden, versinfo, {'type': 'haha', 'size': 20})
+            self.eq(info.get('version'), (1, 1, 0))
+            self.eq(versinfo.get('version'), (1, 1, 0))
+
+            versinfo = {'version': (1, 0, 0), 'updated': tick, 'updater': rootuser}
+            info, versinfo = await cell.setDriveData(iden, versinfo, {'type': 'hehe', 'size': 0})
+            self.eq(info.get('version'), (1, 1, 0))
+            self.eq(versinfo.get('version'), (1, 0, 0))
+
+            versinfo10, data10 = await cell.getDriveData(iden, vers=(1, 0, 0))
+            self.eq(versinfo10.get('updated'), tick)
+            self.eq(versinfo10.get('updater'), rootuser)
+            self.eq(versinfo10.get('version'), (1, 0, 0))
+
+            versinfo11, data11 = await cell.getDriveData(iden, vers=(1, 1, 0))
+            self.eq(versinfo11.get('updated'), tick + 10)
+            self.eq(versinfo11.get('updater'), rootuser)
+            self.eq(versinfo11.get('version'), (1, 1, 0))
+
+            versions = [vers async for vers in cell.getDriveDataVersions(iden)]
+            self.len(2, versions)
+            self.eq(versions[0], versinfo11)
+            self.eq(versions[1], versinfo10)
+
+            info = await cell.delDriveData(iden, vers=(0, 0, 0))
+
+            versions = [vers async for vers in cell.getDriveDataVersions(iden)]
+            self.len(2, versions)
+            self.eq(versions[0], versinfo11)
+            self.eq(versions[1], versinfo10)
+
+            info = await cell.delDriveData(iden, vers=(1, 1, 0))
+            self.eq(info.get('updated'), tick)
+            self.eq(info.get('version'), (1, 0, 0))
+
+            info = await cell.delDriveData(iden, vers=(1, 0, 0))
+            self.eq(info.get('size'), 0)
+            self.eq(info.get('version'), (0, 0, 0))
+            self.none(info.get('updated'))
+            self.none(info.get('updater'))
+
+            # repopulate a couple data versions to test migration and delete
+            versinfo = {'version': (1, 0, 0), 'updated': tick, 'updater': rootuser}
+            info, versinfo = await cell.setDriveData(iden, versinfo, {'type': 'hehe', 'size': 0})
+            versinfo = {'version': (1, 1, 0), 'updated': tick + 10, 'updater': rootuser}
+            info, versinfo = await cell.setDriveData(iden, versinfo, {'type': 'haha', 'size': 17})
+            self.eq(versinfo, (await cell.getDriveData(iden))[0])
+
+            # This will be done by the cell in a cell storage version migration...
+            async def migrate_v1(info, versinfo, data):
+                data['woot'] = 'woot'
+                return data
+
+            await cell.drive.setTypeSchema('woot', testDataSchema_v1, migrate_v1)
+
+            versinfo, data = await cell.getDriveData(iden, vers=(1, 0, 0))
+            self.eq('woot', data.get('woot'))
+
+            versinfo, data = await cell.getDriveData(iden, vers=(1, 1, 0))
+            self.eq('woot', data.get('woot'))
+
+            self.nn(await cell.getDriveInfo(iden))
+            self.len(2, [vers async for vers in cell.getDriveDataVersions(iden)])
+
+            await cell.delDriveData(iden)
+            self.len(1, [vers async for vers in cell.getDriveDataVersions(iden)])
+
+            await cell.delDriveInfo(iden)
+
+            self.none(await cell.getDriveInfo(iden))
+            self.len(0, [vers async for vers in cell.getDriveDataVersions(iden)])
+
+            with self.raises(s_exc.NoSuchPath):
+                await cell.getDrivePath('users/root/win32k.sys')
+
+            pathinfo = await cell.addDrivePath('foo/bar/baz')
+            self.len(3, pathinfo)
+            self.eq('foo', pathinfo[0].get('name'))
+            self.eq(1, pathinfo[0].get('kids'))
+            self.eq('bar', pathinfo[1].get('name'))
+            self.eq(1, pathinfo[1].get('kids'))
+            self.eq('baz', pathinfo[2].get('name'))
+            self.eq(0, pathinfo[2].get('kids'))
+
+            self.eq(pathinfo, await cell.addDrivePath('foo/bar/baz'))
+
+            baziden = pathinfo[2].get('iden')
+            self.eq(pathinfo, await cell.drive.getItemPath(baziden))
+
+            info = await cell.setDriveInfoPerm(baziden, {'users': {rootuser: 3}, 'roles': {}})
+            self.eq(3, info['perm']['users'][rootuser])
+
+            with self.raises(s_exc.NoSuchIden):
+                # s_drive.rootdir is all 00s... ;)
+                await cell.setDriveInfoPerm(s_drive.rootdir, {'users': {}, 'roles': {}})
+
+            await cell.addDrivePath('hehe/haha')
+            pathinfo = await cell.setDriveInfoPath(baziden, 'hehe/haha/hoho')
+
+            self.eq('hoho', pathinfo[-1].get('name'))
+            self.eq(baziden, pathinfo[-1].get('iden'))
+
+            self.true(await cell.drive.hasPathInfo('hehe/haha/hoho'))
+            self.false(await cell.drive.hasPathInfo('foo/bar/baz'))
+
+            pathinfo = await cell.getDrivePath('foo/bar')
+            self.eq(0, pathinfo[-1].get('kids'))
+
+            pathinfo = await cell.getDrivePath('hehe/haha')
+            self.eq(1, pathinfo[-1].get('kids'))
+
+            with self.raises(s_exc.DupName):
+                iden = pathinfo[-2].get('iden')
+                name = pathinfo[-1].get('name')
+                cell.drive.reqFreeStep(iden, name)
+
+            walks = [item async for item in cell.drive.walkPathInfo('hehe')]
+            self.len(3, walks)
+            # confirm walked paths are yielded depth first...
+            self.eq('hoho', walks[0].get('name'))
+            self.eq('haha', walks[1].get('name'))
+            self.eq('hehe', walks[2].get('name'))
+
+            iden = walks[2].get('iden')
+            walks = [item async for item in cell.drive.walkItemInfo(iden)]
+            self.len(3, walks)
+            self.eq('hoho', walks[0].get('name'))
+            self.eq('haha', walks[1].get('name'))
+            self.eq('hehe', walks[2].get('name'))
+
+            self.none(cell.drive.getTypeSchema('newp'))
+
+            cell.drive.validators.pop('woot')
+            self.nn(cell.drive.getTypeValidator('woot'))
+
+            # move to root dir
+            pathinfo = await cell.setDriveInfoPath(baziden, 'zipzop')
+            self.len(1, pathinfo)
+            self.eq(s_drive.rootdir, pathinfo[-1].get('parent'))
+
+            pathinfo = await cell.setDriveInfoPath(baziden, 'hehe/haha/hoho')
+            self.len(3, pathinfo)
+
     async def test_cell_auth(self):
 
         with self.getTestDir() as dirn:
@@ -2914,3 +3124,17 @@ class CellTest(s_t_utils.SynTest):
 
             async with self.getTestCell(s_cell.Cell, dirn=dirn):
                 pass
+
+    async def test_cell_initslab_fini(self):
+        class SlabCell(s_cell.Cell):
+            async def initServiceStorage(self):
+                self.long_lived_slab = await self._initSlabFile(os.path.join(self.dirn, 'slabs', 'long.lmdb'))
+                short_slab = await self._initSlabFile(os.path.join(self.dirn, 'slabs', 'short.lmdb'), ephemeral=True)
+                self.short_slab_path = short_slab.lenv.path()
+                await short_slab.fini()
+
+        async with self.getTestCell(SlabCell) as cell:
+            self.true(os.path.isdir(cell.short_slab_path))
+            self.isin(cell.long_lived_slab.fini, cell._fini_funcs)
+            slabs = [s for s in cell.tofini if isinstance(s, s_lmdbslab.Slab) and s.lenv.path() == cell.short_slab_path]
+            self.len(0, slabs)

synapse/tests/test_lib_coro.py

@@ -41,6 +41,18 @@ def nopickle():
 
 class CoroTest(s_t_utils.SynTest):
 
+    async def test_coro_chunks(self):
+        async def agen():
+            for i in range(101):
+                yield i
+
+        chunks = []
+        async for chunk in s_coro.chunks(agen()):
+            chunks.append(chunk)
+
+        self.len(1, chunks[1])
+        self.len(100, chunks[0])
+
     async def test_coro_event(self):
 
         evnt = s_coro.Event()

synapse/tests/test_lib_stormhttp.py

@@ -692,6 +692,9 @@ class StormHttpTest(s_test.SynTest):
             tlscadir = s_common.gendir(dirn, 'cadir')
             cacertpath = shutil.copyfile(os.path.join(cadir, 'somelocalca.crt'), os.path.join(tlscadir, 'somelocalca.crt'))
 
+            with s_common.genfile(cacertpath) as fd:
+                ca_cert = fd.read().decode()
+
             pkey, cert = tdir.genUserCert('someuser', signas='somelocalca')
             user_pkey = tdir._pkeyToByts(pkey).decode()
             user_cert = tdir._certToByts(cert).decode()
@@ -835,3 +838,40 @@ class StormHttpTest(s_test.SynTest):
                 ## bad cert
                 sslopts['client_cert'] = 'not-gonna-work'
                 await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+            # Provide a CA certificate directly
+            async with self.getTestCore(dirn=dirn) as core:
+
+                sslctx = core.initSslCtx(certpath, pkeypath)
+                sslctx.load_verify_locations(cafile=cacertpath)
+
+                addr, port = await core.addHttpsPort(0, sslctx=sslctx)
+                root = await core.auth.getUserByName('root')
+                await root.setPasswd('root')
+
+                core.addHttpApi('/api/v0/test', s_test.HttpReflector, {'cell': core})
+
+                sslopts = {}
+
+                opts = {
+                    'vars': {
+                        'url': f'https://root:root@localhost:{port}/api/v0/test',
+                        'verify': True,
+                        'sslopts': sslopts,
+                    },
+                }
+
+                q = 'return($lib.inet.http.get($url, ssl_verify=$verify, ssl_opts=$sslopts))'
+
+                size, sha256 = await core.callStorm('return($lib.bytes.put($lib.base64.decode(Zm9v)))')
+                opts['vars']['sha256'] = sha256
+
+                ## no cert provided
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(-1, resp['code'])
+                self.isin('certificate verify failed', resp['reason'])
+
+                ## provide just the CA Certificate
+                sslopts['ca_cert'] = ca_cert
+                resp = await core.callStorm(q, opts=opts)
+                self.eq(200, resp['code'])

synapse/tests/test_lib_stormlib_modelext.py

@@ -57,12 +57,24 @@ class StormtypesModelextTest(s_test.SynTest):
             model_defs = await core.callStorm('return ( $lib.model.ext.getExtModel() )')
             self.isinstance(model_defs, dict)
 
+            self.len(1, await core.nodes('_visi:int:tick'))
+            await core._delAllFormProp('_visi:int', 'tick', {})
+            self.len(0, await core.nodes('_visi:int:tick'))
+
+            self.len(1, await core.nodes('._woot'))
+            await core._delAllUnivProp('_woot', {})
+            self.len(0, await core.nodes('._woot'))
+
+            self.len(1, await core.nodes('#lol:score'))
+            await core._delAllTagProp('score', {})
+            self.len(0, await core.nodes('#lol:score'))
+
             await core.callStorm('_visi:int=10 test:int=1234 | delnode')
             await core.callStorm('''
-                $lib.model.ext.delTagProp(score)
-                $lib.model.ext.delUnivProp(_woot)
+                $lib.model.ext.delTagProp(score, force=(true))
+                $lib.model.ext.delUnivProp(_woot, force=(true))
                 $lib.model.ext.delFormProp(_visi:int, tick)
-                $lib.model.ext.delFormProp(test:int, _tick)
+                $lib.model.ext.delFormProp(test:int, _tick, force=(true))
                 $lib.model.ext.delForm(_visi:int)
                 $lib.model.ext.delEdge(inet:user, _copies, *)
             ''')
@@ -276,6 +288,46 @@ class StormtypesModelextTest(s_test.SynTest):
 
             self.nn(core.model.edge(('inet:user', '_copies', None)))
 
+        # Property values left behind in layers are cleanly removed
+        async with self.getTestCore() as core:
+            await core.callStorm('''
+                $typeinfo = ({})
+                $docinfo = ({"doc": "NEWP"})
+                $lib.model.ext.addUnivProp(_woot, (int, ({})), $docinfo)
+                $lib.model.ext.addTagProp(score, (int, ({})), $docinfo)
+                $lib.model.ext.addFormProp(test:int, _tick, (time, ({})), $docinfo)
+            ''')
+            fork = await core.callStorm('return ( $lib.view.get().fork().iden ) ')
+            nodes = await core.nodes('[test:int=1234 :_tick=2024 ._woot=1 +#hehe:score=10]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('._woot'), 1)
+
+            nodes = await core.nodes('test:int=1234 [:_tick=2023 ._woot=2 +#hehe:score=9]',
+                                     opts={'view': fork})
+            self.len(1, nodes)
+            self.eq(nodes[0].get('._woot'), 2)
+
+            self.len(0, await core.nodes('test:int | delnode'))
+
+            with self.raises(s_exc.CantDelUniv):
+                await core.callStorm('$lib.model.ext.delUnivProp(_woot)')
+            with self.raises(s_exc.CantDelProp):
+                await core.callStorm('$lib.model.ext.delFormProp(test:int, _tick)')
+            with self.raises(s_exc.CantDelProp):
+                await core.callStorm('$lib.model.ext.delTagProp(score)')
+
+            await core.callStorm('$lib.model.ext.delUnivProp(_woot, force=(true))')
+            await core.callStorm('$lib.model.ext.delFormProp(test:int, _tick, force=(true))')
+            await core.callStorm('$lib.model.ext.delTagProp(score, force=(true))')
+
+            nodes = await core.nodes('[test:int=1234]')
+            self.len(1, nodes)
+            self.none(nodes[0].get('._woot'))
+            self.none(nodes[0].get('_tick'))
+            nodes = await core.nodes('test:int=1234', opts={'view': fork})
+            self.none(nodes[0].get('._woot'))
+            self.none(nodes[0].get('_tick'))
+
     async def test_lib_stormlib_behold_modelext(self):
         self.skipIfNexusReplay()
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_stix.py

@@ -410,6 +410,21 @@ class StormLibStixTest(s_test.SynTest):
             self.len(1, [n for n in nodes if n[0][0] == 'it:cmd'])
             self.stormIsInWarn("STIX bundle ingest has no relationship definition for: ('threat-actor', 'gronks', 'threat-actor')", msgs)
 
+            msgs = await core.stormlist('yield $lib.stix.import.ingest(({}), newp)')
+            self.stormIsInErr('config must be a dictionary', msgs)
+
+            msgs = await core.stormlist('yield $lib.stix.import.ingest(({}), ({"relationships": 5}))')
+            self.stormIsInErr('Error processing relationships', msgs)
+
+            msgs = await core.stormlist('yield $lib.stix.import.ingest(({}), ({"bundle": 3}))')
+            self.stormIsInErr('bundle value must be a dictionary', msgs)
+
+            msgs = await core.stormlist('yield $lib.stix.import.ingest(({}), ({"bundle": {"storm": 3}}))')
+            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)
+
     async def test_stix_export_custom(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_vault.py

@@ -159,10 +159,13 @@ class StormlibVaultTest(s_test.SynTest):
 
             # Rename vault
             opts = {'vars': {'giden': giden}}
+            self.eq('gvault', await core.callStorm('return($lib.vault.get($giden).name)', opts=opts))
             q = '$lib.vault.get($giden).name = foobar'
             await core.callStorm(q, opts=opts)
             vault = core.getVault(giden)
             self.eq(vault.get('name'), 'foobar')
+            self.nn(await core.callStorm('return($lib.vault.byname(foobar))'))
+            await self.asyncraises(s_exc.NoSuchName, core.callStorm('return($lib.vault.byname(gvault))'))
 
             # Get secrets without EDIT perms
             opts = {'vars': {'giden': giden}, 'user': visi1.iden}
@@ -222,10 +225,17 @@ class StormlibVaultTest(s_test.SynTest):
             q = '$vault = $lib.vault.get($giden) return($vault.setPerm($iden, $lib.auth.easyperm.level.deny))'
             self.true(await core.callStorm(q, opts=opts))
 
-            # List vaults again
             opts = {'user': visi1.iden}
             self.eq(0, await core.callStorm('return($lib.len($lib.vault.list()))', opts=opts))
 
+            # Remove permission on global vault
+            opts = {'vars': {'iden': visi1.iden, 'giden': giden}}
+            q = '$vault = $lib.vault.get($giden) return($vault.setPerm($iden, $lib.null))'
+            self.true(await core.callStorm(q, opts=opts))
+
+            opts = {'user': visi1.iden}
+            self.eq(1, await core.callStorm('return($lib.len($lib.vault.list()))', opts=opts))
+
             # Runtime asroot
 
             await core.addStormPkg({

synapse/tests/test_lib_stormtypes.py

@@ -6388,6 +6388,11 @@ words\tword\twrd'''
             self.eq(1, await core.callStorm('return($lib.math.number(1.23).toint())'))
             self.eq(2, await core.callStorm('return($lib.math.number(1.23).toint(rounding=ROUND_UP))'))
 
+            with self.raises(s_exc.BadCast):
+                    await core.callStorm('return($lib.math.number((null)))')
+            with self.raises(s_exc.BadCast):
+                    await core.callStorm('return($lib.math.number(newp))')
+
             with self.raises(s_exc.StormRuntimeError):
                 await core.callStorm('return($lib.math.number(1.23).toint(rounding=NEWP))')
 

synapse/tests/test_lib_types.py

@@ -1606,3 +1606,12 @@ class TypesTest(s_t_utils.SynTest):
 
             core.getLayer()._testAddPropArrayIndx(buid, 'test:int', '_hehe', ('newp' * 100,))
             self.len(0, await core.nodes('test:int:_hehe*[~=newp]'))
+
+    async def test_types_typehash(self):
+        async with self.getTestCore() as core:
+            self.true(core.model.form('inet:fqdn').type.typehash is core.model.prop('inet:dns:a:fqdn').type.typehash)
+            self.true(core.model.form('it:prod:softname').type.typehash is core.model.prop('it:network:name').type.typehash)
+            self.true(core.model.form('inet:asn').type.typehash is not core.model.prop('inet:proto:port').type.typehash)
+
+            self.true(s_common.isguid(core.model.form('inet:fqdn').type.typehash))
+            self.true(s_common.isguid(core.model.form('inet:fqdn').typehash))

synapse/tests/test_model_dns.py

@@ -108,6 +108,14 @@ class DnsModelTest(s_t_utils.SynTest):
             self.eq(node.get('name:fqdn'), 'vertex.link')
             self.eq(node.get('type'), 255)
 
+            nodes = await core.nodes('[inet:dns:request=* :reply:code=NXDOMAIN]')
+            self.eq(nodes[0].get('reply:code'), 3)
+            self.eq(nodes[0].repr('reply:code'), 'NXDOMAIN')
+
+            nodes = await core.nodes('[inet:dns:request=* :reply:code=1138]')
+            self.eq(nodes[0].get('reply:code'), 1138)
+            self.eq(nodes[0].repr('reply:code'), '1138')
+
             nodes = await core.nodes('[inet:dns:query=("tcp://1.2.3.4", 4.3.2.1.in-addr.arpa, 255)]')
             self.len(1, nodes)
             node = nodes[0]

synapse/tests/test_model_geospace.py

@@ -2,7 +2,6 @@ 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
 
 import synapse.lib.module as s_module
 
@@ -499,6 +498,7 @@ class GeoTest(s_t_utils.SynTest):
                     :place:name=woot
                     :place={[geo:place=* :name=woot]}
                     :accuracy=10m
+                    :node=(test:int, 1234)
                 ]
             ''')
             self.eq(1655510400000, nodes[0].get('time'))
@@ -507,6 +507,8 @@ class GeoTest(s_t_utils.SynTest):
             self.eq('woot', nodes[0].get('place:name'))
             self.eq(10000, nodes[0].get('accuracy'))
             self.len(1, await core.nodes('geo:telem -> geo:place +:name=woot'))
+            self.eq(('test:int', 1234), nodes[0].get('node'))
+            self.len(1, await core.nodes('test:int=1234'))
 
     async def test_model_geospace_area(self):
 

synapse/tests/test_model_infotech.py

@@ -407,6 +407,35 @@ class InfotechModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('net6'), ('fe80::', 'fe80::ffff:ffff:ffff:ffff'))
             self.eq(nodes[0].get('type'), 'virtual.sdn.')
 
+            nodes = await core.nodes('''[
+                it:sec:stix:indicator=*
+                    :id=zoinks
+                    :name=woot
+                    :confidence=90
+                    :revoked=(false)
+                    :description="my neato indicator"
+                    :pattern="some rule text"
+                    :pattern_type=yara
+                    :created=20240815
+                    :updated=20240815
+                    :labels=(hehe, haha)
+                    :valid_from=20240815
+                    :valid_until=20240815
+            ]''')
+            self.len(1, nodes)
+            self.eq('zoinks', nodes[0].get('id'))
+            self.eq('woot', nodes[0].get('name'))
+            self.eq(90, nodes[0].get('confidence'))
+            self.eq(False, nodes[0].get('revoked'))
+            self.eq('my neato indicator', nodes[0].get('description'))
+            self.eq('some rule text', nodes[0].get('pattern'))
+            self.eq('yara', nodes[0].get('pattern_type'))
+            self.eq(('haha', 'hehe'), nodes[0].get('labels'))
+            self.eq(1723680000000, nodes[0].get('created'))
+            self.eq(1723680000000, nodes[0].get('updated'))
+            self.eq(1723680000000, nodes[0].get('valid_from'))
+            self.eq(1723680000000, nodes[0].get('valid_until'))
+
     async def test_infotech_ios(self):
 
         async with self.getTestCore() as core:
@@ -1553,6 +1582,24 @@ class InfotechModelTest(s_t_utils.SynTest):
             self.eq(rule, nodes[0].get('rule'))
             self.eq(0x10000200003, nodes[0].get('version'))
 
+            nodes = await core.nodes('''[
+                (it:app:yara:netmatch=* :node=(inet:fqdn, foo.com))
+                (it:app:yara:netmatch=* :node=(inet:ipv4, 1.2.3.4))
+                (it:app:yara:netmatch=* :node=(inet:ipv6, "::ffff"))
+                (it:app:yara:netmatch=* :node=(inet:url, "http://foo.com"))
+                    :rule=$rule
+                    :version=1.2.3
+            ]''', opts=opts)
+            self.len(4, nodes)
+            for node in nodes:
+                self.nn(node.get('node'))
+                self.nn(node.get('version'))
+
+            self.len(4, await core.nodes('it:app:yara:rule=$rule -> it:app:yara:netmatch', opts=opts))
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('[it:app:yara:netmatch=* :node=(it:dev:str, foo)]')
+
     async def test_it_app_snort(self):
 
         async with self.getTestCore() as core: