synapse 2.167.0__py311-none-any.whl → 2.169.0__py311-none-any.whl

synapse/models/planning.py

@@ -0,0 +1,161 @@
+import synapse.lib.module as s_module
+
+class PlanModule(s_module.CoreModule):
+
+    def getModelDefs(self):
+        return (('plan', {
+            'types': (
+                ('plan:system', ('guid', {}), {
+                    'doc': 'A planning or behavioral analysis system that defines phases and procedures.'}),
+
+                ('plan:phase', ('guid', {}), {
+                    'doc': 'A phase within a planning system which may be used to group steps within a procedure.'}),
+
+                ('plan:procedure', ('guid', {}), {
+                    'doc': 'A procedure consisting of steps.'}),
+
+                ('plan:procedure:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of procedure types.'}),
+
+                ('plan:procedure:variable', ('guid', {}), {
+                    'doc': 'A variable used by a procedure.'}),
+
+                ('plan:procedure:step', ('guid', {}), {
+                    'doc': 'A step within a procedure.'}),
+
+                ('plan:procedure:link', ('guid', {}), {
+                    'doc': 'A link between steps in a procedure.'}),
+            ),
+
+            'forms': (
+                ('plan:system', {}, (
+
+                    ('name', ('str', {'lower': True, 'onespace': True}), {
+                        'ex': 'mitre att&ck flow',
+                        'doc': 'The name of the planning system.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the purpose and use case for the planning system.'}),
+
+                    ('author', ('ps:contact', {}), {
+                        'doc': 'The contact of the person or organization which authored the system.'}),
+
+                    ('created', ('time', {}), {
+                        'doc': 'The time the planning system was first created.'}),
+
+                    ('updated', ('time', {}), {
+                        'doc': 'The time the planning system was last updated.'}),
+
+                    ('version', ('it:semver', {}), {
+                        'doc': 'The version of the planning system.'}),
+
+                    ('url', ('inet:url', {}), {
+                        'doc': 'The primary URL which documents the planning system.'}),
+                )),
+                ('plan:phase', {}, (
+                    ('title', ('str', {}), {
+                        'ex': 'Reconnaissance Phase',
+                        'doc': 'The title of the phase.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the definition of the phase.'}),
+
+                    ('index', ('int', {}), {
+                        'doc': 'The index of this phase within the phases of the system.'}),
+
+                    ('url', ('inet:url', {}), {
+                        'doc': 'A URL which links to the full documentation about the phase.'}),
+
+                    ('system', ('plan:system', {}), {
+                        'doc': 'The planning system which defines this phase.'}),
+                )),
+                ('plan:procedure:type:taxonomy', {}, ()),
+                ('plan:procedure', {}, (
+
+                    ('title', ('str', {}), {
+                        'ex': 'Network Reconnaissance Procedure',
+                        'doc': 'The name of the procedure.'}),
+
+                    ('summary', ('str', {}), {
+                        'disp': {'hint': 'text'},
+                        'doc': 'A summary of the purpose and use cases for the procedure.'}),
+
+                    ('author', ('ps:contact', {}), {
+                        'doc': 'The contact of the person or organization which authored the procedure.'}),
+
+                    ('created', ('time', {}), {
+                        'doc': 'The time the procedure was created.'}),
+
+                    ('updated', ('time', {}), {
+                        'doc': 'The time the procedure was last updated.'}),
+
+                    ('version', ('it:semver', {}), {
+                        'doc': 'The version of the procedure.'}),
+
+                    ('system', ('plan:system', {}), {
+                        'doc': 'The planning system which defines this procedure.'}),
+
+                    ('type', ('plan:procedure:type:taxonomy', {}), {
+                        'doc': 'A type classification for the procedure.'}),
+
+                    ('inputs', ('array', {'type': 'plan:procedure:variable', 'uniq': True, 'sorted': True}), {
+                        'doc': 'An array of inputs required to execute the procedure.'}),
+
+                    ('firststep', ('plan:procedure:step', {}), {
+                        'doc': 'The first step in the procedure.'}),
+                )),
+                ('plan:procedure:variable', {}, (
+
+                    ('name', ('str', {}), {
+                        'doc': 'The name of the variable.'}),
+
+                    ('type', ('str', {}), {
+                        'doc': 'The type for the input. Types are specific to the planning system.'}),
+
+                    ('default', ('data', {}), {
+                        'doc': 'The optional default value if the procedure is invoked without the input.'}),
+
+                    ('procedure', ('plan:procedure', {}), {
+                        'doc': 'The procedure which defines the variable.'}),
+                )),
+                ('plan:procedure:step', {}, (
+
+                    ('phase', ('plan:phase', {}), {
+                        'doc': 'The phase that the step belongs within.'}),
+
+                    ('procedure', ('plan:procedure', {}), {
+                        'doc': 'The procedure which defines the step.'}),
+
+                    ('title', ('str', {}), {
+                        'ex': 'Scan the IPv4 address range for open ports',
+                        'doc': 'The title of the step.'}),
+
+                    ('summary', ('str', {}), {
+                        'doc': 'A summary of the tasks executed within the step.'}),
+
+                    ('outputs', ('array', {'type': 'plan:procedure:variable', 'uniq': True, 'sorted': True}), {
+                        'doc': 'An array of variables defined in this step.'}),
+
+                    ('techniques', ('array', {'type': 'ou:technique', 'uniq': True, 'sorted': True}), {
+                        'doc': 'An array of techniques used when executing this step.'}),
+
+                    ('links', ('array', {'type': 'plan:procedure:link', 'uniq': True}), {
+                        'doc': 'An array of links to subsequent steps.'}),
+
+                )),
+                ('plan:procedure:link', {}, (
+
+                    ('condition', ('bool', {}), {
+                        'doc': 'Set to true/false if this link is conditional based on a decision step.'}),
+
+                    ('next', ('plan:procedure:step', {}), {
+                        'doc': 'The next step in the plan.'}),
+
+                    ('procedure', ('plan:procedure', {}), {
+                        'doc': 'The procedure which defines the link.'}),
+                )),
+            ),
+        }),)

synapse/tests/test_cortex.py

@@ -7958,7 +7958,7 @@ class CortexBasicTest(s_t_utils.SynTest):
                     waiter = core01.stormpool.waiter(1, 'svc:del')
                     msgs = await core01.stormlist('aha.pool.svc.del pool00... 01.core...', opts={'mirror': False})
                     self.stormHasNoWarnErr(msgs)
-                    self.stormIsInPrint('AHA service (01.core...) removed from service pool (pool00.loop.vertex.link)', msgs)
+                    self.stormIsInPrint('AHA service (01.core.loop.vertex.link) removed from service pool (pool00.loop.vertex.link)', msgs)
 
                     # TODO: this wait should not return None
                     await waiter.wait(timeout=3)

synapse/tests/test_lib_agenda.py

@@ -1,3 +1,4 @@
+import json
 import asyncio
 import hashlib
 import datetime
@@ -156,7 +157,7 @@ class AgendaTest(s_t_utils.SynTest):
         newts = ar.nexttime(now)
         self.eq(newts, datetime.datetime(year=2018, month=12, day=5, hour=7, minute=2, tzinfo=tz.utc).timestamp())
 
-    async def test_agenda(self):
+    async def test_agenda_base(self):
         MONO_DELT = 1543827303.0
         unixtime = datetime.datetime(year=2018, month=12, day=5, hour=7, minute=0, tzinfo=tz.utc).timestamp()
 
@@ -382,8 +383,21 @@ class AgendaTest(s_t_utils.SynTest):
                 self.true(appt.enabled)
                 self.eq(0, appt.startcount)
 
-                unixtime = datetime.datetime(year=2019, month=2, day=13, hour=10, minute=16, tzinfo=tz.utc).timestamp()
-                self.eq((12, 'bar'), await asyncio.wait_for(core.callStorm('return($lib.queue.gen(visi).pop(wait=$lib.true))'), timeout=5))
+                # Ensure structured logging captures the cron iden value
+                core.stormlog = True
+                with self.getStructuredAsyncLoggerStream('synapse.storm') as stream:
+                    unixtime = datetime.datetime(year=2019, month=2, day=13, hour=10, minute=16,
+                                                 tzinfo=tz.utc).timestamp()
+                    self.eq((12, 'bar'), await asyncio.wait_for(core.callStorm('return($lib.queue.gen(visi).pop(wait=$lib.true))'), timeout=5))
+                core.stormlog = False
+
+                data = stream.getvalue()
+                raw_mesgs = [m for m in data.split('\n') if m]
+                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = [m for m in msgs if m['text'] == '$lib.queue.gen(visi).put(bar)']
+                self.gt(len(msgs), 0)
+                for m in msgs:
+                    self.eq(m.get('cron'), appt.iden)
 
                 self.eq(1, appt.startcount)
 

synapse/tests/test_lib_aha.py

@@ -1126,7 +1126,7 @@ class AhaTest(s_test.SynTest):
                     ready = svcinfo.get('ready')
                     online = svcinfo.get('online')
                     self.none(online)
-                    self.true(ready)  # Ready is not cleared upon restart
+                    self.false(ready)  # Ready is cleared upon restart / setting service down.
 
                     n = 3
                     if len(stack._exit_callbacks) > 0:
@@ -1245,7 +1245,12 @@ class AhaTest(s_test.SynTest):
 
                         msgs = await core00.stormlist('aha.pool.svc.del pool00... 00...')
                         self.stormHasNoWarnErr(msgs)
-                        self.stormIsInPrint('AHA service (00...) removed from service pool (pool00.loop.vertex.link)', msgs)
+                        self.stormIsInPrint('AHA service (00.loop.vertex.link) removed from service pool (pool00.loop.vertex.link)',
+                                            msgs)
+
+                        msgs = await core00.stormlist('aha.pool.svc.del pool00... 00...')
+                        self.stormHasNoWarnErr(msgs)
+                        self.stormIsInPrint('Did not remove (00...) from the service pool.', msgs)
 
                         await waiter.wait(timeout=3)
                         run00 = await (await pool.proxy(timeout=3)).getCellRunId()

synapse/tests/test_lib_cell.py

@@ -496,52 +496,6 @@ class CellTest(s_t_utils.SynTest):
                 with self.raises(s_exc.AuthDeny):
                     await prox.setCellUser(visiiden)
 
-    async def test_cell_hiveboot(self):
-
-        with self.getTestDir() as dirn:
-
-            tree = {
-                'kids': {
-                    'hehe': {'value': 'haha'},
-                }
-            }
-
-            bootpath = os.path.join(dirn, 'hiveboot.yaml')
-
-            s_common.yamlsave(tree, bootpath)
-
-            with warnings.catch_warnings(record=True) as warns:
-                async with self.getTestCell(s_cell.Cell, dirn=dirn) as cell:
-                    self.eq('haha', await cell.hive.get(('hehe',)))
-
-                self.isin('Initial hive config from hiveboot.yaml', str(warns[0].message))
-
-            # test that the file does not load again
-            tree['kids']['redballoons'] = {'value': 99}
-            s_common.yamlsave(tree, bootpath)
-
-            async with self.getTestCell(s_cell.Cell, dirn=dirn) as cell:
-                self.none(await cell.hive.get(('redballoons',)))
-
-        # Do a full hive dump/load
-        with self.getTestDir() as dirn:
-            dir0 = s_common.genpath(dirn, 'cell00')
-            dir1 = s_common.genpath(dirn, 'cell01')
-            async with self.getTestCell(s_cell.Cell, dirn=dir0, conf={'auth:passwd': 'root'}) as cell00:
-                await cell00.hive.set(('beeps',), [1, 2, 'three'])
-
-                tree = await cell00.saveHiveTree()
-                s_common.yamlsave(tree, dir1, 'hiveboot.yaml')
-                with s_common.genfile(dir1, 'cell.guid') as fd:
-                    _ = fd.write(cell00.iden.encode())
-
-            async with self.getTestCell(s_cell.Cell, dirn=dir1) as cell01:
-                resp = await cell01.hive.get(('beeps',))
-                self.isinstance(resp, tuple)
-                self.eq(resp, (1, 2, 'three'))
-
-            self.eq(cell00.iden, cell01.iden)
-
     async def test_cell_getinfo(self):
         async with self.getTestCore() as cell:
             cell.COMMIT = 'mycommit'
@@ -2243,8 +2197,8 @@ class CellTest(s_t_utils.SynTest):
                 async with self.getTestCore(dirn=dirn, conf=conf) as core:
                     pass
 
-                stream.seek(0)
-                self.isin('onboot optimization complete!', stream.read())
+            stream.seek(0)
+            self.isin('onboot optimization complete!', stream.read())
 
             stat01 = os.stat(lmdbfile)
             self.ne(stat00.st_ino, stat01.st_ino)
@@ -2266,10 +2220,25 @@ class CellTest(s_t_utils.SynTest):
                     async with self.getTestCore(dirn=dirn, conf=conf) as core:
                         pass
 
-                    stream.seek(0)
-                    buf = stream.read()
-                    self.notin('onboot optimization complete!', buf)
-                    self.isin('not on the same volume', buf)
+                stream.seek(0)
+                buf = stream.read()
+                self.notin('onboot optimization complete!', buf)
+                self.isin('not on the same volume', buf)
+
+            # Local backup files are skipped
+            async with self.getTestCore(dirn=dirn) as core:
+                await core.runBackup()
+
+            with self.getAsyncLoggerStream('synapse.lib.cell') as stream:
+
+                conf = {'onboot:optimize': True}
+                async with self.getTestCore(dirn=dirn, conf=conf) as core:
+                    pass
+
+            stream.seek(0)
+            buf = stream.read()
+            self.isin('Skipping backup file', buf)
+            self.isin('onboot optimization complete!', buf)
 
     async def test_cell_gc(self):
         async with self.getTestCore() as core:

synapse/tests/test_lib_stormlib_aha.py

@@ -139,7 +139,7 @@ Member:     00.cell.loop.vertex.link'''
                 self.len(nevents, await waiter.wait(timeout=12))
 
                 msgs = await core00.stormlist('aha.svc.list')
-                self.stormIsInPrint('01.cell.loop.vertex.link                      false  false  true', msgs)
+                self.stormIsInPrint('01.cell.loop.vertex.link                      false  false  false', msgs)
 
                 # Fake a record
                 await aha.addAhaSvc('00.newp', info={'urlinfo': {'scheme': 'tcp', 'host': '0.0.0.0', 'port': '3030'}},

synapse/tests/test_lib_stormlib_cortex.py

@@ -281,6 +281,18 @@ $request.reply(206, headers=$headers, body=({"no":"body"}))
                 self.eq(data.get('json'), 'err')
                 self.eq(data.get('path'), 'echo/words/wOw')
 
+                # Storm query logging includes the httpapi iden in structlog data
+                core.stormlog = True
+                with self.getStructuredAsyncLoggerStream('synapse.storm', 'Executing storm query') as stream:
+                    resp = await sess.get(url)
+                    self.eq(resp.status, 200)
+                    self.true(await stream.wait(timeout=12))
+                data = stream.getvalue()
+                raw_mesgs = [m for m in data.split('\n') if m]
+                msgs = [json.loads(m) for m in raw_mesgs]
+                self.eq(msgs[0].get('httpapi'), echoiden)
+                core.stormlog = False
+
                 # Sad paths on the $request methods
                 q = '''$api = $lib.cortex.httpapi.add(testpath02)
                 $api.methods.get = ${ $request.sendcode(200) $request.sendheaders('beep beep') }

synapse/tests/test_lib_stormlib_model.py

@@ -1,4 +1,5 @@
 import synapse.exc as s_exc
+import synapse.lib.time as s_time
 import synapse.lib.layer as s_layer
 
 import synapse.tests.utils as s_test
@@ -295,3 +296,107 @@ class StormlibModelTest(s_test.SynTest):
 
                 self.stormIsInWarn('.pdep is not yet locked', mesgs)
                 self.stormNotInWarn('test:dep:easy.pdep is not yet locked', mesgs)
+
+    async def test_stormlib_model_migration(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('[ test:str=src test:str=dst test:str=deny test:str=other ]')
+            otheriden = nodes[3].iden()
+
+            lowuser = await core.auth.addUser('lowuser')
+            aslow = {'user': lowuser.iden}
+
+            # copy node data
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyData($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyData(newp, $node)'))
+
+            nodes = await core.nodes('''
+                test:str=src
+                $node.data.set(a, a-src)
+                $node.data.set(b, b-src)
+                $n=$node -> {
+                    test:str=dst
+                    $node.data.set(a, a-dst)
+                    $lib.model.migration.copyData($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq(
+                [('a', 'a-dst'), ('b', 'b-src')],
+                [data async for data in nodes[0].iterData()]
+            )
+
+            nodes = await core.nodes('''
+                test:str=src $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyData($n, $node, overwrite=$lib.true)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq(
+                [('a', 'a-src'), ('b', 'b-src')],
+                [data async for data in nodes[0].iterData()]
+            )
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyData($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))
+
+            # copy edges
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyEdges($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyEdges(newp, $node)'))
+
+            nodes = await core.nodes('''
+                test:str=src
+                [ <(foo)+ { test:str=other } +(bar)> { test:str=other } ]
+                $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyEdges($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.eq([('bar', otheriden)], [edge async for edge in nodes[0].iterEdgesN1()])
+            self.eq([('foo', otheriden)], [edge async for edge in nodes[0].iterEdgesN2()])
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyEdges($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))
+
+            # copy tags
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=src $lib.model.migration.copyTags($node, newp)'))
+            await self.asyncraises(s_exc.BadArg, core.nodes('test:str=dst $lib.model.migration.copyTags(newp, $node)'))
+
+            await core.nodes('$lib.model.ext.addTagProp(test, (str, ({})), ({}))')
+
+            nodes = await core.nodes('''
+                test:str=src
+                [ +#foo=(2010, 2012) +#foo.bar +#baz:test=src ]
+                $n=$node -> {
+                    test:str=dst
+                    [ +#foo=(2010, 2011) +#baz:test=dst ]
+                    $lib.model.migration.copyTags($n, $node)
+                }
+            ''')
+            self.len(1, nodes)
+            self.sorteq([
+                ('baz', (None, None)),
+                ('foo', (s_time.parse('2010'), s_time.parse('2012'))),
+                ('foo.bar', (None, None))
+            ], nodes[0].getTags())
+            self.eq([], nodes[0].getTagProps('foo'))
+            self.eq([], nodes[0].getTagProps('foo.bar'))
+            self.eq([('test', 'dst')], [(k, nodes[0].getTagProp('baz', k)) for k in nodes[0].getTagProps('baz')])
+
+            nodes = await core.nodes('''
+                test:str=src $n=$node -> {
+                    test:str=dst
+                    $lib.model.migration.copyTags($n, $node, overwrite=$lib.true)
+                }
+            ''')
+            self.len(1, nodes)
+            self.eq([('test', 'src')], [(k, nodes[0].getTagProp('baz', k)) for k in nodes[0].getTagProps('baz')])
+
+            q = 'test:str=src $n=$node -> { test:str=deny $lib.model.migration.copyTags($n, $node) }'
+            await self.asyncraises(s_exc.AuthDeny, core.nodes(q, opts=aslow))

synapse/tests/test_lib_stormtypes.py

@@ -575,6 +575,32 @@ class StormTypesTest(s_test.SynTest):
             self.len(1, nodes)
             self.eq(30, nodes[0].ndef[1])
 
+            # $lib.min / $lib.max behavior with 1 item
+            ret = await core.callStorm('$x = ([(1234)]) return ( $lib.min($x) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('return ( $lib.min(1234) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('$x = ([(1234)]) return ( $lib.max($x) )')
+            self.eq(ret, 1234)
+
+            ret = await core.callStorm('return ( $lib.max(1234) )')
+            self.eq(ret, 1234)
+
+            # $lib.min / $lib.max behavior with 0 items
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.max()')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$l=() $lib.max($l)')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$lib.min()')
+
+            with self.raises(s_exc.StormRuntimeError):
+                await core.callStorm('$l=() $lib.min($l)')
+
             nodes = await core.nodes('[ inet:asn=$lib.len(asdf) ]')
             self.len(1, nodes)
             self.eq(4, nodes[0].ndef[1])

synapse/tests/test_lib_trigger.py

@@ -369,7 +369,7 @@ class TrigTest(s_t_utils.SynTest):
 
             # coverage for migration mode
             await core.nodes('[inet:fqdn=vertex.link +#foo]') # for additional migration mode trigger tests below
-            with core.enterMigrationMode():
+            async with core.enterMigrationMode():
                 await core.nodes('inet:fqdn=vertex.link [ +#bar -#foo ]')
 
     async def test_trigger_delete(self):
@@ -774,7 +774,7 @@ class TrigTest(s_t_utils.SynTest):
             await core.nodes('trigger.add edge:add --verb r* --n2form test:int --query { [ +#n2 ] }')
             await core.nodes('trigger.add edge:add --verb no** --form test:int --n2form test:str --query { [ +#both ] }')
 
-            with core.enterMigrationMode():
+            async with core.enterMigrationMode():
                 nodes = await core.nodes('[test:int=123 +(foo:beep:boop)> { [test:str=neato] }]')
                 self.len(1, nodes)
                 self.notin('foo', nodes[0].tags)
@@ -834,7 +834,7 @@ class TrigTest(s_t_utils.SynTest):
             await core.nodes('trigger.add edge:del --verb r* --n2form test:int --query { [ +#del.two ] }')
             await core.nodes('trigger.add edge:del --verb no** --form test:int --n2form test:str --query { [ +#del.all ] }')
 
-            with core.enterMigrationMode():
+            async with core.enterMigrationMode():
                 nodes = await core.nodes('test:int=123 | [ -(foo:beep:boop)> { test:str=neato } ]')
                 self.len(1, nodes)
                 self.notin('del.none', nodes[0].tags)

synapse/tests/test_model_planning.py

@@ -0,0 +1,126 @@
+import synapse.exc as s_exc
+import synapse.common as s_common
+import synapse.tests.utils as s_t_utils
+
+class PlanModelTest(s_t_utils.SynTest):
+
+    async def test_model_planning(self):
+
+        async with self.getTestCore() as core:
+            nodes = await core.nodes('''
+                [ plan:system=*
+                    :name="Woot CNO Planner"
+                    :author={[ ps:contact=* :name=visi ]}
+                    :created=20240202
+                    :updated=20240203
+                    :version=1.0.0
+                    :url=https://vertex.link
+                ]
+            ''')
+            self.len(1, nodes)
+            self.eq('woot cno planner', nodes[0].get('name'))
+            self.eq(1706832000000, nodes[0].get('created'))
+            self.eq(1706918400000, nodes[0].get('updated'))
+            self.eq(1099511627776, nodes[0].get('version'))
+            self.eq('https://vertex.link', nodes[0].get('url'))
+
+            self.len(1, await core.nodes('plan:system :author -> ps:contact +:name=visi'))
+
+            nodes = await core.nodes('''
+                [ plan:phase=*
+                    :system={ plan:system:name="Woot CNO Planner"}
+                    :title="Recon"
+                    :summary="Do some recon."
+                    :index=17
+                    :url=https://vertex.link/recon
+                ]
+            ''')
+
+            self.len(1, nodes)
+            self.eq('Recon', nodes[0].get('title'))
+            self.eq('Do some recon.', nodes[0].get('summary'))
+            self.eq(17, nodes[0].get('index'))
+            self.eq('https://vertex.link/recon', nodes[0].get('url'))
+
+            self.len(1, await core.nodes('plan:phase :system -> plan:system +:name="Woot CNO Planner"'))
+
+            nodes = await core.nodes('''
+                [ plan:procedure=*
+                    :system={ plan:system:name="Woot CNO Planner"}
+                    :title="Pwn Some Boxes"
+                    :summary="Yoink."
+                    :author={ ps:contact:name=visi }
+                    :created=20240202
+                    :updated=20240203
+                    :version=1.0.0
+                    :type=cno.offense
+                    :system={ plan:system:name="Woot CNO Planner" }
+                ]
+
+                $guid = $node.value()
+
+                [
+                    :inputs={[ plan:procedure:variable=*
+                        :name=network
+                        :type=cidr
+                        :default=127.0.0.0/24
+                        :procedure=$guid
+                    ]}
+
+                    :firststep={[ plan:procedure:step=*
+                        :title="Are there vulnerable services?"
+                        :summary="Scan the target network and identify available services."
+                        :procedure=$guid
+                        :phase={ plan:phase:title=Recon }
+                        :outputs={[ plan:procedure:variable=* :name=services ]}
+                        :techniques={[ ou:technique=* :name=netscan ]}
+
+                        :links={[ plan:procedure:link=*
+                            :condition=(true)
+                            :procedure=$guid
+                            :next={[ plan:procedure:step=*
+                                :title="Exploit Services"
+                                :summary="Gank that stuff."
+                                :procedure=$guid
+                                :outputs={[ plan:procedure:variable=* :name=shellz ]}
+                            ]}
+
+                        ]}
+                    ]}
+                ]
+            ''')
+
+            self.len(1, nodes)
+            self.eq('Pwn Some Boxes', nodes[0].get('title'))
+            self.eq('Yoink.', nodes[0].get('summary'))
+            self.nn(nodes[0].get('author'))
+            self.eq(1706832000000, nodes[0].get('created'))
+            self.eq(1706918400000, nodes[0].get('updated'))
+            self.eq(1099511627776, nodes[0].get('version'))
+
+            self.len(1, await core.nodes('plan:procedure :type -> plan:procedure:type:taxonomy'))
+            self.len(1, await core.nodes('plan:procedure :system -> plan:system +:name="Woot CNO Planner"'))
+            self.len(1, await core.nodes('plan:procedure :firststep -> plan:procedure:step -> plan:procedure:link'))
+
+            nodes = await core.nodes('plan:procedure :inputs -> plan:procedure:variable')
+            self.len(1, nodes)
+            self.eq('network', nodes[0].get('name'))
+            self.eq('cidr', nodes[0].get('type'))
+            self.eq('127.0.0.0/24', nodes[0].get('default'))
+            self.nn(nodes[0].get('procedure'))
+
+            nodes = await core.nodes('plan:procedure :firststep -> plan:procedure:step')
+            self.len(1, nodes)
+            self.eq('Are there vulnerable services?', nodes[0].get('title'))
+            self.eq('Scan the target network and identify available services.', nodes[0].get('summary'))
+            self.nn(nodes[0].get('procedure'))
+
+            self.len(1, await core.nodes('plan:procedure :firststep -> plan:procedure:step -> plan:phase'))
+            self.len(1, await core.nodes('plan:procedure :firststep -> plan:procedure:step :techniques -> ou:technique'))
+            self.len(1, await core.nodes('plan:procedure :firststep -> plan:procedure:step :outputs -> plan:procedure:variable'))
+
+            nodes = await core.nodes('plan:procedure :firststep -> plan:procedure:step -> plan:procedure:link')
+            self.len(1, nodes)
+            self.eq(True, nodes[0].get('condition'))
+            self.nn(nodes[0].get('next'))
+            self.nn(nodes[0].get('procedure'))