Test failures with Python 3.13 #45

$ uv venv -p 3.13
Using CPython 3.13.2 interpreter at: /usr/bin/python3.13
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate
$ uv pip install -e . pytest
Resolved 5 packages in 522ms
      Built ioflo @ file:///tmp/ioflo
Prepared 1 package in 604ms
░░░░░░░░░░░░░░░░░░░░ [0/5] Installing wheels...                                                                                        warning: Failed to hardlink files; falling back to full copy. This may lead to degraded performance.
         If the cache and target directories are on different filesystems, hardlinking may not be supported.
         If this is intentional, set `export UV_LINK_MODE=copy` or use `--link-mode=copy` to suppress this warning.
Installed 5 packages in 4ms
 + iniconfig==2.0.0
 + ioflo==2.0.3 (from file:///tmp/ioflo)
 + packaging==24.2
 + pluggy==1.5.0
 + pytest==8.3.5
$ uv run pytest --ignore ioflo/aio/tcp/test/test_tcping.py
========================================================= test session starts =========================================================
platform linux -- Python 3.13.2, pytest-8.3.5, pluggy-1.5.0
rootdir: /tmp/ioflo
collected 117 items                                                                                                                   

ioflo/aid/test/test_aiding.py .                                                                                                 [  0%]
ioflo/aid/test/test_blending.py .                                                                                               [  1%]
ioflo/aid/test/test_byting.py .....                                                                                             [  5%]
ioflo/aid/test/test_classing.py .....                                                                                           [ 10%]
ioflo/aid/test/test_eventing.py ...                                                                                             [ 12%]
ioflo/aid/test/test_odicting.py ...                                                                                             [ 15%]
ioflo/aid/test/test_osetting.py .                                                                                               [ 16%]
ioflo/aid/test/test_quating.py ....                                                                                             [ 19%]
ioflo/aid/test/test_sixing.py .                                                                                                 [ 20%]
ioflo/aid/test/test_timing.py ....                                                                                              [ 23%]
ioflo/aid/test/test_vectoring.py .........                                                                                      [ 31%]
ioflo/aio/http/test/test_clienting.py ..FFFFFFFFF....FFFFFFFF.                                                                  [ 52%]
ioflo/aio/http/test/test_serving.py .F.F......                                                                                  [ 60%]
ioflo/aio/proto/test/test_devicing.py ..                                                                                        [ 62%]
ioflo/aio/proto/test/test_exchanging.py .                                                                                       [ 63%]
ioflo/aio/proto/test/test_packeting.py .....                                                                                    [ 67%]
ioflo/aio/proto/test/test_stacking.py ......                                                                                    [ 72%]
ioflo/aio/serial/test/test_serialing.py .                                                                                       [ 73%]
ioflo/aio/test/test_aioing.py .                                                                                                 [ 74%]
ioflo/aio/test/test_wiring.py ..                                                                                                [ 76%]
ioflo/aio/udp/test/test_udping.py ..                                                                                            [ 77%]
ioflo/aio/uxd/test/test_uxding.py .                                                                                             [ 78%]
ioflo/aio/win/test/test_wining.py .                                                                                             [ 79%]
ioflo/base/test/test_acting.py FFF                                                                                              [ 82%]
ioflo/base/test/test_globaling.py .                                                                                             [ 82%]
ioflo/base/test/test_logging.py ...............                                                                                 [ 95%]
ioflo/base/test/test_storing.py .....                                                                                           [100%]

============================================================== FAILURES ===============================================================
_____________________________________________ BasicTestCase.testNonBlockingRequestEchoTLS _____________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestEchoTLS>

    def testNonBlockingRequestEchoTLS(self):
        """
        Test NonBlocking HTTPS (TLS/SSL) client
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestEchoTLS.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True,  same=True)
        result = wireLogBeta.reopen()
    
        #serverKeypath = '/etc/pki/tls/certs/server_key.pem'  # local server private key
        #serverCertpath = '/etc/pki/tls/certs/server_cert.pem'  # local server public cert
        #clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
    
        #clientKeypath = '/etc/pki/tls/certs/client_key.pem'  # local client private key
        #clientCertpath = '/etc/pki/tls/certs/client_cert.pem'  # local client public cert
        #serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
    
        serverKeypath = self.certdirpath + '/server_key.pem'  # local server private key
        serverCertpath = self.certdirpath + '/server_cert.pem'  # local server public cert
        clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
    
        clientKeypath = self.certdirpath + '/client_key.pem'  # local client private key
        clientCertpath = self.certdirpath + '/client_cert.pem'  # local client public cert
        serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
    
        alpha = tcp.ServerTls(host='localhost',
                                      port = 6101,
                                      bufsize=131072,
                                      wlog=wireLogAlpha,
                                      context=None,
                                      version=None,
                                      certify=None,
                                      keypath=serverKeypath,
                                      certpath=serverCertpath,
                                      cafilepath=clientCafilepath,
                                      )
        self.assertIs(alpha.reopen(), True)
        self.assertEqual(alpha.ha, ('127.0.0.1', 6101))
        self.assertEqual(alpha.eha, ('127.0.0.1', 6101))
    
        serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
    
        beta = tcp.ClientTls(ha=alpha.ha,
                                      bufsize=131072,
                                      wlog=wireLogBeta,
                                      context=None,
                                      version=None,
                                      certify=None,
                                      hostify=None,
                                      certedhost=serverCertCommonName,
                                      keypath=clientKeypath,
                                      certpath=clientCertpath,
                                      cafilepath=serverCafilepath,
                                      )
        self.assertIs(beta.reopen(), True)
        self.assertIs(beta.accepted, False)
        self.assertIs(beta.connected, False)
        self.assertIs(beta.cutoff, False)
    
        console.terse("Connecting  and Handshaking beta to alpha\n")
        while True:
>           beta.serviceConnect()

ioflo/aio/http/test/test_clienting.py:1198: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
ioflo/aio/tcp/clienting.py:307: in serviceConnect
    self.connect()
ioflo/aio/tcp/clienting.py:640: in connect
    self.handshake()
ioflo/aio/tcp/clienting.py:602: in handshake
    self.cs.do_handshake()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <ssl.SSLSocket [closed] fd=-1, family=2, type=1, proto=0>, block = False

    @_sslcopydoc
    def do_handshake(self, block=False):
        self._check_connected()
        timeout = self.gettimeout()
        try:
            if timeout == 0.0 and block:
                self.settimeout(None)
>           self._sslobj.do_handshake()
E           ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)

/usr/lib/python3.13/ssl.py:1372: SSLCertVerificationError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking HTTPS (TLS/SSL) client

      Added node .meta to Store3
      Added share time to store Store3
      Added share realtime to store Store3
      Added share datetime to store Store3
      Added node .meta to Store4
      Added share time to store Store4
      Added share realtime to store Store4
      Added share datetime to store Store4
Connecting  and Handshaking beta to alpha
_____________________________________________ BasicTestCase.testNonBlockingRequestStream ______________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStream>

    def testNonBlockingRequestStream(self):
        """
        Test NonBlocking Http client with SSE streaming server
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStream.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:206: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client with SSE streaming server

      Added node .meta to Store5
      Added share time to store Store5
      Added share realtime to store Store5
      Added share datetime to store Store5
socket.error = [Errno 98] Address already in use
__________________________________________ BasicTestCase.testNonBlockingRequestStreamChunked __________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStreamChunked>

    def testNonBlockingRequestStreamChunked(self):
        """
        Test NonBlocking Http client with SSE streaming server with transfer encoding (chunked)
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStreamChunked.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:359: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client with SSE streaming server with transfer encoding (chunked)

      Added node .meta to Store6
      Added share time to store Store6
      Added share realtime to store Store6
      Added share datetime to store Store6
socket.error = [Errno 98] Address already in use
___________________________________________ BasicTestCase.testNonBlockingRequestStreamFancy ___________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStreamFancy>

    def testNonBlockingRequestStreamFancy(self):
        """
        Test NonBlocking Http client to SSE server
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStreamFancy.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:512: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client to SSE server

      Added node .meta to Store7
      Added share time to store Store7
      Added share realtime to store Store7
      Added share datetime to store Store7
socket.error = [Errno 98] Address already in use
_______________________________________ BasicTestCase.testNonBlockingRequestStreamFancyChunked ________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStreamFancyChunked>

    def testNonBlockingRequestStreamFancyChunked(self):
        """
        Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStreamFancyChunked.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:666: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding

      Added node .meta to Store8
      Added share time to store Store8
      Added share realtime to store Store8
      Added share datetime to store Store8
socket.error = [Errno 98] Address already in use
_________________________________________ BasicTestCase.testNonBlockingRequestStreamFancyJson _________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStreamFancyJson>

    def testNonBlockingRequestStreamFancyJson(self):
        """
        Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStreamFancyJson.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:832: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding

      Added node .meta to Store9
      Added share time to store Store9
      Added share realtime to store Store9
      Added share datetime to store Store9
socket.error = [Errno 98] Address already in use
_____________________________________ BasicTestCase.testNonBlockingRequestStreamFancyJsonChunked ______________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testNonBlockingRequestStreamFancyJsonChunked>

    def testNonBlockingRequestStreamFancyJsonChunked(self):
        """
        Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding
        """
        console.terse("{0}\n".format(self.testNonBlockingRequestStreamFancyJsonChunked.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        wireLogBeta = wiring.WireLog(buffify=True, same=True)
        result = wireLogBeta.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:988: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test NonBlocking Http client to server Fancy SSE with chunked transfer encoding

      Added node .meta to Store10
      Added share time to store Store10
      Added share realtime to store Store10
      Added share datetime to store Store10
socket.error = [Errno 98] Address already in use
_______________________________________________ BasicTestCase.testPatronEchoSimpleFirst _______________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronEchoSimpleFirst>

    def testPatronEchoSimpleFirst(self):
        """
        Test Patron Simple First time request pattern
        """
        console.terse("{0}\n".format(self.testPatronEchoSimpleFirst.__doc__))
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:1974: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron Simple First time request pattern

      Added node .meta to Store11
      Added share time to store Store11
      Added share realtime to store Store11
      Added share datetime to store Store11
socket.error = [Errno 98] Address already in use
________________________________________________ BasicTestCase.testPatronPipelineEcho _________________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronPipelineEcho>

    def testPatronPipelineEcho(self):
        """
        Test Patron pipeline servicing
        """
        console.terse("{0}\n".format(self.testPatronPipelineEcho.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:1570: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron pipeline servicing

      Added node .meta to Store12
      Added share time to store Store12
      Added share realtime to store Store12
      Added share datetime to store Store12
socket.error = [Errno 98] Address already in use
__________________________________________ BasicTestCase.testPatronPipelineEchoSimpleSecure ___________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronPipelineEchoSimpleSecure>

    def testPatronPipelineEchoSimpleSecure(self):
        """
        Test Patron pipeline servicing
        """
        console.terse("{0}\n".format(self.testPatronPipelineEchoSimpleSecure.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        #serverKeypath = '/etc/pki/tls/certs/server_key.pem'  # local server private key
        #serverCertpath = '/etc/pki/tls/certs/server_cert.pem'  # local server public cert
        #clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
    
        #clientKeypath = '/etc/pki/tls/certs/client_key.pem'  # local client private key
        #clientCertpath = '/etc/pki/tls/certs/client_cert.pem'  # local client public cert
        #serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
    
        serverKeypath = self.certdirpath + '/server_key.pem'  # local server private key
        serverCertpath = self.certdirpath + '/server_cert.pem'  # local server public cert
        clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
    
        clientKeypath = self.certdirpath + '/client_key.pem'  # local client private key
        clientCertpath = self.certdirpath + '/client_cert.pem'  # local client public cert
        serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
    
        serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
    
        alpha = tcp.ServerTls(host=serverCertCommonName,
                                      port = 6101,
                                      bufsize=131072,
                                      wlog=wireLogAlpha,
                                      context=None,
                                      version=None,
                                      certify=None,
                                      keypath=serverKeypath,
                                      certpath=serverCertpath,
                                      cafilepath=clientCafilepath,
                                      )
        self.assertIs(alpha.reopen(), True)
        self.assertEqual(alpha.ha, ('127.0.0.1', 6101))
        self.assertEqual(alpha.eha, ('127.0.0.1', 6101))
    
        console.terse("{0}\n".format("Building Patron ...\n"))
    
        wireLogBeta = wiring.WireLog(buffify=True,  same=True)
        result = wireLogBeta.reopen()
        host = alpha.eha[0]
        port = alpha.eha[1]
    
        beta = clienting.Patron(hostname=serverCertCommonName,
                              port=alpha.eha[1],
                              bufsize=131072,
                              wlog=wireLogBeta,
                              scheme='https',
                              reconnectable=True,
                              certedhost=serverCertCommonName,
                              keypath=clientKeypath,
                              certpath=clientCertpath,
                              cafilepath=serverCafilepath,
                            )
    
        self.assertIs(beta.connector.reopen(), True)
        self.assertIs(beta.connector.accepted, False)
        self.assertIs(beta.connector.connected, False)
        self.assertIs(beta.connector.cutoff, False)
    
        request = odict([('method', u'GET'),
                         ('path', u'/echo?name=fame'),
                         ('qargs', odict()),
                         ('fragment', u''),
                         ('headers', odict([('Accept', 'application/json')])),
                         ('body', None),
                        ])
    
        beta.requests.append(request)
    
        while (not alpha.ixes or beta.requests or
               beta.connector.txes or not beta.respondent.ended):
            self.mockEchoServiceSecure(alpha)
            time.sleep(0.05)
>           beta.serviceAll()

ioflo/aio/http/test/test_clienting.py:2967: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
ioflo/aio/http/clienting.py:1129: in serviceAll
    self.connector.serviceConnect()
ioflo/aio/tcp/clienting.py:307: in serviceConnect
    self.connect()
ioflo/aio/tcp/clienting.py:640: in connect
    self.handshake()
ioflo/aio/tcp/clienting.py:602: in handshake
    self.cs.do_handshake()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <ssl.SSLSocket [closed] fd=-1, family=2, type=1, proto=0>, block = False

    @_sslcopydoc
    def do_handshake(self, block=False):
        self._check_connected()
        timeout = self.gettimeout()
        try:
            if timeout == 0.0 and block:
                self.settimeout(None)
>           self._sslobj.do_handshake()
E           ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)

/usr/lib/python3.13/ssl.py:1372: SSLCertVerificationError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron pipeline servicing

      Added node .meta to Store21
      Added share time to store Store21
      Added share realtime to store Store21
      Added share datetime to store Store21
Building Patron ...

      Added node .meta to Store22
      Added share time to store Store22
      Added share realtime to store Store22
      Added share datetime to store Store22
________________________________________ BasicTestCase.testPatronPipelineEchoSimpleSecurePath _________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronPipelineEchoSimpleSecurePath>

    def testPatronPipelineEchoSimpleSecurePath(self):
        """
        Test Patron pipeline servicing
        """
        console.terse("{0}\n".format(self.testPatronPipelineEchoSimpleSecurePath.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        #serverKeypath = '/etc/pki/tls/certs/server_key.pem'  # local server private key
        #serverCertpath = '/etc/pki/tls/certs/server_cert.pem'  # local server public cert
        #clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
    
        #clientKeypath = '/etc/pki/tls/certs/client_key.pem'  # local client private key
        #clientCertpath = '/etc/pki/tls/certs/client_cert.pem'  # local client public cert
        #serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
    
        serverKeypath = self.certdirpath + '/server_key.pem'  # local server private key
        serverCertpath = self.certdirpath + '/server_cert.pem'  # local server public cert
        clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
    
        clientKeypath = self.certdirpath + '/client_key.pem'  # local client private key
        clientCertpath = self.certdirpath + '/client_cert.pem'  # local client public cert
        serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
    
        serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
    
        alpha = tcp.ServerTls(host=serverCertCommonName,
                                      port = 6101,
                                      bufsize=131072,
                                      wlog=wireLogAlpha,
                                      context=None,
                                      version=None,
                                      certify=None,
                                      keypath=serverKeypath,
                                      certpath=serverCertpath,
                                      cafilepath=clientCafilepath,
                                      )
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:3106: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron pipeline servicing

      Added node .meta to Store23
      Added share time to store Store23
      Added share realtime to store Store23
      Added share datetime to store Store23
socket.error = [Errno 98] Address already in use
_______________________________________________ BasicTestCase.testPatronPipelineStream ________________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronPipelineStream>

    def testPatronPipelineStream(self):
        """
        Test Patron pipeline stream
        """
        console.terse("{0}\n".format(self.testPatronPipelineStream.__doc__))
    
    
    
        store = storing.Store(stamp=0.0)
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101,
                                   bufsize=131072,
                                   wlog=wireLogAlpha,
                                   store=store)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:2641: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron pipeline stream

      Added node .meta to Store24
      Added share time to store Store24
      Added share realtime to store Store24
      Added share datetime to store Store24
socket.error = [Errno 98] Address already in use
_______________________________________________ BasicTestCase.testPatronRedirectComplex _______________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronRedirectComplex>

    def testPatronRedirectComplex(self):
        """
        Test Patron redirect
        """
        console.terse("{0}\n".format(self.testPatronRedirectComplex.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:3447: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron redirect

      Added node .meta to Store25
      Added share time to store Store25
      Added share realtime to store Store25
      Added share datetime to store Store25
socket.error = [Errno 98] Address already in use
____________________________________________ BasicTestCase.testPatronRedirectComplexSecure ____________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronRedirectComplexSecure>

    def testPatronRedirectComplexSecure(self):
        """
        Test Patron redirect
        """
        console.terse("{0}\n".format(self.testPatronRedirectComplexSecure.__doc__))
    
    
    
        serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
        #serverKeypath = '/etc/pki/tls/certs/server_key.pem'  # local server private key
        #serverCertpath = '/etc/pki/tls/certs/server_cert.pem'  # local server public cert
        #clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
    
        serverKeypath = self.certdirpath + '/server_key.pem'  # local server private key
        serverCertpath = self.certdirpath + '/server_cert.pem'  # local server public cert
        clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.ServerTls(host=serverCertCommonName,
                                   port = 6101,
                                   bufsize=131072,
                                   wlog=wireLogAlpha,
                                   context=None,
                                   version=None,
                                   certify=None,
                                   keypath=serverKeypath,
                                   certpath=serverCertpath,
                                   cafilepath=clientCafilepath,)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:3637: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron redirect

      Added node .meta to Store26
      Added share time to store Store26
      Added share realtime to store Store26
      Added share datetime to store Store26
socket.error = [Errno 98] Address already in use
_______________________________________________ BasicTestCase.testPatronRedirectSimple ________________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronRedirectSimple>

    def testPatronRedirectSimple(self):
        """
        Test Patron redirect
        """
        console.terse("{0}\n".format(self.testPatronRedirectSimple.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:3283: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron redirect

      Added node .meta to Store27
      Added share time to store Store27
      Added share realtime to store Store27
      Added share datetime to store Store27
socket.error = [Errno 98] Address already in use
_________________________________________________ BasicTestCase.testPatronRequestEcho _________________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronRequestEcho>

    def testPatronRequestEcho(self):
        """
        Test Patron request echo non blocking
        """
        console.terse("{0}\n".format(self.testPatronRequestEcho.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:1309: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron request echo non blocking

      Added node .meta to Store28
      Added share time to store Store28
      Added share realtime to store Store28
      Added share datetime to store Store28
socket.error = [Errno 98] Address already in use
_________________________________________________ BasicTestCase.testPatronServiceEcho _________________________________________________

self = <ioflo.aio.http.test.test_clienting.BasicTestCase testMethod=testPatronServiceEcho>

    def testPatronServiceEcho(self):
        """
        Test Patron service request response of echo non blocking
        """
        console.terse("{0}\n".format(self.testPatronServiceEcho.__doc__))
    
    
    
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = tcp.Server(port = 6101, bufsize=131072, wlog=wireLogAlpha)
>       self.assertIs(alpha.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_clienting.py:1440: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Patron service request response of echo non blocking

      Added node .meta to Store29
      Added share time to store Store29
      Added share realtime to store Store29
      Added share datetime to store Store29
socket.error = [Errno 98] Address already in use
_________________________________________________ BasicTestCase.testPorterServiceEcho _________________________________________________

self = <ioflo.aio.http.test.test_serving.BasicTestCase testMethod=testPorterServiceEcho>

    def testPorterServiceEcho(self):
        """
        Test Porter service request response of echo non blocking
        """
        console.terse("{0}\n".format(self.testPorterServiceEcho.__doc__))
    
    
    
        store = storing.Store(stamp=0.0)
    
        console.terse("{0}\n".format("Building Valet ...\n"))
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        alpha = serving.Porter(port = 6101,
                              bufsize=131072,
                              wlog=wireLogAlpha,
                              store=store)
>       self.assertIs(alpha.servant.reopen(), True)
E       AssertionError: False is not True

ioflo/aio/http/test/test_serving.py:129: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Porter service request response of echo non blocking

      Added node .meta to Store30
      Added share time to store Store30
      Added share realtime to store Store30
      Added share datetime to store Store30
Building Valet ...

socket.error = [Errno 98] Address already in use
______________________________________________ BasicTestCase.testValetServiceBasicSecure ______________________________________________

self = <ioflo.aio.http.test.test_serving.BasicTestCase testMethod=testValetServiceBasicSecure>

    def testValetServiceBasicSecure(self):
        """
        Test Valet WSGI service with secure TLS request response
        """
        console.terse("{0}\n".format(self.testValetServiceBasicSecure.__doc__))
    
        store = storing.Store(stamp=0.0)
    
        def wsgiApp(environ, start_response):
            start_response('200 OK', [('Content-type','text/plain'),
                                      ('Content-length', '12')])
            return [b"Hello World!"]
    
        console.terse("{0}\n".format("Building Valet ...\n"))
        wireLogAlpha = wiring.WireLog(buffify=True, same=True)
        result = wireLogAlpha.reopen()
    
        serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
        #serverKeypath = '/etc/pki/tls/certs/server_key.pem'  # local server private key
        #serverCertpath = '/etc/pki/tls/certs/server_cert.pem'  # local server public cert
        #clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
    
        serverKeypath = self.certdirpath + '/server_key.pem'  # local server private key
        serverCertpath = self.certdirpath + '/server_cert.pem'  # local server public cert
        clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
    
        alpha = serving.Valet(port = 6101,
                              bufsize=131072,
                              wlog=wireLogAlpha,
                              store=store,
                              app=wsgiApp,
                              scheme='https',
                              keypath=serverKeypath,
                              certpath=serverCertpath,
                              cafilepath=clientCafilepath,)
    
        self.assertIs(alpha.servant.reopen(), True)
        self.assertEqual(alpha.servant.ha, ('0.0.0.0', 6101))
        self.assertEqual(alpha.servant.eha, ('127.0.0.1', 6101))
    
        console.terse("{0}\n".format("Building Patron ...\n"))
        wireLogBeta = wiring.WireLog(buffify=True,  same=True)
        result = wireLogBeta.reopen()
    
        #clientKeypath = '/etc/pki/tls/certs/client_key.pem'  # local client private key
        #clientCertpath = '/etc/pki/tls/certs/client_cert.pem'  # local client public cert
        #serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
    
        clientKeypath = self.certdirpath + '/client_key.pem'  # local client private key
        clientCertpath = self.certdirpath + '/client_cert.pem'  # local client public cert
        serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
    
        path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
    
        beta = clienting.Patron(bufsize=131072,
                                     wlog=wireLogBeta,
                                     store=store,
                                     path=path,
                                     reconnectable=True,
                                     scheme='https',
                                     certedhost=serverCertCommonName,
                                     keypath=clientKeypath,
                                     certpath=clientCertpath,
                                     cafilepath=serverCafilepath
                                     )
    
        self.assertIs(beta.connector.reopen(), True)
        self.assertIs(beta.connector.accepted, False)
        self.assertIs(beta.connector.connected, False)
        self.assertIs(beta.connector.cutoff, False)
    
        request = odict([('method', u'GET'),
                         ('path', u'/echo?name=fame'),
                         ('qargs', odict()),
                         ('fragment', u''),
                         ('headers', odict([('Accept', 'application/json'),
                                            ('Content-Length', 0)])),
                        ])
    
        beta.requests.append(request)
    
        while (beta.requests or beta.connector.txes or not beta.responses or
               not alpha.idle()):
            alpha.serviceAll()
            time.sleep(0.05)
>           beta.serviceAll()

ioflo/aio/http/test/test_serving.py:907: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
ioflo/aio/http/clienting.py:1129: in serviceAll
    self.connector.serviceConnect()
ioflo/aio/tcp/clienting.py:307: in serviceConnect
    self.connect()
ioflo/aio/tcp/clienting.py:640: in connect
    self.handshake()
ioflo/aio/tcp/clienting.py:602: in handshake
    self.cs.do_handshake()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <ssl.SSLSocket [closed] fd=-1, family=2, type=1, proto=0>, block = False

    @_sslcopydoc
    def do_handshake(self, block=False):
        self._check_connected()
        timeout = self.gettimeout()
        try:
            if timeout == 0.0 and block:
                self.settimeout(None)
>           self._sslobj.do_handshake()
E           ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)

/usr/lib/python3.13/ssl.py:1372: SSLCertVerificationError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------

Test Valet WSGI service with secure TLS request response

      Added node .meta to Store32
      Added share time to store Store32
      Added share realtime to store Store32
      Added share datetime to store Store32
Building Valet ...

Building Patron ...

______________________________________________________ BasicTestCase.testActify _______________________________________________________

self = <ioflo.base.test.test_acting.BasicTestCase testMethod=testActify>

    def testActify(self):
        """
        Test the actify decorator
        """
        console.terse("{0}\n".format(self.testActify.__doc__))
        @acting.actify("BlueBeard")
        def bearded(self, x=1, y=2):
            """
            Actor action method
            """
            z = x +  y
            return (self, z)
    
        self.assertIn("BlueBeard", acting.Actor.Registry)
        actor, inits, ioinits, parms = acting.Actor.__fetch__("BlueBeard")
        self.assertIs(actor._Parametric, True)
        self.assertDictEqual(actor.Inits, {})
        self.assertDictEqual(actor.Ioinits, {})
        self.assertDictEqual(actor.Parms, {})
        self.assertDictEqual(inits, {})
        self.assertDictEqual(ioinits, {})
        self.assertDictEqual(parms, {})
    
        actor = actor()  # create instance
        self.assertIsInstance(actor, acting.Actor )
        self.assertEqual(actor.__class__.__name__, "BlueBeard")
    
        self.assertEqual(actor.action.__self__.__class__.__name__, "BlueBeard")
        self.assertIs(actor.action.__func__, bearded)
        self.assertIs(actor.action.__self__, actor)
    
>       self.assertEqual(actor.action.__doc__, '\n            Actor action method\n            ')
E       AssertionError: '\nActor action method\n' != '\n            Actor action method\n            '
E         
E       - Actor action method
E       +             Actor action method
E       ? ++++++++++++
E       - 
E       +

ioflo/base/test/test_acting.py:76: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------
   Ordering taskable taskers for House 'HouseTest' ...

Test the actify decorator

_______________________________________________________ BasicTestCase.testDoify _______________________________________________________

self = <ioflo.base.test.test_acting.BasicTestCase testMethod=testDoify>

    def testDoify(self):
        """
        Test the doify decorator
        """
        console.terse("{0}\n".format(self.testDoify.__doc__))
        @doing.doify("BlackSmith")
        def blackened(self, x=3, y=2):
            """
            Doer action method
            """
            z = x + y
            return (self, z)
    
        self.assertIn("BlackSmith", doing.Doer.Registry)
        actor, inits, ioinits, parms = doing.Doer.__fetch__("BlackSmith")
        self.assertIs(actor._Parametric, False)
        self.assertDictEqual(actor.Inits, {})
        self.assertDictEqual(actor.Ioinits, {})
        self.assertDictEqual(actor.Parms, {})
        self.assertDictEqual(inits, {})
        self.assertDictEqual(ioinits, {})
        self.assertDictEqual(parms, {})
    
        actor = actor()  # create instance
        self.assertIsInstance(actor, doing.Doer )
        self.assertEqual(actor.__class__.__name__, "BlackSmith")
    
        self.assertEqual(actor.action.__self__.__class__.__name__, "BlackSmith")
        self.assertIs(actor.action.__func__, blackened)
        self.assertIs(actor.action.__self__, actor)
    
>       self.assertEqual(actor.action.__doc__, '\n            Doer action method\n            ')
E       AssertionError: '\nDoer action method\n' != '\n            Doer action method\n            '
E         
E       - Doer action method
E       +             Doer action method
E       ? ++++++++++++
E       - 
E       +

ioflo/base/test/test_acting.py:115: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------
   Ordering taskable taskers for House 'HouseTest' ...

Test the doify decorator

_____________________________________________________ BasicTestCase.testFrameDoer _____________________________________________________

self = <ioflo.base.test.test_acting.BasicTestCase testMethod=testFrameDoer>

    def testFrameDoer(self):
        """
        Test adding a Doer to a frame and running it
        """
        console.terse("{0}\n".format(self.testFrameDoer.__doc__))
        @doing.doify("TestDoer")
        def action(self, a="Felgercarb", **kwa):
            """
            Doer action method
            """
            share = self.store.create(".test.a").update(value=a)
    
        self.assertIn("TestDoer", doing.Doer.Registry)
        act = self.addDoer("TestDoer")
        self.assertIsInstance(act, acting.Act)
        self.assertIn(act, self.frame.reacts)
        self.assertEqual(act.actor, "TestDoer")
        self.assertEqual(act.frame, self.frame.name)
    
        self.resolve()  # resolve House
        self.assertIs(act.frame, self.frame)
        self.assertIs(act.frame.framer, self.framer)
        self.assertIs(act.actor.store, self.store)
        self.assertIn(act.actor.name, doing.Doer.Registry)
        self.assertEqual(act.actor.name, "TestDoer")
        self.assertIsInstance(act.actor, doing.Doer)
        self.assertEqual(act.actor.__class__.__name__, "TestDoer")
    
        self.assertEqual(act.actor.action.__self__.__class__.__name__, "TestDoer")
        self.assertIs(act.actor.action.__func__, action)
        self.assertIs(act.actor.action.__self__, act.actor)
    
>       self.assertEqual(act.actor.action.__doc__, '\n            Doer action method\n            ')
E       AssertionError: '\nDoer action method\n' != '\n            Doer action method\n            '
E         
E       - Doer action method
E       +             Doer action method
E       ? ++++++++++++
E       - 
E       +

ioflo/base/test/test_acting.py:154: AssertionError
-------------------------------------------------------- Captured stdout call ---------------------------------------------------------
   Ordering taskable taskers for House 'HouseTest' ...

Test adding a Doer to a frame and running it

   Resolving House 'HouseTest' ...
     Presolving Framer FramerTest
       Resolving original moots for named clones ...
       Presolving frames for framer FramerTest
        Presolving Frame FrameTest
     Resolving Framer FramerTest
       Resolving frames for framer FramerTest
        Resolving Frame FrameTest
         Resolved act's Frame 'FrameTest' in Act for TestDoer
       Tracing outlines for framer FramerTest
========================================================== warnings summary ===========================================================
ioflo/aid/aiding.py:138
  /tmp/ioflo/ioflo/aid/aiding.py:138: SyntaxWarning: invalid escape sequence '\w'
    """Returns True if string s is valid Store path name

ioflo/aid/aiding.py:204
  /tmp/ioflo/ioflo/aid/aiding.py:204: SyntaxWarning: invalid escape sequence '\w'
    """Returns True if string s is valid python identifier (variable, attribute etc)

ioflo/aid/test/test_eventing.py::BasicTestCase::testEventify
  /tmp/ioflo/ioflo/aid/test/test_eventing.py:92: DeprecationWarning: datetime.datetime.utcnow() is deprecated and scheduled for removal in a future version. Use timezone-aware objects to represent datetimes in UTC: datetime.datetime.now(datetime.UTC).
    dt = datetime.datetime.utcnow()

ioflo/aid/test/test_eventing.py::BasicTestCase::testEventify
ioflo/aid/test/test_eventing.py::BasicTestCase::testEventize
ioflo/aid/test/test_eventing.py::BasicTestCase::testEventize
ioflo/aid/test/test_timing.py::BasicTestCase::testIso8601
  /tmp/ioflo/ioflo/aid/timing.py:59: DeprecationWarning: datetime.datetime.utcnow() is deprecated and scheduled for removal in a future version. Use timezone-aware objects to represent datetimes in UTC: datetime.datetime.now(datetime.UTC).
    dt = datetime.datetime.utcnow()  # naive

ioflo/aio/http/test/test_serving.py::BasicTestCase::testValetServiceBasic
  /tmp/ioflo/ioflo/aio/http/serving.py:369: DeprecationWarning: datetime.datetime.utcnow() is deprecated and scheduled for removal in a future version. Use timezone-aware objects to represent datetimes in UTC: datetime.datetime.now(datetime.UTC).
    self.headers[u'date'] = httping.httpDate1123(datetime.datetime.utcnow())

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
======================================================= short test summary info =======================================================
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestEchoTLS - ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStream - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStreamChunked - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStreamFancy - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStreamFancyChunked - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStreamFancyJson - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testNonBlockingRequestStreamFancyJsonChunked - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronEchoSimpleFirst - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronPipelineEcho - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronPipelineEchoSimpleSecure - ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronPipelineEchoSimpleSecurePath - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronPipelineStream - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronRedirectComplex - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronRedirectComplexSecure - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronRedirectSimple - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronRequestEcho - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_clienting.py::BasicTestCase::testPatronServiceEcho - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_serving.py::BasicTestCase::testPorterServiceEcho - AssertionError: False is not True
FAILED ioflo/aio/http/test/test_serving.py::BasicTestCase::testValetServiceBasicSecure - ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: invalid CA certificate (_ssl.c:1032)
FAILED ioflo/base/test/test_acting.py::BasicTestCase::testActify - AssertionError: '\nActor action method\n' != '\n            Actor action method\n            '
FAILED ioflo/base/test/test_acting.py::BasicTestCase::testDoify - AssertionError: '\nDoer action method\n' != '\n            Doer action method\n            '
FAILED ioflo/base/test/test_acting.py::BasicTestCase::testFrameDoer - AssertionError: '\nDoer action method\n' != '\n            Doer action method\n            '
============================================== 22 failed, 95 passed, 8 warnings in 5.38s ==============================================