Merge pull request #4 in TM/task from ~UNODE/task:2.4.0 to 2.4.0

* commit '715a414abd1d2dcd9ee83cd535656b95d0245733':
  UnitTests
  PKI
  Make wait time configurable. Could be needed in slower machines.
  Prevent reuse of Taskd after being destroyed

test/basetest/exceptions.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+
+class CommandError(Exception):
+    def __init__(self, cmd, code, out, err, msg=None):
+        if msg is None:
+            self.msg = ("Command '{0}' finished with unexpected exit code "
+                        "'{1}':\nStdout: '{2}'\nStderr: '{3}'")
+        else:
+            self.msg = msg
+
+        self.cmd = cmd
+        self.out = out
+        self.err = err
+        self.code = code
+
+    def __str__(self):
+        return self.msg.format(self.cmd, self.code, self.out, self.err)
+
+# vim: ai sts=4 et sw=4

test/basetest/task.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+
+import os
+import tempfile
+import shutil
+import atexit
+from .utils import run_cmd_wait, run_cmd_wait_nofail
+from .exceptions import CommandError
+
+
+class Task(object):
+    """Manage a task warrior instance
+
+    A temporary folder is used as data store of task warrior.
+    This class can be instanciated multiple times if multiple taskw clients are
+    needed.
+
+    This class can be given a Taskd instance for simplified configuration.
+
+    A taskw client should not be used after being destroyed.
+    """
+    def __init__(self, taskw="task", taskd=None):
+        """Initialize a Task warrior (client) that can interact with a taskd
+        server. The task client runs in a temporary folder.
+
+        :arg taskw: Task binary to use as client (defaults: task in PATH)
+        :arg taskd: Taskd instance for client-server configuration
+        """
+        self.taskw = taskw
+        self.taskd = taskd
+
+        # Configuration of the isolated environment
+        self._original_pwd = os.getcwd()
+        self.datadir = tempfile.mkdtemp()
+        self.taskrc = os.path.join(self.datadir, "test.rc")
+
+        # Ensure any instance is properly destroyed at session end
+        atexit.register(lambda: self.destroy())
+
+        # Copy all env variables to avoid clashing subprocess environments
+        self.env = os.environ.copy()
+
+        # Make sure no TASKDDATA is isolated
+        self.env["TASKDATA"] = self.datadir
+        # As well as TASKRC
+        self.env["TASKRC"] = self.taskrc
+
+        # Cannot call self.config until confirmation is disabled
+        with open(self.taskrc, 'w') as rc:
+            rc.write("data.location={0}\n"
+                     "confirmation=no".format(self.datadir))
+
+        # Setup configuration to talk to taskd automatically
+        if self.taskd is not None:
+            self.bind_taskd_server(self.taskd)
+
+    def __repr__(self):
+        txt = super(Task, self).__repr__()
+        return "{0} running from {1}>".format(txt[:-1], self.datadir)
+
+    def bind_taskd_server(self, taskd):
+        """Configure the present task client to talk to given taskd server
+
+        Note that this can be performed automatically by passing taskd when
+        creating an instance of the current class.
+        """
+        self.taskd = taskd
+
+        cert = os.path.join(self.taskd.certpath, "test_client.cert.pem")
+        key = os.path.join(self.taskd.certpath, "test_client.key.pem")
+        self.config("taskd.certificate", cert)
+        self.config("taskd.key", key)
+        self.config("taskd.ca", self.taskd.ca_cert)
+
+        address = ":".join((self.taskd.address, str(self.taskd.port)))
+        self.config("taskd.server", address)
+
+        # Also configure the default user for given taskd server
+        self.set_taskd_user()
+
+    def set_taskd_user(self, taskd_user=None, default=True):
+        """Assign a new user user to the present task client
+
+        If default==False, a new user will be assigned instead of reusing the
+        default taskd user for the corresponding instance.
+        """
+        if taskd_user is None:
+            if default:
+                user, group, org, userkey = self.taskd.default_user
+            else:
+                user, group, org, userkey = self.taskd.create_user()
+        else:
+            user, group, org, userkey = taskd_user
+
+        self.credentials = "/".join((org, user, userkey))
+        self.config("taskd.credentials", self.credentials)
+
+    def config(self, var, value):
+        """Run setup `var` as `value` in taskd config
+        """
+        # Add -- to avoid misinterpretation of - in things like UUIDs
+        cmd = (self.taskw, "config", "--", var, value)
+        return run_cmd_wait(cmd, env=self.env)
+
+    def runSuccess(self, args=(), input=None, merge_streams=True):
+        """Invoke task with the given arguments
+
+        Use runError if you want exit_code to be tested automatically and
+        *not* fail if program finishes abnormally.
+
+        If you wish to pass instructions to task such as confirmations or other
+        input via stdin, you can do so by providing a input string.
+        Such as input="y\ny".
+
+        If merge_streams=True stdout and stderr will be merged into stdout.
+
+        Returns (exit_code, stdout, stderr)
+        """
+        command = [self.taskw]
+        command.extend(args)
+
+        return run_cmd_wait(command, input,
+                            merge_streams=merge_streams, env=self.env)
+
+    def runError(self, args=(), input=None, merge_streams=True):
+        """Same as runSuccess but Invoke task with the given arguments
+
+        Use runSuccess if you want exit_code to be tested automatically and
+        *fail* if program finishes abnormally.
+
+        If you wish to pass instructions to task such as confirmations or other
+        input via stdin, you can do so by providing a input string.
+        Such as input="y\ny".
+
+        If merge_streams=True stdout and stderr will be merged into stdout.
+
+        Returns (exit_code, stdout, stderr)
+        """
+        command = [self.taskw]
+        command.extend(args)
+
+        output = run_cmd_wait_nofail(command, input,
+                                     merge_streams=merge_streams, env=self.env)
+
+        # output[0] is the exit code
+        if output[0] == 0:
+            raise CommandError(command, *output)
+
+        return output
+
+    def destroy(self):
+        """Cleanup the data folder and release server port for other instances
+        """
+        try:
+            shutil.rmtree(self.datadir)
+        except OSError as e:
+            if e.errno == 2:
+                # Directory no longer exists
+                pass
+            else:
+                raise
+
+        # Prevent future reuse of this instance
+        self.runSuccess = self.__destroyed
+        self.runError = self.__destroyed
+
+        # self.destroy will get called when the python session closes.
+        # If self.destroy was already called, turn the action into a noop
+        self.destroy = lambda: None
+
+    def __destroyed(self, *args, **kwargs):
+        raise AttributeError("Task instance has been destroyed. "
+                             "Create a new instance if you need a new client.")
+
+    def diag(self, out):
+        """Diagnostics are just lines preceded with #.
+        """
+        print '# --- diag start ---'
+        for line in out.split("\n"):
+            print '#', line
+        print '# --- diag end ---'
+
+# vim: ai sts=4 et sw=4

test/basetest/taskd.py

@@ -4,9 +4,11 @@ import os
 import tempfile
 import shutil
 import signal
+import atexit
 from time import sleep
 from subprocess import Popen
 from .utils import find_unused_port, release_port, port_used, run_cmd_wait
+from .exceptions import CommandError
 
 try:
     from subprocess import DEVNULL
@@ -18,7 +20,7 @@ _curdir = os.path.dirname(os.path.abspath(__file__))
 DEFAULT_CERT_PATH = os.path.abspath(os.path.join(_curdir, "..", "test_certs"))
 
 
-class TaskdServer(object):
+class Taskd(object):
     """Manage a taskd instance
 
     A temporary folder is used as data store of taskd.
@@ -40,17 +42,21 @@ class TaskdServer(object):
         :arg address: Address to bind to
         """
         self.taskd = taskd
+        self.usercount = 0
+
         # Will hold the taskd subprocess if it's running
         self.proc = None
         self.datadir = tempfile.mkdtemp()
         self.tasklog = os.path.join(self.datadir, "taskd.log")
         self.taskpid = os.path.join(self.datadir, "taskd.pid")
 
-        # Make sure no TASKDDATA is defined
+        # Ensure any instance is properly destroyed at session end
-        try:
+        atexit.register(lambda: self.destroy())
-            del os.environ["TASKDDATA"]
+
-        except KeyError:
+        # Copy all env variables to avoid clashing subprocess environments
-            pass
+        self.env = os.environ.copy()
+        # Make sure TASKDDATA points to the temporary folder
+        self.env["TASKDATA"] = self.datadir
 
         if certpath is None:
             certpath = DEFAULT_CERT_PATH
@@ -69,7 +75,7 @@ class TaskdServer(object):
 
         # Initialize taskd
         cmd = (self.taskd, "init", "--data", self.datadir)
-        run_cmd_wait(cmd)
+        run_cmd_wait(cmd, env=self.env)
 
         self.config("server", "{0}:{1}".format(self.address, self.port))
         self.config("log", self.tasklog)
@@ -85,12 +91,71 @@ class TaskdServer(object):
         self.config("server.crl", self.server_crl)
         self.config("ca.cert", self.ca_cert)
 
+        self.default_user = self.create_user()
+
+    def __repr__(self):
+        txt = super(Taskd, self).__repr__()
+        return "{0} running from {1}>".format(txt[:-1], self.datadir)
+
+    def create_user(self, user=None, group=None, org=None):
+        """Create a user/group in the server and return the user
+        credentials to use in a taskw client.
+        """
+        if user is None:
+            # Create a unique user ID
+            uid = self.usercount
+            user = "test_user_{0}".format(uid)
+
+            # Increment the user_id
+            self.usercount += 1
+
+        if group is None:
+            group = "default_group"
+
+        if org is None:
+            org = "default_org"
+
+        self._add_entity("org", org, ignore_exists=True)
+        self._add_entity("group", org, group, ignore_exists=True)
+        userkey = self._add_entity("user", org, user)
+
+        return user, group, org, userkey
+
+    def _add_entity(self, keyword, org, value=None, ignore_exists=False):
+        """Add an organization, group or user to the current server
+
+        If a user creation is requested, the user unique ID is returned
+        """
+        cmd = (self.taskd, "add", "--data", self.datadir, keyword, org)
+
+        if value is not None:
+            cmd += (value,)
+
+        try:
+            code, out, err = run_cmd_wait(cmd, env=self.env)
+        except CommandError as e:
+            match = False
+            for line in e.out.splitlines():
+                if line.endswith("already exists.") and ignore_exists:
+                    match = True
+                    break
+
+            # If the error was not "Already exists" report it
+            if not match:
+                raise
+
+        if keyword == "user":
+            expected = "New user key: "
+            for line in out.splitlines():
+                if line.startswith(expected):
+                    return line.replace(expected, '')
+
     def config(self, var, value):
         """Run setup `var` as `value` in taskd config
         """
         cmd = (self.taskd, "config", "--force", "--data", self.datadir, var,
                value)
-        run_cmd_wait(cmd)
+        run_cmd_wait(cmd, env=self.env)
 
         # If server is running send a SIGHUP to force config reload
         if self.proc is not None:
@@ -116,19 +181,18 @@ class TaskdServer(object):
 
         return True
 
-    def start(self):
+    def start(self, minutes=5):
         """Start the taskd server if it's not running.
         If it's already running OSError will be raised
         """
         if self.proc is None:
             cmd = (self.taskd, "server", "--data", self.datadir)
-            self.proc = Popen(cmd, stdout=DEVNULL, stdin=DEVNULL)
+            self.proc = Popen(cmd, stdout=DEVNULL, stdin=DEVNULL, env=self.env)
         else:
             raise OSError("Taskd server is still running or crashed")
 
         # Wait for server to listen by checking connectivity in the port
-        # Wait up to 5 minutes checking once second
+        # Default is to wait up to 5 minutes checking once each second
-        minutes = 5
         for i in range(minutes * 60):
             if not self.status():
                 sleep(1)
@@ -183,4 +247,17 @@ class TaskdServer(object):
 
         release_port(self.port)
 
+        # Prevent future reuse of this instance
+        self.start = self.__destroyed
+        self.config = self.__destroyed
+        self.stop = self.__destroyed
+
+        # self.destroy will get called when the python session closes.
+        # If self.destroy was already called, turn the action into a noop
+        self.destroy = lambda: None
+
+    def __destroyed(self, *args, **kwargs):
+        raise AttributeError("Taskd instance has been destroyed. "
+                             "Create a new instance if you need a new server.")
+
 # vim: ai sts=4 et sw=4

test/basetest/utils.py

@@ -1,19 +1,49 @@
 # -*- coding: utf-8 -*-
+import os
 import socket
-from subprocess import Popen, PIPE
+from subprocess import Popen, PIPE, STDOUT
+from .exceptions import CommandError
 
 USED_PORTS = set()
 
 
-def run_cmd_wait(cmd):
+def run_cmd_wait(cmd, input=None, stdout=PIPE, stderr=PIPE,
+                 merge_streams=False, env=os.environ):
     "Run a subprocess and wait for it to finish"
-    p = Popen(cmd, stdout=PIPE, stderr=PIPE)
+
-    out, err = p.communicate()
+    if input is None:
+        stdin = None
+    else:
+        stdin = PIPE
+
+    if merge_streams:
+        stderr = STDOUT
+    else:
+        stderr = PIPE
+
+    p = Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr, env=env)
+    out, err = p.communicate(input)
+
+    # In python3 we will be able use the following instead of the previous
+    # line to avoid locking if task is unexpectedly waiting for input
+    # try:
+    #     out, err = p.communicate(input, timeout=15)
+    # except TimeoutExpired:
+    #     p.kill()
+    #     out, err = proc.communicate()
 
     if p.returncode != 0:
-        raise IOError("Failed to run '{0}', exit code was '{1}', stdout"
+        raise CommandError(cmd, p.returncode, out, err)
-                      " '{2}' and stderr '{3}'".format(cmd, p.returncode,
+
-                                                       out, err))
+    return p.returncode, out, err
+
+
+def run_cmd_wait_nofail(*args, **kwargs):
+    "Same as run_cmd_wait but silence the exception if it happens"
+    try:
+        return run_cmd_wait(*args, **kwargs)
+    except CommandError as e:
+        return e.code, e.out, e.err
 
 
 def port_used(addr="localhost", port=None):
@@ -29,7 +59,7 @@ def port_used(addr="localhost", port=None):
 
 
 def find_unused_port(addr="localhost", start=53589, track=True):
-    """Find an unused port starting at `port`
+    """Find an unused port starting at `start` port
 
     If track=False the returned port will not be marked as in-use and the code
     will rely entirely on the ability to connect to addr:port as detection

test/test_certs/README

@@ -0,0 +1,5 @@
+WARNING
+
+These certificates are part of the testing framework, DO NOT USE FOR OTHER PURPOSES
+
+WARNING

test/test_certs/ca.cert.pem

@@ -1,24 +1,24 @@
 -----BEGIN CERTIFICATE-----
-MIIEGzCCAtOgAwIBAgIEU3emwDANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
+MIIEGzCCAtOgAwIBAgIEU7iVFTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
 RTEeMBwGA1UECgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5MRIwEAYDVQQHDAlHw7Z0
 ZWJvcmcxGjAYBgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5kMR4wHAYDVQQDDBVHw7Z0
-ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNTE3MTgxMzIwWhcNMTUwNTE3MTgxMzIw
+ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNzA2MDAxNTE3WhcNMTUwNzA2MDAxNTE3
 WjB9MQswCQYDVQQGEwJTRTEeMBwGA1UECgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5
 MRIwEAYDVQQHDAlHw7Z0ZWJvcmcxGjAYBgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5k
 MR4wHAYDVQQDDBVHw7Z0ZWJvcmcgQml0IEZhY3RvcnkwggFSMA0GCSqGSIb3DQEB
-AQUAA4IBPwAwggE6AoIBMQDCQyFXOUPIymI7+4nY1T7yNfe1b+vzznJgtJpPOZxW
+AQUAA4IBPwAwggE6AoIBMQDFIrOoUuh91JyRl81/IK5TFyWVJQSvcWJ3UFE47rmI
-gPJSiT0yVPmKAYpitn9x1ADncO61FmqTowaZKauwifLhAp8cC/r5N6Y/yppxSEZ+
+/ddmgF+J1UWNQQ0+2jzS7AGYwTC1vbBEiwQAm90QtvqMrPY1ocXJGFrb4Ei59SMx
-czybasCNB/bsmpBB0OeTDAAZ6BF8zLzzFC/54g3JVhsSGwtYKfQlqUlfp89BeCrg
+2vxutHznvz7tQKpWvKk1oXQaOqTWHynb1OpGPcIL+rKmJDNP6udFhUuoVYJULy1Y
-qzO1YO+uJ0K2dXPuyuFjH+Vwr6QLcVKRDvgc/I/C7lx+JKXd/lmiNS5uOc9RhFyD
+geBwwIXkWOZq6pTUF/m8NNTnNFydjuJyvVio8MlM9Tk/9N7qTLROU1mWRqmjWDlE
-0xtqCnyhWpa8Ed26Y0B8CAhHWdJWEU33iWLpvlLcfYvFus4cPnEjuIu/Ql64cgIW
+n2zYuUa2k2k+ZIiaD8disRtU9kFKW9ailGPCQGWH7yh38Hwi9vUoQ2owWHw6cD3S
-xeQQ4lPZYLXVOh/2LeYwbTIBBtvNZdQb8S6VSJG9zex/nzrBq/4M9qlA9kpRW6TA
+by2E3wSujnUACkojWNxEreusNt7j6e9KeQrC8HB3azteU5DUQaEeLHVPYRx44yPK
-1G/eInMBzUp2LPW8V4HhspPqFo5SP2sfbaE5Pp2neCWPAgMBAAGjQzBBMA8GA1Ud
+ZiOQ061r0h74Im7jE5dT5snhCi5fhcxreME4uuDBlrZ3AgMBAAGjQzBBMA8GA1Ud
-EwEB/wQFMAMBAf8wDwYDVR0PAQH/BAUDAwcEADAdBgNVHQ4EFgQUDZvEvP9T4ftv
+EwEB/wQFMAMBAf8wDwYDVR0PAQH/BAUDAwcEADAdBgNVHQ4EFgQUV6hrNd+llELY
-3cVT711JQT5wPWswDQYJKoZIhvcNAQELBQADggExAC+aizDsErZVIuuSFZ0pI1+c
+w9FhchM/2QvO37UwDQYJKoZIhvcNAQELBQADggExAGS0ebZUZ8r4O/9MDbRHxhFx
-fsUdC7vKum/B+ANCLOezUgGzfHkohaVd1aY9Qvt7/0q0aTCd7ssiZ7pGZArx2ZEw
+Xgs7Vtn+LgyzBommGvoJXITBr3UduE5QfvM+8U4XmDnW4AMRU01YWWo/0UESkeiF
-3vvKvU0xgwE5YZucExXDrdYqMYtjSDQ4Q+OwS4Q0AiADXpUDtjkIFcuXr7wf/5RN
+OzbS+LR4G6PtlSXCJnm79CJMgAv+uZJmG9QUYlAnJ72/Op4iQsgX4nFySOLYu/44
-M+wzl5W3fuNofAoXY6cE8MwrlgXZcjzKzkq0H2hR0ifwJ00uf1tQ0kgUHrKlTfHC
+cDMhtrYmdWwbjJJAVVbyQVW7qtPVtXjpKt8RBg0pmfaW5JAyup3RkvUr2wSsSxRl
-xnTD2IXcfhUNJtAutxV8eKOjmrT7X/hT2Hur2Xgp/a1K+95QaNJIc7PtdbOvfh4o
+5oXKeE7PE6zdTrnIWKyeEyyh6sSDZzd9D8DVa+tjFt4EKbxD90/s7RZml6YK244W
-Kb4wGVy8fQNYaZXxYQgvfr8trgraTn73Vr7jYkeQAgn3yOdk5qyS14Dhnrvht2VX
+eJY9jl3nx2wORewLrIMZuDU62h9ZCt4/IClVoVqUDMI5wfsN367GkLyyjvKvAo4p
-DaoDPz3glAzNY6/oL3ElGbL7CVKBXUk/OdURlgyoXzKm7EPgp4zAHg8KiNtKrYk=
+B9I2pZXT6Cp5+dW0yMOYsaogoPzfSk5yuQ4BR+Z5S/NV1yZb1tekxnqn7mPik2M=
 -----END CERTIFICATE-----

test/test_certs/ca.key.pem

@@ -1,32 +1,32 @@
 -----BEGIN RSA PRIVATE KEY-----
-MIIFewIBAAKCATEAwkMhVzlDyMpiO/uJ2NU+8jX3tW/r885yYLSaTzmcVoDyUok9
+MIIFewIBAAKCATEAxSKzqFLofdSckZfNfyCuUxcllSUEr3Fid1BROO65iP3XZoBf
-MlT5igGKYrZ/cdQA53DutRZqk6MGmSmrsIny4QKfHAv6+TemP8qacUhGfnM8m2rA
+idVFjUENPto80uwBmMEwtb2wRIsEAJvdELb6jKz2NaHFyRha2+BIufUjMdr8brR8
-jQf27JqQQdDnkwwAGegRfMy88xQv+eINyVYbEhsLWCn0JalJX6fPQXgq4KsztWDv
+578+7UCqVrypNaF0Gjqk1h8p29TqRj3CC/qypiQzT+rnRYVLqFWCVC8tWIHgcMCF
-ridCtnVz7srhYx/lcK+kC3FSkQ74HPyPwu5cfiSl3f5ZojUubjnPUYRcg9Mbagp8
+5FjmauqU1Bf5vDTU5zRcnY7icr1YqPDJTPU5P/Te6ky0TlNZlkapo1g5RJ9s2LlG
-oVqWvBHdumNAfAgIR1nSVhFN94li6b5S3H2LxbrOHD5xI7iLv0JeuHICFsXkEOJT
+tpNpPmSImg/HYrEbVPZBSlvWopRjwkBlh+8od/B8Ivb1KENqMFh8OnA90m8thN8E
-2WC11Tof9i3mMG0yAQbbzWXUG/EulUiRvc3sf586wav+DPapQPZKUVukwNRv3iJz
+ro51AApKI1jcRK3rrDbe4+nvSnkKwvBwd2s7XlOQ1EGhHix1T2EceOMjymYjkNOt
-Ac1Kdiz1vFeB4bKT6haOUj9rH22hOT6dp3gljwIDAQABAoIBMDWWCvZih341xY9C
+a9Ie+CJu4xOXU+bJ4QouX4XMa3jBOLrgwZa2dwIDAQABAoIBMHIhMw4CYeNnkfWg
-Pa4gdLKfjGryKqYgRpDCgOZlv+hkvXNjBAyEQCl/b0r3iIQ/tNgi4NX3DwMWr1VE
+gzJUg1hLkFCWi+3eoPkeoMdrPjMXcvs+2xD7TjcHMFnxE0GxrQL45fByD3i/WuPX
-l2WlR+glrvovm9VvMl7aZmvlQfzTkN5WPjMpBUYTBMQC+j4ny0daKqjAWUa8RNer
+WNbyeH+1Kx3FuLJBzWh6ouA2EdgtRfP5vk6VJCNLStLIitYn0QXWadQlWqCQ1ckw
-MZ5eMC14ZFK3j+9rmR/XzGYE3d8HmsXnrXXewppOH+K4+B89xy6kZJ37bokwmmza
+vAUfcQpK7wIXpylSkIi2aKvAXGpfVscwTtPyvAOuJ9fawZS6qX/piq0VKfjurFuE
-IWWd4tcC5QvkV7Cvna9qRNkrrREeUT9xNCjeFRXHv001D0Eva5pz1nEnHiDtz5ah
+AlEUqwhrazxB7Ff7KutAvPkvLyX0MRs5BPhHbBRMAYb+lfxyJdg04tqe2gwhOVoc
-keMRn+hM/edj0SJjJImBF6cUhADdt7Kp+Avlf1g5gAgLoiYn6w/tKzEKuEGuqCe7
+8zaOxCIlMfvk0IRbaezfTm9MwXGjHB9yicQj+BtgKtw1YihvaTWebpNUs8UbhUDX
-Sq2ACXXqzfxr+QUrNxIdVp6FNQr98kX3fBDO1ESQmQXbiSf798MQUNELxl5do8u+
+gnzSyRiHVKa6utjfF6oI2DD5nQ7WA50saFD0R0+OCpSTBPYR5NF3LHkBZS1tdni9
-MfsxltECgZkAzQAeDNyFH17mKwO4tVpoyzURjAoBUwR+ahauiq61VawBFyKvkccP
+B4W5gLECgZkAx89Shl7BrMk4zGWjHiU18tm/bZkxSDmKOxRFjnWaUT0sWWWo/jNj
-RaDmslKWb8oFrS5GecF/aF+B4SUBjD516MEYxnAfdgMVxVZt+wIkdZXWmButfFL5
+7zXVzYQoI/tLmismzcJqHMPRxR+jFGGFdHhp9uf04pBqLquCgPHxNHIMpopolFYK
-B7kwU9CZ4HBzhpp8fdfO2BbRcXrXE117GkEDymLpGei9S2eHOJaPUJT3U5LRTg4l
+krlLQjDNSqZAdPtCZR5lM1DPC/+YDvhMyRqBBLFmoo0awlcGMTs8pFHVjOpYtTSH
-qvnKNKJMbgB9sYBRat70Wv0CgZkA8pcgTJUjTlQ1nUfbf3KaMj2MPBfzyFFfl2Lm
+a+1NR+yyd7/tNAbO7PieXFUCgZkA/JLaCtBb3mu076onvZP6twZKUd+5m9G5Gi7v
-wWdFW4RmPEF8R1RFlgRYF+2Jb3ewnu1TiEQmrmAB1kZQ6P/SeDfGK1OQVG75ClwQ
+Pr4W34vtNhtlVdsORgc5NQQB+v1bE2Glp5AtTR4itVUViBxq7Xi3WOwDAmwhpT5H
-Gz4w9hr0gYQRiACZnhcfE1sNeEt3oD4Kb7TKnUK1F1Bgb/rJaV6mOA2MEQBSUSC9
+2L8End887PaZyy3EaSzyvFvc3JqCi3fJ38JMHw07PKmzZcgMY5z69V67R67sLLKy
-A/r9jqmLif9RJDpXo+6uzF74EQ6uMw1EzSUwhnsCgZgGXMSR/Z4cFSPrndfzuPSb
+oot6NJMu7KsdFZUXQtU6NWAYqcJtVqnLdM/wk5sCgZhCF5PmmoVZ0B2Xjq8ME6bq
-qe/7eqwD2ZXa0Q1lvHpgSFBYWXk9ewIcVRwT2MBWg9ydPVxulvTPVnd/d1iO87lR
+s5gceqXQjCfrLuNrIf9vi9qVn4jsvLb7s0ULfAGDFWaGkmt9eCd9aFCE8dgRr8hj
-Gf0c24n+baYVU9NiAPUEuTvJyMIfo6ua88JuN4EvGA5d1RmcBkCjMEIb1YYrUbFq
+JEl4wHVCVB6rXVQHrv/oJymEFRhOqL9KlTwNovLlFGURzOLDa/BxrvMtttfna76K
-ZS4q79rwNOr7FiF6PiIAjD8I1vusAoBkyA/ghlD88QL1qVfdi0HmOQKBmQDgqtPP
+btfqY3vdnOsTCZIkysFeYStQN1wsZDm/O3lqpyLJdZTStsXPoNVRGQKBmQCO+eZ6
-+SMcjOKmigEftGxX8SZqFSjCMZKdKoxZO6JBUoo4bdGCYeqcN+O6LVRmNmwNk/AT
+Vqaayyfav9zNQXacou/xVw9v+JGrE8SVJPA3zbMTfQCpUF7NH4uvyjwAw+kJmK44
-uEI2plWtM6wFTb+HdOgEAj0d5TShwodsI5nGo0oklMKDuUKL5g/yphYAfawJbMvP
+o7IxRIzrT2Xn7gZNtZc8vCWb+nA1ZYMwXDmV0OhhT9uRm6/ixfIG1I27R6/8mWvq
-jplDMZ9zOw5FRva3rl+0c99vc2PJHM/Q2udu81h28k0chyfZe9jJD38glP8B6tz4
+wcdrkIbm+T23sT3qKdQakGy90HSbfPEIeKJOHr9idB77t7E6QRA5ZNOxTYGtnGKz
-POQG9wKBmEja9a6og+oEBuSXL+kW07neMkhYl4/SegqoRItwBgUD1mWrWSp1wumG
+Fn8eXwKBmCyXLInD+mMRDdolQNBtcDUzocsyxnvqGlIqxXoQR2vIID4pnDFSjEMg
-BNyM5j0rwcVH2EATXF31AxAyRV9JvWYl9DnvZ2E5ZedBqGMrlPBlk8dVEoAowd5x
+UBugRNApwvIbfhF1xzAB5k1jNiNY+fPxMHyceK3S5huwEQr9myJDNqhKSpH2Ai62
-bV3wLTGXuZckvRRClLyb4a9PPWbXgrHY3pT7X34f5fyNuEDok53yxiJ6DQ9p7Rpk
+NTykZTya9d4wsGxGwCERrHuKrAQZuNVvRPS2ahyILT6Wh/9ipC8iCrm4hTHRqTKY
-chM11UKgKHb19nNDCl34
+PiYowq/WR28SzglSbdL1
 -----END RSA PRIVATE KEY-----

test/test_certs/client.cert.pem

@@ -1,24 +1,24 @@
 -----BEGIN CERTIFICATE-----
-MIIEETCCAsmgAwIBAgIEU3emwTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
+MIIEETCCAsmgAwIBAgIEU7iVFjANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
 RTEeMBwGA1UECgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5MRIwEAYDVQQHDAlHw7Z0
 ZWJvcmcxGjAYBgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5kMR4wHAYDVQQDDBVHw7Z0
-ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNTE3MTgxMzIxWhcNMTUwNTE3MTgxMzIx
+ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNzA2MDAxNTE4WhcNMTUwNzA2MDAxNTE4
 WjBAMR4wHAYDVQQKDBVHw7Z0ZWJvcmcgQml0IEZhY3RvcnkxHjAcBgNVBAMMFUfD
 tnRlYm9yZyBCaXQgRmFjdG9yeTCCAVIwDQYJKoZIhvcNAQEBBQADggE/ADCCAToC
-ggExAO6f5rY86ZHF7MxsvX03waVX7epxqPtaJHFjWByqnRl3k25nqakVUXYWWqhv
+ggExAL6It+naOjFmWwYkQMXLirYPrGvvGppjl1RSyBpXnnMEdWteJ8Qsi2cjF53e
-N1asRJQEPTteDqdhfWs6+Qut/5a6H/Jbco/MYqinLLEgoeot7N32bjchpQRWKTzg
+1W4WSJMHl5aP07PsKpXvCHo7F1bKX38gRmkSwpBz9Csir708eML7l+HBjI3dOWcK
-fKcvfChC2Bce7QmJes4PTDMGQdSMSEbkpJFACzrsges56UW6t85/yipPJkkHBeG5
+QKT5ViCe9/0GaJIAEoVbcJEhd8zlLKgfwGvNiqpgb/YkhjPvJY+TdmajvqZxtrQC
-I+bXjpmXkQPwp+cKsA8HvMrn/jdfMSbhJIhApwPoQqgjKEbKxVu4gy430Q1nRN0j
+TgeptjdLtPjc2Q+weO8H63kNlAIiUuEiypVuYxu/WGnjEP4w34DZ95DDla2j21QG
-/0k0BN8PLNDnEuAE0cd7+jvR/RZvfpFVkc7JCG2Mhm//DBMue12juAuPLcw/KwJ4
+YUXfTFWn0/ple9FtJVQr8HBjTkVjovid9089CpIdl/9En5km97jo6FkLHV6gny0F
-joNYPWoUzOv6HS8fVs90k5gUCEeKR8zkhTlKWLlz2jsWjhHqovYKi8720ZBAzuR1
+44291G3zqWygUIbay9Hif2Q5f8B40Qt0unchGNLZ76qEfx7AsFZGzL0FL8VNDSEj
-Tp+dr9/+x+ujCq3lZ5jo/BHgyY8CAwEAAaN2MHQwDAYDVR0TAQH/BAIwADATBgNV
+43bx9Ah4+zTYYjIprsjXT/Mu7b8CAwEAAaN2MHQwDAYDVR0TAQH/BAIwADATBgNV
-HSUEDDAKBggrBgEFBQcDAjAPBgNVHQ8BAf8EBQMDB6AAMB0GA1UdDgQWBBRysTeC
+HSUEDDAKBggrBgEFBQcDAjAPBgNVHQ8BAf8EBQMDB6AAMB0GA1UdDgQWBBRf+4GQ
-R7WPMegs0+3S+ofbHnCxIDAfBgNVHSMEGDAWgBQNm8S8/1Ph+2/dxVPvXUlBPnA9
+KyzlXZYDg2ohrAwvA3RpejAfBgNVHSMEGDAWgBRXqGs136WUQtjD0WFyEz/ZC87f
-azANBgkqhkiG9w0BAQsFAAOCATEAUxK/EELzmDJCawzDPIK0wRraozCLfnyUZHC+
+tTANBgkqhkiG9w0BAQsFAAOCATEATdroMMwiuz0sbPXOdcZt5A5Ifvxhihclvg8f
-D6doLzi1xNH70wQS2WowA/zE7HLpVPfA/VrhE/xTPtWcoQx57AvcYnPYH2wkBdoR
+jK9Vmrr/sOW0BKUVxP8hmPDrgsjaykLNhNxF509puDJg2zeutrsJwKwueCC3Bq7w
-ExpA6tPlL/g25tn90wByafQ6TnaVWClLRPkfqOYg5yV/31xp7Q5A5/8tA0vomGRI
+Hz++LIk/Zp6r85BOyXO7kL+bWX67UKcWdvS3j2zEuxGlWvcXE4oT8fOLqRPOuV99
-X/U3wAkpsmwo0EhawYGNuzflsBl91EvWgEYDE3Xv1fgfsgL/mNRmIj5kFLGUbafc
+4ztYjisaIy/h/cmXjlU5vRe+Y65H3gteTFOJvrQME2Nf3yG6oK1MoD+ZDxiIOKRC
-iB7bl5vyD04HUuPRb86e+wrnxzmaPXA116YGb1PZolT7avCP+twjjbPA6lMCxRxR
+aAJ3g0vkzTvkruoTWKRmX6Mne/QItTvsvVue24WAKM05CLBZhTG657nWS544+KTH
-Tv3h/Cgp2zaTRzHuMt22JSc6CPKd+KAeCsnMDNXpchpj5d7W0fjelMW9gNTIlKxz
++KoY0Eb6geN/8FbWxTOyH7vpGmaMVLocAGDGMYt1yDBP7WUj5NaPEW9dtKjc7G7t
-hgG3zhyC2CXtkZyE8IK0hFCgdBfQpjv6AMmH2SNlsN0rBy71RA==
+ZBwoMHSYNJRJYsfqkG6w/GxZtlIJigB716cL3QBi3k9BHKHlgA==
 -----END CERTIFICATE-----

test/test_certs/client.key.pem

@@ -1,32 +1,32 @@
 -----BEGIN RSA PRIVATE KEY-----
-MIIFfAIBAAKCATEA7p/mtjzpkcXszGy9fTfBpVft6nGo+1okcWNYHKqdGXeTbmep
+MIIFfQIBAAKCATEAvoi36do6MWZbBiRAxcuKtg+sa+8ammOXVFLIGleecwR1a14n
-qRVRdhZaqG83VqxElAQ9O14Op2F9azr5C63/lrof8ltyj8xiqKcssSCh6i3s3fZu
+xCyLZyMXnd7VbhZIkweXlo/Ts+wqle8IejsXVspffyBGaRLCkHP0KyKvvTx4wvuX
-NyGlBFYpPOB8py98KELYFx7tCYl6zg9MMwZB1IxIRuSkkUALOuyB6znpRbq3zn/K
+4cGMjd05ZwpApPlWIJ73/QZokgAShVtwkSF3zOUsqB/Aa82KqmBv9iSGM+8lj5N2
-Kk8mSQcF4bkj5teOmZeRA/Cn5wqwDwe8yuf+N18xJuEkiECnA+hCqCMoRsrFW7iD
+ZqO+pnG2tAJOB6m2N0u0+NzZD7B47wfreQ2UAiJS4SLKlW5jG79YaeMQ/jDfgNn3
-LjfRDWdE3SP/STQE3w8s0OcS4ATRx3v6O9H9Fm9+kVWRzskIbYyGb/8MEy57XaO4
+kMOVraPbVAZhRd9MVafT+mV70W0lVCvwcGNORWOi+J33Tz0Kkh2X/0SfmSb3uOjo
-C48tzD8rAniOg1g9ahTM6/odLx9Wz3STmBQIR4pHzOSFOUpYuXPaOxaOEeqi9gqL
+WQsdXqCfLQXjjb3UbfOpbKBQhtrL0eJ/ZDl/wHjRC3S6dyEY0tnvqoR/HsCwVkbM
-zvbRkEDO5HVOn52v3/7H66MKreVnmOj8EeDJjwIDAQABAoIBMHT8y91Ya6JeCMQI
+vQUvxU0NISPjdvH0CHj7NNhiMimuyNdP8y7tvwIDAQABAoIBMQC3Nqp68YChvgXr
-I7Y6GaP4QdoIszHXdbppXA9hzfdoWk1sYQ9WNkPQnc2qCNVjS5PNqD9s035YG2bw
+KvMp/6Z7mSi4hSw0p21+BTgrtHNFsFTkkJ52kkreOy1bfkoHWOAimdtXSShOS9tL
-2JxTR9UblwH4t2esakoI+64zM25d6ZzAbjR1ODOyEjGYVUSZ0SLj8pETRl7AmgZg
+X5XsS2QO7fzUNoneQc7brtRsoicRNdP90oZi7IWmaMLo5T/yI1yBc7uNEBt/wRgO
-FZmGXcvYoq6u9ceIQHk47lDmaWkYK3j/yZuIhlqTKN0LKYDI+U5vslbeK1LnRiJn
+KjZdKCyV1w2RAS87umMLoD4pF0gBKoYYwLjKy8vpK1F/WPQFhFkWZPM5lswWu3VF
-nHnaco4lQyC5ccBGhisf1qCgLGGiecPgy4bFX6W+Sc4sXRg7SNt9itrW+ZNVqPnI
+tvIwBk91HoL6eueIZ3vO8z7+T1pQvComeELG5sZ3HALte39YfTEwQaTRBSGyPolf
-g8bJ6QNYOifu+gZ1XFVN5kd1IfaqfXHHCnoRe/5QRTI0ifYM+nJ71sN7NLmLe2Gx
+sB2098b1bhzsXLJAjkdmD2SKP0g9eVBFDn/t+2XXsEtFiqq5JB2INdu8pseOHuBR
-aaNAP/ZPaU/Y+Za++2EpknGkcungSrY3ZXslHMlbzRkkIhmB96mpnSQKzrWjR48n
+V1w7FL7jPT2z/lx3BflhVWLijKVfU5F5/DnDMmiCFY0/aIZxZJU+PO/zyIWHYpPb
-SFWIIBECgZkA+TbyCZGV2Mm2M9G6aMCVWfJLx8q5YvXhOaaAxHEAefpN58qP76Ww
+mxBTdB7xAoGZAPPzAiWMVFVs10p8oMwXnHwdMVLZsAd49qXSTKgTCdyF30BxVVCV
-Q3Arz7YhVIyjK88JgXnblHpRUNLw/xFy4W3yx55YWePcTZeRiYfx5MXFwPYmeyxK
+drg4aGyoUT7T676IgG1aqF7YmpFkMjTaDIiYIRTLhsQrRHmsZpKKsrYclU77m80Q
-wMjiq4Xf5dL465+udERADol560kBq2SK32GKoYTwgEZJTuHA/ZYEVlkalYsgTa67
+5V6S4IbW0rdM0pZ2PjtmZMwk2NkpH1Yl/ANNd2tkM9f9e9ZMRAiKxkyC8cj0pLRm
-lCwMmu06MfSCnYhruesmXYMCgZkA9R8kYqjUGFMpRjRmV+JPitIb8rXW61bRQ+KE
+Rnuu5e9RiUsVq/g92/2OyE83AoGZAMfyOCuGs6o+YpTTQPgnMShViz9Xu4GqaVcH
-ahQanxfVFaWkwErU+A2VkKLcZmyhBThR2xFe1YBdXbEP3JaOFCxwx3YDG/b4Zg4Q
+dg6dtaOiSLW053ShCOKTOpCtBW++IQzZE9iAd+dyIIQCAZXwOKDdVxH3x3uUvwaY
-C1oinXfFmspRoMbY1S+rtOKWw75flkg6bFptFnw1Xbda0OjWd7Nvgtk/NhPCb+4W
+rbdX2gsObbB4K9UgZ774n0FNTT8OlI7XOKAY+qW5H+GV22iDANrp2HvqL0s4pcUj
-8pQThAIIS0CvsoKspuqT7Z86iGABTcQSr/yPUgUCgZkA1c7gBHmU17Lm0LpkdS6U
++2oqpgWSOG5XHnlcOUsgGtKn4U9wZpwmTHtuYUm5AoGZAOgTN+iWrqgyCkKPe72N
-c+C+RyCTwGU236EL5H0WbY/jerN8nZvHB3SbAc899S3bZ+BuRVjonA/855yyCgNM
+fM5KS2EhPShuuF6aSVjf+9Kx/OhmqR4ngrDQ4O711YzquOwjGeJui5znfWxxoJ3N
-Tj9oBP7CygwFm8QnppitXRqYOJ52EULEt3Uhkwp+NsyzpmMO5s0PL+meYc/20Lan
+Dn1oFJie4s9+xf7mtxIUJt2/JX/lN5wHxd2J51X/yqicyf5f8OY7jAr1xuIZD/m5
-tlIW/8/wDf0/M5/XVTh5bCNx/U6pXjxEzjCkd96DCQy/aqv50D4AYkUCgZkAtYEp
+2x0dNk2RHw0M1iHRnituMiYZsIFX09TXM5h4k8Bvlig7LsXTu5RloERTAoGYMmQ8
-4CRDaP+rQGDsp4bcf161czNSwVC4BBxnEGVykPuEvVK6e+jtagAlD8SIjw9A7CyX
+fdPMEhr483Mui5wtCnJMzuEIk8xkEhgCS/q5XY037/uw3bb8K0ZZ2z6QATKU180Z
-8C8cmdtDR20k4aJZ8nY1zHyGMN7fcDJZjw5fM1rM56GIcBTN2o5CBt8B5E/DV/SD
+8FWoYn9j7IEo7yYEz54ZJKEi+GVro3j1RyDwBhtTz8bpnSQ2oW29jVKzJjJBhKJ/
-zlfnDw9KNOrgRHEk3d3wZGOZeuGGyHr0YwtiqA0ZNx/e+b/pOG/aucl9/h2Y2Yym
+VfIVsZCvlUYUbwmdPI71DX3e/4E+XioMYhxvjTXl3QE93+47TlDAEdlXspKseaw5
-icnqFkECgZhxYTS8xvZFm6WzjjDd4QyWYfGNPNEa0vCktYpz3GJ3hxKQQGj4N/lk
+WF5gTJkCgZkA8Hi24HicbqzxpQ8WeiG8Vl/Qkm7kANqDTwO6ZhcuWrO5rTqFlmMl
-w7mrGGOiOM9lR9rUmc0g8qXO7fGpxE8Djt5Os4+orO9PLNfdr0sJSp3T4Vb99d71
+Q5IpyYVVmSRo+Sd+2MRXskie6/tmaAgXlNUIBL0cDupIwk66z3loiKUSaocTpeia
-NwYQWmo2j855EYPziLN0x+0OqsjLNjyvX7EJgsRJYA8nn52D1LeBxBNOJZWqrV9R
+Pt8HJcpTk/JWlqJ78mfVS9KKaBdC/TSVs9N9EO/KHAJDl8UsbLh2q3T8Wjc2+ROZ
-4vIwLFDO8/bpjIDJrqjMgg==
+XnwlBhqrbULWIEcvGWW4FzQ=
 -----END RSA PRIVATE KEY-----

test/test_certs/server.cert.pem

@@ -1,25 +1,25 @@
 -----BEGIN CERTIFICATE-----
-MIIEMzCCAuugAwIBAgIEU3emwDANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
+MIIEMzCCAuugAwIBAgIEU7iVFjANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
 RTEeMBwGA1UECgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5MRIwEAYDVQQHDAlHw7Z0
 ZWJvcmcxGjAYBgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5kMR4wHAYDVQQDDBVHw7Z0
-ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNTE3MTgxMzIwWhcNMTUwNTE3MTgxMzIw
+ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNzA2MDAxNTE4WhcNMTUwNzA2MDAxNTE4
 WjBAMR4wHAYDVQQKDBVHw7Z0ZWJvcmcgQml0IEZhY3RvcnkxHjAcBgNVBAMMFUfD
 tnRlYm9yZyBCaXQgRmFjdG9yeTCCAVIwDQYJKoZIhvcNAQEBBQADggE/ADCCAToC
-ggExAM2soV1TPLKp8SjqTtxBHj+Uu9SJM56eyHaK6kwCN6DQyA8dea+cqNJLRWKw
+ggExAKsv5Nau53tmC8n3UH+FmraZPNr7glF0sDe0ofGz7YL2omKgE4QXIumiJ6ab
-dIyK0HqAdE9xf0Q9VkR5JuGCHB80802c3AkwnXdE3syFYEGISqTbFZr14V0m87fn
+5jXWaFwubhiy6WEdSPtOkdB1VelNzfm0jPSXsDJhowfaUBP5F4iw7UUfapJ3feXf
-axnGHZ0dyKWoRQbJ2purbWpQ23jZIUZQUhTD4e84aqnUco9aUCyzJ3gkvDgFeBg9
+Y5ieJj+Dd1jsOIWwnOFvl+qvMC+KtjH4v+4nTRJ0QdI5/EheEJECmtxAS4XtmNJV
-EwHMlaavkddJa+In5qOcSrTNJq+XmNrMly0ifr/CA/LfWAk7LEvqk/JjaLS5DWs+
+qQ2lRquGOxHz4tAzH1dl2WDKZm6/Jn9gKxH66iGIKMrkbRuaVTbZI838SK2GJRLp
-VnLaQSSD82CEorypFqo4mR1u/Q5G7+AWXatJEbnf4SbI0agcU/IZMLzPPhfNvNEL
+3FAIEps87kOitfZkQeMh15nsTW1e+HCitsyDiCY+cW7D5uTSn07c4pMYo0VXU5BH
-jPelfrrXi3LqI+Y53w85PvdEd2S/SeS6QN1rK3KHQ8b/2QjekROfxCRBNn/SZCgN
+Gwj+gaNYZPP0G088g9hRg4c1oufYGhkO0G4P583+/7Nc2eZWOve3o/tJwEfGT8pk
-PqcD/kwzDxSdRrqECaMcmxIVsJMCAwEAAaOBlzCBlDAMBgNVHRMBAf8EAjAAMB4G
+FTgAOc+ZBSQUgqyoswiWyTsZhqcCAwEAAaOBlzCBlDAMBgNVHRMBAf8EAjAAMB4G
 A1UdEQQXMBWCDXRhc2t0b29scy5vcmeHBGFrjWswEwYDVR0lBAwwCgYIKwYBBQUH
-AwEwDwYDVR0PAQH/BAUDAwegADAdBgNVHQ4EFgQU/CLd6IX4ns73IW9JtetxKjEz
+AwEwDwYDVR0PAQH/BAUDAwegADAdBgNVHQ4EFgQURXMgYOwqEdOjh4T6gXCNph1i
-GOcwHwYDVR0jBBgwFoAUDZvEvP9T4ftv3cVT711JQT5wPWswDQYJKoZIhvcNAQEL
+W+kwHwYDVR0jBBgwFoAUV6hrNd+llELYw9FhchM/2QvO37UwDQYJKoZIhvcNAQEL
-BQADggExADjPCZnLCxWYK5YklECLa8avBedw5p0Z17Fu38ZkAmhnUEqpyzqy/ZQ/
+BQADggExAG/0Fr2FYjtxnQNqQukODgLhE0nuR78G4aLbO3UYEP7vAaclUKlF2IsE
-P0FrZpqs0KNnPgYm7tRqWqYKc/kPHLfJO5HZGyeMzMLc5xGKH92YNRPMJHtiGOKf
+aTSnvOqIF4pwrrA08D0fu5ZlHwJ//JQhxyrJAHmmYol3zX48iVAau8KD4FvEsLV7
-KAf9N+OIdfyzasMX+4JoVIuRiawilldJY/kolHewBBMTR8r+UK/KqfhBRFQCWAbh
+d2SERbtl02yZ/e2J50pyEikwgke4I+V/Wjphg28tOZVRPFZy+N8J+j7Dn/faTlJF
-/kOn/nHd0/uSYZY3AgpEePpJLZ2uVvZWRfic+JjLhqHDNYn2Xc8CViWDqjC6R6ZJ
+mp121KuyR098YV6EDNSnUMDsaVCO8y/OfQXewDMJdVTeYapH91S6RU5b1q16mIHQ
-XFovWXBcs8R4C3kWoaJOisyPNFGCg/nCELSpm2BehcUwr76TRVtMU+Ge3aOTBWjP
+bFBJhWcOXTJdCpxq8nSAXYOIk5EKFIJqrlzA6ZcoiOtva5m1isSjyhQ/fotLAduX
-DoHbp2VvC2L2PI6lcksfH+nnnHAgxIqKgnP11seB6t55ecwtTiaoKrYMUd1E++iH
+YJ1qbTghXCTWuUxX+GjUDqnNK3pHfTCUYJALaT95IunyB/YJGGgFmUoc3hqP+rcQ
-8hCm7ND5cJb4yJ+clGCdpXoOq+bN83k=
+2EyLepPryOLhqXsETgYnMKyBhXRhzAM=
 -----END CERTIFICATE-----

test/test_certs/server.crl.pem

@@ -2,13 +2,13 @@
 MIICKTCB4gIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJTRTEeMBwGA1UE
 CgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5MRIwEAYDVQQHDAlHw7Z0ZWJvcmcxGjAY
 BgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5kMR4wHAYDVQQDDBVHw7Z0ZWJvcmcgQml0
-IEZhY3RvcnkXDTE0MDUxNzE4MTMyMFoXDTE1MDUxNzE4MTMyMFowAKAvMC0wHwYD
+IEZhY3RvcnkXDTE0MDcwNjAwMTUxOFoXDTE1MDcwNjAwMTUxOFowAKAvMC0wHwYD
-VR0jBBgwFoAUDZvEvP9T4ftv3cVT711JQT5wPWswCgYDVR0UBAMCAQAwDQYJKoZI
+VR0jBBgwFoAUV6hrNd+llELYw9FhchM/2QvO37UwCgYDVR0UBAMCAQAwDQYJKoZI
-hvcNAQEFBQADggExAJRdlrW0zbhr2R9iScc9bkflv7x2f8Cha/M+To8fik8OsDs0
+hvcNAQEFBQADggExAFoR5SJ/D0SWE9kGgvgotRFFeXfkgel9im/sQdHdUrKn/MGG
-xmNOSTfbisA60YvFudBSGXwUzGyx8nAoYJgFrpIrG3gco8uCPnFPW5f2yvumelxA
+imT4upSBU1hTgDqy252DRUPrs3DXON/T4L8sWq7t7PfzlDbO6fV2Wkmsd43/yCPt
-KYGLic2iAIHb290UttfcM+ft/5eILciFaPkycSyppA5ZBRnJ7N20ppat071bFZOo
+tK6dsrcnAhWFCamkBNVGi/RZt6da3y72Y7fo7cfzkK8UeF6UWgGBt4+raR3pmRIw
-c+jT6+DLI3ondy6HPBkuCyfUjjVd8bJFEx2JjBFd6rjOgwlPN/j1Pb83oZ5A8ETV
++FpDEYuUOXajvtIxMD0CMdeFo+w8/5RGxXyqR4sftnRrD2hX6aFljrejxP/Pa7M9
-JSdxADBf0DLMW7zE+J8OU4Q7aAW2bwdDqxZglBT8lNvGDkD4/BsFYAmaSvdm9JRM
+TvgKtUMxsOSauSWN7vg59+FE92PNqNa3KEquO7h5CI5yjr/+85K7o/6FGHOV4iD2
-iCbnTxgbFVHwR4d0x2bQ1Qy2l1CALRHlhmvha3mWdOGDNKanQRT3Xb7iOL0N02le
+h/RQHI2l8AEpqDqJLZu5GvjN6mblhIYlo+uMTZOXHWxoIDDQLsOXJyCpHSNWjGRs
-+1vZMtwH7W03eqTimSPH7nmgWUP7cvCA4ErldD4=
+dP4OMD0/0ykppjogdOdUMEN/8smqtPumPzP/ykg=
 -----END X509 CRL-----

test/test_certs/server.key.pem

@@ -1,32 +1,32 @@
 -----BEGIN RSA PRIVATE KEY-----
-MIIFfAIBAAKCATEAzayhXVM8sqnxKOpO3EEeP5S71Ikznp7IdorqTAI3oNDIDx15
+MIIFegIBAAKCATEAqy/k1q7ne2YLyfdQf4Watpk82vuCUXSwN7Sh8bPtgvaiYqAT
-r5yo0ktFYrB0jIrQeoB0T3F/RD1WRHkm4YIcHzTzTZzcCTCdd0TezIVgQYhKpNsV
+hBci6aInppvmNdZoXC5uGLLpYR1I+06R0HVV6U3N+bSM9JewMmGjB9pQE/kXiLDt
-mvXhXSbzt+drGcYdnR3IpahFBsnam6ttalDbeNkhRlBSFMPh7zhqqdRyj1pQLLMn
+RR9qknd95d9jmJ4mP4N3WOw4hbCc4W+X6q8wL4q2Mfi/7idNEnRB0jn8SF4QkQKa
-eCS8OAV4GD0TAcyVpq+R10lr4ifmo5xKtM0mr5eY2syXLSJ+v8ID8t9YCTssS+qT
+3EBLhe2Y0lWpDaVGq4Y7EfPi0DMfV2XZYMpmbr8mf2ArEfrqIYgoyuRtG5pVNtkj
-8mNotLkNaz5WctpBJIPzYISivKkWqjiZHW79Dkbv4BZdq0kRud/hJsjRqBxT8hkw
+zfxIrYYlEuncUAgSmzzuQ6K19mRB4yHXmexNbV74cKK2zIOIJj5xbsPm5NKfTtzi
-vM8+F8280QuM96V+uteLcuoj5jnfDzk+90R3ZL9J5LpA3WsrcodDxv/ZCN6RE5/E
+kxijRVdTkEcbCP6Bo1hk8/QbTzyD2FGDhzWi59gaGQ7Qbg/nzf7/s1zZ5lY697ej
-JEE2f9JkKA0+pwP+TDMPFJ1GuoQJoxybEhWwkwIDAQABAoIBMQC6ewRP1rGZGKa0
++0nAR8ZPymQVOAA5z5kFJBSCrKizCJbJOxmGpwIDAQABAoIBMEYSQq+FxIcETEsN
-v0VDRLOFWHi5arDn5/XALZHj2rrPT52kvsffJv6WtXKy2WTDLPV7rM5IXZLTr31x
+isvIGn4n13sjfEJvazpCHA/dwJjc77dDIvnspoPPtj9CjUb4Tpt8/d/qTBFOdXM4
-VhufqdWPofXb8BY9KtwLEOGltGSi5k0vjgjX2Io+aJvfqa6cztl45FFRifEUB57z
+xAL6JIJtMKTHvPLZrGvS/3LVb/Xc/j8bfOPQakUt2EDh4di0058n5xBlEPXYRz8X
-OApbs/ZaaxxVYWwascQ/nvpvA1XfjjZVYRavQzd439SUvYNnRTSGzndAKKztfjns
++K09rJGpS87ErXuEZs3o/JBa3+OXbVyOHmmNf9yAVw+xtJM7VeQb+83rcKobt0X6
-HX19iT6JBfO2/5rfB8zjSHe+0kcRSB/ebKoI6NGvOa/jRqxO1vJ5Xq2RWjCI38SL
+aPm1lYkc4oiYcaPa/Vz39jdP5eBekrIbJ4/uLDhZ1UKBxEn7vW+J5cGGqJpksC18
-abNDI6+0UynpjQn7cHZWvlMno5l1K/4DSzYPthD44rJPfx6UTrJrcYHkukuv/n+C
+UHrTpm3T+SXKnEU8eGFHH3ukNuESTPa5Ywp8Jgkrs23HjUi26nwxqsPuXzVEL++/
-yN5PdK0ORTd2XvVDPWImbjbWp8BdUHE2q+R4Brl12agcQXBzR1N71BJiGl6N/i2e
+AgTX8NXXy4c8HQ7d6WDC9wL6b7h75uStrdRrTRPPYvWXJRfwB+WF1IE2MpAtiG96
-iATiMA3BAoGZAOerWQ+al5i0kYEFG9OfEJUBuUB2FhLgojpM7ZuE6PJAChv99Y7Q
+ORL445ECgZkA3kwxkP27KtpFRVdPc3S+pb7WCoNNx40F8OUKiCht1w1vRnHJY3N+
-U/kXgUoF7j11NK3VS2CtCDrAgUSuzVdHQa9UXvj6c7DKus4OdE+vqVxci28Vmz2a
+K5Xv1lMIAU0LsVME5QDGmu1O2bhb/95NKNkHm54l5NhuwSMDL4iP4h0CUb4XbD/O
-5EjFSu2Ijt6t06aDnpRCqDaqv7vwqB/Cn5YV5vaBIfSfnLSlMAGPPMzFf86MYKR2
+02t7xN6kh9wmUDkPOPX8IuNupc/ipK9r98xBdxW9dCwXcixjmbihrSi1xG1qKqSH
-LYTfqiJP8VmGGTKM5UB7m89hAoGZAONGYdabtRvALgOvb6zwMiXNm2Pi5mlc1YOj
+fdQlp4mjAk9PW5SEJ6A3XBsCgZkAxSP/+maMAT8jhNe5ISgeMfLqbf1S6xqIYGtn
-WX4CxKcCbV3psf0mTc2pM2I6nfhRsbFC2Jb2awd1qsIoG+GDsmI7Xbe38krn05U4
+G6VZWGOCjm1MdSlDk4HmkgnLOJLZseKnuNVOEjiolqOgpaPdkacdI2RdUhoLXazA
-lZm93xlGBkn7sbwQ5xO74SW8bgs+OSZzEkfJcfB8XQb6XQRJNrkxu1Shx9IuxhML
+7ZQ6YfG15pwCzS/xcuhURByhBiP7LvwfSjTA5iESsgnFu9WXbxMf2Py7ttpooHDk
-5eQ2a5xKilvrzzhlGQQgizCqVhy5HMFGgSpIbIhzAoGYWIhVx63HYzcWJ90g7jVq
+vreawetHrSe00ZAotV0Y1zWHeLUkvB9JYjWJkGUCgZh3mY7hb2IQADdcw0jf2WPp
-a9c1yVmXQ+2OcYM2hmk7cGBivKHHtqUMgjOmV/h+PARPdmL9pFtbusAYZnv6wvDb
+UO9f4J0sS9dycAhmkTnnhjbkM7wiYbT0RksviKS57nXoBb6QZwZzvFG8GdCFrVje
-PDqc9L8ZeSVwUBCcCFvT+BTxwCjco6VOujSTVsUJ/DUnngnMj1IN4J5OGW91gHWq
+LUZGl6PTqA6OowPHwzWGdg0VZay8dOgWH7ILja3/2pZSeyCRiOcK7kpNs7dA25C/
-8Ps7wVZF+KsKgsph1ya7EHIlTnS89fynlpC2/tfYHuMtO/E2JvdV6uECgZkA1pbi
+VYmzRGMV6dMDfpZn0kpKG6kP8b45CyRKsqU/qnGlgH41y4X+u9iNGQKBmDhYKLI9
-1BYqt2wKRlKEOB6GyujKWlKnyT3tH6DBY9hLQ4FoMC7ybpqXBaNHr+y2sPq5syvx
+muhETneKXHwwhijKf9w92fQeGjpMmCSbpqSPlGH2tTKLP6gqKWc162JY/mVMHZnD
-gwBh6CYyt6XVRWXqrRNuloPpEs63GQLXRdVf6+YRFBPBKlgvRpOzrsSuhpEWtvYZ
+RVQJ441iaOjOo+YcOETES7PKg9MbK+z7P5B8z/uAPYC9oimwY10wPYmOwRzVrG++
-gYxzt2RFFcyYvO4/7DZHsU4bdJnTTbKDOqojiutanhYVjyLtrtbndWiva+lgfCEM
+Eh/z9e7ywhQEYQq7EZAn89K4K80nVwl3WoDwKQVBYvm+VRQ47n+b6gNC6qPl4Uhz
-3haJ238CgZgbnkF4IlwNat95eKl+ddIBAl3/SDAMct/McLLYN1R8j+zhtotUf5wA
+esTNAoGYCBL0d9Rhl3ViQCGM/qkaM9YJ7nm1EJ9g9rCOCQCQOK6J40hY8q+BtQph
-/wSHZgPpa7GbBymVERycogmyIs5LbfKpIPBNcwtl2O/So6R/+qCj39uMPrVIodqp
+LfYQSqyoN2p/M3toHEeXtnKmgO4+9o7g52zKOBvN566+tEEZUirsane29UuaZBXp
-Dkb7OBhH+uo6xzQLi/Jd2CbMAqq1MVWmDEIftJjAPacWDjJODlg6lg0+c/2MZav8
+ixW1i7VOtDOU//oeWvJnd1oufYIi9rZ/F1pK+aqNHgknCxQ3Ogolz3n23TdWcFXj
-PXsW0Mtrlz2wCGhkcaQffA==
+FGx/3NV/ZgtZ3UVTxXM=
 -----END RSA PRIVATE KEY-----

test/test_certs/test_client.cert.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEETCCAsmgAwIBAgIEU7iVYjANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJT
+RTEeMBwGA1UECgwVR8O2dGVib3JnIEJpdCBGYWN0b3J5MRIwEAYDVQQHDAlHw7Z0
+ZWJvcmcxGjAYBgNVBAgMEVbDpHN0cmEgR8O2dGFsYW5kMR4wHAYDVQQDDBVHw7Z0
+ZWJvcmcgQml0IEZhY3RvcnkwHhcNMTQwNzA2MDAxNjM0WhcNMTUwNzA2MDAxNjM0
+WjBAMR4wHAYDVQQKDBVHw7Z0ZWJvcmcgQml0IEZhY3RvcnkxHjAcBgNVBAMMFUfD
+tnRlYm9yZyBCaXQgRmFjdG9yeTCCAVIwDQYJKoZIhvcNAQEBBQADggE/ADCCAToC
+ggExALeprOEBf9cRr0ZjieNvXMyAKk3J/CBI9381PkvYhxldPYMOhcWNPBcdn3Qc
+bnDY7JiRYFZUnRNorj2rdh7DB8DUHeCccgpP0o3eByUttkIxixVKEkAA2rD7qKCv
+6giCu1Iyt1FQxdJV7Y+A+oECar8VmOLVHjjiSa7Q16yy4uJtGQ/u8MdPAXOzoDbO
+0zGZIHnhJODdwZtTgG0iAq6Pa29bWAzUK2g5EWGkJUPwbYf1R2QcCqa7j7u+5Nmm
+i9iefoPkP6H5cNgZitrscF+57/UsbYo38s++OgNt+dZeRsbpVwHSgWrnA9EOk0Bs
+aQFk/eNlbOn8NzC+FYBGHUhkjzXfeWdm/obnZlH3VmzRxFer1ujikyX+0XVfEbWo
+inWrswVsYEgum6CZVHEJKy5tQE8CAwEAAaN2MHQwDAYDVR0TAQH/BAIwADATBgNV
+HSUEDDAKBggrBgEFBQcDAjAPBgNVHQ8BAf8EBQMDB6AAMB0GA1UdDgQWBBQoLP1q
+l8tKYMDoScUs1AFsc7E4PDAfBgNVHSMEGDAWgBRXqGs136WUQtjD0WFyEz/ZC87f
+tTANBgkqhkiG9w0BAQsFAAOCATEAM/tpjJHUHniDtjiuYQtoxtSJTBZuph5a584D
+o8syrNhf5r6ykZHDq4njHF2rc7QBiQaBIyl+BpDdfi3exVMjgUw6LisNIBl32dN9
+g63E4/RlulNxpJCXM+o/q0F5A+cQvD0Y9q0bGigUeUFLWzmwUH2ZLgF+puJtCzsy
+CIfyp+gewKNttLMPe3wTe6JKo3HEvRP9qfSJhu00qlKM5ynzsiBqpfatu2BMQV/P
+PG51JsQMYXBW97d5lI+RYYCE5aJCrj6iBfnvvRf5qGIXYlgZ1JZVTz0/7EXrKlNe
+sVZtVgEFpiPTjOWE5hm4CAW8yRAi1f89R0guQcBqm6KmCoab4acSwVkB+qTzgi9E
+5uqNREDdHnrIXXExEWHMBsBTynwYf04ouMaBPFHNEI2xWF4JQA==
+-----END CERTIFICATE-----

test/test_certs/test_client.key.pem

@@ -0,0 +1,32 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIFewIBAAKCATEAt6ms4QF/1xGvRmOJ429czIAqTcn8IEj3fzU+S9iHGV09gw6F
+xY08Fx2fdBxucNjsmJFgVlSdE2iuPat2HsMHwNQd4JxyCk/Sjd4HJS22QjGLFUoS
+QADasPuooK/qCIK7UjK3UVDF0lXtj4D6gQJqvxWY4tUeOOJJrtDXrLLi4m0ZD+7w
+x08Bc7OgNs7TMZkgeeEk4N3Bm1OAbSICro9rb1tYDNQraDkRYaQlQ/Bth/VHZBwK
+pruPu77k2aaL2J5+g+Q/oflw2BmK2uxwX7nv9Sxtijfyz746A2351l5GxulXAdKB
+aucD0Q6TQGxpAWT942Vs6fw3ML4VgEYdSGSPNd95Z2b+hudmUfdWbNHEV6vW6OKT
+Jf7RdV8RtaiKdauzBWxgSC6boJlUcQkrLm1ATwIDAQABAoIBMHnFafYVRGmYNBn7
+TSUaZPDB2UqSLTRKrK4O4yrueUR76ZjHPDJrHfhFj78wSplPei791F3o4+xGb6A7
+2qkyriVPfi+6CnKD0hp1p08jK8BfkNOgtNDywAywDnHbsNPLud8Z+SlU4JRAnK2U
+2oJG0/e1nhRnMQ6OGkRp+1VplbyCkSdbSREcdN39rrAoGSa9XCby+7yLyx3r8pFs
+fQR9BFN3JDKUSbHoeQODegMwBbofTthkmFxmMzXB1ij0jYT/YcN3q8zd+/cHV1bo
+xd/vL6eY/v64jRoijhi3XLRpfRfWpsi0LbBDMvx8wtVPJqAhEXU98XgrjQZRb5e4
+wPRQkHAOzpbcQovROIA3AmuZHc++m+7o3tW3qtT6MHs1HfgCnz7lq1cLaMpY1Tza
+ilBejkECgZkA7HJNXwmIzCFt2hGJz2HCdodKfubLXRYYhGLGoV6iXGMJS14WVAQV
++Dqfy5HRqIRb8nv0cL4R5HzZ5Z4ssbxrq7WM0b6sE9FhI5Y7d07h9/iQEE9/Bznc
+EqqBBa6sofC6ZCMsiQR/EStL6vTRIdwJbxpGh4FMJb/5XbGjsnIddNxKlJttTsyl
+iMSBWN/+3OautZWopmL7fzcCgZkAxtnqBeLyKXhrtwBy2DrcoSUri5m4uZEm91Ly
+Yan0NDH113IGz/b1UEd3yPINAaJclScXsMZRuV9Wnb787U4lVLZvLpMZeyJ5btWk
+5+mJHanhtK1f8BObwzFy5G032ELsEXW/h1IxNMs2E8CAjMD/Q03wqEGKm3QD8aFc
+EOdnqZXGVZ7sZaYNHxkJ4zR9U3dJAXjA7t9sY6kCgZhL2PLG3MkcKlER1fRuKP73
+hLi58pEj4DWnKgRruW690ismGR1ygAkIIs4lwDYQJ71TEL49+ErHD+HaDZ5quXWU
+lF2C3vZWOSE/CC81O4GzSPH1uXqXN9FHz5gp2XmZTR6Nhtb/cQjN2iS1TylTAkGo
+eTZMu4ZQyb9Vdel8Ea0vUoc+Gom68FzdfaO8fcZE2F8M8uAx16iziwKBmQCg+0m5
++kCR0ithu7s90mlLDAx0t74UfK5PC5et+Sj6GHguMuHQ+t0eYL1YsJxW9lp9ZWiI
+dAU1TTmR+0xH0TvnmMnpqqy2QvKMB+m41hdrLFzNKI7CjR1MqHua8dCEA6mZePnV
+U3UCiID+/JkVWilNE4wAqw7LSuDmfPtLtAr3/4jRSBeZMxTsWBjpF1VefPNdfaSz
+vazCAQKBmBBZ76P4WxjSwo5QC9mGQvBZp7res0hrXoC8m49Xys7NL/zqSMYMUJdM
+uR+Ia4rM562s9lR5Oklt80KY1qyCqAeAW2xEpFchg+Cc81UHdxnM6oTewzcl54yF
+/nvj7e9kq7V3pLvDs6j4izvKSpubg6MX725fKNJ9C3Fkt3rxAihdJSFRlAWgYue1
+SNmpNgd7F3spzRXX+tH1
+-----END RSA PRIVATE KEY-----