synapse 2.173.1__py311-none-any.whl → 2.175.0__py311-none-any.whl

synapse/tests/test_lib_msgpack.py

@@ -17,6 +17,50 @@ class MsgPackTest(s_t_utils.SynTest):
         byts = s_msgpack._fallback_en(('hehe', 10))
         self.eq(byts, b'\x92\xa4hehe\n')
 
+    def test_msgpack_ext(self):
+        valu = 0xffffffffffffffffffffffffffffffff
+        item = ('woot', valu)
+        byts = s_msgpack.en(item)
+        self.eq(item, s_msgpack.un(byts))
+        self.eq(byts, s_msgpack._fallback_en(item))
+
+        unpk = s_msgpack.Unpk()
+        self.eq(((24, item),), unpk.feed(byts))
+        with self.raises(s_exc.SynErr):
+            s_msgpack._ext_un(99, b'red baloons')
+
+        # Negative number support as well.
+        negvalu = -1 * valu
+        negitem = ('woot', negvalu)
+        negbytes = s_msgpack.en(negitem)
+        self.eq(negitem, s_msgpack.un(negbytes))
+        self.eq(negbytes, s_msgpack._fallback_en(negitem))
+
+        # Check across item.bit_length() boundaries
+        v = 0xffffffffffffffff
+        for i in (1, 0xffffffffffffffff + 1, 0xffffffffffffffff + 2):
+            nv = v + i
+            buf = s_msgpack.en(nv)
+            self.eq(nv, s_msgpack.un(buf))
+        v = -0x8000000000000000
+        for i in (1, 0x7fffffffffffffff, 0x7fffffffffffffff + 1):
+            nv = v - i
+            buf = s_msgpack.en(nv)
+            self.eq(nv, s_msgpack.un(buf))
+
+        # We can also support values > 128 bits in width
+        valu = 0xfffffffffffffffffffffffffffffffff
+        item = ('woot', valu)
+        byts = s_msgpack.en(item)
+        self.eq(item, s_msgpack.un(byts))
+        self.eq(byts, s_msgpack._fallback_en(item))
+
+        negvalu = -1 * valu
+        negitem = ('woot', negvalu)
+        negbytes = s_msgpack.en(negitem)
+        self.eq(negitem, s_msgpack.un(negbytes))
+        self.eq(negbytes, s_msgpack._fallback_en(negitem))
+
     def test_msgpack_un(self):
         item = s_msgpack.un(b'\x92\xa4hehe\n')
         self.eq(item, ('hehe', 10))
@@ -106,8 +150,8 @@ class MsgPackTest(s_t_utils.SynTest):
         self.checkLoadfile(s_msgpack._fallback_en)
 
     def checkTypes(self, enfunc):
-        # This is a future-proofing test for msgpack to ensure that
-        buf = b'\x92\xa4hehe\x85\xa3str\xa41234\xa3int\xcd\x04\xd2\xa5float\xcb@(\xae\x14z\xe1G\xae\xa3bin\xc4\x041234\xa9realworld\xac\xc7\x8b\xef\xbf\xbd\xed\xa1\x82\xef\xbf\xbd\x12'
+        # This is a future-proofing test for msgpack to ensure that we have stability with msgpack-python
+        buf = b'\x92\xa4hehe\x8b\xa3str\xa41234\xa3int\xcd\x04\xd2\xa5float\xcb@(\xae\x14z\xe1G\xae\xa3bin\xc4\x041234\xa9realworld\xac\xc7\x8b\xef\xbf\xbd\xed\xa1\x82\xef\xbf\xbd\x12\xabalmostlarge\xcf\xff\xff\xff\xff\xff\xff\xff\xfe\xb1extlargeThreshold\xcf\xff\xff\xff\xff\xff\xff\xff\xff\xa8extlarge\xc7\t\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\xabalmostsmall\xd3\x80\x00\x00\x00\x00\x00\x00\x01\xb4almostsmallThreshold\xd3\x80\x00\x00\x00\x00\x00\x00\x00\xa8extsmall\xc7\t\x01\xff\x7f\xff\xff\xff\xff\xff\xff\xff'
         struct = (
             'hehe',
             {
@@ -115,7 +159,15 @@ class MsgPackTest(s_t_utils.SynTest):
                 'int': 1234,
                 'float': 12.34,
                 'bin': b'1234',
-                'realworld': '\u01cb\ufffd\ud842\ufffd\u0012'
+                'realworld': '\u01cb\ufffd\ud842\ufffd\u0012',
+                'almostlarge': 0xffffffffffffffff - 1,
+                'extlargeThreshold': 0xffffffffffffffff,
+                # extlarge is handled with our custom extension type
+                'extlarge': 0xffffffffffffffff + 1,
+                'almostsmall': -0x8000000000000000 + 1,
+                'almostsmallThreshold': -0x8000000000000000,
+                # extsmall is handled with our custom extension type
+                'extsmall': -0x8000000000000000 - 1,
             }
         )
         unode = s_msgpack.un(buf)
@@ -135,7 +187,7 @@ class MsgPackTest(s_t_utils.SynTest):
         unpk = s_msgpack.Unpk()
         objs = unpk.feed(buf)
         self.len(1, objs)
-        self.eq(objs[0], (71, struct))
+        self.eq(objs[0], (212, struct))
 
         # Generic isok helper
         self.true(s_msgpack.isok(1))
@@ -148,6 +200,8 @@ class MsgPackTest(s_t_utils.SynTest):
         self.true(s_msgpack.isok([1]))
         self.true(s_msgpack.isok((1,)))
         self.true(s_msgpack.isok({1: 1}))
+        self.true(s_msgpack.isok(0xffffffffffffffff + 1))
+        self.true(s_msgpack.isok(-0x8000000000000000 - 1))
         # unpackage types
         self.false(s_msgpack.isok({1, 2}))  # set
         self.false(s_msgpack.isok(print))  # function
@@ -198,10 +252,6 @@ class MsgPackTest(s_t_utils.SynTest):
         self.raises(s_exc.NotMsgpackSafe, enfunc, {1, 2})
         self.raises(s_exc.NotMsgpackSafe, enfunc, Exception())
         self.raises(s_exc.NotMsgpackSafe, enfunc, s_msgpack.en)
-        # too long
-        with self.raises(s_exc.NotMsgpackSafe) as cm:
-            enfunc({'longlong': 45234928034723904723906})
-        self.isin('OverflowError', cm.exception.get('mesg'))
 
     def test_msgpack_bad_types(self):
         self.checkBadTypes(s_msgpack.en)

synapse/tests/test_lib_nexus.py

@@ -3,7 +3,6 @@ from unittest import mock
 
 import synapse.exc as s_exc
 import synapse.common as s_common
-import synapse.cortex as s_cortex
 
 import synapse.lib.cell as s_cell
 import synapse.lib.nexus as s_nexus
@@ -302,3 +301,47 @@ class NexusTest(s_t_utils.SynTest):
                     with self.raises(s_exc.IsReadOnly):
                         await cell01.sync()
                     self.isin(s_nexus.leaderversion, cell01.nexsroot.writeholds)
+
+    async def test_mirror_nexus_loop_failure(self):
+        with self.getTestDir() as dirn:
+
+            s_common.yamlsave({'nexslog:en': True}, dirn, 'cell.yaml')
+            async with await s_cell.Cell.anit(dirn=dirn) as cell00:
+
+                await cell00.runBackup(name='cell01')
+
+                path = s_common.genpath(dirn, 'backups', 'cell01')
+
+                conf = s_common.yamlload(path, 'cell.yaml')
+                conf['mirror'] = f'cell://{dirn}'
+                s_common.yamlsave(conf, path, 'cell.yaml')
+
+                seen = False
+                restarted = False
+                orig = s_nexus.NexsRoot.delWriteHold
+
+                # Patch NexsRoot.delWriteHold so we can cause an exception in
+                # the setup part of the nexus loop (NexsRoot.runMirrorLoop). The
+                # exception should only happen one time so we can check that the
+                # proxy and the nexus loop were both restarted
+                async def delWriteHold(self, reason):
+                    nonlocal seen
+                    nonlocal restarted
+                    if not seen:
+                        seen = True
+                        raise Exception('Knock over the nexus setup.')
+
+                    restarted = True
+                    return await orig(self, reason)
+
+                with mock.patch('synapse.lib.nexus.NexsRoot.delWriteHold', delWriteHold):
+                    with self.getLoggerStream('synapse.lib.nexus') as stream:
+                        async with await s_cell.Cell.anit(dirn=path) as cell01:
+                            await cell01.sync()
+
+                    stream.seek(0)
+                    data = stream.read()
+                    mesg = 'Unknown error during mirror loop startup: Knock over the nexus setup.'
+                    self.isin(mesg, data)
+
+                self.true(restarted)

synapse/tests/test_lib_storm.py

@@ -1348,6 +1348,12 @@ class StormTest(s_t_utils.SynTest):
 
             self.len(0, await core.nodes('diff', opts=altview))
 
+            await core.nodes('[ ps:contact=* :name=con0 +#con0 +#con0.foo +#conalt ]', opts=altview)
+            await core.nodes('[ ps:contact=* :name=con1 +#con1 +#conalt ]', opts=altview)
+
+            nodes = await core.nodes('diff --tag conalt con1 con0.foo con0 newp', opts=altview)
+            self.sorteq(['con0', 'con1'], [n.get('name') for n in nodes])
+
             q = '''
             [ ou:name=foo +(bar)> {[ ou:name=bar ]} ]
             { for $i in $lib.range(1001) { $node.data.set($i, $i) }}
@@ -1537,6 +1543,112 @@ class StormTest(s_t_utils.SynTest):
             await core.nodes('inet:ssl:cert | merge --apply', opts=altview)
             self.len(1, await core.nodes('inet:ipv4'))
 
+    async def test_storm_merge_perms(self):
+
+        async with self.getTestCore() as core:
+
+            await core.addTagProp('score', ('int', {}), {})
+
+            visi = await core.auth.addUser('visi')
+            opts = {'user': visi.iden}
+
+            view2 = await core.callStorm('return($lib.view.get().fork())')
+            view2opts = opts | {'view': view2['iden']}
+            layr2 = view2['layers'][0]['iden']
+            layr1 = view2['layers'][1]['iden']
+
+            await visi.addRule((True, ('view',)))
+            await visi.addRule((True, ('node', 'add')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'prop', 'set')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'tag', 'add')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'data', 'set')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'edge', 'add')), gateiden=layr2)
+
+            await core.nodes('[ ou:name=test ]')
+
+            await core.nodes('''
+                [ ps:contact=*
+                    :name=test0
+                    +(test)> { ou:name=test }
+                    +#test1.foo=now
+                    +#test2
+                    +#test3:score=42
+                ]
+                $node.data.set(foo, bar)
+            ''', opts=view2opts)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.del.ps:contact', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.add.ps:contact', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'add')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.prop.del.ps:contact..created', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'prop', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.prop.set.ps:contact..created', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'prop', 'set')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test1.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test1', 'foo')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test1.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test1', 'foo')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test3', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test3')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test3', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test3')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test2', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test2')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test2', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test2')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.data.pop.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'data', 'pop')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.data.set.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'data', 'set')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.edge.del.test', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'edge', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.edge.add.test', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'edge', 'add')), gateiden=layr1)
+
+            await core.nodes('ps:contact merge --apply', opts=view2opts)
+
     async def test_storm_movenodes(self):
 
         async with self.getTestCore() as core:
@@ -2283,9 +2395,9 @@ class StormTest(s_t_utils.SynTest):
             msgs = await core.stormlist(f'pkg.load --ssl-noverify https://127.0.0.1:{port}/api/v1/pkgtest/notok')
             self.stormIsInWarn('pkg.load got JSON error: FooBar', msgs)
 
-            replay = s_common.envbool('SYNDEV_NEXUS_REPLAY')
-            nevents = 4 if replay else 2
-            waiter = core.waiter(nevents, 'core:pkg:onload:complete')
+            # onload will on fire once. all other pkg.load events will effectively bounce
+            # because the pkg hasn't changed so no loading occurs
+            waiter = core.waiter(1, 'core:pkg:onload:complete')
 
             with self.getAsyncLoggerStream('synapse.cortex') as stream:
                 msgs = await core.stormlist(f'pkg.load --ssl-noverify https://127.0.0.1:{port}/api/v1/pkgtest/yep')
@@ -2301,10 +2413,10 @@ class StormTest(s_t_utils.SynTest):
             self.isin("No var with name: newp", buf)
             self.len(1, await core.nodes(f'ps:contact={cont}'))
 
-            evnts = await waiter.wait(timeout=2)
-            exp = []
-            for _ in range(nevents):
-                exp.append(('core:pkg:onload:complete', {'pkg': 'testload'}))
+            evnts = await waiter.wait(timeout=4)
+            exp = [
+                ('core:pkg:onload:complete', {'pkg': 'testload'})
+            ]
             self.eq(exp, evnts)
 
     async def test_storm_tree(self):
@@ -2912,27 +3024,30 @@ class StormTest(s_t_utils.SynTest):
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * }'
             nodes = await core.nodes(q)
-            self.len(3, nodes)
+            self.len(4, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * } { -> edge:refs:n2 :n1 -> * }'
             nodes = await core.nodes(q)
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # Queries can be a heavy list
             q = '$list = $lib.list(${ -> * }, ${ <- * }, ${ -> edge:refs:n2 :n1 -> * }) inet:ipv4=1.2.3.4 | tee --join $list'
             nodes = await core.nodes(q)
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # A empty list of queries still works as an nop
             q = '$list = $lib.list() | tee $list'
@@ -2959,11 +3074,12 @@ class StormTest(s_t_utils.SynTest):
             q = 'inet:ipv4=1.2.3.4 | tee --join $list'
             queries = ('-> *', '<- *', '-> edge:refs:n2 :n1 -> *')
             nodes = await core.nodes(q, {'vars': {'list': queries}})
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # Empty queries are okay - they will just return the input node
             q = 'inet:ipv4=1.2.3.4 | tee {}'

synapse/tests/test_lib_stormsvc.py

@@ -2,7 +2,6 @@ import asyncio
 import contextlib
 import synapse.exc as s_exc
 import synapse.common as s_common
-import synapse.cortex as s_cortex
 
 import synapse.tests.utils as s_test
 
@@ -796,56 +795,134 @@ class StormSvcTest(s_test.SynTest):
 
         with self.getTestDir() as dirn:
             async with self.getTestCore(dirn=dirn) as core:
-                with self.getTestDir() as svcd:
-                    async with await ChangingService.anit(svcd) as chng:
-                        chng.dmon.share('chng', chng)
-
-                        root = await chng.auth.getUserByName('root')
-                        await root.setPasswd('root')
-
-                        info = await chng.dmon.listen('tcp://127.0.0.1:0/')
-                        host, port = info
-
-                        curl = f'tcp://root:root@127.0.0.1:{port}/chng'
-
-                        await core.nodes(f'service.add chng {curl}')
-                        await core.nodes('$lib.service.wait(chng)')
-
-                        self.nn(core.getStormCmd('oldcmd'))
-                        self.nn(core.getStormCmd('old.bar'))
-                        self.nn(core.getStormCmd('old.baz'))
-                        self.none(core.getStormCmd('new.baz'))
-                        self.none(core.getStormCmd('runtecho'))
-                        self.none(core.getStormCmd('newcmd'))
-                        self.isin('old', core.stormpkgs)
-                        self.isin('old.bar', core.stormmods)
-                        self.isin('old.baz', core.stormmods)
-                        pkg = await core.getStormPkg('old')
-                        self.eq(pkg.get('version'), '0.0.1')
-
-                        waiter = core.waiter(1, 'stormsvc:client:unready')
-
-                    self.true(await waiter.wait(10))
-                    async with await ChangingService.anit(svcd, {'updated': True}) as chng:
-                        chng.dmon.share('chng', chng)
-                        await chng.dmon.listen(f'tcp://127.0.0.1:{port}/')
-
-                        await core.nodes('$lib.service.wait(chng)')
-
-                        self.nn(core.getStormCmd('newcmd'))
-                        self.nn(core.getStormCmd('new.baz'))
-                        self.nn(core.getStormCmd('old.bar'))
-                        self.nn(core.getStormCmd('runtecho'))
-                        self.none(core.getStormCmd('oldcmd'))
-                        self.none(core.getStormCmd('old.baz'))
-                        self.isin('old', core.stormpkgs)
-                        self.isin('new', core.stormpkgs)
-                        self.isin('echo', core.stormmods)
-                        self.isin('old.bar', core.stormmods)
-                        self.isin('new.baz', core.stormmods)
-                        self.notin('old.baz', core.stormmods)
-                        pkg = await core.getStormPkg('old')
-                        self.eq(pkg.get('version'), '0.1.0')
+                async with core.beholder() as wind:
+                    with self.getTestDir() as svcd:
+                        async with await ChangingService.anit(svcd) as chng:
+                            chng.dmon.share('chng', chng)
+
+                            root = await chng.auth.getUserByName('root')
+                            await root.setPasswd('root')
+
+                            info = await chng.dmon.listen('tcp://127.0.0.1:0/')
+                            host, port = info
+
+                            curl = f'tcp://root:root@127.0.0.1:{port}/chng'
+
+                            await core.nodes(f'service.add chng {curl}')
+                            await core.nodes('$lib.service.wait(chng)')
+
+                            self.nn(core.getStormCmd('oldcmd'))
+                            self.nn(core.getStormCmd('old.bar'))
+                            self.nn(core.getStormCmd('old.baz'))
+                            self.none(core.getStormCmd('new.baz'))
+                            self.none(core.getStormCmd('runtecho'))
+                            self.none(core.getStormCmd('newcmd'))
+                            self.isin('old', core.stormpkgs)
+                            self.isin('old.bar', core.stormmods)
+                            self.isin('old.baz', core.stormmods)
+                            pkg = await core.getStormPkg('old')
+                            self.eq(pkg.get('version'), '0.0.1')
+
+                            waiter = core.waiter(1, 'stormsvc:client:unready')
+
+                        self.true(await waiter.wait(10))
+                        async with await ChangingService.anit(svcd, {'updated': True}) as chng:
+                            chng.dmon.share('chng', chng)
+                            await chng.dmon.listen(f'tcp://127.0.0.1:{port}/')
+
+                            await core.nodes('$lib.service.wait(chng)')
+
+                            self.nn(core.getStormCmd('newcmd'))
+                            self.nn(core.getStormCmd('new.baz'))
+                            self.nn(core.getStormCmd('old.bar'))
+                            self.nn(core.getStormCmd('runtecho'))
+                            self.none(core.getStormCmd('oldcmd'))
+                            self.none(core.getStormCmd('old.baz'))
+                            self.isin('old', core.stormpkgs)
+                            self.isin('new', core.stormpkgs)
+                            self.isin('echo', core.stormmods)
+                            self.isin('old.bar', core.stormmods)
+                            self.isin('new.baz', core.stormmods)
+                            self.notin('old.baz', core.stormmods)
+                            pkg = await core.getStormPkg('old')
+                            self.eq(pkg.get('version'), '0.1.0')
+
+                        async with await ChangingService.anit(svcd, {'updated': False}) as chng:
+                            chng.dmon.share('chng', chng)
+                            await chng.dmon.listen(f'tcp://127.0.0.1:{port}/')
+
+                            await core.nodes('$lib.service.wait(chng)')
+                            self.nn(core.getStormCmd('oldcmd'))
+                            self.nn(core.getStormCmd('old.bar'))
+                            self.nn(core.getStormCmd('old.baz'))
+                            self.none(core.getStormCmd('new.baz'))
+                            self.none(core.getStormCmd('runtecho'))
+                            self.none(core.getStormCmd('newcmd'))
+                            self.isin('old', core.stormpkgs)
+                            self.isin('old.bar', core.stormmods)
+                            self.isin('old.baz', core.stormmods)
+
+                            self.none(await core.getStormPkg('new'))
+
+                            pkg = await core.getStormPkg('old')
+                            self.eq(pkg.get('version'), '0.0.1')
+
+                            svcs = await core.callStorm('return($lib.service.list())')
+                            self.len(1, svcs)
+
+                        async with await ChangingService.anit(svcd, {'updated': True}) as chng:
+                            chng.dmon.share('chng', chng)
+                            await chng.dmon.listen(f'tcp://127.0.0.1:{port}/')
+
+                            await core.nodes('$lib.service.wait(chng)')
+
+                        async with await ChangingService.anit(svcd, {'updated': True}) as chng:
+                            chng.dmon.share('chng', chng)
+                            await chng.dmon.listen(f'tcp://127.0.0.1:{port}/')
+
+                            await core.nodes('$lib.service.wait(chng)')
+
+                events = []
+                async for m in wind:
+                    events.append(m)
+
+                self.len(16, events)
+
+                # updated = false
+                self.eq('svc:set', events[-9]['event'])
+                self.eq('chng', events[-9]['info']['name'])
+                self.eq((0, 0, 1), events[-9]['info']['version'])
+
+                self.eq('pkg:del', events[-8]['event'])
+                self.eq('old', events[-8]['info']['name'])
+
+                self.eq('pkg:add', events[-7]['event'])
+                self.eq('old', events[-7]['info']['name'])
+                self.eq('0.0.1', events[-7]['info']['version'])
+
+                self.eq('pkg:del', events[-6]['event'])
+                self.eq('new', events[-6]['info']['name'])
+
+                # updated = true
+                self.eq('svc:set', events[-5]['event'])
+                self.eq('chng', events[-5]['info']['name'])
+                self.eq((0, 0, 1), events[-5]['info']['version'])
+
+                self.eq('pkg:del', events[-4]['event'])
+                self.eq('old', events[-4]['info']['name'])
+
+                self.eq('pkg:add', events[-3]['event'])
+                self.eq('old', events[-3]['info']['name'])
+                self.eq('0.1.0', events[-3]['info']['version'])
+
+                self.eq('pkg:add', events[-2]['event'])
+                self.eq('new', events[-2]['info']['name'])
+
+                # we get the set to let us know things are back, not no adds since the pkgs are the same
+                # so this is the last
+                self.eq('svc:set', events[-1]['event'])
+                self.eq('chng', events[-1]['info']['name'])
+                self.eq((0, 0, 1), events[-1]['info']['version'])
 
             # This test verifies that storm commands loaded from a previously connected service are still available,
             # even if the service is not available now

synapse/tests/test_lib_stormtypes.py

@@ -322,6 +322,42 @@ class StormTypesTest(s_test.SynTest):
             msgs = await core.stormlist('$lib.debug = (1) hehe.haha')
             self.stormIsInPrint('hehe.haha', msgs)
 
+    async def test_storm_doubleadd_pkg(self):
+        async with self.getTestCore() as core:
+            async with core.beholder() as wind:
+                pkg = {
+                    'name': 'hehe',
+                    'version': '1.1.1',
+                    'modules': [
+                        {'name': 'hehe', 'storm': 'function getDebug() { return($lib.debug) }'},
+                    ],
+                    'commands': [
+                        {'name': 'hehe.haha', 'storm': 'if $lib.debug { $lib.print(hehe.haha) }'},
+                    ],
+                }
+
+                # all but the first of these should bounce
+                for i in range(5):
+                    await core.addStormPkg(pkg)
+
+                pkg['version'] = '1.2.3'
+
+                # all but the first of these should bounce
+                for i in range(5):
+                    await core.addStormPkg(pkg)
+
+            events = []
+            async for m in wind:
+                events.append(m)
+            self.len(2, events)
+            self.eq('pkg:add', events[0]['event'])
+            self.eq('hehe', events[0]['info']['name'])
+            self.eq('1.1.1', events[0]['info']['version'])
+
+            self.eq('pkg:add', events[1]['event'])
+            self.eq('hehe', events[1]['info']['name'])
+            self.eq('1.2.3', events[1]['info']['version'])
+
     async def test_storm_private(self):
         async with self.getTestCore() as core:
             await core.addStormPkg({
@@ -4642,6 +4678,11 @@ class StormTypesTest(s_test.SynTest):
 
             opts = {'vars': {'iden': iden0}}
 
+            # for coverage...
+            self.false(await core.killCronTask('newp'))
+            self.false(await core._killCronTask('newp'))
+            self.false(await core.callStorm(f'return($lib.cron.get({iden0}).kill())'))
+
             cdef = await core.callStorm('return($lib.cron.get($iden).pack())', opts=opts)
             self.eq('mydoc', cdef.get('doc'))
             self.eq('myname', cdef.get('name'))
@@ -4793,12 +4834,10 @@ class StormTypesTest(s_test.SynTest):
                 self.stormIsInErr('does not match', mesgs)
 
                 # Make sure the old one didn't run and the new query ran
+                nextlayroffs = await layr.getEditOffs() + 1
                 unixtime += 60
-                await asyncio.sleep(0)
+                await layr.waitEditOffs(nextlayroffs, timeout=5)
                 self.eq(1, await prox.count('meta:note:type=m1'))
-                # UNG WTF
-                await asyncio.sleep(0)
-                await asyncio.sleep(0)
                 self.eq(1, await prox.count('meta:note:type=m2'))
 
                 # Delete the job