#!/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 . 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()