def test_get_command(self):
c = CommandFactory.get_command('')
self.assertEqual(len(c.arguments), 1)
self.assertEqual(c.arguments[0], '')
c = CommandFactory.get_command(' ')
self.assertEqual(len(c.arguments), 1)
self.assertEqual(c.arguments[0], '')
c = CommandFactory.get_command('a ')
self.assertEqual(len(c.arguments), 1)
self.assertEqual(c.arguments[0], 'a')
c = CommandFactory.get_command("żółć@ 'drugi argument'")
self.assertEqual(len(c.arguments), 2)
self.assertEqual(c.arguments[0], 'żółć@')
self.assertEqual(c.arguments[1], 'drugi argument')
c = CommandFactory.get_command(
"it's ''a' 'crazy' 'almost a good day' xD'' ")
self.assertEqual(len(c.arguments), 5)
self.assertEqual(c.arguments[0], "it's")
self.assertEqual(c.arguments[1], "'a")
self.assertEqual(c.arguments[2], 'crazy')
self.assertEqual(c.arguments[3], 'almost a good day')
self.assertEqual(c.arguments[4], "xD''")
def test_unrecognized(self, mock_logging):
self.q1.get = MagicMock(
return_value=CommandFactory.get_command('unrecognized command'))
self.mt.run()
self.assertEqual(
self.q2.get(),
MumjolandiaResponseObject(
MumjolandiaReturnValue.mumjolandia_unrecognized_command,
CommandFactory.get_command('unrecognized command')))
def test_sanity_supervisors_not_called(self, mock_food, mock_task,
mock_logging):
self.q1.get = MagicMock(return_value=CommandFactory.get_command(''))
self.mt.run()
self.assertEqual(
self.q2.get(),
MumjolandiaResponseObject(
MumjolandiaReturnValue.mumjolandia_unrecognized_command,
CommandFactory.get_command('')))
self.assertEqual(mock_food.call_count, 0)
self.assertEqual(mock_task.call_count, 0)
class Console:
def __init__(self):
self.command_factory = CommandFactory()
self.async_command = None
self.thread = None
def get_next_command(self):
return self.command_factory.get_command(input())
def get_next_text(self):
return input()
def get_async_command(self):
if self.async_command is None:
if self.thread is None:
self.thread = threading.Thread(target=self.__thread_get_input,
args=())
self.thread.start()
return_value = None
else:
return_value = self.async_command
self.async_command = None
self.thread = None
return CommandFactory().get_command(return_value)
def __thread_get_input(self):
self.async_command = input()
def test_pass_random_command(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.run()
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('task task ls'))
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 1)
def test_exit(self, mock_logging):
self.q1.get = MagicMock(
return_value=CommandFactory.get_command('exit'))
self.mt.run()
self.assertEqual(
self.q2.get(),
MumjolandiaResponseObject(
status=MumjolandiaReturnValue.mumjolandia_exit))
def test_calling_exit_with_mode(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.mode = MumjolandiaCliMode.task
self.cli.run()
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('exit'))
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 1)
def _MumjolandiaConnectionHandler__parse_received_message(self, message):
if message == 'exit':
self.server_loop_exit_flag = True
return_value = 'Server shutting down'
else:
return_value = MumjolandiaResultParser().parse(
self.data_passer.pass_command(
CommandFactory.get_command(message)))
return return_value
def get_async_command(self):
if self.async_command is None:
if self.thread is None:
self.thread = threading.Thread(target=self.__thread_get_input,
args=())
self.thread.start()
return_value = None
else:
return_value = self.async_command
self.async_command = None
self.thread = None
return CommandFactory().get_command(return_value)
def test_change_modes(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 2)
self.assertEqual(mock_passer.call_count, 1)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.task)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('task test'))
self.assertEqual(mock_command.call_count, 4)
self.assertEqual(mock_passer.call_count, 2)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.food)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('food test'))
self.assertEqual(mock_command.call_count, 6)
self.assertEqual(mock_passer.call_count, 3)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.food)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('food test'))
self.assertEqual(mock_command.call_count, 8)
self.assertEqual(mock_passer.call_count, 4)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 10)
self.assertEqual(mock_passer.call_count, 5)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.game)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('game test'))
self.assertEqual(mock_command.call_count, 12)
self.assertEqual(mock_passer.call_count, 6)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 14)
self.assertEqual(mock_passer.call_count, 7)
def test_pass_command(self, mock_clear, mock_wait):
qi = Queue()
qo = Queue()
qi.put = MagicMock(return_value=None)
qo.get = MagicMock(
return_value=MumjolandiaReturnValue.mumjolandia_exit)
qo.task_done = MagicMock(return_value=None)
mutex = threading.Lock()
event = threading.Event()
dp = MumjolandiaDataPasser(qi, qo, mutex, event)
command = CommandFactory.get_command('xD')
return_value = dp.pass_command(command)
qi.put.assert_called_with(command)
qo.get.assert_called_with()
qo.task_done.assert_called_with()
self.assertEqual(mock_wait.call_count, 1)
self.assertEqual(mock_clear.call_count, 1)
self.assertEqual(return_value, MumjolandiaReturnValue.mumjolandia_exit)
class MumjolandiaStarter:
def __init__(self, sysargs):
self.commands = None
self.__init_commands(
sysargs[1:]) # rest of arguments are user passed commands
self.config = ConfigLoader.get_config()
self.log_location = ConfigLoader.get_mumjolandia_location(
) + 'data/log.log'
self.command_queue_request = Queue()
self.command_queue_response = Queue()
self.command_responded_event = threading.Event()
self.data_passer = None
self.command_mutex = threading.Lock()
self.mumjolandia_thread = None
self.__run_init()
def run(self):
self.__run_mumjolandia()
if ConfigLoader.get_config().background_server == 'true':
self.run_server()
self.run_cli()
def run_cli(self):
cli = MumjolandiaCli(self.data_passer, self.commands)
cli.setName('cli thread')
cli.start()
def run_server(self):
server = MumjolandiaServer(self.data_passer)
server.setName('mumjolandia server')
server.start()
def get_mumjolandia_thread(self):
return self.mumjolandia_thread
def set_commands(self, commands):
self.commands = CommandFactory().get_command(commands)
self.commands.append(CommandFactory().get_command('exit'))
def __run_mumjolandia(self):
self.mumjolandia_thread = MumjolandiaThread(
self.command_queue_request, self.command_queue_response,
self.command_responded_event)
self.mumjolandia_thread.setName('mumjolandia thread')
self.mumjolandia_thread.start()
def __run_init(self):
if not os.path.isdir(ConfigLoader.get_mumjolandia_location() + "data"):
try:
os.mkdir(ConfigLoader.get_mumjolandia_location() + "data")
except OSError as e:
pass
try:
if os.path.isfile(self.log_location):
os.remove(self.log_location)
except OSError as e:
pass
try:
handlers = []
if self.config.log_to_display.lower() == 'True'.lower():
handlers.append(logging.StreamHandler())
if self.config.log_to_file.lower() == 'True'.lower():
handlers.append(logging.FileHandler(self.log_location))
if len(handlers) == 0:
logging.getLogger().disabled = True
else:
logging.basicConfig(
format=
'%(asctime)s [%(levelname).1s] %(module)s::%(funcName)s --- %(message)s',
datefmt='%d/%m/%Y %H:%M:%S',
handlers=handlers,
level=self.config.log_level.upper())
except ValueError:
logging.error('Logging level: "' + self.config.log_level +
'" is incorrect.')
self.data_passer = MumjolandiaDataPasser(self.command_queue_request,
self.command_queue_response,
self.command_mutex,
self.command_responded_event)
def __init_commands(self, commands):
self.commands = CommandFactory().get_command(commands)
if not len(self.commands):
self.commands = None
if self.commands is not None:
self.commands.append(CommandFactory().get_command('exit'))
def __init__(self):
self.command_factory = CommandFactory()
self.async_command = None
self.thread = None
def test_food(self, mock_food_supervisor, mock_logging):
self.q1.get = MagicMock(
return_value=CommandFactory.get_command('food print'))
self.mt.run()
self.assertEqual(mock_food_supervisor.call_count, 1)
self.assertEqual(self.q2.get(), 'not important, just passing by')
def __init_commands(self, commands):
self.commands = CommandFactory().get_command(commands)
if not len(self.commands):
self.commands = None
if self.commands is not None:
self.commands.append(CommandFactory().get_command('exit'))
class TestMumjolandiaCli(TestCase):
def setUp(self):
self.dp = MumjolandiaDataPasser(1, 1, 1, 1)
self.cli = MumjolandiaCli(self.dp)
self.cp = MumjolandiaCliPrinter()
# cli.run() exits when flag is raised, but for some commands (mode, cls) the check is skipped.
# to exit, it is necessary to call extra command that is passed to DataPasser (so the flag check will occur)
def execute_patched():
self.cli.exit_flag = MumjolandiaImmutableTypeWrapper(True)
return None
self.cp.execute = MagicMock(side_effect=execute_patched())
self.cli.cli_printer = self.cp
@patch(
'src.modules.mumjolandia.mumjolandia_data_passer.MumjolandiaDataPasser.pass_command',
return_value=None)
@patch('src.modules.console.console.Console.get_next_command',
side_effect=[
CommandFactory.get_command('mode'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode task'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode food'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode invalid'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode none'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode game'),
CommandFactory.get_command('test'),
CommandFactory.get_command('mode'),
CommandFactory.get_command('test')
])
@unittest.skip(
"test_change_modes"
"This test uses parowa flow which was fixed during refactor\n"
"Test shall be refactored")
def test_change_modes(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 2)
self.assertEqual(mock_passer.call_count, 1)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.task)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('task test'))
self.assertEqual(mock_command.call_count, 4)
self.assertEqual(mock_passer.call_count, 2)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.food)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('food test'))
self.assertEqual(mock_command.call_count, 6)
self.assertEqual(mock_passer.call_count, 3)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.food)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('food test'))
self.assertEqual(mock_command.call_count, 8)
self.assertEqual(mock_passer.call_count, 4)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 10)
self.assertEqual(mock_passer.call_count, 5)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.game)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('game test'))
self.assertEqual(mock_command.call_count, 12)
self.assertEqual(mock_passer.call_count, 6)
self.cli.run()
self.assertEqual(self.cli.mode, MumjolandiaCliMode.none)
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('test'))
self.assertEqual(mock_command.call_count, 14)
self.assertEqual(mock_passer.call_count, 7)
@patch(
'src.modules.mumjolandia.mumjolandia_data_passer.MumjolandiaDataPasser.pass_command',
return_value=None)
@patch('src.modules.console.console.Console.get_next_command',
side_effect=[
CommandFactory.get_command('cls'),
CommandFactory.get_command('path')
])
def test_not_passable_commands(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.run()
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 0)
self.cli.run()
self.assertEqual(mock_command.call_count, 2)
self.assertEqual(mock_passer.call_count, 0)
@patch(
'src.modules.mumjolandia.mumjolandia_data_passer.MumjolandiaDataPasser.pass_command',
return_value=MumjolandiaResponseObject(
status=MumjolandiaReturnValue.task_get, arguments=[]))
@patch('src.modules.console.console.Console.get_next_command',
side_effect=[CommandFactory.get_command('task ls')])
def test_pass_random_command(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.run()
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('task task ls'))
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 1)
@patch(
'src.modules.mumjolandia.mumjolandia_data_passer.MumjolandiaDataPasser.pass_command',
return_value=None)
@patch('src.modules.console.console.Console.get_next_command',
side_effect=[
CommandFactory.get_command('cls'),
CommandFactory.get_command('path')
])
def test_calling_not_passable_commands_with_mode(self, mock_command,
mock_passer):
with HiddenPrints():
self.cli.mode = MumjolandiaCliMode.task
self.cli.run()
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 0)
self.cli.run()
self.assertEqual(mock_command.call_count, 2)
self.assertEqual(mock_passer.call_count, 0)
@patch(
'src.modules.mumjolandia.mumjolandia_data_passer.MumjolandiaDataPasser.pass_command',
return_value=MumjolandiaResponseObject(
status=MumjolandiaReturnValue.mumjolandia_exit, arguments=[]))
@patch('src.modules.console.console.Console.get_next_command',
side_effect=[CommandFactory.get_command('exit')])
def test_calling_exit_with_mode(self, mock_command, mock_passer):
with HiddenPrints():
self.cli.mode = MumjolandiaCliMode.task
self.cli.run()
self.assertEqual(mock_passer.call_args[0][0],
CommandFactory.get_command('exit'))
self.assertEqual(mock_command.call_count, 1)
self.assertEqual(mock_passer.call_count, 1)
def __execute_mumjolandia_command(self, command):
return self.data_passer.pass_command(CommandFactory().get_command(command))
def __call_shutdown(self):
logging.info("Update succeeded. Restarting...")
self.data_passer.pass_command(CommandFactory().get_command("exit"))
self.exit_flag = True
def set_commands(self, commands):
self.commands = CommandFactory().get_command(commands)
self.commands.append(CommandFactory().get_command('exit'))
