synapse 2.173.1__py311-none-any.whl → 2.175.0__py311-none-any.whl

synapse/models/economic.py

@@ -48,11 +48,11 @@ class EconModule(s_module.CoreModule):
                     'doc': 'An invoice issued requesting payment.'}),
 
                 ('econ:price', ('hugenum', {'norm': False}), {
-                    'doc': 'The amount of money expected, required, or given in payment for something',
+                    'doc': 'The amount of money expected, required, or given in payment for something.',
                     'ex': '2.20'}),
 
                 ('econ:currency', ('str', {'lower': True, 'strip': False}), {
-                    'doc': 'The name of a system of money in general use',
+                    'doc': 'The name of a system of money in general use.',
                     'ex': 'usd'}),
 
                 ('econ:fin:exchange', ('guid', {}), {
@@ -99,6 +99,7 @@ class EconModule(s_module.CoreModule):
 
             'forms': (
 
+                ('econ:currency', {}, ()),
                 ('econ:pay:iin', {}, (
 
                     ('org', ('ou:org', {}), {
@@ -205,6 +206,9 @@ class EconModule(s_module.CoreModule):
                     ('fee', ('econ:price', {}), {
                         'doc': 'The transaction fee paid by the recipient to the payment processor.'}),
 
+                    ('from:cash', ('bool', {}), {
+                        'doc': 'Set to true if the payment input was in cash.'}),
+
                     ('from:account', ('econ:bank:account', {}), {
                         'doc': 'The bank account which made the payment.'}),
 
@@ -220,6 +224,9 @@ class EconModule(s_module.CoreModule):
                     ('from:contact', ('ps:contact', {}), {
                         'doc': 'Contact information for the entity making the payment.'}),
 
+                    ('to:cash', ('bool', {}), {
+                        'doc': 'Set to true if the payment output was in cash.'}),
+
                     ('to:account', ('econ:bank:account', {}), {
                         'doc': 'The bank account which received the payment.'}),
 
@@ -256,6 +263,20 @@ class EconModule(s_module.CoreModule):
                     ('receipt', ('econ:acct:receipt', {}), {
                         'doc': 'The receipt that was issued for the payment.'}),
 
+                    ('place', ('geo:place', {}), {
+                        'doc': 'The place where the payment occurred.'}),
+
+                    ('place:name', ('geo:name', {}), {
+                        'doc': 'The name of the place where the payment occurred.'}),
+
+                    ('place:address', ('geo:address', {}), {
+                        'doc': 'The address of the place where the payment occurred.'}),
+
+                    ('place:loc', ('loc', {}), {
+                        'doc': 'The loc of the place where the payment occurred.'}),
+
+                    ('place:latlong', ('geo:latlong', {}), {
+                        'doc': 'The latlong where the payment occurred.'}),
                 )),
 
                 ('econ:acct:balance', {}, (

synapse/models/entity.py

@@ -0,0 +1,16 @@
+import synapse.lib.module as s_module
+
+class EntityModule(s_module.CoreModule):
+
+    def getModelDefs(self):
+        return (('entity', {
+
+            'types': (
+                ('entity:name', ('str', {'onespace': True, 'lower': True}), {
+                    'doc': 'A name used to refer to an entity.'}),
+            ),
+
+            'forms': (
+                ('entity:name', {}, ()),
+            ),
+        }),)

synapse/models/files.py

@@ -412,7 +412,10 @@ class FileModule(s_module.CoreModule):
                     'doc': 'The GUID of the metadata pulled from a Windows shortcut or LNK file.',
                 }),
             ),
-
+            'edges': (
+                (('file:bytes', 'refs', 'it:dev:str'), {
+                    'doc': 'The source file contains the target string.'}),
+            ),
             'forms': (
 
                 ('file:bytes', {}, (

synapse/models/geopol.py

@@ -88,6 +88,9 @@ class PolModule(s_module.CoreModule):
 
                         ('vitals', ('pol:vitals', {}), {
                             'doc': 'The most recent known vitals for the country.'}),
+
+                        ('currencies', ('array', {'type': 'econ:currency', 'sorted': True, 'uniq': True}), {
+                            'doc': 'The official currencies used in the country.'}),
                     )),
                     ('pol:immigration:status:type:taxonomy', {}, ()),
                     ('pol:immigration:status', {}, (

synapse/models/orgs.py

@@ -731,8 +731,7 @@ class OuModule(s_module.CoreModule):
                     ('contact', ('ps:contact', {}), {
                         'doc': 'The contact info for the person who holds the position.',
                     }),
-                    # TODO migrate to ou:jobtitle
-                    ('title', ('str', {'lower': True, 'onespace': True}), {
+                    ('title', ('ou:jobtitle', {}), {
                         'doc': 'The title of the position.',
                     }),
                     ('reports', ('array', {'type': 'ou:position', 'uniq': True, 'sorted': True}), {
@@ -1024,11 +1023,11 @@ class OuModule(s_module.CoreModule):
                     ('sponsors', ('array', {'type': 'ps:contact', 'uniq': True, 'sorted': True}), {
                         'doc': 'An array of contacts which sponsored the conference.',
                     }),
-                    ('name', ('str', {'lower': True}), {
+                    ('name', ('entity:name', {}), {
                         'doc': 'The full name of the conference.',
                         'ex': 'defcon 2017'}),
 
-                    ('names', ('array', {'type': 'str', 'typeopts': {'lower': True}, 'uniq': True, 'sorted': True}), {
+                    ('names', ('array', {'type': 'entity:name', 'uniq': True, 'sorted': True}), {
                         'doc': 'An array of alternate names for the conference.'}),
 
                     ('desc', ('str', {'lower': True}), {

synapse/tests/test_cortex.py

@@ -269,6 +269,19 @@ class CortexTest(s_t_utils.SynTest):
                     self.eq(await core00.getJsonObj('foo/bar'), 'zoinks')
                     self.eq(await core01.getJsonObj('foo/bar'), 'zoinks')
 
+        # Test startup sequencing. We must create the child cells prior to
+        # the nexus recover() call from occuring :)
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn) as core:
+                await core.callStorm('$lib.jsonstor.set((path,), hehe)')
+
+            with self.getAsyncLoggerStream('synapse.lib.nexus') as stream:
+                async with self.getTestCore(dirn=dirn) as core:
+                    q = 'return( $lib.jsonstor.get((path,)) )'
+                    self.eq('hehe', await core.callStorm(q))
+            stream.seek(0)
+            self.notin('Exception while replaying log', stream.read())
+
     async def test_cortex_layer_mirror(self):
 
         # test a layer mirror from a layer

synapse/tests/test_daemon.py

@@ -75,6 +75,42 @@ class DaemonTest(s_t_utils.SynTest):
             async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}') as proxy:
                 self.eq(proxy._ahainfo, ahainfo)
 
+    async def test_dmon_errors(self):
+
+        async with self.getTestCell(s_cell.Cell, conf={'dmon:listen': 'tcp://0.0.0.0:0/', 'auth:anon': 'root'}) as cell:
+            host, port = cell.sockaddr
+
+            async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}') as prox:
+
+                # Throw an exception when trying to handle mesg outright
+                async with await prox.getPoolLink() as link:
+                    with self.getAsyncLoggerStream('synapse.daemon', 'Dmon.onLinkMesg Handler: mesg=') as stream:
+                        await link.tx(31337)
+                        self.true(await stream.wait(timeout=6))
+
+                # Valid format; do not know what the message is.
+                async with await prox.getPoolLink() as link:
+                    mesg = ('newp', {})
+                    emsg = "Dmon.onLinkMesg Invalid mesg: mesg=('newp', {})"
+                    with self.getAsyncLoggerStream('synapse.daemon', emsg) as stream:
+                        await link.tx(mesg)
+                        self.true(await stream.wait(timeout=6))
+
+                # Invalid data casues a link to fail on rx
+                async with await prox.getPoolLink() as link:
+                    with self.getAsyncLoggerStream('synapse.lib.link', 'rx error') as stream:
+                        byts = b'\x16\x03\x01\x02\x00\x01\x00\x01\xfc\x03\x03\xa6\xa3D\xd5\xdf%\xac\xa9\x92\xc3'
+                        await link.send(byts)
+                        self.true(await stream.wait(timeout=6))
+
+                # bad t2:init message
+                async with await prox.getPoolLink() as link:
+                    mesg = ('t2:init', {})
+                    emsg = "Error on t2:init:"
+                    with self.getAsyncLoggerStream('synapse.daemon', emsg) as stream:
+                        await link.tx(mesg)
+                        self.true(await stream.wait(timeout=6))
+
 class SvcApi(s_cell.CellApi, s_stormsvc.StormSvc):
     _storm_svc_name = 'foo'
     _storm_svc_pkgs = (  # type:  ignore

synapse/tests/test_lib_agenda.py

@@ -331,7 +331,17 @@ class AgendaTest(s_t_utils.SynTest):
                 appt = await agenda.get(guid)
                 self.eq(appt.isrunning, True)
                 self.eq(core.view.iden, appt.task.info.get('view'))
-                await appt.task.kill()
+
+                self.true(await core._killCronTask(guid))
+
+                events = [
+                    {'event': 'cron:stop', 'info': {'iden': appt.iden}},
+                ]
+
+                task = core.schedCoro(s_t_utils.waitForBehold(core, events))
+                await asyncio.wait_for(task, timeout=5)
+
+                self.false(await core._killCronTask(guid))
 
                 appt = await agenda.get(guid)
                 self.eq(appt.isrunning, False)
@@ -798,3 +808,121 @@ class AgendaTest(s_t_utils.SynTest):
                 stream.seek(0)
                 data = stream.read()
                 self.isin("_Appt.edits() Invalid attribute received: invalid = 'newp'", data)
+
+    async def test_cron_kill(self):
+        async with self.getTestCore() as core:
+
+            data = []
+            evt = asyncio.Event()
+
+            async def task():
+                async for mesg in core.behold():
+                    data.append(mesg)
+                    if mesg.get('event') == 'cron:stop':
+                        evt.set()
+
+            core.schedCoro(task())
+
+            q = '$q=$lib.queue.gen(test) for $i in $lib.range(60) { $lib.time.sleep(0.1) $q.put($i) }'
+            guid = s_common.guid()
+            cdef = {
+                'creator': core.auth.rootuser.iden, 'iden': guid,
+                'storm': q,
+                'reqs': {'now': True}
+            }
+            await core.addCronJob(cdef)
+
+            q = '$q=$lib.queue.gen(test) for $valu in $q.get((0), wait=(true)) { return ($valu) }'
+            valu = await core.callStorm(q)
+            self.eq(valu, 0)
+
+            opts = {'vars': {'iden': guid}}
+            get_cron = 'return($lib.cron.get($iden).pack())'
+            cdef = await core.callStorm(get_cron, opts=opts)
+            self.true(cdef.get('isrunning'))
+
+            self.true(await core.callStorm('return($lib.cron.get($iden).kill())', opts=opts))
+
+            self.true(await asyncio.wait_for(evt.wait(), timeout=12))
+
+            cdef = await core.callStorm(get_cron, opts=opts)
+            self.false(cdef.get('isrunning'))
+
+    async def test_cron_kill_pool(self):
+
+        async with self.getTestAhaProv() as aha:
+
+            import synapse.cortex as s_cortex
+            import synapse.lib.base as s_base
+
+            async with await s_base.Base.anit() as base:
+
+                with self.getTestDir() as dirn:
+
+                    dirn00 = s_common.genpath(dirn, 'cell00')
+                    dirn01 = s_common.genpath(dirn, 'cell01')
+
+                    core00 = await base.enter_context(self.addSvcToAha(aha, '00.core', s_cortex.Cortex, dirn=dirn00))
+                    provinfo = {'mirror': '00.core'}
+                    core01 = await base.enter_context(self.addSvcToAha(aha, '01.core', s_cortex.Cortex, dirn=dirn01, provinfo=provinfo))
+
+                    self.len(1, await core00.nodes('[inet:asn=0]'))
+                    await core01.sync()
+                    self.len(1, await core01.nodes('inet:asn=0'))
+
+                    msgs = await core00.stormlist('aha.pool.add pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Created AHA service pool: pool00.loop.vertex.link', msgs)
+
+                    msgs = await core00.stormlist('aha.pool.svc.add pool00... 01.core...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('AHA service (01.core...) added to service pool (pool00.loop.vertex.link)', msgs)
+
+                    msgs = await core00.stormlist('cortex.storm.pool.set --connection-timeout 1 --sync-timeout 1 aha://pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Storm pool configuration set.', msgs)
+
+                    await core00.stormpool.waitready(timeout=12)
+
+                    data = []
+                    evt = asyncio.Event()
+
+                    async def task():
+                        async for mesg in core00.behold():
+                            data.append(mesg)
+                            if mesg.get('event') == 'cron:stop':
+                                evt.set()
+
+                    core00.schedCoro(task())
+
+                    q = '$q=$lib.queue.gen(test) for $i in $lib.range(60) { $lib.time.sleep(0.1) $q.put($i) }'
+                    guid = s_common.guid()
+                    cdef = {
+                        'creator': core00.auth.rootuser.iden, 'iden': guid,
+                        'storm': q,
+                        'reqs': {'NOW': True},
+                        'pool': True,
+                    }
+                    await core00.addCronJob(cdef)
+
+                    q = '$q=$lib.queue.gen(test) for $valu in $q.get((0), wait=(true)) { return ($valu) }'
+                    valu = await core00.callStorm(q, opts={'mirror': False})
+                    self.eq(valu, 0)
+
+                    opts = {'vars': {'iden': guid}, 'mirror': False}
+                    get_cron = 'return($lib.cron.get($iden).pack())'
+                    cdef = await core00.callStorm(get_cron, opts=opts)
+                    self.true(cdef.get('isrunning'))
+
+                    self.true(await core00.callStorm('return($lib.cron.get($iden).kill())', opts=opts))
+
+                    self.true(await asyncio.wait_for(evt.wait(), timeout=12))
+
+                    cdef00 = await core00.callStorm(get_cron, opts=opts)
+                    self.false(cdef00.get('isrunning'))
+
+                    cdef01 = await core01.callStorm(get_cron, opts=opts)
+                    self.false(cdef01.get('isrunning'))
+                    self.eq(cdef01.get('lastresult'), 'cancelled')
+                    self.gt(cdef00['laststarttime'], 0)
+                    self.eq(cdef00['laststarttime'], cdef01['laststarttime'])

synapse/tests/test_lib_ast.py

@@ -356,6 +356,27 @@ class AstTest(s_test.SynTest):
             self.len(1, nodes)
             self.none(nodes[0].get('.seen'))
 
+            # array var filter
+            q = '''
+                [(test:arrayprop=* :strs=(neato, burrito))
+                 (test:arrayprop=* :ints=(1,2,3,4,5))] |
+                 $pvar = "strs"
+                 +:$pvar*[=neato]
+            '''
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.eq(('neato', 'burrito'), nodes[0].get('strs'))
+
+            q = '$pvar=ints $avar=4 test:arrayprop +:$pvar*[=$avar]'
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.eq((1, 2, 3, 4, 5), nodes[0].get('ints'))
+
+            q = '$pvar=strs $avar=burr test:arrayprop +:$pvar*[^=$avar]'
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.eq(('neato', 'burrito'), nodes[0].get('strs'))
+
             # Sad paths
             q = '[test:str=newp -.newp]'
             await self.asyncraises(s_exc.NoSuchProp, core.nodes(q))
@@ -692,6 +713,41 @@ class AstTest(s_test.SynTest):
             self.len(3, await core.nodes('test:str=ndefs :ndefs -> *'))
             self.len(2, await core.nodes('test:str=ndefs :ndefs -> it:dev:int'))
 
+            await core.nodes('[ risk:technique:masquerade=* :node=(it:dev:int, 1) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ :target=(it:dev:int, 1) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ :target=(it:dev:int, 2) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ -:node ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(1, nodes)
+            self.eq('test:str', nodes[0].ndef[0])
+
+            await core.nodes('test:str=ndefs [ :ndefs-=(it:dev:int, 1) ]')
+            self.len(0, await core.nodes('it:dev:int=1 <- *'))
+            nodes = await core.nodes('it:dev:int=2 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ -:target ]')
+            await core.nodes('test:str=ndefs [ -:ndefs ]')
+            self.len(0, await core.nodes('it:dev:int=1 <- *'))
+            self.len(0, await core.nodes('it:dev:int=2 <- *'))
+
     async def test_ast_pivot(self):
         # a general purpose pivot test. come on in!
         async with self.getTestCore() as core:

synapse/tests/test_lib_cell.py

@@ -503,6 +503,13 @@ class CellTest(s_t_utils.SynTest):
             cell.COMMIT = 'mycommit'
             cell.VERSION = (1, 2, 3)
             cell.VERSTRING = '1.2.3'
+
+            http_info = []
+            host, port = await cell.addHttpsPort(0)
+            http_info.append({'host': host, 'port': port})
+            host, port = await cell.addHttpsPort(0, host='127.0.0.1')
+            http_info.append({'host': host, 'port': port})
+
             async with cell.getLocalProxy() as prox:
                 info = await prox.getCellInfo()
                 # Cell information
@@ -527,6 +534,10 @@ class CellTest(s_t_utils.SynTest):
                 self.eq(snfo.get('verstring'), s_version.verstring),
                 self.eq(snfo.get('commit'), s_version.commit)
 
+                netw = cnfo.get('network')
+                https = netw.get('https')
+                self.eq(https, http_info)
+
     async def test_cell_dyncall(self):
 
         with self.getTestDir() as dirn:

synapse/tests/test_lib_grammar.py

@@ -721,6 +721,8 @@ Queries = [
     '$foo=({"bar": null})',
     '$p="names" ps:contact:name=foo [ :$p?+=bar ]',
     '$p="names" ps:contact:name=foo [ :$p?-=bar ]',
+    '$pvar=stuff test:arrayprop +:$pvar*[=neato]',
+    '$pvar=ints test:arrayprop +:$pvar*[=$othervar]',
 ]
 
 # Generated with print_parse_list below
@@ -1346,6 +1348,8 @@ _ParseResults = [
     'Query: [SetVarOper: [Const: foo, DollarExpr: [ExprDict: [Const: bar, Const: None]]]]',
     'Query: [SetVarOper: [Const: p, Const: names], LiftPropBy: [Const: ps:contact:name, Const: =, Const: foo], EditPropSet: [RelProp: [VarValue: [Const: p]], Const: ?+=, Const: bar]]',
     'Query: [SetVarOper: [Const: p, Const: names], LiftPropBy: [Const: ps:contact:name, Const: =, Const: foo], EditPropSet: [RelProp: [VarValue: [Const: p]], Const: ?-=, Const: bar]]',
+    'Query: [SetVarOper: [Const: pvar, Const: stuff], LiftProp: [Const: test:arrayprop], FiltOper: [Const: +, ArrayCond: [RelProp: [VarValue: [Const: pvar]], Const: =, Const: neato]]]',
+    'Query: [SetVarOper: [Const: pvar, Const: ints], LiftProp: [Const: test:arrayprop], FiltOper: [Const: +, ArrayCond: [RelProp: [VarValue: [Const: pvar]], Const: =, VarValue: [Const: othervar]]]]',
 ]
 
 class GrammarTest(s_t_utils.SynTest):

synapse/tests/test_lib_httpapi.py

@@ -916,6 +916,7 @@ class HttpApiTest(s_tests.SynTest):
                     await core.callStorm('$c = $lib.cron.get($cron) $c.set("doc", "some docs")', opts=opts)
                     await core.callStorm('cron.del $cron', opts=opts)
 
+                    await core.addStormPkg(spkg)
                     await core.addStormPkg(spkg)
                     await core.addStormSvc(ssvc)
 

synapse/tests/test_lib_lmdbslab.py

@@ -1,4 +1,5 @@
 import os
+import json
 import asyncio
 import pathlib
 import multiprocessing
@@ -350,7 +351,7 @@ class LmdbSlabTest(s_t_utils.SynTest):
         with self.getTestDir() as dirn, patch('synapse.lib.lmdbslab.Slab.WARN_COMMIT_TIME_MS', 1), \
                 patch('synapse.common.now', self.simplenow):
             path = os.path.join(dirn, 'test.lmdb')
-            with self.getAsyncLoggerStream('synapse.lib.lmdbslab', 'Commit with') as stream:
+            with self.getStructuredAsyncLoggerStream('synapse.lib.lmdbslab', 'Commit with') as stream:
                 async with await s_lmdbslab.Slab.anit(path, map_size=100000) as slab:
                     foo = slab.initdb('foo', dupsort=True)
                     byts = b'\x00' * 256
@@ -358,6 +359,20 @@ class LmdbSlabTest(s_t_utils.SynTest):
                         slab.put(b'\xff\xff\xff\xff' + s_common.guid(i).encode('utf8'), byts, db=foo)
                 self.true(await stream.wait(timeout=1))
 
+            data = stream.getvalue()
+            msgs = [json.loads(m) for m in data.split('\\n') if m]
+            self.gt(len(msgs), 0)
+            self.nn(msgs[0].get('delta'))
+            self.nn(msgs[0].get('path'))
+            self.nn(msgs[0].get('xactopslen'))
+            self.sorteq([
+                'vm.swappiness',
+                'vm.dirty_expire_centisecs',
+                'vm.dirty_writeback_centisecs',
+                'vm.dirty_background_ratio',
+                'vm.dirty_ratio',
+            ], msgs[0].get('sysctls', {}).keys())
+
     async def test_lmdbslab_max_replay(self):
         with self.getTestDir() as dirn:
             path = os.path.join(dirn, 'test.lmdb')

synapse/tests/test_lib_modelrev.py

@@ -473,3 +473,89 @@ class ModelRevTest(s_tests.SynTest):
             nodes = await core.nodes('it:mitre:attack:technique=T0100')
             self.len(1, nodes)
             self.eq('lockpicking', nodes[0].get('name'))
+
+    async def test_modelrev_0_2_25(self):
+        async with self.getRegrCore('model-0.2.25') as core:
+
+            self.len(1, await core.nodes('econ:currency=usd'))
+
+            nodes = await core.nodes('ou:conference')
+            self.len(3, nodes)
+            names = [n.get('name') for n in nodes]
+            self.sorteq(names, (
+                'sleuthcon',
+                'defcon',
+                'recon',
+            ))
+
+            namess = [n.get('names') for n in nodes]
+            self.sorteq(namess, (
+                ('defcon 2024',),
+                ('recon 2024 conference',),
+                ('sleuthcon 2024',),
+            ))
+
+            connames = (
+                'sleuthcon', 'sleuthcon 2024',
+                'defcon', 'defcon 2024',
+                'recon', 'recon 2024 conference',
+            )
+
+            nodes = await core.nodes('entity:name')
+            self.len(6, nodes)
+            names = [n.ndef[1] for n in nodes]
+            self.sorteq(names, connames)
+
+            nodes = await core.nodes('ou:conference -> entity:name')
+            self.len(6, nodes)
+            names = [n.ndef[1] for n in nodes]
+            self.sorteq(names, connames)
+
+            positions = (
+                'president of the united states',
+                'vice president of the united states',
+            )
+
+            nodes = await core.nodes('ou:position')
+            self.len(2, nodes)
+            titles = [n.get('title') for n in nodes]
+            self.sorteq(titles, positions)
+
+            nodes = await core.nodes('ou:jobtitle')
+            self.len(2, nodes)
+            titles = [n.ndef[1] for n in nodes]
+            self.sorteq(titles, positions)
+
+            nodes = await core.nodes('ou:position -> ou:jobtitle')
+            self.len(2, nodes)
+            titles = [n.ndef[1] for n in nodes]
+            self.sorteq(titles, positions)
+
+    async def test_modelrev_0_2_26(self):
+        async with self.getRegrCore('model-0.2.26') as core:
+
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(3, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['risk:vulnerable', 'risk:vulnerable', 'inet:fqdn'])
+
+            nodes = await core.nodes('it:dev:int=2 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['inet:fqdn', 'inet:fqdn'])
+
+            nodes = await core.nodes('it:dev:int=3 <- *')
+            self.len(1, nodes)
+            self.eq(nodes[0].ndef[0], 'risk:vulnerable')
+
+            nodes = await core.nodes('it:dev:int=4 <- *')
+            self.len(1, nodes)
+            self.eq(nodes[0].ndef[0], 'inet:fqdn')
+
+            nodes = await core.nodes('risk:vulnerable:node=(it:dev:int, 1)')
+            self.len(2, nodes)
+
+            rnodes = await core.nodes('reverse(risk:vulnerable:node=(it:dev:int, 1))')
+            self.len(2, rnodes)
+
+            self.eq([node.ndef[0] for node in nodes], [node.ndef[0] for node in reversed(rnodes)])