opennel-pymanager/tests/test_manager.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# create certificate (use for test)
#    Copyright (C) 2017  AleaJactaEst
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <https://www.gnu.org/licenses/>.

import unittest
import tempfile
import os
import configparser
import multiprocessing
import time
import re
import queue
import signal
import http.server
import logging
import json
from unittest.mock import patch
from unittest.mock import MagicMock

try:
    import pymanager.manager as Manager
except ImportError:
    import sys
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
    import pymanager.manager as Manager
#try:
#    import pymanager.certificate as cert
#except ImportError:
#    import sys
#    import os
#    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
#    import pymanager.certificate as cert


def handler(signum, frame):
    print("TimeOut !")
    raise Exception("end of time")


class TestManager(unittest.TestCase):
    def setUp(self):
        self.openssl = '/usr/bin/openssl'
        self.size_root = 4096
        self.size_appli = 4096
        self.size_child = 2048
        self.passroot = 'BadPasswordRoot'
        self.passappli = 'BadPasswordApplication'
        self.country_name = 'FR'
        self.state_or_province_name = 'France'
        self.locality_name = 'Paris'
        self.organization_name = 'khanat'
        self.common_name = 'khanat'
        self.path = os.path.dirname(os.path.abspath(__file__))
        self.program = os.path.join(self.path, 'simulate_program.py')
        self.badprogram = os.path.join(self.path, 'test.cfg')
        signal.signal(signal.SIGALRM, handler)

    def test_load_config(self):
        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.set('config:server', 'port', '8000')
        config.set('config:server', 'keyfile', '/home/gameserver/ca/appli/private/serverkey.pem')
        config.set('config:server', 'certfile', '/home/gameserver/ca/appli/certs/servercert.pem')
        config.set('config:server', 'ca_cert', '/home/gameserver/ca/appli/certs/cachaincert.pem')
        config.set('config:server', 'address', '')
        config.set('config:server', 'authentification', 'yes')
        config.set('config:server', 'method', 'https')
        config.add_section('config:client')
        config.set('config:client', 'port', '8000')
        config.set('config:client', 'keyfile', '/home/gameserver/ca/appli/private/clientkey.pem')
        config.set('config:client', 'certfile', '/home/gameserver/ca/appli/certs/clientcert.pem')
        config.set('config:client', 'ca_cert', '/home/gameserver/ca/appli/certs/cachaincert.pem')
        config.set('config:client', 'address', '127.0.0.1')
        config.set('config:client', 'method', 'https')
        config.add_section('command:test')
        config.set('command:test', 'path', '/home/gameserver')
        config.set('command:test', 'command', '/bin/sleep 10')
        config.set('command:test', 'logsize', '10')
        config.set('command:test', 'bufsize', '10')
        config.add_section('config:user')
        config.set('config:user', 'usename', 'filter_all, filter_admin')
        try:
            manager = Manager.Manager(False)
            manager._load_config(config)
            self.assertTrue(True)
        except:
            self.fail('Error detected on load config')

    def test_load_config2(self):
        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.set('config:server', 'authentification', 'no')
        config.add_section('command:test')
        config.set('command:test', 'path', '/home/gameserver')
        config.set('command:test', 'command', '/bin/sleep 10')
        try:
            manager = Manager.Manager(False)
            manager._load_config(config)
            self.assertTrue(True)
        except:
            self.fail('Error detected on load config')

    def test_load_config_bad_param_logsize(self):
        config = configparser.ConfigParser()
        config.add_section('command:test')
        config.set('command:test', 'command', '/bin/sleep 10')
        config.set('command:test', 'logsize', 'bidon')
        with self.assertRaises(ValueError):
            manager = Manager.Manager(False)
            manager._load_config(config)
            self.assertTrue(True)

    def test_load_config_bad_param_bufsize(self):
        config = configparser.ConfigParser()
        config.add_section('command:test')
        config.set('command:test', 'command', '/bin/sleep 10')
        config.set('command:test', 'bufsize', 'bidon')
        with self.assertRaises(ValueError):
            manager = Manager.Manager(False)
            manager._load_config(config)
            self.assertTrue(True)

    def test_load_config_empty(self):
        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.add_section('config:client')
        config.set('config:client', 'port', '8000')
        config.set('config:client', 'keyfile', '/home/gameserver/ca/appli/private/clientkey.pem')
        config.set('config:client', 'certfile', '/home/gameserver/ca/appli/certs/clientcert.pem')
        config.set('config:client', 'ca_cert', '/home/gameserver/ca/appli/certs/cachaincert.pem')
        config.set('config:client', 'address', '127.0.0.1')
        config.set('config:client', 'method', 'https')
        config.add_section('config:user')
        config.add_section('command:test')
        config.set('command:test', 'command', '/bin/sleep 10')
        try:
            manager = Manager.Manager(False)
            manager._load_config(config)
            self.assertTrue(True)
        except:
            self.fail('Error detected on load config')

    def test_load_config_file(self):
        cfgfile = tempfile.NamedTemporaryFile(suffix="config.cfg", mode='w+t')
        cfgfile.write('#\n[config:server]\nauthentification = No\n')
        cfgfile.flush()
        try:
            manager = Manager.Manager(False)
            manager.load_config(cfgfile)
            self.assertTrue(True)
        except:
            self.fail('Error detected on load configuration')

    def test_load_config_file_none(self):
        with self.assertRaises(ValueError):
            manager = Manager.Manager(False)
            manager.load_config(None)

    def test_load_password_file(self):
        pwdfile = tempfile.NamedTemporaryFile(suffix="password.cfg", mode='w+t')

        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.set('config:server', 'authentification', 'yes')
        config.set('config:server', 'passwordfile', pwdfile.name)
        pwdfile.write('username:$2a$12$2C97xW0KC/vFp3YyjlOgU.fWXJ3EiGT2Ihb0SWN9Mw0XI4WngiUqS\n\nusername2:badhash\n')
        pwdfile.flush()
        try:
            manager = Manager.Manager(False)
            manager._load_config(config)
            manager.load_password()
            self.assertTrue(True)
        except:
            self.fail('Error detected on load password')

    def test_constructor_manager_command(self):
        try:
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_constructor_manager_command',
                                                  self.program,
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event)
            manageCommand.list_thread()
            self.assertTrue(True)
        except:
            self.fail('Error initialize object ManageCommand')

    def test_execute_manager_command(self):
        try:
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_manager_command',
                                                  self.program,
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event)
            manageCommand.status()
            manageCommand.start()
            manageCommand.status()
            manageCommand.start()
            foundEnd = re.compile('.*(Started).*')
            foundY = re.compile('.*(sendToStdinY).*')
            loop = 10
            while loop > 0:
                time.sleep(1)
                out = manageCommand.getlog(0)
                if foundEnd.match(out):
                    break
                loop -= 1
            if not foundEnd.match(out):
                manageCommand.stop()
                self.assertTrue(False, 'Missing message in log')
            manageCommand.list_thread()
            retA = manageCommand.action("sendToStdinA")
            self.assertEqual(retA, "ok", 'Error impossible to send to stdin')
            for i in range(0,  120):
                retX = manageCommand.action("sendToStdin%d" % i)
                self.assertEqual(retX, "ok", 'Error impossible to send to stdin')
            retY = manageCommand.action("sendToStdinY")
            self.assertEqual(retY, "ok", 'Error impossible to send to stdin')
            loop = 10
            while loop > 0:
                time.sleep(1)
                out = manageCommand.getlog(0)
                if foundY.match(out):
                    break
                loop -= 1
            if not foundY.match(out):
                manageCommand.stop()
                self.assertTrue(False, 'Missing message in log')

            manageCommand.stop()
            manageCommand.status()
            retZ = manageCommand.action("sendToStdinZ")
            manageCommand.stop()
            self.assertEqual(retZ, "ko", 'Error send to stdin when process is down')
            self.assertTrue(True)
        except:
            self.fail('Error initialize object ManageCommand')

    def test_execute_crash_manager_command(self):
        try:
            signal.alarm(30)
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_crash_manager_command',
                                                  self.program + ' --no-loop --timeout 1',
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event)
            res = manageCommand.start()
            self.assertEqual(res, 'started')
            wait = True
            while wait:
                time.sleep(1)
                res = manageCommand.status()
                if res == 'stopped':
                    wait = False
            manageCommand.list_thread()
            manageCommand.stop()
            manageCommand.status()
            self.assertTrue(True)
        except:
            self.fail('Error initialize object ManageCommand')

    def test_execute_not_kill_manager_command(self):
        try:
            signal.alarm(30)
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_not_kill_manager_command',
                                                  self.program + " --disable-kill",
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event,
                                                  maxWaitEnd = 2)
        except:
            self.fail('Error initialize object ManageCommand')
        try:
            res = manageCommand.start()
            self.assertEqual(res, 'started')
            wait = True
            while wait:
                time.sleep(1)
                res = manageCommand.status()
                self.assertEqual(res, 'started')
                res = manageCommand.getlog(0)
                try:
                    resjson = json.loads(res)
                    if 'last-line' in res:
                        if resjson['last-line'] == 3:
                                wait = False
                except:
                    pass
            manageCommand.list_thread()
            manageCommand.stop()
            res = manageCommand.status()
            self.assertEqual(res, 'stopped')
            self.assertTrue(True)
        except Exception as e:
            self.fail('Error when run test (%s)' % str(e))

    def test_execute_command_crashed(self):
        try:
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_command_crashed',
                                                  self.program + " --no-loop --timeout=1",
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event,
                                                  waitDelay = 10)
            manageCommand.start()
            wait = True
            while wait:
                time.sleep(1)
                res = manageCommand.status()
                if res == 'stopped':
                    wait = False
            res = manageCommand.status()
            self.assertEqual(res, 'stopped')
            manageCommand.start()
            wait = True
            while wait:
                time.sleep(1)
                res = manageCommand.status()
                if res == 'stopped':
                    wait = False
            res = manageCommand.status()
            self.assertEqual(res, 'stopped')
            manageCommand.stop()
            self.assertTrue(True)
        except:
            self.fail('Error initialize object ManageCommand')

    def test_execute_command_file_not_found(self):
        try:
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_command_file_not_found',
                                                  self.program + "_not_exist",
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event)
            ret = manageCommand.start()
            manageCommand.stop()
            self.assertEqual(ret, "crashed", 'Error object not generate error when program not exist')
        except:
            self.fail('Error initialize object ManageCommand')

    def test_execute_command_permission(self):
        try:
            logsize = 10
            bufsize = 10
            queueIn = multiprocessing.Queue()
            queueOut = multiprocessing.Queue()
            event = multiprocessing.Event()
            manageCommand = Manager.ManageCommand('test_execute_command_permission',
                                                  self.badprogram,
                                                  self.path,
                                                  logsize,
                                                  bufsize,
                                                  queueIn,
                                                  queueOut,
                                                  event)
            ret = manageCommand.start()
            manageCommand.stop()
            self.assertEqual(ret, "crashed", 'Error object not generate error when bad permission')
        except:
            self.fail('Error initialize object ManageCommand')

    def _runCommand(self, name, command, path, logsize, bufsize, queueIn, queueOut, event):
        """
            Thread to manage khaganat program
        """
        manageCommand = Manager.ManageCommand(name=name,
                                      command=command,
                                      path=path,
                                      logsize=logsize,
                                      bufsize=bufsize,
                                      queueIn=queueIn,
                                      queueOut=queueOut,
                                      event=event)
        manageCommand.run()

    def test_root_bad_loglevel(self):
        with self.assertRaises(ValueError):
            Manager.root(None,
                      None,
                      'NOTEXIST',
                      False,
                      False)

    def test_root_bad_configfile(self):
        logfile = tempfile.NamedTemporaryFile(suffix="password.cfg", mode='w+t')
        with self.assertRaises(ValueError):
            Manager.root(None,
                      logfile,
                      'DEBUG',
                      True,
                      True)

    def test_main(self):
        config = tempfile.NamedTemporaryFile(suffix="password.cfg", mode='w+t')
        config.write('[config:server]\nauthentification=no\n')
        config.flush()
        Manager.main(['--conf=' + config.name])

    def test_run_manager_command(self):
        # Enable timeout
        signal.alarm(10)
        class MockServerHttp:
            def append(self, name, queueIn, queueOut, event):
                pass
            def terminate(self):
                pass
            def join(self):
                pass
        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.add_section('command:test')
        config.set('command:test', 'command', self.program)

        manage = Manager.Manager(False)
        manage.serverHttp = MockServerHttp()
        manage._load_config(config)
        manage.launch_command()
        for key in manage.info:
            queueIn = manage.info[key]['queueIn']
            queueOut = manage.info[key]['queueOut']
            event = manage.info[key]['event']

        queueIn.put("START")
        event.set()
        # Enable timeout
        signal.alarm(10)
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "started", 'Error impossible to start program')
        signal.alarm(0)
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("STATUS")
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "started", 'Error impossible to read status')
        time.sleep(1)
        event.set()
        queueIn.put("STDIN arg")
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "ok", 'Error when send STDIN')
        signal.alarm(0)
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("STDOUT 4")
        item = queueOut.get(timeout=4)
        signal.alarm(0)
        self.assertRegex(item,
            '^[{](.*)("first-line": 4)(.*)[}]$',
            'Error when read STDOUT (Missing first-line)')
        self.assertRegex(item,
            '^[{](.*)("last-line": 4)(.*)[}]$',
            'Error when read STDOUT (Missing last-line)')
        self.assertRegex(item,
            '^[{](.*)(4 arg")(.*)[}]$',
            'Error when read STDOUT (bad record)')
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("BADCOMMAND")
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "error : command unknown", 'Error impossible to read status')
        signal.alarm(0)
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("STOP")
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "stopped", 'Error impossible to read status')
        signal.alarm(0)
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("SHUTDOWN")
        with self.assertRaises(queue.Empty):
            item = queueOut.get(timeout=4)
        #threadCommand.join()
        manage.receive_signal(15, 1)
        manage.wait_children_commands()
        #Disable timeout
        signal.alarm(0)
        self.assertTrue(True)

    def test_run_manager_command_autostart(self):
        # Enable timeout
        signal.alarm(10)
        class MockServerHttp:
            def append(self, name, queueIn, queueOut, event):
                pass
            def terminate(self):
                pass
            def join(self):
                pass
        config = configparser.ConfigParser()
        config.add_section('config:server')
        config.add_section('command:test')
        config.set('command:test', 'command', self.program)

        manage = Manager.Manager(True)
        manage.serverHttp = MockServerHttp()
        manage._load_config(config)
        manage.launch_command()

        key = list(manage.info.keys())[0]
        queueIn = manage.info[key]['queueIn']
        queueOut = manage.info[key]['queueOut']
        event = manage.info[key]['event']

        signal.alarm(10)
        event.set()
        queueIn.put("STATUS")
        item = queueOut.get(timeout=4)
        self.assertEqual(item, "started", 'Error impossible to read status')
        time.sleep(1)
        signal.alarm(10)
        event.set()
        queueIn.put("SHUTDOWN")
        with self.assertRaises(queue.Empty):
            item = queueOut.get(timeout=4)
        #threadCommand.join()
        manage.receive_signal(15, 1)
        manage.wait_children_commands()
        #Disable timeout
        signal.alarm(0)
        self.assertTrue(True)

    class MockStreamRequestHandler():
        def __init__(self):
            self.value = "{}"
            self.message = None
        def define_return(self, value):
            self.value = value
        def read(self, numbercar):
            return bytes(self.value, "utf-8")
        def write(self,  message):
            self.message = message

    class MockServer():
        def __init__(self):
            self.listEvent = {}
            self.listQueueIn = {}
            self.listQueueOut = {}
            self.authentification = False

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_log_message(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.address_string = MagicMock()
        manage.log_message('example')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_set_headers(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage._set_headers()
        manage.send_response.assert_called_with(200)
        # manage.send_header.assert_called_with('Content-type', 'application/json')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.headers = {}
        manage._command_log()
        manage.send_error.assert_called_with(400, "bad content-type")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.headers = {'content-type' : 'application/json'}
        manage._command_log()
        manage.send_error.assert_called_with(400, "bad content-length")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage.rfile = TestManager.MockStreamRequestHandler()
        manage._command_log()
        manage.send_error.assert_called_with(400, 'Missing param name')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.rfile.define_return( '{"name": "test"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._command_log()
        manage.send_error.assert_called_with(400, 'Name unknown')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listQueueIn = {'test': ''}
        manage.rfile.define_return( '{"name": "test"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._command_log()
        manage.send_error.assert_called_with(400, 'Missing param first-line')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_6(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listQueueIn = {'test': ''}
        manage.rfile.define_return( '{"name": "test", "first-line" : "test"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._command_log()
        manage.send_error.assert_called_with(400, 'Impossible to read first-line')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_7(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        #manage.server.listQueueOut['test'].put("empty")
        manage.rfile.define_return( '{"name": "test", "first-line" : "1"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._command_log()
        #self.assertEqual(b'empty',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_command_log_8(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.server.listQueueOut['test'].put("empty")
        manage.rfile.define_return( '{"name": "test", "first-line" : "1"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._command_log()
        self.assertEqual(b'empty',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_list(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage._send_list()
        self.assertEqual(b'{"0": "test"}',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_shutdown(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage._send_shutdown()
        self.assertEqual(b'{"shutdown": "ok"}',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_all(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.server.listQueueOut['test'].put("empty")
        manage._send_command_all("test")
        self.assertEqual(b'{"test": "empty"}',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_all_timeout(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage._send_command_all("test")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_action()
        manage.send_error.assert_called_with(400, 'Missing param name')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.rfile.define_return( '{"name": "testnew"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_action()
        manage.send_error.assert_called_with(400, 'Name unknown')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.rfile.define_return( '{"name": "test"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_action()
        manage.send_error.assert_called_with(400, 'Missing param action')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.rfile.define_return( '{"name": "test", "action": "example"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_action()
        self.assertEqual(None,manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.server.listQueueOut['test'].put("empty")
        manage.rfile.define_return( '{"name": "test", "action": "example"}' )
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_action()
        self.assertEqual(b'{"state": "empty"}',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_action_6(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.headers = {}
        manage._send_action()

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.headers = {}
        manage._send_command("STATUS")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage._send_command("STATUS")
        manage.send_error.assert_called_with(400, 'Missing param name')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage.server.listQueueOut['test'].put("empty")
        manage.rfile.define_return( '{"name": "test"}' )
        manage._send_command("STATUS")
        self.assertEqual(b'{"state": "empty"}',manage.wfile.message)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage.rfile.define_return( '{"name": "test"}' )
        manage._send_command("STATUS")
        manage.send_error.assert_called_with(500, 'Missing return')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_send_command_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()

        manage.rfile = TestManager.MockStreamRequestHandler()
        manage.wfile = TestManager.MockStreamRequestHandler()
        manage.server = TestManager.MockServer()
        manage.server.listEvent = {'test': multiprocessing.Event() }
        manage.server.listQueueIn = {'test': multiprocessing.Queue() }
        manage.server.listQueueOut = {'test': multiprocessing.Queue()}
        manage.headers = {'content-length' : '1000', 'content-type' : 'application/json'}
        manage.server.listQueueOut['test'].put("empty")
        manage.rfile.define_return( '{"name": "testnew"}' )
        manage._send_command("STATUS")
        manage.send_error.assert_called_with(400, 'Name unknown')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._command_log = MagicMock()
        manage.path = "/STDOUT"
        manage.do_GET()
        manage._command_log.assert_called_with()

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        res = manage.check_authentication()
        self.assertEqual(True, res)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.server.authentification = True
        res = manage.check_authentication()
        self.assertEqual(False, res)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        logging.error = MagicMock()
        manage.server.authentification = True
        manage.headers = {'Authorization' : 'Other'}
        res = manage.check_authentication()
        self.assertEqual(False, res)
        logging.error.assert_called_with("Authentification with Bad method (Other)")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        logging.error = MagicMock()
        manage.server.authentification = True
        manage.headers = {'Authorization' : 'Basic '}
        res = manage.check_authentication()
        self.assertEqual(False, res)
        logging.error.assert_called_with("Error detected list index out of range")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        logging.error = MagicMock()
        manage.server.authentification = True
        manage.headers = {'Authorization' : 'Basic test:$2b$12$AoRGhrAYsuSlROUDx.0AZ.3SPBVYd8wD.Vyz7jCRXZdwm7ArEN3Oi'}
        res = manage.check_authentication()
        self.assertEqual(False, res)
        logging.error.assert_called_with("Error detected Incorrect padding")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_6(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.server.users = {"user1": ""}
        logging.error = MagicMock()
        manage.server.authentification = True
        manage.headers = {'Authorization' : 'Basic dGVzdDokMmIkMTIkQW9SR2hyQVlzdVNsUk9VRHguMEFaLjNTUEJWWWQ4d0QuVnl6N2pDUlhaZHdtN0FyRU4zT2k='}
        res = manage.check_authentication()
        self.assertEqual(False, res)
        logging.error.assert_called_with("Authentification with unknown user (test)")
        signal.alarm(0)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_7(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        #manage.server.users = {"username": bytes("$2b$12$f5kbmfXvUq3LDequGHcoqu06AueJ35TpIU2MIf5L8c9Y1PE/6Rz4i", "utf-8")}
        #manage.server.users = {"username": b"$2b$12$f5kbmfXvUq3LDequGHcoqu06AueJ35TpIU2MIf5L8c9Y1PE/6Rz4i"}
        manage.server.users = {"username": "$2b$12$f5kbmfXvUq3LDequGHcoqu06AueJ35TpIU2MIf5L8c9Y1PE/6Rz4i".encode('utf-8')}
        logging.error = MagicMock()
        manage.server.authentification = True
        #manage.headers = {'Authorization': bytes('Basic dXNlcm5hbWU6cGFzc3dvcmQ=', 'UTF-8')}
        manage.headers = {'Authorization': 'Basic dXNlcm5hbWU6cGFzc3dvcmQ='}
        res = manage.check_authentication()
        self.assertEqual(True, res)
        #logging.error.assert_called_with("Authentification with user (username)")
        signal.alarm(0)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_check_authentication_8(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.server.users = {"username": "$2b$12$/rfBBlTy3E9CgB8ZGeWFBOo54UN5Ogj3PuEOHVJcXyQ2hL6kYVwWW".encode('utf-8')}
        logging.error = MagicMock()
        manage.server.authentification = True
        manage.headers = {'Authorization': 'Basic dXNlcm5hbWU6cGFzc3dvcmQ='}
        res = manage.check_authentication()
        self.assertEqual(False, res)
        logging.error.assert_called_with("Authentification with wrong password for user (username)")
        signal.alarm(0)

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command = MagicMock()
        manage.path = "/STATUS"
        manage.do_GET()
        manage._send_command.assert_called_with("STATUS")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_list = MagicMock()
        manage.path = "/LIST"
        manage.do_GET()
        manage._send_list.assert_called_with()

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command_all = MagicMock()
        manage.path = "/STATUSALL"
        manage.do_GET()
        manage._send_command_all.assert_called_with("STATUS")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.send_error = MagicMock()
        manage.path = "/BADPATH"
        manage.do_GET()
        manage.send_error.assert_called_with(400, 'Path unknown')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_GET_6(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.server.authentification = True
        manage.send_error = MagicMock()
        manage.path = "/BADPATH"
        manage.do_GET()
        manage.send_error.assert_called_with(403, 'Wrong authentication')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_1(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command = MagicMock()
        manage.path = "/START"
        manage.do_POST()
        manage._send_command.assert_called_with("START")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_2(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command = MagicMock()
        manage.path = "/STOP"
        manage.do_POST()
        manage._send_command.assert_called_with("STOP")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_3(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_action = MagicMock()
        manage.path = "/STDIN"
        manage.do_POST()
        manage._send_action.assert_called_with()

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_4(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_shutdown = MagicMock()
        manage.path = "/SHUTDOWN"
        manage.do_POST()
        manage._send_shutdown.assert_called_with()

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_5(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command_all = MagicMock()
        manage.path = "/STARTALL"
        manage.do_POST()
        manage._send_command_all.assert_called_with("START")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_6(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage._send_command_all = MagicMock()
        manage.path = "/STOPALL"
        manage.do_POST()
        manage._send_command_all.assert_called_with("STOP")

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_7(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()
        manage._send_command = MagicMock()
        manage._send_action = MagicMock()
        manage._send_shutdown = MagicMock()
        manage._send_command_all = MagicMock()
        manage.path = "/BADPATH"
        manage.do_POST()
        manage.send_error.assert_called_with(400, 'Path unknown')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_POST_8(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.server = TestManager.MockServer()
        manage.server.authentification = True
        manage.send_error = MagicMock()
        manage.path = "/BADPATH"
        manage.do_POST()
        manage.send_error.assert_called_with(403, 'Wrong authentication')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_HEAD(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()
        manage.path = "test"
        manage.do_HEAD()
        manage.send_error.assert_called_with(404, 'File Not Found: test')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_PUT(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()
        manage.path = "test"
        manage.do_PUT()
        manage.send_error.assert_called_with(404, 'File Not Found: test')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_PATCH(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()
        manage.path = "test"
        manage.do_PATCH()
        manage.send_error.assert_called_with(404, 'File Not Found: test')

    @patch.object(http.server.SimpleHTTPRequestHandler, '__init__')
    def test_run_manage_do_DELETE(self, init):
        # Enable timeout
        signal.alarm(10)
        manage = Manager.ManageHttpRequest(None, None, None)
        manage.log_message = MagicMock()
        manage.send_response = MagicMock()
        manage.send_header = MagicMock()
        manage.send_error = MagicMock()
        manage.end_headers = MagicMock()
        manage.path = "test"
        manage.do_DELETE()
        manage.send_error.assert_called_with(404, 'File Not Found: test')

if __name__ == '__main__':
    unittest.main()