synapse 2.183.0__py311-none-any.whl → 2.185.0__py311-none-any.whl

synapse/models/proj.py

@@ -1,14 +1,5 @@
 import synapse.lib.module as s_module
 
-prioenums = (
-    (0, 'none'),
-    (10, 'lowest'),
-    (20, 'low'),
-    (30, 'medium'),
-    (40, 'high'),
-    (50, 'highest'),
-)
-
 statusenums = (
     (0, 'new'),
     (10, 'in validation'),
@@ -47,11 +38,63 @@ class ProjectModule(s_module.CoreModule):
 
             ('proj', {
 
+                'interfaces': (
+                    ('proj:task', {
+
+                        'doc': 'A common interface for tasks.',
+
+                        'template': {
+                            'task': 'task'},
+
+                        'props': (
+
+                            ('id', ('str', {'strip': True}), {
+                                'doc': 'The ID of the {task}.'}),
+
+                            ('project', ('proj:project', {}), {
+                                'doc': 'The project containing the {task}.'}),
+
+                            ('status', ('int', {}), {
+                                # TODO: make runtime setable int enum typeopts
+                                'doc': 'The status of the {task}.'}),
+
+                            ('priority', ('meta:priority', {}), {
+                                'doc': 'The priority of the {task}.'}),
+
+                            ('created', ('time', {}), {
+                                'doc': 'The time the {task} was created.'}),
+
+                            ('updated', ('time', {}), {
+                                'doc': 'The time the {task} was last updated.'}),
+
+                            ('due', ('time', {}), {
+                                'doc': 'The time the {task} must be complete.'}),
+
+                            ('completed', ('time', {}), {
+                                'doc': 'The time the {task} was completed.'}),
+
+                            ('creator', ('syn:user', {}), {
+                                'doc': 'The user which created the {task}.'}),
+
+                            ('assignee', ('syn:user', {}), {
+                                'doc': 'The user assigned to complete the {task}.'}),
+
+                            ('ext:creator', ('ps:contact', {}), {
+                                'doc': 'The contact information of the creator from an external system.'}),
+
+                            ('ext:assignee', ('ps:contact', {}), {
+                                'doc': 'The contact information of the assignee from an external system.'}),
+                        ),
+                    }),
+                ),
                 'types': (
                     ('proj:epic', ('guid', {}), {
-                        'doc': 'A collection of tickets related to a topic.',
-                    }),
+                        'doc': 'A collection of tickets related to a topic.'}),
+
                     ('proj:ticket', ('guid', {}), {
+                        'interfaces': ('proj:task',),
+                        'template': {
+                            'task': 'ticket'},
                         'doc': 'A ticket in a ticketing system.'}),
 
                     ('proj:project:type:taxonomy', ('taxonomy', {}), {
@@ -180,30 +223,16 @@ class ProjectModule(s_module.CoreModule):
 
                     ('proj:ticket', {}, (
 
-                        ('project', ('proj:project', {}), {
-                            'doc': 'The project containing the ticket.'}),
-
                         ('ext:id', ('str', {'strip': True}), {
-                            'doc': 'A ticket ID from an external system.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :id.'}),
 
                         ('ext:url', ('inet:url', {}), {
                             'doc': 'A URL to the ticket in an external system.'}),
 
-                        ('ext:creator', ('ps:contact', {}), {
-                            'doc': 'Ticket creator contact information from an external system.'}),
-
-                        ('ext:assignee', ('ps:contact', {}), {
-                            'doc': 'Ticket assignee contact information from an external system.'}),
-
                         ('epic', ('proj:epic', {}), {
                             'doc': 'The epic that includes the ticket.'}),
 
-                        ('created', ('time', {}), {
-                            'doc': 'The time the ticket was created.'}),
-
-                        ('updated', ('time', {'ismax': True}), {
-                            'doc': 'The last time the ticket was updated.'}),
-
                         ('name', ('str', {'onespace': True}), {
                             'doc': 'The name of the ticket.'}),
 
@@ -219,17 +248,8 @@ class ProjectModule(s_module.CoreModule):
                         ('sprint', ('proj:sprint', {}), {
                             'doc': 'The sprint that contains the ticket.'}),
 
-                        ('priority', ('int', {'enums': prioenums}), {
-                            'doc': 'The priority of the ticket.'}),
-
                         ('type', ('str', {'lower': True, 'strip': True}), {
                             'doc': 'The type of ticket. (eg story / bug)'}),
-
-                        ('creator', ('syn:user', {}), {
-                            'doc': 'The synapse user who created the ticket.'}),
-
-                        ('assignee', ('syn:user', {}), {
-                            'doc': 'The synapse user who the ticket is assigned to.'}),
                     )),
                 ),
             }),

synapse/models/risk.py

@@ -96,12 +96,17 @@ class RiskModule(s_module.CoreModule):
                         ),
                     },
                 }),
+                ('risk:mitigation:type:taxonomy', ('taxonomy', {}), {
+                    'interaces': ('taxonomy',),
+                    'doc': 'A taxonomy of mitigation types.',
+                }),
                 ('risk:mitigation', ('guid', {}), {
                     'doc': 'A mitigation for a specific risk:vuln.',
                     'display': {
                         'columns': (
                             {'type': 'prop', 'opts': {'name': 'name'}},
                             {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                            {'type': 'prop', 'opts': {'name': 'type'}},
                             {'type': 'prop', 'opts': {'name': 'tag'}},
                         ),
                     },
@@ -198,9 +203,22 @@ class RiskModule(s_module.CoreModule):
                     'doc': 'The tool uses the target node.'}),
                 (('risk:compromise', 'stole', None), {
                     'doc': 'The target node was stolen or copied as a result of the compromise.'}),
+
                 (('risk:mitigation', 'addresses', 'ou:technique'), {
                     'doc': 'The mitigation addresses the technique.'}),
 
+                (('risk:mitigation', 'uses', 'meta:rule'), {
+                    'doc': 'The mitigation uses the rule.'}),
+
+                (('risk:mitigation', 'uses', 'it:app:yara:rule'), {
+                    'doc': 'The mitigation uses the YARA rule.'}),
+
+                (('risk:mitigation', 'uses', 'it:app:snort:rule'), {
+                    'doc': 'The mitigation uses the Snort rule.'}),
+
+                (('risk:mitigation', 'uses', 'inet:service:rule'), {
+                    'doc': 'The mitigation uses the service rule.'}),
+
                 (('risk:leak', 'leaked', None), {
                     'doc': 'The leak included the disclosure of the target node.'}),
 
@@ -334,6 +352,7 @@ class RiskModule(s_module.CoreModule):
                         'doc': 'A mapping to a MITRE ATT&CK software if applicable.'}),
 
                 )),
+                ('risk:mitigation:type:taxonomy', {}, ()),
                 ('risk:mitigation', {}, (
 
                     ('vuln', ('risk:vuln', {}), {
@@ -342,6 +361,9 @@ class RiskModule(s_module.CoreModule):
                     ('name', ('str', {'lower': True, 'onespace': True}), {
                         'doc': 'A brief name for this risk mitigation.'}),
 
+                    ('type', ('risk:mitigation:type:taxonomy', {}), {
+                        'doc': 'A taxonomy type entry for the mitigation.'}),
+
                     ('desc', ('str', {}), {
                         'disp': {'hint': 'text'},
                         'doc': 'A description of the mitigation approach for the vulnerability.'}),

synapse/models/syn.py

@@ -2,10 +2,67 @@ import logging
 
 import synapse.exc as s_exc
 
+import synapse.lib.types as s_types
 import synapse.lib.module as s_module
 
 logger = logging.getLogger(__name__)
 
+class SynUser(s_types.Guid):
+
+    def _normPyStr(self, text):
+
+        core = self.modl.core
+        if core is not None:
+
+            # direct use of an iden takes precedence...
+            user = core.auth.user(text)
+            if user is not None:
+                return user.iden, {}
+
+            user = core.auth._getUserByName(text)
+            if user is not None:
+                return user.iden, {}
+
+        return s_types.Guid._normPyStr(self, text)
+
+    def repr(self, iden):
+
+        core = self.modl.core
+        if core is not None:
+            user = core.auth.user(iden)
+            if user is not None:
+                return user.name
+
+        return iden
+
+class SynRole(s_types.Guid):
+
+    def _normPyStr(self, text):
+
+        core = self.modl.core
+        if core is not None:
+
+            # direct use of an iden takes precedence...
+            role = core.auth.role(text)
+            if role is not None:
+                return role.iden, {}
+
+            role = core.auth._getRoleByName(text)
+            if role is not None:
+                return role.iden, {}
+
+        return s_types.Guid._normPyStr(self, text)
+
+    def repr(self, iden):
+
+        core = self.modl.core
+        if core is not None:
+            role = core.auth.role(iden)
+            if role is not None:
+                return role.name
+
+        return iden
+
 class SynModule(s_module.CoreModule):
 
     def initCoreModule(self):
@@ -105,6 +162,13 @@ class SynModule(s_module.CoreModule):
 
         return (('syn', {
 
+            'ctors': (
+                ('syn:user', 'synapse.models.syn.SynUser', {}, {
+                    'doc': 'A Synapse user.'}),
+
+                ('syn:role', 'synapse.models.syn.SynRole', {}, {
+                    'doc': 'A Synapse role.'}),
+            ),
             'types': (
                 ('syn:type', ('str', {'strip': True}), {
                     'doc': 'A Synapse type used for normalizing nodes and properties.',
@@ -130,12 +194,6 @@ class SynModule(s_module.CoreModule):
                 ('syn:nodedata', ('comp', {'fields': (('key', 'str'), ('form', 'syn:form'))}), {
                     'doc': 'A nodedata key and the form it may be present on.',
                 }),
-                ('syn:user', ('guid', {'strip': True}), {
-                    'doc': 'A Synapse user GUID.'
-                }),
-                ('syn:role', ('guid', {'strip': True}), {
-                    'doc': 'A Synapse role GUID.'
-                }),
             ),
 
             'forms': (

synapse/tests/test_cortex.py

@@ -108,6 +108,7 @@ class CortexTest(s_t_utils.SynTest):
                         await core00.handoff(core00.getLocalUrl())
 
                     self.false((await core00.getCellInfo())['cell']['uplink'])
+                    self.none((await core00.getCellInfo())['cell']['mirror'])
 
                     # provision with the new hostname and mirror config
                     provinfo = {'mirror': '00.cortex'}
@@ -130,10 +131,13 @@ class CortexTest(s_t_utils.SynTest):
                         self.true(await s_coro.event_wait(core01.nexsroot.miruplink, timeout=2))
                         self.false((await core00.getCellInfo())['cell']['uplink'])
                         self.true((await core01.getCellInfo())['cell']['uplink'])
+                        self.none((await core00.getCellInfo())['cell']['mirror'])
+                        self.eq((await core01.getCellInfo())['cell']['mirror'], 'aha://root@00.cortex...')
 
                         outp = s_output.OutPutStr()
                         argv = ('--svcurl', core01.getLocalUrl())
-                        await s_tools_promote.main(argv, outp=outp)  # this is a graceful promotion
+                        ret = await s_tools_promote.main(argv, outp=outp)  # this is a graceful promotion
+                        self.eq(ret, 0)
 
                         self.true(core01.isactive)
                         self.false(core00.isactive)
@@ -141,6 +145,10 @@ class CortexTest(s_t_utils.SynTest):
                         self.true(await s_coro.event_wait(core00.nexsroot.miruplink, timeout=2))
                         self.true((await core00.getCellInfo())['cell']['uplink'])
                         self.false((await core01.getCellInfo())['cell']['uplink'])
+                        # Note: The following mirror may change when SYN-7659 is addressed and greater
+                        # control over the topology update is available during the promotion process.
+                        self.eq((await core00.getCellInfo())['cell']['mirror'], 'aha://01.cortex.synapse')
+                        self.none((await core01.getCellInfo())['cell']['mirror'])
 
                         mods00 = s_common.yamlload(core00.dirn, 'cell.mods.yaml')
                         mods01 = s_common.yamlload(core01.dirn, 'cell.mods.yaml')
@@ -2942,6 +2950,36 @@ class CortexTest(s_t_utils.SynTest):
             with self.raises(s_exc.NoSuchProp):
                 await core.nodes('inet:ipv4 +:asn::_pivo::notaprop')
 
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :email=a@v.lk]}]')
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :email=b@v.lk]}]')
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :email=c@v.lk]}]')
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :emails=(a@v.lk, b@v.lk)]}]')
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :emails=(c@v.lk, d@v.lk)]}]')
+            await core.nodes('[ou:org=* :hq={[ps:contact=* :emails=(a@v.lk, d@v.lk)]}]')
+
+            nodes = await core.nodes('ou:org:hq::email::user=a')
+            self.len(1, nodes)
+            for node in nodes:
+                self.eq('ou:org', node.ndef[0])
+
+            nodes = await core.nodes('ou:org:hq::email::user*in=(a, b)')
+            self.len(2, nodes)
+            for node in nodes:
+                self.eq('ou:org', node.ndef[0])
+
+            nodes = await core.nodes('ou:org:hq::emails*[=a@v.lk]')
+            self.len(2, nodes)
+            for node in nodes:
+                self.eq('ou:org', node.ndef[0])
+
+            nodes = await core.nodes('ou:org:hq::emails*[in=(a@v.lk, c@v.lk)]')
+            self.len(3, nodes)
+            for node in nodes:
+                self.eq('ou:org', node.ndef[0])
+
+            with self.raises(s_exc.NoSuchProp):
+                nodes = await core.nodes('ou:org:hq::email::newp=a')
+
 class CortexBasicTest(s_t_utils.SynTest):
     '''
     The tests that are unlikely to break with different types of layers installed
@@ -3419,50 +3457,6 @@ class CortexBasicTest(s_t_utils.SynTest):
             self.eq(nodes[0].ndef, ('inet:ipv4', 0x01020304))
             self.nn(nodes[0].getTag('hehe.haha'))
 
-    async def test_storm_varlistset(self):
-
-        async with self.getTestCore() as core:
-
-            opts = {'vars': {'blob': ('vertex.link', '9001')}}
-            text = '($fqdn, $crap) = $blob [ inet:fqdn=$fqdn ]'
-
-            nodes = await core.nodes(text, opts=opts)
-            self.len(1, nodes)
-            for node in nodes:
-                self.eq(node.ndef, ('inet:fqdn', 'vertex.link'))
-
-            now = s_common.now()
-            ret = await core.callStorm('($foo, $bar)=$lib.cast(ival, $lib.time.now()) return($foo)')
-            self.ge(ret, now)
-
-            text = '.created ($foo, $bar, $baz) = $blob'
-            with self.raises(s_exc.StormVarListError):
-                await core.nodes(text, opts)
-
-            text = '($foo, $bar, $baz) = $blob'
-            with self.raises(s_exc.StormVarListError):
-                await core.nodes(text, opts)
-
-            text = 'for ($x, $y) in ((1),) { $lib.print($x) }'
-            with self.raises(s_exc.StormVarListError):
-                await core.nodes(text)
-
-            text = 'for ($x, $y) in ($lib.layer.get(),) { $lib.print($x) }'
-            with self.raises(s_exc.StormRuntimeError):
-                await core.nodes(text)
-
-            text = '[test:str=foo] for ($x, $y) in ((1),) { $lib.print($x) }'
-            with self.raises(s_exc.StormVarListError):
-                await core.nodes(text)
-
-            text = '[test:str=foo] for ($x, $y) in ((1),) { $lib.print($x) }'
-            with self.raises(s_exc.StormRuntimeError):
-                await core.nodes(text)
-
-            text = '($x, $y) = (1)'
-            with self.raises(s_exc.StormRuntimeError):
-                await core.nodes(text)
-
     async def test_storm_contbreak(self):
 
         async with self.getTestCore() as core:
@@ -3929,6 +3923,15 @@ class CortexBasicTest(s_t_utils.SynTest):
             opts['vars']['useriden'] = visi.iden
 
             await self.asyncraises(s_exc.AuthDeny, core.nodes('$lib.graph.del($iden2)', opts=uopts))
+            await core.nodes('$lib.graph.grant($iden2, users, $useriden, 3)', opts=opts)
+
+            await core.nodes('$lib.graph.mod($iden2, ({"name": "newname"}))', opts=uopts)
+            gdef = await core.callStorm('return($lib.graph.get($iden2))', opts=opts)
+            self.eq(gdef['name'], 'newname')
+
+            await core.nodes('$lib.graph.revoke($iden2, users, $useriden)', opts=opts)
+            await self.asyncraises(s_exc.AuthDeny, core.nodes('$lib.graph.mod($iden2, ({"name": "newp"}))', opts=uopts))
+
             await core.nodes('$lib.graph.grant($iden2, users, $useriden, 3)', opts=opts)
             await core.nodes('$lib.graph.del($iden2)', opts=uopts)
 
@@ -4018,6 +4021,12 @@ class CortexBasicTest(s_t_utils.SynTest):
             async with self.getTestCore(dirn=dirn) as core:
                 self.len(3, await core.callStorm('return($lib.graph.list())', opts=opts))
 
+                gdef = await core.callStorm('return($lib.graph.add(({"name": "nodef"})))')
+                self.eq(1, gdef['permissions']['default'])
+
+                gdef = await core.callStorm('return($lib.graph.add(({"name": "def", "permissions": {"default": 0}})))')
+                self.eq(0, gdef['permissions']['default'])
+
     async def test_storm_two_level_assignment(self):
         async with self.getTestCore() as core:
             q = '$foo=baz $bar=$foo [test:str=$bar]'

synapse/tests/test_lib_ast.py

@@ -4331,3 +4331,61 @@ class AstTest(s_test.SynTest):
             _assert_edge(msgs, small, {'type': 'prop', 'prop': 'ndefs', 'reverse': True}, nidx=1)
             _assert_edge(msgs, small, {'type': 'edge', 'verb': 'seen', 'reverse': True}, nidx=2)
             _assert_edge(msgs, small, {'type': 'edge', 'verb': 'someedge', 'reverse': True}, nidx=3)
+
+    async def test_ast_varlistset(self):
+
+        async with self.getTestCore() as core:
+
+            opts = {'vars': {'blob': ('vertex.link', '9001')}}
+            text = '($fqdn, $crap) = $blob [ inet:fqdn=$fqdn ]'
+
+            nodes = await core.nodes(text, opts=opts)
+            self.len(1, nodes)
+            for node in nodes:
+                self.eq(node.ndef, ('inet:fqdn', 'vertex.link'))
+
+            now = s_common.now()
+            ret = await core.callStorm('($foo, $bar)=$lib.cast(ival, $lib.time.now()) return($foo)')
+            self.ge(ret, now)
+
+            # The runtsafe invocation of the VarListSetOper is done per node.
+            q = '''
+            init { $count = ({ 'c': (0) }) }
+            function foo(){
+                $count.c = ( $count.c + (1) )
+                return((a, b))
+            }
+            inet:fqdn=vertex.link
+            ($a, $b) = $foo()
+            fini { return ( $count ) }
+            '''
+            valu = await core.callStorm(q)
+            self.eq(valu, {'c': 1})
+
+            text = '.created ($foo, $bar, $baz) = $blob'
+            with self.raises(s_exc.StormVarListError):
+                await core.nodes(text, opts)
+
+            text = '($foo, $bar, $baz) = $blob'
+            with self.raises(s_exc.StormVarListError):
+                await core.nodes(text, opts)
+
+            text = 'for ($x, $y) in ((1),) { $lib.print($x) }'
+            with self.raises(s_exc.StormVarListError):
+                await core.nodes(text)
+
+            text = 'for ($x, $y) in ($lib.layer.get(),) { $lib.print($x) }'
+            with self.raises(s_exc.StormRuntimeError):
+                await core.nodes(text)
+
+            text = '[test:str=foo] for ($x, $y) in ((1),) { $lib.print($x) }'
+            with self.raises(s_exc.StormVarListError):
+                await core.nodes(text)
+
+            text = '[test:str=foo] for ($x, $y) in ((1),) { $lib.print($x) }'
+            with self.raises(s_exc.StormRuntimeError):
+                await core.nodes(text)
+
+            text = '($x, $y) = (1)'
+            with self.raises(s_exc.StormRuntimeError):
+                await core.nodes(text)

synapse/tests/test_lib_autodoc.py

@@ -288,3 +288,57 @@ Returns:
         }
         with self.raises(s_exc.SchemaViolation):
             s_autodoc.docStormTypes(page, (doc,), linkprefix='test')
+
+        libdepr = s_t_utils.LibDepr
+        locls = copy.deepcopy(libdepr._storm_locals)
+        [obj.get('type', {}).pop('_funcname', None) for obj in locls]
+        doc = {
+            'desc': s_stormtypes.getDoc(libdepr, "err"),
+            'path': ('lib',) + libdepr._storm_lib_path,
+            'locals': locls,
+            'deprecated': libdepr._storm_lib_deprecation
+        }
+        page = s_autodoc.RstHelp()
+        page.addHead('Test')
+        page.addLines('I am a line.')
+        s_autodoc.docStormTypes(page, (doc,), linkprefix='test', islib=True)
+        text = page.getRstText()
+        expected = '''
+####
+Test
+####
+
+I am a line.
+
+
+.. _test-lib-depr:
+
+*********
+$lib.depr
+*********
+
+Deprecate me!
+
+
+
+.. _test-lib-depr-boop:
+
+$lib.depr.boop(valu)
+====================
+
+.. warning::
+   ``$lib.depr.boop`` has been deprecated and will be removed in version v3.0.0.
+
+
+An example storm function that's not deprecated on its own, but the entire library is.
+
+
+
+Args:
+    valu (str): What to boop.
+
+
+
+Returns:
+    The booped. The return type is ``str``.'''
+        self.eq(text, expected)

synapse/tests/test_lib_cell.py

@@ -8,7 +8,6 @@ import signal
 import socket
 import asyncio
 import tarfile
-import warnings
 import collections
 import multiprocessing
 
@@ -751,6 +750,7 @@ class CellTest(s_t_utils.SynTest):
                 self.ge(cnfo.get('nexsindx'), 0)
                 self.true(cnfo.get('active'))
                 self.false(cnfo.get('uplink'))
+                self.none(cnfo.get('mirror', True))
                 # A Cortex populated cellvers
                 self.isin('cortex:defaults', cnfo.get('cellvers', {}))
 
@@ -3151,3 +3151,46 @@ class CellTest(s_t_utils.SynTest):
             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)
+
+    async def test_lib_cell_promote_schism_prevent(self):
+
+        async with self.getTestAha() as aha:
+            async with await s_base.Base.anit() as base:
+                with self.getTestDir() as dirn:
+                    dirn00 = s_common.genpath(dirn, '00.cell')
+                    dirn01 = s_common.genpath(dirn, '01.cell')
+                    dirn02 = s_common.genpath(dirn, '02.cell')
+
+                    cell00 = await base.enter_context(self.addSvcToAha(aha, '00.cell', s_cell.Cell, dirn=dirn00))
+                    cell01 = await base.enter_context(self.addSvcToAha(aha, '01.cell', s_cell.Cell, dirn=dirn01,
+                                                                       provinfo={'mirror': 'cell'}))
+                    cell02 = await base.enter_context(self.addSvcToAha(aha, '02.cell', s_cell.Cell, dirn=dirn02,
+                                                                       provinfo={'mirror': 'cell'}))
+
+                    self.true(cell00.isactive)
+                    self.false(cell01.isactive)
+                    self.false(cell02.isactive)
+                    await cell02.sync()
+
+                    with self.raises(s_exc.BadState) as cm:
+                        await cell01.handoff('some://url')
+                    self.isin('01.cell is not the current leader', cm.exception.get('mesg'))
+
+                    # Note: The following behavior may change when SYN-7659 is addressed and greater
+                    # control over the topology update is available during the promotion process.
+                    # Promote 02.cell -> Promote 01.cell -> Promote 00.cell -> BadState exception
+                    await cell02.promote(graceful=True)
+                    self.false(cell00.isactive)
+                    self.false(cell01.isactive)
+                    self.true(cell02.isactive)
+                    await cell02.sync()
+
+                    await cell01.promote(graceful=True)
+                    self.false(cell00.isactive)
+                    self.true(cell01.isactive)
+                    self.false(cell02.isactive)
+                    await cell02.sync()
+
+                    with self.raises(s_exc.BadState) as cm:
+                        await cell00.promote(graceful=True)
+                    self.isin('02.cell is not the current leader', cm.exception.get('mesg'))

synapse/tests/test_lib_grammar.py

@@ -727,6 +727,7 @@ Queries = [
     '$p="names" ps:contact:name=foo [ :$p?-=bar ]',
     '$pvar=stuff test:arrayprop +:$pvar*[=neato]',
     '$pvar=ints test:arrayprop +:$pvar*[=$othervar]',
+    '$foo = ({"foo": ${ inet:fqdn }})',
 ]
 
 # Generated with print_parse_list below
@@ -1356,6 +1357,7 @@ _ParseResults = [
     '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]]]]',
+    'Query: [SetVarOper: [Const: foo, DollarExpr: [ExprDict: [Const: foo, EmbedQuery: inet:fqdn]]]]',
 ]
 
 class GrammarTest(s_t_utils.SynTest):