synapse 2.208.0__py311-none-any.whl → 2.210.0__py311-none-any.whl

synapse/tests/test_lib_cell.py

@@ -2238,7 +2238,7 @@ class CellTest(s_t_utils.SynTest):
                             self.false(core00.isactive)
 
                             modinfo = s_common.yamlload(core00.dirn, 'cell.mods.yaml')
-                            self.isin('01.core', modinfo.get('mirror', ''))
+                            self.eq('aha://root@core...', modinfo.get('mirror', ''))
                             modinfo = s_common.yamlload(core01.dirn, 'cell.mods.yaml')
                             self.none(modinfo.get('mirror'))
 
@@ -2321,7 +2321,7 @@ class CellTest(s_t_utils.SynTest):
                             self.false(core00.isactive)
 
                             modinfo = s_common.yamlload(core00.dirn, 'cell.mods.yaml')
-                            self.isin('01.core', modinfo.get('mirror', ''))
+                            self.eq('aha://root@core...', modinfo.get('mirror', ''))
                             modinfo = s_common.yamlload(core01.dirn, 'cell.mods.yaml')
                             self.none(modinfo.get('mirror'))
 
@@ -2333,7 +2333,7 @@ class CellTest(s_t_utils.SynTest):
                             modinfo = s_common.yamlload(core00.dirn, 'cell.mods.yaml')
                             self.none(modinfo.get('mirror'))
                             modinfo = s_common.yamlload(core01.dirn, 'cell.mods.yaml')
-                            self.isin('00.core', modinfo.get('mirror', ''))
+                            self.eq('aha://root@core...', modinfo.get('mirror', ''))
 
                             # Backup the mirror (core01) which points to the core00
                             async with await axon00.upload() as upfd:
@@ -3285,6 +3285,7 @@ class CellTest(s_t_utils.SynTest):
                     dirn00 = s_common.genpath(dirn, '00.cell')
                     dirn01 = s_common.genpath(dirn, '01.cell')
                     dirn02 = s_common.genpath(dirn, '02.cell')
+                    dirn0002 = s_common.genpath(dirn, '00.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,
@@ -3301,24 +3302,43 @@ class CellTest(s_t_utils.SynTest):
                         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
+                    # Promote 02.cell -> Promote 01.cell -> Promote 00.cell, without breaking the configured topology
                     await cell02.promote(graceful=True)
                     self.false(cell00.isactive)
+                    self.eq(cell00.conf.get('mirror'), 'aha://root@cell...')
                     self.false(cell01.isactive)
+                    self.eq(cell01.conf.get('mirror'), 'aha://root@cell...')
                     self.true(cell02.isactive)
+                    self.none(cell02.conf.get('mirror'))
                     await cell02.sync()
 
                     await cell01.promote(graceful=True)
                     self.false(cell00.isactive)
+                    self.eq(cell00.conf.get('mirror'), 'aha://root@cell...')
                     self.true(cell01.isactive)
+                    self.none(cell01.conf.get('mirror'))
                     self.false(cell02.isactive)
+                    self.eq(cell02.conf.get('mirror'), 'aha://root@cell...')
                     await cell02.sync()
 
+                    await cell00.promote(graceful=True)
+                    self.true(cell00.isactive)
+                    self.none(cell00.conf.get('mirror'))
+                    self.false(cell01.isactive)
+                    self.eq(cell01.conf.get('mirror'), 'aha://root@cell...')
+                    self.false(cell02.isactive)
+                    self.eq(cell02.conf.get('mirror'), 'aha://root@cell...')
+                    await cell02.sync()
+
+                    # A follower of a follower cannot be promoted up since its leader is not the active cell.
+                    cell0002 = await base.enter_context(self.addSvcToAha(aha, '00.02.cell', s_cell.Cell, dirn=dirn0002,
+                                                                      provinfo={'mirror': '02.cell'}))
+                    self.false(cell0002.isactive)
+                    self.eq(cell0002.conf.get('mirror'), 'aha://root@02.cell...')
                     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'))
+                        await cell0002.promote(graceful=True)
+                    mesg = 'ahaname=02.cell is not the current leader and cannot handoff leadership to aha://00.02.cell.synapse.'
+                    self.isin(mesg, cm.exception.get('mesg'))
 
     async def test_cell_get_aha_proxy(self):
 

synapse/tests/test_lib_coro.py

@@ -212,3 +212,26 @@ class CoroTest(s_t_utils.SynTest):
 
         with self.raises(Exception):
             await s_coro._parserforked(newp)
+
+    async def test_lib_coro_create_task(self):
+
+        async def sleep(n):
+            await asyncio.sleep(n)
+            if n == 0:
+                return 1 / 0
+            return n
+
+        s_coro.create_task(sleep(0.1))
+        s_coro.create_task(sleep(0.15))
+        s_coro.create_task(sleep(0.2))
+        self.len(3, s_coro.bgtasks)
+        results = await s_coro.await_bg_tasks()
+        self.eq(set(results), {0.1, 0.15, 0.2})
+        self.len(0, s_coro.bgtasks)
+        results = await s_coro.await_bg_tasks()
+        self.eq(results, [])
+
+        s_coro.create_task(sleep(0))
+        results = await s_coro.await_bg_tasks()
+        self.len(1, results)
+        self.isinstance(results[0], ZeroDivisionError)

synapse/tests/test_lib_json.py

@@ -1,7 +1,7 @@
 import io
 import json
 
-import orjson
+import yyjson
 
 import synapse.exc as s_exc
 import synapse.common as s_common
@@ -44,9 +44,9 @@ class JsonTest(s_test.SynTest):
         inval = '{"a": "😀\ud83d\ude47"}'
         outval = {'a': '😀\ud83d\ude47'}
 
-        # orjson.dumps fails because of the surrogate pairs
-        with self.raises(orjson.JSONDecodeError):
-            orjson.loads(inval)
+        # yyjson.loads fails because of the surrogate pairs
+        with self.raises(ValueError):
+            yyjson.loads(inval)
 
         # stdlib json.loads passes because of voodoo magic
         self.eq(outval, json.loads(inval))
@@ -63,9 +63,9 @@ class JsonTest(s_test.SynTest):
         inval = {'a': '😀\ud83d\ude47'}
         outval = b'{"a": "\\ud83d\\ude00\\ud83d\\ude47"}'
 
-        # orjson.dumps fails because of the surrogate pairs
-        with self.raises(TypeError):
-            orjson.dumps(inval)
+        # yyjson.dumps fails because of the surrogate pairs
+        with self.raises(UnicodeEncodeError):
+            yyjson.dumps(inval)
 
         # stdlib json.dumps passes because of voodoo magic
         self.eq(outval.decode(), json.dumps(inval))
@@ -85,15 +85,15 @@ class JsonTest(s_test.SynTest):
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({}.items())
-        self.eq(exc.exception.get('mesg'), 'Type is not JSON serializable: dict_items')
+        self.eq(exc.exception.get('mesg'), "TypeError: Object of type 'dict_items' is not JSON serializable")
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({1: 'foo'})
-        self.eq(exc.exception.get('mesg'), 'Dict key must be str')
+        self.eq(exc.exception.get('mesg'), "TypeError: Dictionary keys must be strings")
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({'\ud83d\ude47': {}.items()})
-        self.eq(exc.exception.get('mesg'), 'Object of type dict_items is not JSON serializable')
+        self.eq(exc.exception.get('mesg'), "TypeError: Dictionary keys must be strings")
 
         self.eq(b'"dict_items([])"', s_json.dumps({}.items(), default=str))
 
@@ -111,6 +111,20 @@ class JsonTest(s_test.SynTest):
         s_json.dump({'c': 'd', 'a': 'b'}, buf)
         self.eq(b'{"c":"d","a":"b"}', buf.getvalue())
 
+    async def test_lib_json_large_integers(self):
+        valu = [
+            1, 2,
+            -1, -2,
+            1.0, 2.0,
+            -1.0, -2.0,
+            2**63, -2**63, -2**63 - 1,
+            2**64, -2**64, 2**64 + 1,
+            2**128, 2**128 + 1,
+            -2**128, -2**128 - 1,
+        ]
+
+        self.eq(valu, s_json.loads(s_json.dumps(valu)))
+
     async def test_jsload(self):
         with self.getTestDir() as dirn:
             with s_common.genfile(dirn, 'jsload.json') as fp:
@@ -147,41 +161,52 @@ class JsonTest(s_test.SynTest):
 
         buf = io.BytesIO()
 
+        msg = "Object of type '_io.BytesIO' is not JSON serializable"
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(buf)
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe({'foo': buf})
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(['foo', buf])
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         items = (
             (None, None),
             (1234, None),
             ('1234', None),
+            ('1234"', None),
             ({'asdf': 'haha'}, None),
             ({'a': (1,), 'b': [{'': 4}, 56, None, {'t': True, 'f': False}, 'oh my']}, None),
             (b'1234', s_exc.MustBeJsonSafe),
+            (b'1234"', s_exc.MustBeJsonSafe),
+            ({'a': float('nan')}, s_exc.MustBeJsonSafe),
             ({'a': 'a', 2: 2}, s_exc.MustBeJsonSafe),
             ({'a', 'b', 'c'}, s_exc.MustBeJsonSafe),
             (s_common.novalu, s_exc.MustBeJsonSafe),
         )
         for (item, eret) in items:
             if eret is None:
-                self.none(s_json.reqjsonsafe(item))
+                self.none(s_json.reqjsonsafe(item), msg=item)
             else:
                 with self.raises(eret):
                     s_json.reqjsonsafe(item)
 
-        text = '😀\ud83d\ude47'
+        for text in ['😀', 'asdf', 'asdf"', '"asdf']:
+            s_json.reqjsonsafe(text)
+
+        text = ['😀\ud83d\ude47']
         s_json.reqjsonsafe(text)
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(text, strict=True)
-        self.eq(exc.exception.get('mesg'), 'str is not valid UTF-8: surrogates not allowed')
+        self.eq(exc.exception.get('mesg'), "'utf-8' codec can't encode characters in position 1-2: surrogates not allowed")
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe(b'1234', strict=True)
+        self.eq(exc.exception.get('mesg'), 'Object of type bytes is not JSON serializable')
 
     async def test_lib_json_data_at_rest(self):
         async with self.getRegrCore('json-data') as core:

synapse/tests/test_lib_rstorm.py

@@ -119,7 +119,7 @@ clear_storm_opts = '''
 .. storm-cortex:: default
 .. storm-opts:: {"vars": {"foobar": "bar"}}
 .. storm-clear-http:: true
-.. storm:: $lib.print($lib.str.concat($foobar, "bizboz"))
+.. storm:: $lib.print(`{$foobar}bizboz`)
 '''
 
 stormenv = '''
@@ -381,8 +381,9 @@ class RStormLibTest(s_test.SynTest):
             path = s_common.genpath(dirn, 'clear_storm_opts.rst')
             with s_common.genfile(path) as fd:
                 fd.write(clear_storm_opts.encode())
-            with self.raises(s_exc.StormRuntimeError):
-                text = await get_rst_text(path)
+            with self.raises(s_exc.StormRuntimeError) as cm:
+                await get_rst_text(path)
+            self.eq('Missing variable: foobar', cm.exception.get('mesg'))
 
             # boom1 test
             path = s_common.genpath(dirn, 'boom1.rst')

synapse/tests/test_lib_stormtypes.py

@@ -3802,7 +3802,6 @@ class StormTypesTest(s_test.SynTest):
         async with self.getTestCore() as core:
             async with self.getTestCore() as core2:
 
-                await core2.nodes('[ inet:ipv4=1.2.3.4 ]')
                 url = core2.getLocalUrl('*/layer')
 
                 layriden = core2.view.layers[0].iden
@@ -3819,8 +3818,141 @@ class StormTypesTest(s_test.SynTest):
 
                 layr = core.getLayer(uplayr)
 
-                evnt = await layr.waitUpstreamOffs(layriden, offs)
-                self.true(await asyncio.wait_for(evnt.wait(), timeout=6))
+                async def query(q):
+                    '''
+                    Run a query on core2 and wait for it to sync to layr from core
+                    '''
+                    nodes = await core2.nodes(q)
+                    offs = await core2.view.layers[0].getEditIndx()
+                    evnt = await layr.waitUpstreamOffs(layriden, offs)
+                    self.true(await asyncio.wait_for(evnt.wait(), timeout=6))
+                    return nodes
+
+                vdef = {
+                    'layers': [layr.iden]
+                }
+
+                view00 = await core.addView(vdef)
+                self.nn(view00)
+
+                # No foobar in core
+                opts = {'view': view00.get('iden')}
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(0, nodes)
+
+                # Add foobar in core2
+                nodes = await query('[ it:dev:str=foobar ]')
+                self.len(1, nodes)
+
+                # foobar shows up in core
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(1, nodes)
+
+                self.len(1, layr.activetasks)
+
+                # The upstream key only accepts null
+                q = f'layer.set {uplayr} upstream (true)'
+                msgs = await core.stormlist(q)
+                self.stormIsInErr('Layer only supports setting "mirror" and "upstream" to null.', msgs)
+
+                with self.raises(s_exc.BadOptValu) as exc:
+                    await layr.setLayerInfo('upstream', False)
+                self.eq(exc.exception.get('mesg'), 'Layer only supports setting "mirror" and "upstream" to None.', msgs)
+
+                # Now remove the upstream configuration
+                q = f'layer.set {uplayr} upstream (null)'
+                msgs = await core.stormlist(q)
+                self.stormHasNoWarnErr(msgs)
+
+                layr = core.getLayer(uplayr)
+                self.len(0, layr.activetasks)
+                self.none(layr.layrinfo.get('upstream'))
+
+                with self.raises(TimeoutError):
+                    await query('[ it:dev:str=newp ]')
+
+                # No newp in core because layer upstream is disabled
+                nodes = await core.nodes('it:dev:str=newp', opts=opts)
+                self.len(0, nodes)
+
+    async def test_storm_lib_layer_mirror(self):
+        async with self.getTestCore() as core:
+            async with self.getTestCore() as core2:
+
+                url = core2.getLocalUrl('*/layer')
+
+                layers = set(core.layers.keys())
+                q = f'layer.add --mirror {url}'
+                mesgs = await core.stormlist(q)
+                uplayr = list(set(core.layers.keys()) - layers)[0]
+
+                q = f'layer.set {uplayr} name "woot woot"'
+                mesgs = await core.stormlist(q)
+                self.stormIsInPrint('(name: woot woot)', mesgs)
+
+                layr = core.getLayer(uplayr)
+
+                async def query(q):
+                    '''
+                    Run a query on core2 and wait for it to sync to layr from core
+                    '''
+                    nodes = await core2.nodes(q)
+                    offs = await core2.view.layers[0].getEditOffs()
+                    self.true(await layr.waitEditOffs(offs, timeout=10))
+                    return nodes
+
+                vdef = {
+                    'layers': [layr.iden]
+                }
+
+                view00 = await core.addView(vdef)
+                self.nn(view00)
+
+                # No foobar in core
+                opts = {'view': view00.get('iden')}
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(0, nodes)
+
+                # Add foobar in core2
+                nodes = await query('[ it:dev:str=foobar ]')
+                self.len(1, nodes)
+
+                # foobar shows up in core
+                nodes = await core.nodes('it:dev:str=foobar', opts=opts)
+                self.len(1, nodes)
+
+                self.true(layr.ismirror)
+                self.nn(layr.leadtask)
+                self.nn(layr.leader)
+                self.len(0, layr.activetasks)
+
+                # The mirror key only accepts null
+                q = f'layer.set {uplayr} mirror (true)'
+                msgs = await core.stormlist(q)
+                self.stormIsInErr('Layer only supports setting "mirror" and "upstream" to null.', msgs)
+
+                with self.raises(s_exc.BadOptValu) as exc:
+                    await layr.setLayerInfo('mirror', False)
+                self.eq(exc.exception.get('mesg'), 'Layer only supports setting "mirror" and "upstream" to None.', msgs)
+
+                # Now remove the mirror configuration
+                q = f'layer.set {uplayr} mirror (null)'
+                msgs = await core.stormlist(q)
+                self.stormHasNoWarnErr(msgs)
+
+                layr = core.getLayer(uplayr)
+                self.none(layr.layrinfo.get('mirror'))
+                self.none(layr.leadtask)
+                self.none(layr.leader)
+                self.false(layr.ismirror)
+
+                # Add newp in core2
+                nodes = await query('[ it:dev:str=newp ]')
+                self.len(1, nodes)
+
+                # No newp in core because layer mirroring is disabled
+                nodes = await core.nodes('it:dev:str=newp', opts=opts)
+                self.len(0, nodes)
 
     async def test_storm_lib_view(self):
 

synapse/tests/test_lib_view.py

@@ -310,6 +310,28 @@ class ViewTest(s_t_utils.SynTest):
             # But not the same layer twice
             await self.asyncraises(s_exc.DupIden, core.view.addLayer(layriden))
 
+            # Nodes with a large number of edge edits may be chunked by iterLayerNodeEdits
+            await core.nodes('[ test:str=foo ] for $i in $lib.range(102) {[ test:int=$i ]}')
+
+            vdef2 = await core.view.fork()
+            opts = {'view': vdef2['iden']}
+            await core.nodes('[ test:str=foo +(refs)> { for $i in $lib.range(102) { test:int=$i } } ]', opts=opts)
+
+            strt = core.nexsroot.nexslog.index()
+            await core.nodes('$lib.view.get().merge()', opts=opts)
+
+            self.len(102, await core.nodes('test:str=foo -(refs)> test:int'))
+
+            edits = [edit async for edit in core.nexsroot.nexslog.iter(strt)]
+            self.len(1, edits)
+
+            nodeedit = edits[0][1][2][0]
+
+            # We should have two chunks of edits for the same buid due to the number of edges
+            self.eq(nodeedit[0][0], nodeedit[1][0])
+            self.len(100, nodeedit[0][2])
+            self.len(2, nodeedit[1][2])
+
     async def test_view_merge_ival(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_model_entity.py

@@ -0,0 +1,21 @@
+import synapse.tests.utils as s_test
+
+class EntityModelTest(s_test.SynTest):
+
+    async def test_entity_relationship(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('''[
+                entity:relationship=*
+                    :type=tasks
+                    :period=(2022, ?)
+                    :source={[ ou:org=({"name": "China Ministry of State Security (MSS)"}) ]}
+                    :target={[ risk:threat=({"org:name": "APT34", "reporter:name": "vertex"}) ]}
+            ]''')
+
+            self.len(1, nodes)
+            self.eq(nodes[0].get('type'), 'tasks.')
+            self.eq(nodes[0].get('period'), (1640995200000, 9223372036854775807))
+            self.eq(nodes[0].get('source'), ('ou:org', '3332a704ed21dc3274d5731acc54a0ee'))
+            self.eq(nodes[0].get('target'), ('risk:threat', 'e15738ebae52273300b51c08eaad3a36'))

synapse/tests/test_model_gov_intl.py

@@ -1,6 +1,6 @@
-from synapse.tests.utils import SynTest
+import synapse.tests.utils as s_t_utils
 
-class IntlGovTest(SynTest):
+class IntlGovTest(s_t_utils.SynTest):
 
     async def test_models_intl(self):
 

synapse/tests/test_model_inet.py

@@ -3164,6 +3164,7 @@ class InetModelTest(s_t_utils.SynTest):
                 :creator=$visiiden
                 :platform=$platiden
                 :instance=$instiden
+                :topic=' My Topic   '
             ]
             '''
             opts = {'vars': {
@@ -3175,6 +3176,7 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('inet:service:channel', s_common.guid(('general', 'channel', 'vertex', 'slack'))))
             self.eq(nodes[0].get('name'), 'general')
+            self.eq(nodes[0].get('topic'), 'my topic')
             self.eq(nodes[0].get('period'), (1420070400000, 9223372036854775807))
             self.eq(nodes[0].get('creator'), visiacct.ndef[1])
             self.eq(nodes[0].get('platform'), platform.ndef[1])
@@ -3243,12 +3245,18 @@ class InetModelTest(s_t_utils.SynTest):
                     :group=$devsiden
                     :public=$lib.false
                     :repost=*
+                    :mentions=(
+                        (inet:service:group, $devsiden),
+                        (inet:service:account, $blckiden),
+                        (inet:service:account, $blckiden),
+                    )
                 )
 
                 (inet:service:message=(blackout, visi, 1715856900000, vertex, slack)
                     :type=chat.direct
                     :to=$visiiden
                     :public=$lib.false
+                    :mentions?=((inet:service:message:attachment, $atchiden),)
                 )
 
                 (inet:service:message=(blackout, general, 1715856900000, vertex, slack)
@@ -3296,10 +3304,15 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('group'), devsgrp.ndef[1])
             self.false(nodes[0].get('public'))
             self.eq(nodes[0].get('type'), 'chat.group.')
+            self.eq(
+                nodes[0].get('mentions'),
+                (('inet:service:account', blckacct.ndef[1]), ('inet:service:group', devsgrp.ndef[1]))
+            )
 
             self.eq(nodes[1].get('to'), visiacct.ndef[1])
             self.false(nodes[1].get('public'))
             self.eq(nodes[1].get('type'), 'chat.direct.')
+            self.none(nodes[1].get('mentions'))
 
             self.eq(nodes[2].get('channel'), gnrlchan.ndef[1])
             self.true(nodes[2].get('public'))
@@ -3397,6 +3410,7 @@ class InetModelTest(s_t_utils.SynTest):
             q = '''
             [ inet:service:message=(visi, says, relax)
                 :title="Hehe Haha"
+                :hashtags="#hehe,#haha,#hehe"
                 :thread={[
                     inet:service:thread=*
                         :title="Woot  Woot"
@@ -3410,6 +3424,7 @@ class InetModelTest(s_t_utils.SynTest):
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
+            self.eq(['#haha', '#hehe'], nodes[0].get('hashtags'))
             self.len(1, await core.nodes('inet:service:message=(visi, says, hello) -> inet:service:thread:message'))
             self.len(1, await core.nodes('''
                 inet:service:message:title="hehe haha"

synapse/tests/test_model_media.py

@@ -1,5 +1,6 @@
 import logging
 
+import synapse.exc as s_exc
 import synapse.common as s_common
 
 import synapse.tests.utils as s_t_utils

synapse/tests/test_model_person.py

@@ -151,6 +151,10 @@ class PsModelTest(s_t_utils.SynTest):
                 'users': ('visi', 'invisigoth'),
                 'crypto:address': 'btc/1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2',
                 'langs': (lang00 := s_common.guid(),),
+                'banner': file0,
+                'passwd': 'hunter2',
+                'website': 'https://blogs.vertex.link/brutus',
+                'websites': ('https://foo.com', 'https://bar.com', 'https://foo.com'),
             }
             opts = {'vars': {'valu': con0, 'p': props}}
             q = '''[(ps:contact=$valu
@@ -172,6 +176,10 @@ class PsModelTest(s_t_utils.SynTest):
                     :death:place=$p."death:place" :death:place:loc=$p."death:place:loc"
                     :death:place:name=$p."death:place:name"
                     :service:accounts=(*, *) :langs=$p.langs
+                    :banner=$p.banner
+                    :passwd=$p.passwd
+                    :website=$p.website
+                    :websites=$p.websites
                         )]'''
             nodes = await core.nodes(q, opts=opts)
             self.len(1, nodes)
@@ -215,6 +223,10 @@ class PsModelTest(s_t_utils.SynTest):
             self.eq(node.get('death:place:loc'), 'us.va.reston')
             self.eq(node.get('birth:place:name'), 'reston, va, usa, earth, sol, milkyway')
             self.eq(node.get('death:place:name'), 'reston, va, usa, earth, sol, milkyway')
+            self.eq(node.get('banner'), file0)
+            self.eq(node.get('passwd'), 'hunter2')
+            self.eq(node.get('website'), 'https://blogs.vertex.link/brutus')
+            self.eq(node.get('websites'), ('https://bar.com', 'https://foo.com'))
             self.len(1, await core.nodes('ps:contact :birth:place -> geo:place'))
             self.len(1, await core.nodes('ps:contact :death:place -> geo:place'))
             self.len(2, await core.nodes('ps:contact :service:accounts -> inet:service:account'))