synapse 2.195.0__py311-none-any.whl → 2.196.0__py311-none-any.whl

synapse/tests/test_lib_stormtypes.py

@@ -3,6 +3,7 @@ import bz2
 import gzip
 import json
 import base64
+import struct
 import asyncio
 import hashlib
 import binascii
@@ -6467,13 +6468,29 @@ words\tword\twrd'''
         async with self.getTestCore() as core:
 
             viewiden = await core.callStorm('return($lib.view.get().fork().iden)')
-            await core.nodes('[ ou:org=* :name=foobar +#hehe ]')
+            q = '[ ou:org=* :name=foobar +#hehe ] $node.data.set(foo, bar) return($node.iden())'
+            basenode = await core.callStorm(q)
 
             opts = {'view': viewiden}
-            nodeiden = await core.callStorm('[ ou:org=* :name=foobar +#hehe ] return($node.iden())', opts=opts)
+            nodeiden = await core.callStorm('''
+                [ ou:org=* :name=foobar +#hehe ]
+                $node.data.set(foo, bar)
+                return($node.iden())
+            ''', opts=opts)
+
+            nodeiden2 = await core.callStorm('[test:str=yup] $node.data.set(foo, yup) return ($node.iden())',
+                                             opts=opts)
 
             self.len(2, await core.nodes('ou:org +:name=foobar +#hehe', opts=opts))
 
+            nodes = await core.nodes('yield $lib.layer.get().liftByNodeData(foo)', opts=opts)
+            self.len(2, nodes)
+            self.eq(set((nodeiden, nodeiden2)), {node.iden() for node in nodes})
+
+            nodes = await core.nodes('yield $lib.layer.get().liftByNodeData(foo)')
+            self.len(1, nodes)
+            self.eq(nodes[0].iden(), basenode)
+
             nodes = await core.nodes('yield $lib.layer.get().liftByProp(ou:org)', opts=opts)
             self.len(1, nodes)
             self.eq(nodes[0].iden(), nodeiden)
@@ -6487,7 +6504,7 @@ words\tword\twrd'''
             self.eq(nodes[0].iden(), nodeiden)
 
             nodes = await core.nodes('yield $lib.layer.get().liftByProp(".created")', opts=opts)
-            self.len(1, nodes)
+            self.len(2, nodes)
             self.eq(nodes[0].iden(), nodeiden)
 
             nodes = await core.nodes('yield $lib.layer.get().liftByTag(hehe)', opts=opts)
@@ -7084,3 +7101,73 @@ words\tword\twrd'''
 
             with self.raises(s_exc.BadState):
                 await core.callStorm(merging)
+
+    async def test_storm_lib_axon_read_unpack(self):
+
+        async with self.getTestCore() as core:
+
+            visi = await core.auth.addUser('visi')
+
+            orig_axoninfo = core.axoninfo
+            core.axoninfo = {'features': {}}
+            data = struct.pack('>Q', 1)
+            size, sha256 = await core.axon.put(data)
+            sha256_s = s_common.ehex(sha256)
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            await self.asyncraises(s_exc.FeatureNotSupported,
+                                   core.callStorm(q, opts={'vars': {'sha256': sha256_s}}))
+            core.axoninfo = orig_axoninfo
+
+            data = b'vertex.link'
+            size, sha256 = await core.axon.put(data)
+            sha256_s = s_common.ehex(sha256)
+
+            _, emptyhash = await core.axon.put(b'')
+            emptyhash = s_common.ehex(emptyhash)
+
+            opts = {'user': visi.iden, 'vars': {'sha256': sha256_s, 'emptyhash': emptyhash}}
+            await self.asyncraises(s_exc.AuthDeny,
+                core.callStorm('return($lib.axon.read($sha256, offs=3, size=3))', opts=opts))
+            await visi.addRule((True, ('storm', 'lib', 'axon', 'get')))
+
+            q = 'return($lib.axon.read($sha256, offs=3, size=3))'
+            self.eq(b'tex', await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=7, size=4))'
+            self.eq(b'link', await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=11, size=1))'
+            self.eq(b'', await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.read($emptyhash))'
+            self.eq(b'', await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.read($sha256, size=0))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, offs=-1, size=1))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.read($sha256, size=2097152))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+            intdata = struct.pack('>QQQ', 1, 2, 3)
+            size, sha256 = await core.axon.put(intdata)
+            sha256_s = s_common.ehex(sha256)
+            opts = {'user': visi.iden, 'vars': {'sha256': sha256_s}}
+
+            await visi.delRule((True, ('storm', 'lib', 'axon', 'get')))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            await self.asyncraises(s_exc.AuthDeny, core.callStorm(q, opts=opts))
+            await visi.addRule((True, ('storm', 'lib', 'axon', 'get')))
+
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q"))'
+            self.eq((1,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=8))'
+            self.eq((2,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=16))'
+            self.eq((3,), await core.callStorm(q, opts=opts))
+            q = 'return($lib.axon.unpack($sha256, fmt=">QQ", offs=8))'
+            self.eq((2, 3), await core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.unpack($sha256, fmt="not a valid format"))'
+            await self.asyncraises(s_exc.BadArg, core.callStorm(q, opts=opts))
+
+            q = 'return($lib.axon.unpack($sha256, fmt=">Q", offs=24))'
+            await self.asyncraises(s_exc.BadDataValu, core.callStorm(q, opts=opts))

synapse/tests/test_model_base.py

@@ -227,6 +227,7 @@ class BaseTest(s_t_utils.SynTest):
                     :name="FOO Bar"
                     :type=osint
                     :url="https://foo.bar/index.html"
+                    :ingest:cursor="Woot Woot "
                     :ingest:latest=20241205
                     :ingest:offset=17
                 ]
@@ -238,6 +239,7 @@ class BaseTest(s_t_utils.SynTest):
             self.eq(sorc.get('name'), 'foo bar')
             self.eq(sorc.get('url'), 'https://foo.bar/index.html')
             self.eq(sorc.get('ingest:offset'), 17)
+            self.eq(sorc.get('ingest:cursor'), 'Woot Woot ')
             self.eq(sorc.get('ingest:latest'), 1733356800000)
 
             valu = (sorc.ndef[1], ('inet:fqdn', 'woot.com'))

synapse/tests/test_model_infotech.py

@@ -342,6 +342,7 @@ class InfotechModelTest(s_t_utils.SynTest):
                     :verdict=suspicious
                     :scanner={[ it:prod:softver=* :name="visi scan" ]}
                     :scanner:name="visi scan"
+                    :categories=("Foo  Bar", "baz faz")
                     :signame=omgwtfbbq
                     :target:file=*
                     :target:proc={[ it:exec:proc=* :cmd="foo.exe --bar" ]}
@@ -367,6 +368,7 @@ class InfotechModelTest(s_t_utils.SynTest):
             self.eq(0x01020304, nodes[0].get('target:ipv4'))
             self.eq('::1', nodes[0].get('target:ipv6'))
             self.eq('omgwtfbbq', nodes[0].get('signame'))
+            self.eq(('baz faz', 'foo bar'), nodes[0].get('categories'))
 
             self.len(1, await core.nodes('it:av:scan:result:scanner:name="visi scan" -> it:host'))
             self.len(1, await core.nodes('it:av:scan:result:scanner:name="visi scan" -> inet:url'))
@@ -617,11 +619,36 @@ class InfotechModelTest(s_t_utils.SynTest):
             node = nodes[0]
             self.eq(node.ndef, ('it:dev:int', 1640531528))
 
-            nodes = await core.nodes('[it:sec:cve=CVE-2013-9999 :desc="Some words."]')
+            nodes = await core.nodes('''[
+                it:sec:cve=CVE-2013-9999
+                    :desc="Some words."
+
+                    :nist:nvd:source=NistSource
+                    :nist:nvd:published=2021-10-11
+                    :nist:nvd:modified=2021-10-11
+
+                    :cisa:kev:name=KevName
+                    :cisa:kev:desc=KevDesc
+                    :cisa:kev:action=KevAction
+                    :cisa:kev:vendor=KevVendor
+                    :cisa:kev:product=KevProduct
+                    :cisa:kev:added=2022-01-02
+                    :cisa:kev:duedate=2022-01-02
+            ]''')
             self.len(1, nodes)
             node = nodes[0]
             self.eq(node.ndef, ('it:sec:cve', 'cve-2013-9999'))
             self.eq(node.get('desc'), 'Some words.')
+            self.eq(node.get('nist:nvd:source'), 'nistsource')
+            self.eq(node.get('nist:nvd:published'), 1633910400000)
+            self.eq(node.get('nist:nvd:modified'), 1633910400000)
+            self.eq(node.get('cisa:kev:name'), 'KevName')
+            self.eq(node.get('cisa:kev:desc'), 'KevDesc')
+            self.eq(node.get('cisa:kev:action'), 'KevAction')
+            self.eq(node.get('cisa:kev:vendor'), 'kevvendor')
+            self.eq(node.get('cisa:kev:product'), 'kevproduct')
+            self.eq(node.get('cisa:kev:added'), 1641081600000)
+            self.eq(node.get('cisa:kev:duedate'), 1641081600000)
 
             nodes = await core.nodes('[it:sec:cve=$valu]', opts={'vars': {'valu': 'CVE\u20122013\u20131138'}})
             self.len(1, nodes)

synapse/tests/test_model_orgs.py

@@ -640,6 +640,7 @@ class OuModelTest(s_t_utils.SynTest):
                 ou:contest:result=(*, *)
                     :rank=1
                     :score=20
+                    :period=(20250101, 20250102)
                     :url=http://vertex.link/contest/result
             ]''')
             self.len(1, nodes)
@@ -647,6 +648,7 @@ class OuModelTest(s_t_utils.SynTest):
             self.nn(nodes[0].get('participant'))
             self.eq(1, nodes[0].get('rank'))
             self.eq(20, nodes[0].get('score'))
+            self.eq((1735689600000, 1735776000000), nodes[0].get('period'))
             self.eq('http://vertex.link/contest/result', nodes[0].get('url'))
             self.len(1, await core.nodes('ou:contest:result -> ps:contact'))
             self.len(1, await core.nodes('ou:contest:result -> ou:contest'))

synapse/tests/test_model_risk.py

@@ -111,12 +111,14 @@ class RiskModelTest(s_t_utils.SynTest):
                 :cvss:v3 ?= "newp3.1"
                 :priority=high
                 :severity=high
+                :tag=cno.vuln.woot
             ]''')
 
             self.none(node.get('cvss:v2'))
             self.none(node.get('cvss:v3'))
             self.eq(40, node.get('severity'))
             self.eq(40, node.get('priority'))
+            self.eq('cno.vuln.woot', node.get('tag'))
 
             with self.raises(s_exc.BadTypeValu):
                 node = await addNode(f'''[

synapse/tests/test_model_transport.py

@@ -110,6 +110,7 @@ class TransportTest(s_test.SynTest):
             self.nn(vessel.get('operator'))
 
             self.len(1, await core.nodes('transport:sea:vessel:imo^="IMO 123"'))
+            self.len(1, await core.nodes('transport:sea:vessel :name -> entity:name'))
             self.len(1, await core.nodes('transport:sea:vessel -> transport:sea:vessel:type:taxonomy'))
 
             seatelem = (await core.nodes('''[

synapse/tests/test_telepath.py

@@ -54,6 +54,9 @@ class Beep:
     def beep(self):
         return f'{self.path}: beep'
 
+    def genbeep(self):
+        yield self.beep()
+
 class Foo:
 
     def __init__(self):
@@ -138,6 +141,9 @@ class TeleApi:
     def getFooBar(self, x, y):
         return x - y
 
+    def genGetFooBar(self, x, y):
+        yield self.getFooBar(x, y)
+
     async def customshare(self):
         return await CustomShare.anit(self.link, 42)
 
@@ -160,6 +166,11 @@ class TeleAware(s_telepath.Aware):
 
         return self._initBeep(path[0])
 
+    async def getTeleFeats(self):
+        return {
+            'aware': 1,
+        }
+
 class TeleAuth(s_telepath.Aware):
 
     def getTeleApi(self, link, mesg, path):
@@ -632,7 +643,15 @@ class TeleTest(s_t_utils.SynTest):
                 self.len(1, snfo)
                 self.eq(snfo[0].get('items'), {None: 'synapse.tests.test_telepath.TeleApi'})
 
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
+
+                self.true(proxy._hasTeleMeth('getFooBar'))
+                self.false(proxy._hasTeleMeth('getBarBaz'))
+
                 self.eq(10, await proxy.getFooBar(20, 10))
+                self.eq([10], [m async for m in await proxy.genGetFooBar(20, 10)])
 
                 # check a custom share works
                 obj = await proxy.customshare()
@@ -674,7 +693,14 @@ class TeleTest(s_t_utils.SynTest):
 
             # check that a dynamic share works
             async with await self.getTestProxy(dmon, 'woke/up') as proxy:
+                self.isin('synapse.tests.test_telepath.Beep', proxy._getClasses())
+                self.notin('synapse.tests.test_telepath.TeleApi', proxy._getClasses())
                 self.eq('up: beep', await proxy.beep())
+                self.eq(['up: beep'], [m async for m in await proxy.genbeep()])
+                # Telepath features are a function of the base object, not the result of getTeleApi
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
 
     async def test_telepath_auth(self):
 

synapse/tests/test_tools_aha.py

@@ -3,14 +3,17 @@ import shutil
 
 from unittest import mock
 
+import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.lib.cell as s_cell
+import synapse.lib.version as s_version
 
 import synapse.tests.utils as s_t_utils
 
 import synapse.tools.aha.list as s_a_list
 import synapse.tools.aha.clone as s_a_clone
 import synapse.tools.aha.enroll as s_a_enroll
+import synapse.tools.aha.mirror as s_a_mirror
 import synapse.tools.aha.easycert as s_a_easycert
 import synapse.tools.aha.provision.user as s_a_provision_user
 
@@ -170,3 +173,192 @@ class AhaToolsTest(s_t_utils.SynTest):
 
                 teleyaml = s_common.yamlload(syndir, 'telepath.yaml')
                 self.eq(teleyaml.get('version'), 1)
+
+    async def test_aha_mirror(self):
+
+        async with self.getTestAha() as aha:
+
+            base_svcinfo = {
+                'iden': 'test_iden',
+                'leader': 'leader',
+                'urlinfo': {
+                    'scheme': 'tcp',
+                    'host': '127.0.0.1',
+                    'port': 0,
+                    'hostname': 'test.host'
+                }
+            }
+
+            conf_no_iden = {'aha:provision': await aha.addAhaSvcProv('no.iden')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_iden) as cell_no_iden:
+                svcinfo = {k: v for k, v in base_svcinfo.items() if k != 'iden'}
+                await aha.addAhaSvc('no.iden', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.iden', str(outp))
+
+            conf_no_host = {'aha:provision': await aha.addAhaSvcProv('no.host')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_host) as cell_no_host:
+                svcinfo = dict(base_svcinfo)
+                svcinfo['urlinfo'] = {k: v for k, v in base_svcinfo['urlinfo'].items() if k != 'hostname'}
+                await aha.addAhaSvc('no.host', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.host', str(outp))
+
+            conf_no_leader = {'aha:provision': await aha.addAhaSvcProv('no.leader')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_leader) as cell_no_leader:
+                svcinfo = {k: v for k, v in base_svcinfo.items() if k != 'leader'}
+                await aha.addAhaSvc('no.leader', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.leader', str(outp))
+
+            conf_no_primary = {'aha:provision': await aha.addAhaSvcProv('no.primary')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_primary) as cell_no_primary:
+                svcinfo = dict(base_svcinfo)
+                svcinfo['urlinfo']['hostname'] = 'nonexistent.host'
+                await aha.addAhaSvc('no.primary', svcinfo)
+
+            async with aha.waiter(3, 'aha:svcadd', timeout=10):
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('00.cell')}
+                cell00 = await aha.enter_context(self.getTestCell(conf=conf))
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('01.cell', {'mirror': 'cell'})}
+                cell01 = await aha.enter_context(self.getTestCell(conf=conf))
+
+                await cell01.sync()
+
+            ahaurl = aha.getLocalUrl()
+
+            argv = ['--url', ahaurl]
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 0)
+            outp.expect('Service Mirror Groups:')
+            outp.expect('00.cell.synapse')
+            outp.expect('01.cell.synapse')
+            outp.expect('Group Status: In Sync')
+
+            argv = ['--url', ahaurl, '--timeout', '30']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 0)
+
+            with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          return_value=False):
+                argv = ['--url', ahaurl]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 1)
+                outp.expect(f'Service at {ahaurl} does not support the required callpeers feature.')
+
+            with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          side_effect=s_exc.NoSuchMeth(name='_hasTeleFeat')):
+                argv = ['--url', ahaurl]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 1)
+                outp.expect(f'Service at {ahaurl} does not support the required callpeers feature.')
+
+            argv = ['--url', 'tcp://newp:1234/']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 1)
+            outp.expect('ERROR:')
+
+            async def mockCellInfo():
+                return {
+                    'cell': {'ready': True, 'nexsindx': 10, 'uplink': None},
+                    'synapse': {'verstring': s_version.verstring},
+                }
+
+            async def mockOutOfSyncCellInfo():
+                return {
+                    'cell': {'ready': True, 'nexsindx': 5, 'uplink': cell00.iden},
+                    'synapse': {'verstring': s_version.verstring},
+                }
+
+            with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                    async def mock_call_aha(*args, **kwargs):
+                        todo = args[1]
+                        if todo[0] == 'waitNexsOffs':
+                            yield ('00.cell.synapse', (True, True))
+                            yield ('01.cell.synapse', (True, True))
+                        elif todo[0] == 'getCellInfo':
+                            if not hasattr(mock_call_aha, 'called'):
+                                mock_call_aha.called = True
+                                yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                yield ('01.cell.synapse', (True, await mockOutOfSyncCellInfo()))
+                            else:
+                                yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                yield ('01.cell.synapse', (True, await mockCellInfo()))
+
+                    with mock.patch.object(aha, 'callAhaPeerApi', mock_call_aha):
+                        argv = ['--url', ahaurl, '--wait']
+                        retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                        self.eq(retn, 0)
+                        outp.expect('Group Status: Out of Sync')
+                        outp.expect('Updated status:')
+                        outp.expect('Group Status: In Sync')
+
+            with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                    argv = ['--url', ahaurl, '--timeout', '1']
+                    retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                    self.eq(retn, 0)
+                    outp.expect('Group Status: Out of Sync')
+
+            async with self.getTestCore() as core:
+                curl = core.getLocalUrl()
+                argv = ['--url', curl]
+                with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          return_value=True):
+                    retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                    self.eq(1, retn)
+                    outp.expect(f'Service at {curl} is not an Aha server')
+
+            async with aha.waiter(1, 'aha:svcadd', timeout=10):
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('02.cell', {'mirror': 'cell'})}
+                cell02 = await aha.enter_context(self.getTestCell(conf=conf))
+                await cell02.sync()
+
+            async def mock_failed_api(*args, **kwargs):
+                yield ('00.cell.synapse', (True, {'cell': {'ready': True, 'nexsindx': 10}}))
+                yield ('01.cell.synapse', (False, 'error'))
+                yield ('02.cell.synapse', (True, {'cell': {'ready': True, 'nexsindx': 12}}))
+
+            with mock.patch.object(aha, 'callAhaPeerApi', mock_failed_api):
+                argv = ['--url', ahaurl, '--timeout', '1']
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                outp.expect('00.cell.synapse                          leader     True     True    127.0.0.1', whitespace=False)
+                outp.expect('nexsindx      10', whitespace=False)
+                outp.expect('02.cell.synapse                          leader     True     True    127.0.0.1', whitespace=False)
+                outp.expect('nexsindx      12', whitespace=False)
+                outp.expect('01.cell.synapse                          <unknown>  True     True', whitespace=False)
+                outp.expect('<unknown>    <unknown>', whitespace=False)
+
+        self.eq(s_a_mirror.timeout_type('30'), 30)
+        self.eq(s_a_mirror.timeout_type('0'), 0)
+
+        with self.raises(s_exc.BadArg) as cm:
+            s_a_mirror.timeout_type('-1')
+        self.isin('is not a valid non-negative integer', cm.exception.get('mesg'))
+
+        with self.raises(s_exc.BadArg) as cm:
+            s_a_mirror.timeout_type('foo')
+        self.isin('is not a valid non-negative integer', cm.exception.get('mesg'))
+
+        synerr = s_exc.SynErr(mesg='Oof')
+        with mock.patch('synapse.telepath.openurl', side_effect=synerr):
+            argv = ['--url', 'tcp://test:1234/']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 1)
+            outp.expect('ERROR: Oof')