synapse 2.212.0__py311-none-any.whl → 2.214.0__py311-none-any.whl

synapse/tests/test_lib_certdir.py

@@ -576,6 +576,10 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getHostKey(hostname)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            self.true(cdir.delHostCsr(hostname))
+            self.false(os.path.isfile(path))
+            self.false(cdir.delHostCsr(hostname))
+
             # Per RFC5280 common-name has a length of 1 to 64 characters
             # Do not generate CSRs which exceed that name range.
             with self.raises(s_exc.CryptoErr) as cm:
@@ -610,6 +614,10 @@ class CertDirTest(s_t_utils.SynTest):
             key = cdir.getUserKey(username)
             self.basic_assertions(cdir, cert, key, cacert=cacert)
 
+            self.true(cdir.delUserCsr(username))
+            self.false(os.path.isfile(path))
+            self.false(cdir.delUserCsr(username))
+
             # Per RFC5280 common-name has a length of 1 to 64 characters
             # Do not generate CSRs which exceed that name range.
             with self.raises(s_exc.CryptoErr) as cm:

synapse/tests/test_lib_coro.py

@@ -235,3 +235,8 @@ class CoroTest(s_t_utils.SynTest):
         results = await s_coro.await_bg_tasks()
         self.len(1, results)
         self.isinstance(results[0], ZeroDivisionError)
+
+        task = s_coro.create_task(sleep(10))
+        self.eq([], await s_coro.await_bg_tasks(timeout=0.001))
+        task.cancel()
+        self.eq([], await s_coro.await_bg_tasks())

synapse/tests/test_lib_httpapi.py

@@ -807,8 +807,8 @@ class HttpApiTest(s_tests.SynTest):
                 opts['user'] = newpuser
                 async with sess.get(f'https://localhost:{port}/api/v1/storm', json=data) as resp:
                     self.eq(resp.status, http.HTTPStatus.BAD_REQUEST)
-                    data = await resp.json()
-                    self.eq(data, {'status': 'err', 'code': 'NoSuchUser',
+                    info = await resp.json()
+                    self.eq(info, {'status': 'err', 'code': 'NoSuchUser',
                                    'mesg': f'No user found with iden: {newpuser}'})
 
     async def test_http_coreinfo(self):
@@ -1615,6 +1615,14 @@ class HttpApiTest(s_tests.SynTest):
                                     json={'query': '.created', 'opts': {'user': lowuser.iden, 'view': fork}}) as resp:
                     self.eq(resp.status, http.HTTPStatus.FORBIDDEN)
 
+                # ShuttingDown precondition failure
+                core.boss.is_shutdown = True
+                async with sess.get(f'https://localhost:{port}/api/v1/storm', json={'query': '.created'}) as resp:
+                    self.eq(resp.status, http.HTTPStatus.BAD_REQUEST)
+                    info = await resp.json()
+                    self.eq(info.get('code'), 'ShuttingDown')
+                core.boss.is_shutdown = False
+
                 # check reqvalidstorm with various queries
                 tvs = (
                     ('test:str=test', {}, 'ok'),

synapse/tests/test_lib_link.py

@@ -121,7 +121,7 @@ class LinkTest(s_test.SynTest):
         self.eq(msg0, ('what', {'k': 1}))
         evt.set()
         await asyncio.sleep(0)
-        with self.getAsyncLoggerStream('synapse.lib.link', 'rx error') as stream:
+        with self.getAsyncLoggerStream('synapse.lib.link', 'rx closed unexpectedly') as stream:
             msg1 = await link.rx()
             self.true(await stream.wait(6))
         self.none(msg1)

synapse/tests/test_lib_scrape.py

@@ -203,6 +203,10 @@ A bunch of prefixed urls
 
 https://c2server.com/evil/malware/doesnot[care+]aboutstandards{at-all}
 
+beep “https://unicode.doublequote.org/test.php” boop
+
+x ‘https://unicode.singlequote.org/test.php’ z
+
 '''
 
 data3 = '''
@@ -725,6 +729,8 @@ class ScrapeTest(s_t_utils.SynTest):
         nodes.remove(('inet:url', 'https://www.thingspace.com/blog/giggles.html'))
         nodes.remove(('inet:url', 'https://testme.org/test.php'))
         nodes.remove(('inet:url', 'https://c2server.com/evil/malware/doesnot[care+]aboutstandards{at-all}'))
+        nodes.remove(('inet:url', 'https://unicode.doublequote.org/test.php'))
+        nodes.remove(('inet:url', 'https://unicode.singlequote.org/test.php'))
 
         nodes = list(s_scrape.scrape(btc_addresses))
         self.len(11, nodes)

synapse/tests/test_lib_storm.py

@@ -130,7 +130,6 @@ class StormTest(s_t_utils.SynTest):
             self.none(props.get('phone'))
             self.eq(props.get('name'), 'burrito corp')
             self.eq(props.get('desc'), 'burritos man')
-            self.stormIsInWarn('Skipping bad value for prop ou:org:phone: requires a digit string', msgs)
 
             await self.asyncraises(s_exc.BadTypeValu, core.addNode(core.auth.rootuser, 'ou:org', {'name': 'org name 77', 'phone': 'lolnope'}, props={'desc': 'an org desc'}))
 
@@ -173,6 +172,127 @@ class StormTest(s_t_utils.SynTest):
             nodes = await core.nodes('[ it:exec:proc=(nulltime,) ]')
             self.len(1, nodes)
 
+            # Recursive gutors
+            nodes = await core.nodes('''[
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'fooplatform',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'foomesg')
+            self.nn(node.get('channel'))
+
+            nodes = await core.nodes('inet:service:message -> inet:service:channel')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('id'), 'foochannel')
+            self.nn(node.get('platform'))
+
+            nodes = await core.nodes('inet:service:message -> inet:service:channel -> inet:service:platform')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'fooplatform')
+            self.eq(node.get('url'), 'http://foo.com')
+
+            nodes = await core.nodes('''
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'fooplatform',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            ''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'foomesg')
+
+            nodes = await core.nodes('''[
+                inet:service:message=({
+                    'id': 'barmesg',
+                    'channel': {
+                        'id': 'barchannel',
+                        'platform': {
+                            'name': 'barplatform',
+                            'url': 'http://bar.com'
+                        }
+                    },
+                    '$props': {
+                        'platform': {
+                            'name': 'barplatform',
+                            'url': 'http://bar.com'
+                        }
+                    }
+                })
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef[0], 'inet:service:message')
+            self.eq(node.get('id'), 'barmesg')
+            self.nn(node.get('channel'))
+
+            platguid = node.get('platform')
+            self.nn(platguid)
+            nodes = await core.nodes('inet:service:message:id=barmesg -> inet:service:channel -> inet:service:platform')
+            self.len(1, nodes)
+            self.eq(platguid, nodes[0].ndef[1])
+
+            # No node lifted if no matching node for inner gutor
+            self.len(0, await core.nodes('''
+                inet:service:message=({
+                    'id': 'foomesg',
+                    'channel': {
+                        'id': 'foochannel',
+                        'platform': {
+                            'name': 'newp',
+                            'url': 'http://foo.com'
+                        }
+                    }
+                })
+            '''))
+
+            # BadTypeValu comes through from inner gutor
+            with self.raises(s_exc.BadTypeValu) as cm:
+                await core.nodes('''
+                    inet:service:message=({
+                        'id': 'foomesg',
+                        'channel': {
+                            'id': 'foochannel',
+                            'platform': {
+                                'name': 'newp',
+                                'url': 'newp'
+                            }
+                        }
+                    })
+                ''')
+
+            self.eq(cm.exception.get('form'), 'inet:service:platform')
+            self.eq(cm.exception.get('prop'), 'url')
+            self.eq(cm.exception.get('mesg'), 'Bad value for prop inet:service:platform:url: Invalid/Missing protocol')
+
+            # Ensure inner nodes are not created unless the entire gutor is valid.
+            self.len(0, await core.nodes('''[
+                inet:service:account?=({
+                    "id": "bar",
+                    "platform": {"name": "barplat"},
+                    "url": "newp"})
+            ]'''))
+
+            self.len(0, await core.nodes('inet:service:platform:name=barplat'))
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 
@@ -1736,6 +1856,8 @@ class StormTest(s_t_utils.SynTest):
             self.stormHasNoErr(await core.stormlist('merge --diff', opts=altview))
 
             oldn = await core.nodes('[ ou:name=readonly ]', opts=altview)
+            # need to pause a moment so the created times differ
+            await asyncio.sleep(0.01)
             newn = await core.nodes('[ ou:name=readonly ]')
             self.ne(oldn[0].props['.created'], newn[0].props['.created'])
 

synapse/tests/test_lib_stormlib_spooled.py

@@ -1,3 +1,4 @@
+import os
 import synapse.exc as s_exc
 import synapse.lib.stormtypes as s_stormtypes
 
@@ -124,6 +125,17 @@ class StormlibSpooledTest(s_test.SynTest):
             msgs = await core.stormlist(q, opts={'vars': {'items': [True, 'neato', False, 9001]}})
             self.stormIsInPrint("The set is {'neato'}", msgs)
 
+            q = '''
+            $set = $lib.spooled.set()
+            for $v in $lib.range($n) {
+                $set.add($v)
+            }
+            if $set { return ( (true) ) }
+            else { return ( (false) ) }
+            '''
+            self.false(await core.callStorm(q, opts={'vars': {'n': 0}}))
+            self.true(await core.callStorm(q, opts={'vars': {'n': 1}}))
+
             # force a fallback
             q = '''
                 $set = $lib.spooled.set()
@@ -133,6 +145,20 @@ class StormlibSpooledTest(s_test.SynTest):
             valu = await core.callStorm(q)
             self.eq(1500, valu)
 
+            subq = '''{
+                $sset = $lib.spooled.set()
+                $sset.adds($lib.range(1500))
+                return($sset)
+            }'''
+
+            q = '''
+                $subset = $lib.storm.eval($text)
+                $subset.add(2345)
+                return($subset.size())
+            '''
+            valu = await core.callStorm(q, opts={'vars': {'text': subq}})
+            self.eq(1501, valu)
+
             # sad paths
             # too complex
             q = '''
@@ -188,3 +214,8 @@ class StormlibSpooledTest(s_test.SynTest):
                 return($set)
             '''
             await self.asyncraises(s_exc.StormRuntimeError, core.callStorm(q, {'vars': {'stormnode': stormnode}}))
+
+            # make sure the various spools got trashed
+            path = os.path.join(core.dirn, 'tmp')
+            files = [f for f in os.listdir(os.path.join(path))]
+            self.len(0, files)

synapse/tests/test_lib_stormtypes.py

@@ -1902,6 +1902,17 @@ class StormTypesTest(s_test.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('test:str', 'asdf'))
 
+            q = '''
+            $set = $lib.set()
+            for $v in $lib.range($n) {
+                $set.add($v)
+            }
+            if $set { return ( (true) ) }
+            else { return ( (false) ) }
+            '''
+            self.false(await core.callStorm(q, opts={'vars': {'n': 0}}))
+            self.true(await core.callStorm(q, opts={'vars': {'n': 1}}))
+
             # test that some of the more complex objects we've got uniq down properly
             # Bool
             q = '''

synapse/tests/test_lib_types.py

@@ -338,42 +338,80 @@ class TypesTest(s_t_utils.SynTest):
             t = core.model.type('test:hexa')
             # Test norming to index values
             testvectors = [
-                ('0C', b'\x0c'),
-                ('0X010001', b'\x01\x00\x01'),
-                ('0FfF', b'\x0f\xff'),
-                ('f12A3e', b'\xf1\x2a\x3e'),
-                (b'\x01\x00\x01', b'\x01\x00\x01'),
+                (0xc, '0c'),
+                (-0xc, 'f4'),
+                ('c', '0c'),
+                ('0c', '0c'),
+                ('-0c', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                ('0x0c', '0c'),
+                ('-0x0c', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                (b'\x0c', '0c'),
+
+                (0x10001, '010001'),
+                ('10001', '010001'),
+                ('0x10001', '010001'),
+                ('010001', '010001'),
+                ('0x010001', '010001'),
+                (b'\x01\x00\x01', '010001'),
+
+                (0xFfF, '0fff'),
+                ('FfF', '0fff'),
+                ('0FfF', '0fff'),
+                ('0x0FfF', '0fff'),
+                (b'\x0F\xfF', '0fff'),
+
                 (b'\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\t\x98\xec\xf8B~',
-                 b'\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\t\x98\xec\xf8B~'),
-                (65537, s_exc.BadTypeValu),
+                 'd41d8cd98f00b204e9800998ecf8427e'),
+
+                ('01\udcfe0101', (s_exc.BadTypeValu, 'string argument should contain only ASCII characters')),
             ]
 
-            for v, b in testvectors:
-                if isinstance(b, bytes):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
-            # width = 4
+            # size = 4
             testvectors4 = [
-                ('d41d', b'\xd4\x1d'),
-                (b'\x10\x01', b'\x10\x01'),
-                ('01', s_exc.BadTypeValu),
-                ('010101', s_exc.BadTypeValu),
-                (b'\x10\x01\xff', s_exc.BadTypeValu),
-                (b'\xff', s_exc.BadTypeValu),
-                ('01\udcfe0101', s_exc.BadTypeValu),
+                (0xc, (s_exc.BadTypeValu, 'Invalid width.')),
+                (-0xc, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0c', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x0c', (s_exc.BadTypeValu, 'Invalid width.')),
+                (b'\x0c', (s_exc.BadTypeValu, 'Invalid width.')),
+
+                (0xd41d, 'd41d'),
+                ('d41d', 'd41d'),
+                ('0xd41d', 'd41d'),
+                (b'\xd4\x1d', 'd41d'),
+
+                (0x10001, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('10001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x10001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('010001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x010001', (s_exc.BadTypeValu, 'Invalid width.')),
+                (b'\x01\x00\x01', (s_exc.BadTypeValu, 'Invalid width.')),
+
+                ('01\udcfe0101', (s_exc.BadTypeValu, 'string argument should contain only ASCII characters')),
             ]
             t = core.model.type('test:hex4')
-            for v, b in testvectors4:
-                if isinstance(b, bytes):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors4:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # size = 8, zeropad = True
             testvectors = [
@@ -384,29 +422,45 @@ class TypesTest(s_t_utils.SynTest):
                 ('0X12345678', '12345678'),
                 ('56:78', '00005678'),
                 ('12:34:56:78', '12345678'),
-                ('::', s_exc.BadTypeValu),
-                ('0x::', s_exc.BadTypeValu),
-                ('0x1234qwer', s_exc.BadTypeValu),
-                ('0x123456789a', s_exc.BadTypeValu),
-                ('::', s_exc.BadTypeValu),
+                (-1, 'ffffffff'),
+                (-0xff, 'ffffff01'),
+                (1234, '000004d2'),
+                (0x12345678, '12345678'),
+                (0x123456789a, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('::', (s_exc.BadTypeValu, 'No string left after stripping.')),
+                ('0x::', (s_exc.BadTypeValu, 'No string left after stripping.')),
+                ('0x1234qwer', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                ('0x123456789a', (s_exc.BadTypeValu, 'Invalid width.')),
                 (b'\x12', '00000012'),
                 (b'\x12\x34', '00001234'),
                 (b'\x12\x34\x56', '00123456'),
                 (b'\x12\x34\x56\x78', '12345678'),
-                (b'\x12\x34\x56\x78\x9a', s_exc.BadTypeValu),
+                (b'\x12\x34\x56\x78\x9a', (s_exc.BadTypeValu, 'Invalid width.')),
             ]
             t = core.model.type('test:hexpad')
-            for v, b in testvectors:
-                if isinstance(b, (str, bytes)):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
-                    self.eq(r, b)
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # zeropad = 20
             testvectors = [
+                (-1, 'ffffffffffffffffffff'),
+                (-0xff, 'ffffffffffffffffff01'),
+                (0x12, '00000000000000000012'),
+                (0x123, '00000000000000000123'),
+                (0x1234, '00000000000000001234'),
+                (0x123456, '00000000000000123456'),
+                (0x12345678, '00000000000012345678'),
+                (0x123456789abcdef123456789abcdef, '123456789abcdef123456789abcdef'),
+                (-0x123456789abcdef123456789abcdef, 'edcba9876543210edcba9876543211'),
                 ('0x12', '00000000000000000012'),
                 ('0x123', '00000000000000000123'),
                 ('0x1234', '00000000000000001234'),
@@ -421,14 +475,17 @@ class TypesTest(s_t_utils.SynTest):
                 (b'\x12\x34\x56\x78\x9a\xbc\xde\xf1\x23\x45\x67\x89\xab\xcd\xef', '123456789abcdef123456789abcdef'),
             ]
             t = core.model.type('test:zeropad')
-            for v, b in testvectors:
-                if isinstance(b, (str, bytes)):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
-                    self.eq(r, b)
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # Do some node creation and lifting
             nodes = await core.nodes('[test:hexa="01:00 01"]')
@@ -436,8 +493,19 @@ class TypesTest(s_t_utils.SynTest):
             node = nodes[0]
             self.eq(node.ndef, ('test:hexa', '010001'))
             self.len(1, await core.nodes('test:hexa=010001'))
+            self.len(1, await core.nodes('test:hexa=(0x10001)'))
             self.len(1, await core.nodes('test:hexa=$byts', opts={'vars': {'byts': b'\x01\x00\x01'}}))
 
+            nodes = await core.nodes('[test:hexa=(-10)]')
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), 'f6')
+
+            self.len(1, await core.nodes('test:hexa=(-10)'))
+
+            with self.raises(s_exc.BadTypeValu) as exc:
+                await core.callStorm('test:hexa^=(-10)')
+            self.eq(exc.exception.get('mesg'), 'Hex prefix lift values must be str, not int.')
+
             # Do some fancy prefix searches for test:hexa
             valus = ['deadb33f',
                      'deadb33fb33f',
@@ -467,9 +535,25 @@ class TypesTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('[test:hexa=0xf00fb33b00000000]'))
             self.len(1, await core.nodes('test:hexa=0xf00fb33b00000000'))
             self.len(1, await core.nodes('test:hexa^=0xf00fb33b'))
+            self.len(1, await core.nodes('test:hexa^=0xf00fb33'))
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('test:hexa^=(0xf00fb33b)')
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('test:hexa^=(0xf00fb33)')
 
             # Check creating and lifting zeropadded hex types
-            self.len(3, await core.nodes('[test:zeropad=11 test:zeropad=0x22 test:zeropad=111]'))
+            q = '''
+            [
+                test:zeropad=11
+                test:zeropad=0x22
+                test:zeropad=111
+                test:zeropad=(0x33)
+                test:zeropad=(0x444)
+            ]
+            '''
+            self.len(5, await core.nodes(q))
             self.len(1, await core.nodes('test:zeropad=0x11'))
             self.len(1, await core.nodes('test:zeropad=0x111'))
             self.len(1, await core.nodes('test:zeropad=000000000011'))
@@ -479,6 +563,14 @@ class TypesTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('test:zeropad=000000000022'))
             self.len(1, await core.nodes('test:zeropad=00000000000000000022'))  # len=20
             self.len(0, await core.nodes('test:zeropad=0000000000000000000022'))  # len=22
+            self.len(1, await core.nodes('test:zeropad=(0x33)'))
+            self.len(1, await core.nodes('test:zeropad=000000000033'))
+            self.len(1, await core.nodes('test:zeropad=00000000000000000033'))  # len=20
+            self.len(0, await core.nodes('test:zeropad=0000000000000000000033'))  # len=22
+            self.len(1, await core.nodes('test:zeropad=(0x444)'))
+            self.len(1, await core.nodes('test:zeropad=000000000444'))
+            self.len(1, await core.nodes('test:zeropad=00000000000000000444'))  # len=20
+            self.len(0, await core.nodes('test:zeropad=0000000000000000000444'))  # len=22
 
     def test_int(self):
 
@@ -1228,7 +1320,7 @@ class TypesTest(s_t_utils.SynTest):
             nodes = await core.nodes('test:str:tick=201401*')
             self.eq({node.ndef[1] for node in nodes}, {'a'})
 
-            nodes = await core.nodes('test:str:tick*range=("-4200 days", now)')
+            nodes = await core.nodes('test:str:tick*range=("-6000 days", now)')
             self.eq({node.ndef[1] for node in nodes}, {'a', 'b', 'c', 'd'})
 
             opts = {'vars': {'tick': tick, 'tock': tock}}

synapse/tests/test_model_crypto.py

@@ -545,6 +545,14 @@ class CryptoModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('identities:ipv4s'), (0x01020304, 0x05050505))
             self.eq(nodes[0].get('identities:ipv6s'), ('ff::11', 'ff::aa'))
 
+            nodes = await core.nodes('[ crypto:x509:cert=* :serial=(1234) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('serial'), '00000000000000000000000000000000000004d2')
+
+            nodes = await core.nodes('[ crypto:x509:cert=* :serial=(-1234) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('serial'), 'fffffffffffffffffffffffffffffffffffffb2e')
+
             nodes = await core.nodes('''
                 [
                     crypto:x509:crl=$crl

synapse/tests/test_model_inet.py

@@ -3002,17 +3002,20 @@ class InetModelTest(s_t_utils.SynTest):
                 :url="https://v.vtx.lk/slack"
                 :name="Synapse users slack"
                 :tenant={[ inet:service:tenant=({"id": "VS-31337"}) ]}
+                :app={[ inet:service:app=({"id": "app00"}) ]}
             ]
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
             self.nn(nodes[0].get('tenant'))
+            self.nn(nodes[0].get('app'))
             self.eq(nodes[0].ndef, ('inet:service:instance', s_common.guid(('vertex', 'slack'))))
             self.eq(nodes[0].get('id'), 'T2XK1223Y')
             self.eq(nodes[0].get('platform'), platform.ndef[1])
             self.eq(nodes[0].get('url'), 'https://v.vtx.lk/slack')
             self.eq(nodes[0].get('name'), 'synapse users slack')
             platinst = nodes[0]
+            app00 = nodes[0].get('app')
 
             q = '''
             [
@@ -3023,6 +3026,7 @@ class InetModelTest(s_t_utils.SynTest):
                     :email=blackout@vertex.link
                     :profile={ gen.ps.contact.email vertex.employee blackout@vertex.link }
                     :tenant={[ inet:service:tenant=({"id": "VS-31337"}) ]}
+                    :app={[ inet:service:app=({"id": "a001"}) ]}
                 )
 
                 (inet:service:account=(visi, account, vertex, slack)
@@ -3037,6 +3041,7 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(2, accounts)
 
             self.nn(accounts[0].get('tenant'))
+            self.nn(accounts[0].get('app'))
 
             profiles = await core.nodes('ps:contact')
             self.len(2, profiles)
@@ -3175,6 +3180,7 @@ class InetModelTest(s_t_utils.SynTest):
                 :platform=$platiden
                 :instance=$instiden
                 :topic=' My Topic   '
+                :app={ inet:service:app:id=app00 }
             ]
             '''
             opts = {'vars': {
@@ -3185,6 +3191,7 @@ class InetModelTest(s_t_utils.SynTest):
             nodes = await core.nodes(q, opts=opts)
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('inet:service:channel', s_common.guid(('general', 'channel', 'vertex', 'slack'))))
+            self.eq(nodes[0].get('app'), app00)
             self.eq(nodes[0].get('name'), 'general')
             self.eq(nodes[0].get('topic'), 'my topic')
             self.eq(nodes[0].get('period'), (1420070400000, 9223372036854775807))