synapse 2.165.0__py311-none-any.whl → 2.166.0__py311-none-any.whl

synapse/models/orgs.py

@@ -24,14 +24,27 @@ class OuModule(s_module.CoreModule):
                 }),
                 ('ou:isic', ('str', {'regex': r'^[A-Z]([0-9]{2}[0-9]{0,2})?$'}), {
                     'doc': 'An International Standard Industrial Classification of All Economic Activities (ISIC) code.',
-                    'ex': 'C1393',
-                }),
+                    'ex': 'C1393'}),
+
                 ('ou:org', ('guid', {}), {
                     'doc': 'A GUID for a human organization such as a company or military unit.',
-                }),
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'names'}},
+                            {'type': 'prop', 'opts': {'name': 'country:code'}},
+                        ),
+                    }}),
+
                 ('ou:team', ('guid', {}), {
                     'doc': 'A GUID for a team within an organization.',
-                }),
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'org::name'}},
+                        ),
+                    }}),
+
                 ('ou:orgtype', ('taxonomy', {}), {
                     'doc': 'An org type taxonomy.',
                     'interfaces': ('meta:taxonomy',),
@@ -49,6 +62,11 @@ class OuModule(s_module.CoreModule):
                 }),
                 ('ou:industry', ('guid', {}), {
                     'doc': 'An industry classification type.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                        ),
+                    },
                 }),
                 ('ou:industry:type:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
@@ -113,6 +131,12 @@ class OuModule(s_module.CoreModule):
                 }),
                 ('ou:conference', ('guid', {}), {
                     'doc': 'A conference with a name and sponsoring org.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'start'}},
+                        ),
+                    },
                 }),
                 ('ou:conference:attendee', ('comp', {'fields': (('conference', 'ou:conference'), ('person', 'ps:person'))}), {
                     'deprecated': True,
@@ -133,6 +157,11 @@ class OuModule(s_module.CoreModule):
                 }),
                 ('ou:goal', ('guid', {}), {
                     'doc': 'An assessed or stated goal which may be abstract or org specific.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                        ),
+                    },
                 }),
                 ('ou:goalname', ('str', {'lower': True, 'onespace': True}), {
                     'doc': 'A goal name.',
@@ -154,16 +183,31 @@ class OuModule(s_module.CoreModule):
 
                 ('ou:campaign', ('guid', {}), {
                     'doc': "Represents an org's activity in pursuit of a goal.",
-                }),
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'names'}},
+                            {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                            {'type': 'prop', 'opts': {'name': 'tag'}},
+                        ),
+                    }}),
+
                 ('ou:conflict', ('guid', {}), {
                     'doc': 'Represents a conflict where two or more campaigns have mutually exclusive goals.',
                 }),
                 ('ou:contribution', ('guid', {}), {
-                    'doc': 'Represents a specific instance of contributing material support to a campaign.',
-                }),
+                    'doc': 'Represents a specific instance of contributing material support to a campaign.'}),
+
                 ('ou:technique', ('guid', {}), {
                     'doc': 'A specific technique used to achieve a goal.',
-                }),
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                            {'type': 'prop', 'opts': {'name': 'tag'}},
+                        ),
+                    }}),
+
                 ('ou:technique:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
                     'doc': 'An analyst defined taxonomy to classify techniques in different disciplines.',

synapse/models/person.py

@@ -39,11 +39,19 @@ class PsModule(s_module.CoreModule):
                 ('ps:persona:has', ('comp', {'fields': (('persona', 'ps:persona'), ('node', 'ndef'))}), {
                     'deprecated': True,
                     'doc': 'A persona owns, controls, or has exclusive use of an object or'
-                           ' resource, potentially during a specific period of time.'
-                }),
+                           ' resource, potentially during a specific period of time.'}),
+
                 ('ps:contact', ('guid', {}), {
                     'doc': 'A GUID for a contact info record.',
-                }),
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'type'}},
+                            {'type': 'prop', 'opts': {'name': 'orgname'}},
+                            {'type': 'prop', 'opts': {'name': 'email'}},
+                        ),
+                    }}),
+
                 ('ps:contact:type:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
                     'doc': 'A taxonomy of contact types.',
@@ -55,18 +63,29 @@ class PsModule(s_module.CoreModule):
                     'doc': "A GUID representing entry in a contact's work history.",
                 }),
                 ('ps:vitals', ('guid', {}), {
-                    'doc': 'Statistics and demographic data about a person or contact.',
-                }),
+                    'doc': 'Statistics and demographic data about a person or contact.'}),
+
                 ('ps:skill', ('guid', {}), {
-                    'doc': 'A specific skill which a person or organization may have.'
-                }),
+                    'doc': 'A specific skill which a person or organization may have.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'type'}},
+                        ),
+                    }}),
+
                 ('ps:skill:type:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
-                    'doc': 'A taxonomy of skill types.',
-                }),
+                    'doc': 'A taxonomy of skill types.'}),
+
                 ('ps:proficiency', ('guid', {}), {
-                    'doc': 'The assessment that a given contact possesses a specific skill.'
-                }),
+                    'doc': 'The assessment that a given contact possesses a specific skill.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'contact::name'}},
+                            {'type': 'prop', 'opts': {'name': 'skill::name'}},
+                        ),
+                    }}),
             ),
             'edges': (
                 (('ps:contact', 'has', None), {

synapse/models/risk.py

@@ -68,6 +68,14 @@ class RiskModule(s_module.CoreModule):
 
                 ('risk:threat', ('guid', {}), {
                     'doc': 'A threat cluster or subgraph of threat activity, as reported by a specific organization.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'org:name'}},
+                            {'type': 'prop', 'opts': {'name': 'org:names'}},
+                            {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                            {'type': 'prop', 'opts': {'name': 'tag'}},
+                        ),
+                    },
                 }),
                 ('risk:attack', ('guid', {}), {
                     'doc': 'An instance of an actor attacking a target.',
@@ -81,9 +89,22 @@ class RiskModule(s_module.CoreModule):
                 }),
                 ('risk:compromise', ('guid', {}), {
                     'doc': 'An instance of a compromise and its aggregate impact.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'name'}},
+                            {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                        ),
+                    },
                 }),
                 ('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': 'tag'}},
+                        ),
+                    },
                 }),
                 ('risk:attacktype', ('taxonomy', {}), {
                     'doc': 'A taxonomy of attack types.',
@@ -104,6 +125,14 @@ class RiskModule(s_module.CoreModule):
                 }),
                 ('risk:tool:software', ('guid', {}), {
                     'doc': 'A software tool used in threat activity, as reported by a specific organization.',
+                    'display': {
+                        'columns': (
+                            {'type': 'prop', 'opts': {'name': 'soft:name'}},
+                            {'type': 'prop', 'opts': {'name': 'soft:names'}},
+                            {'type': 'prop', 'opts': {'name': 'reporter:name'}},
+                            {'type': 'prop', 'opts': {'name': 'tag'}},
+                        ),
+                    },
                 }),
 
                 ('risk:alert:verdict:taxonomy', ('taxonomy', {}), {
@@ -128,19 +157,22 @@ class RiskModule(s_module.CoreModule):
                 ('risk:extortion:type:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
                     'doc': 'A taxonomy of extortion event types.'}),
+
                 ('risk:technique:masquerade', ('guid', {}), {
                     'doc': 'Represents the assessment that a node is designed to resemble another in order to mislead.'}),
             ),
             'edges': (
                 # some explicit examples...
                 (('risk:attack', 'uses', 'ou:technique'), {
-                    'doc': 'The attackers used the technique in the attack.'}),
+                    'doc': 'The attacker used the technique in the attack.'}),
                 (('risk:threat', 'uses', 'ou:technique'), {
                     'doc': 'The threat cluster uses the technique.'}),
                 (('risk:tool:software', 'uses', 'ou:technique'), {
                     'doc': 'The tool uses the technique.'}),
                 (('risk:compromise', 'uses', 'ou:technique'), {
-                    'doc': 'The attackers used the technique in the compromise.'}),
+                    'doc': 'The attacker used the technique in the compromise.'}),
+                (('risk:extortion', 'uses', 'ou:technique'), {
+                    'doc': 'The attacker used the technique to extort the victim.'}),
 
                 (('risk:attack', 'uses', 'risk:vuln'), {
                     'doc': 'The attack used the vulnerability.'}),
@@ -936,12 +968,18 @@ class RiskModule(s_module.CoreModule):
                     ('compromise', ('risk:compromise', {}), {
                         'doc': 'The compromise which allowed the leaker access to the information.'}),
 
+                    ('extortion', ('risk:extortion', {}), {
+                        'doc': 'The extortion event which used the threat of the leak as leverage.'}),
+
                     ('public', ('bool', {}), {
                         'doc': 'Set to true if the leaked information was made publicly available.'}),
 
                     ('public:url', ('inet:url', {}), {
                         'doc': 'The URL where the leaked information was made publicly available.'}),
 
+                    ('size:bytes', ('int', {'min': 0}), {
+                        'doc': 'The approximate uncompressed size of the total data leaked.'}),
+
                 )),
 
                 ('risk:extortion:type:taxonomy', {}, ()),
@@ -963,6 +1001,9 @@ class RiskModule(s_module.CoreModule):
                     ('demanded', ('time', {}), {
                         'doc': 'The time that the attacker made their demands.'}),
 
+                    ('deadline', ('time', {}), {
+                        'doc': 'The time that the demand must be met.'}),
+
                     ('goal', ('ou:goal', {}), {
                         'doc': 'The goal of the attacker in extorting the victim.'}),
 
@@ -976,7 +1017,7 @@ class RiskModule(s_module.CoreModule):
                         'doc': 'The extortion target identity.'}),
 
                     ('success', ('bool', {}), {
-                        'doc': 'Set to true if the victim met the attackers demands.'}),
+                        'doc': "Set to true if the victim met the attacker's demands."}),
 
                     ('enacted', ('bool', {}), {
                         'doc': 'Set to true if attacker carried out the threat.'}),

synapse/telepath.py

@@ -135,25 +135,24 @@ def mergeAhaInfo(info0, info1):
 
     return info0
 
-async def open(url, timeout=None):
+async def open(url, onlink=None):
     '''
-    Open a new telepath Client (or AHA Service Pool) based on the given URL.
-    '''
-    # backward compatible support for a list of URLs or urlinfo dicts...
-    if isinstance(url, (tuple, list)): # pragma: no cover
-        return await Client.anit(url)
-
-    urlinfo = chopurl(url)
+    Open a new telepath ClientV2 object based on the given URL.
 
-    if urlinfo.get('scheme') == 'aha':
-
-        ahaclient, ahasvc = await _getAhaSvc(urlinfo, timeout=timeout)
+    Args:
+        url (str): The URL to connect to.
+        onlink: An optional async callback function to run when connections are made.
 
-        # check if we should return a Pool rather than a Client :)
-        if ahasvc.get('services'):
-            return await Pool.anit(ahaclient, ahasvc, urlinfo)
+    Notes:
+        The onlink callback function has the call signature ``(proxy, urlinfo)``.
+        The proxy is the Telepath Proxy object.
+        The urlinfo is the parsed URL information used to create the proxy object.
+        The urlinfo structure may change between versions of Synapse.
 
-    return await Client.anit(urlinfo)
+    Returns:
+        ClientV2: A ClientV2 object.
+    '''
+    return await ClientV2.anit(url, onlink=onlink)
 
 async def _getAhaSvc(urlinfo, timeout=None):
 
@@ -832,7 +831,7 @@ class Proxy(s_base.Base):
 
                         mesg = await link.rx()
                         if mesg is None:
-                            raise s_exc.LinkShutDown(mesg=mesg)
+                            raise s_exc.LinkShutDown(mesg='Remote peer disconnected')
 
                         if mesg[0] != 't2:yield':  # pragma: no cover
                             info = 'Telepath protocol violation:  unexpected message received'
@@ -869,6 +868,8 @@ class Proxy(s_base.Base):
         if self.sess is not None:
             return await self.taskv2(todo, name=name)
 
+        s_common.deprecated('Telepath task with no session', curv='2.166.0')
+
         task = Task()
 
         mesg = ('task:init', {
@@ -980,21 +981,39 @@ class Proxy(s_base.Base):
         setattr(self, name, meth)
         return meth
 
-class Pool(s_base.Base):
+class ClientV2(s_base.Base):
     '''
     A telepath client which:
         * connects to multiple services
         * distributes API calls across them
         * receives topology updates from AHA
+
+    NOTE: This must co-exist with Client until we eliminate uses that
+          attempt to call telepath APIs directly from the Client rather
+          than awaiting a proxy()
     '''
-    async def __anit__(self, aha, ahasvc, urlinfo):
+    async def __anit__(self, urlinfo, onlink=None):
+
         await s_base.Base.__anit__(self)
+
+        # some ugly stuff in order to be backward compatible...
+        if not isinstance(urlinfo, (list, tuple)):
+            urlinfo = (urlinfo,)
+
+        urlinfo = [chopurl(u) for u in urlinfo]
+
+        self.aha = None
+
         self.clients = {}
         self.proxies = set()
 
-        self.aha = aha
-        self.ahasvc = ahasvc
-        self.urlinfo = urlinfo
+        self.poolname = None
+
+        self.onlink = onlink
+
+        self.booturls = urlinfo
+        self.bootdeque = collections.deque()
+        self.bootdeque.extend(self.booturls)
 
         self.ready = asyncio.Event()
         self.deque = collections.deque()
@@ -1003,7 +1022,6 @@ class Pool(s_base.Base):
             'svc:add': self._onPoolSvcAdd,
             'svc:del': self._onPoolSvcDel,
         }
-        self.schedCoro(self._toposync())
 
         async def fini():
             await self._shutDownPool()
@@ -1012,8 +1030,63 @@ class Pool(s_base.Base):
 
         self.onfini(fini)
 
+        self.schedCoro(self._initBootProxy())
+
+    def getNextBootUrl(self):
+        if not self.bootdeque:
+            self.bootdeque.extend(self.booturls)
+        return self.bootdeque.popleft()
+
+    async def _initBootProxy(self):
+
+        lastlog = 0.0
+        while not self.isfini:
+
+            urlinfo = self.getNextBootUrl()
+
+            try:
+
+                if urlinfo.get('scheme') == 'aha':
+
+                    self.aha, svcinfo = await _getAhaSvc(urlinfo)
+
+                    # if the service is a pool, enter pool mode and fire
+                    # the topography sync task to manage pool members.
+                    services = svcinfo.get('services')
+                    if services is not None:
+                        # we are an AHA pool!
+                        if self.poolname is None:
+                            self.poolname = svcinfo.get('name')
+                            self.schedCoro(self._toposync())
+                        return
+
+                # regular telepath client behavior
+                proxy = await openinfo(urlinfo)
+                await self._onPoolLink(proxy, urlinfo)
+
+                async def reconnect():
+                    if not self.isfini:
+                        self.schedCoro(self._initBootProxy())
+
+                proxy.onfini(reconnect)
+                return
+
+            except Exception as e:
+
+                now = time.monotonic()
+                if now > lastlog + 60.0:  # don't logspam the disconnect message more than 1/min
+                    url = s_urlhelp.sanitizeUrl(zipurl(urlinfo))
+                    logger.exception(f'telepath clientv2 ({url}) encountered an error: {e}')
+                    lastlog = now
+
+                retrysleep = float(urlinfo.get('retrysleep', 0.2))
+                await self.waitfini(timeout=retrysleep)
+
+    async def waitready(self, timeout=None):
+        await s_common.wait_for(self.ready.wait(), timeout=timeout)
+
     def size(self):
-        return len(self.clients)
+        return len(self.proxies)
 
     async def _onPoolSvcAdd(self, mesg):
         svcname = mesg[1].get('name')
@@ -1022,7 +1095,7 @@ class Pool(s_base.Base):
             await oldc.fini()
 
         urlinfo = {'scheme': 'aha', 'host': svcname, 'path': ''}
-        self.clients[svcname] = await Client.anit(urlinfo, onlink=self._onPoolLink)
+        self.clients[svcname] = await ClientV2.anit(urlinfo, onlink=self._onPoolLink)
         await self.fire('svc:add', **mesg[1])
 
     async def _onPoolSvcDel(self, mesg):
@@ -1033,10 +1106,11 @@ class Pool(s_base.Base):
         self.deque.clear()
         await self.fire('svc:del', **mesg[1])
 
-    async def _onPoolLink(self, proxy):
+    async def _onPoolLink(self, proxy, urlinfo):
 
         async def onfini():
-            self.proxies.remove(proxy)
+            if proxy in self.proxies:
+                self.proxies.remove(proxy)
             if proxy in self.deque:
                 self.deque.remove(proxy)
             if not len(self.proxies):
@@ -1046,13 +1120,23 @@ class Pool(s_base.Base):
         self.proxies.add(proxy)
         self.ready.set()
 
+        if self.onlink is not None:
+            try:
+                await self.onlink(proxy, urlinfo)
+            except Exception as e:
+                logger.exception(f'onlink: {self.onlink}')
+
     async def _shutDownPool(self):
         # when we reconnect to our AHA service, we need to dump the current
         # topology state and gather it again.
-        for client in self.clients.values():
+        for client in list(self.clients.values()):
             await client.fini()
 
+        for proxy in list(self.proxies):
+            await proxy.fini()
+
         self.deque.clear()
+        self.ready.clear()
         self.clients.clear()
         self.proxies.clear()
 
@@ -1065,16 +1149,14 @@ class Pool(s_base.Base):
 
         while not self.isfini:
 
-            poolname = self.ahasvc.get('name')
-
             try:
                 ahaproxy = await self.aha.proxy()
 
                 await reset()
 
-                async for mesg in ahaproxy.iterPoolTopo(poolname):
+                async for mesg in ahaproxy.iterPoolTopo(self.poolname):
                     hand = self.mesghands.get(mesg[0])
-                    if hand is None: # pragma: no cover
+                    if hand is None:  # pragma: no cover
                         logger.warning(f'Unknown AHA pool topography message: {mesg}')
                         continue
 
@@ -1092,7 +1174,7 @@ class Pool(s_base.Base):
 
                 await self.ready.wait()
 
-                if self.isfini: # pragma: no cover
+                if self.isfini:  # pragma: no cover
                     raise s_exc.IsFini()
 
                 if not self.deque:

synapse/tests/test_cortex.py

@@ -4564,10 +4564,9 @@ class CortexBasicTest(s_t_utils.SynTest):
             await core1.addFeedData('syn.nodes', data)
             self.len(1, await core1.nodes('test:int=8 -#test.12345'))
 
-            # This tag does match regex
             data = [(('test:int', 8), {'tags': {'test.1234': (None, None)}})]
             await core1.addFeedData('syn.nodes', data)
-            self.len(0, await core1.nodes('test:int=8 -#test.1234'))
+            self.len(0, await core1.nodes('test:int=8 -#newtag.1234'))
 
             core1.view.layers[0].readonly = True
             await self.asyncraises(s_exc.IsReadOnly, core1.addFeedData('syn.nodes', data))
@@ -7809,6 +7808,9 @@ class CortexBasicTest(s_t_utils.SynTest):
                     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 newp')
+                    self.stormIsInErr(':// not found in [newp]', 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)
@@ -7817,6 +7819,8 @@ class CortexBasicTest(s_t_utils.SynTest):
 
                     core00 = await base.enter_context(self.getTestCore(dirn=dirn00))
 
+                    await core00.stormpool.waitready(timeout=12)
+
                     with self.getLoggerStream('synapse') as stream:
                         msgs = await alist(core00.storm('inet:asn=0'))
                         self.len(1, [m for m in msgs if m[0] == 'node'])
@@ -7906,28 +7910,28 @@ class CortexBasicTest(s_t_utils.SynTest):
 
                     stream.seek(0)
                     data = stream.read()
-                    self.isin('Unable to get proxy', data)
+                    self.isin('Storm query mirror pool is empty, running query locally.', data)
 
                     with self.getLoggerStream('synapse') as stream:
                         self.true(await core00.callStorm('inet:asn=0 return($lib.true)'))
 
                     stream.seek(0)
                     data = stream.read()
-                    self.isin('Unable to get proxy', data)
+                    self.isin('Storm query mirror pool is empty, running query locally.', data)
 
                     with self.getLoggerStream('synapse') as stream:
                         self.len(1, await alist(core00.exportStorm('inet:asn=0')))
 
                     stream.seek(0)
                     data = stream.read()
-                    self.isin('Unable to get proxy', data)
+                    self.isin('Storm query mirror pool is empty, running query locally.', data)
 
                     with self.getLoggerStream('synapse') as stream:
                         self.eq(1, await core00.count('inet:asn=0'))
 
                     stream.seek(0)
                     data = stream.read()
-                    self.isin('Unable to get proxy', data)
+                    self.isin('Storm query mirror pool is empty, running query locally.', data)
 
                     core01 = await base.enter_context(self.getTestCore(dirn=dirn01))
                     await core01.promote(graceful=True)
@@ -7984,3 +7988,33 @@ class CortexBasicTest(s_t_utils.SynTest):
 
                     msgs = await alist(core01.storm('inet:asn=0', opts={'mirror': False}))
                     self.len(1, [m for m in msgs if m[0] == 'node'])
+
+    async def test_cortex_authgate(self):
+        # TODO - Remove this in 3.0.0
+        with self.getTestDir() as dirn:
+
+            async with self.getTestCore(dirn=dirn) as core:  # type: s_cortex.Cortex
+
+                unfo = await core.addUser('lowuser')
+                lowuser = unfo.get('iden')
+
+                msgs = await core.stormlist('auth.user.addrule lowuser --gate cortex node')
+                self.stormIsInWarn('Adding rule on the "cortex" authgate. This authgate is not used', msgs)
+                msgs = await core.stormlist('auth.role.addrule all --gate cortex hehe')
+                self.stormIsInWarn('Adding rule on the "cortex" authgate. This authgate is not used', msgs)
+
+                aslow = {'user': lowuser}
+
+                # The cortex authgate does nothing
+                with self.raises(s_exc.AuthDeny) as cm:
+                    await core.nodes('[test:str=hello]', opts=aslow)
+
+            with self.getAsyncLoggerStream('synapse.cortex') as stream:
+                async with self.getTestCore(dirn=dirn) as core:  # type: s_cortex.Cortex
+                    # The cortex authgate still does nothing
+                    with self.raises(s_exc.AuthDeny) as cm:
+                        await core.nodes('[test:str=hello]', opts=aslow)
+            stream.seek(0)
+            buf = stream.read()
+            self.isin('(lowuser) has a rule on the "cortex" authgate', buf)
+            self.isin('(all) has a rule on the "cortex" authgate', buf)

synapse/tests/test_datamodel.py

@@ -41,6 +41,28 @@ class DeprecatedModel(s_module.CoreModule):
 
 class DataModelTest(s_t_utils.SynTest):
 
+    async def test_datamodel_basics(self):
+        async with self.getTestCore() as core:
+            core.model.addType('woot:one', 'guid', {}, {
+                'display': {
+                    'columns': (
+                        {'type': 'newp', 'opts': {}},
+                    ),
+                },
+            })
+            with self.raises(s_exc.BadFormDef):
+                core.model.addForm('woot:one', {}, ())
+
+            core.model.addType('woot:two', 'guid', {}, {
+                'display': {
+                    'columns': (
+                        {'type': 'prop', 'opts': {'name': 'hehe'}},
+                    ),
+                },
+            })
+            with self.raises(s_exc.BadFormDef):
+                core.model.addForm('woot:two', {}, ())
+
     async def test_datamodel_formname(self):
         modl = s_datamodel.Model()
         mods = (