def test__given_command_processor__when_command_processor_invoked_with_new_peer_join__then_invoke_add_peer_and_data_upload( self, mock_websocket): calls_for_get_peer = [ mock.call('peer_id_1'), mock.call('peer_id_2'), mock.call('peer_id_3'), mock.call('SAMPLE_PEER_ID') ] calls_for_send_data_to_peer = [ mock.call('peer_id_1'), mock.call('peer_id_2'), mock.call('peer_id_3'), mock.call('SAMPLE_PEER_ID') ] mock_websocket.return_value = self.mock_websocket_instance command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.NEW_PEER_JOIN) expected_output = 'ACK' self.assertEqual(mock_websocket.call_count, 1) self.assertEqual(expected_output, actual_output) self.mock_chain_instance.add_new_peer.assert_called_once_with( 'SAMPLE_PEER_ID', { 'host': '0.0.0.0', 'port': '1234' }) self.mock_chain_instance.get_peer_id_list.assert_called_once() self.mock_chain_instance.get_peer.assert_has_calls(calls_for_get_peer) self.mock_chain_instance.get_block_data.assert_called_once() self.mock_websocket_instance.send.assert_called_once_with( json.dumps(TestCommandProcessor.UPLOAD_DICT))
class IntergrationTestProcessMethod(TestCase): def setUp(self): self.command_processor = CommandProcessor() def test_init_command(self): command = "Create_parking_lot 6" output = self.command_processor.process(command) self.assertEqual(output, "Created parking of 6 slots") def test_init_with_non_positive_int_size(self): command = "Create_parking_lot -6" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Lot size should be positive integer") command = "Create_parking_lot 6.3" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Lot size should be positive integer") command = "Create_parking_lot 0" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Lot size should be positive integer") def test_park_with_valid_data(self): command = "Create_parking_lot 3" output = self.command_processor.process(command) self.assertEqual(output, "Created parking of 3 slots") command = "Park KA-01-HH-1234 driver_age 21" output = self.command_processor.process(command) self.assertEqual( output, 'Car with vehicle registration number "KA-01-HH-1234" has been parked at slot number 1', ) command = "Park KA-01-HH-1234 driver_age 21" output = self.command_processor.process(command) self.assertEqual( output, "Vehicle with this registration number is already parked.") command = "Park KA-01-HH-1235 driver_age 21" output = self.command_processor.process(command) self.assertEqual( output, 'Car with vehicle registration number "KA-01-HH-1235" has been parked at slot number 2', ) command = "Park KA-01-HH-1236 driver_age 21" output = self.command_processor.process(command) self.assertEqual( output, 'Car with vehicle registration number "KA-01-HH-1236" has been parked at slot number 3', ) command = "Park KA-01-HH-1237 driver_age 21" output = self.command_processor.process(command) self.assertEqual(output, "Cannot park more vehicles because parking is full.")
def processRequest(): try: form_data_dict = request.form logger.info("request team_id : %s" % form_data_dict['team_id']) cmdProcessor = CommandProcessor() response = cmdProcessor.processCommand(form_data_dict['text'], form_data_dict) return response except: return "Oops, could not process request."
def test__given_command_processor__when_command_processor_invoked_with_ping__then_return_pong_as_message( self): command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.PING_COMMAND) expected_output = {'CMD': 'PONG'} self.assertEqual(expected_output, actual_output) self.assertIsInstance(actual_output, dict)
def test__given_command_processor__when_command_processor_invoked_with_add_block_comand__then_add_block( self): command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.ADD_BLOCK_COMMAND) expected_output = 'ACK' self.assertEqual(expected_output, actual_output) self.mock_chain_instance.add_block.assert_called_once_with('TEST_DATA')
def test__given_command_processor__when_command_processor_invoked_with_validate_block_comand__then_validate_block( self): command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.VALIDATE_COMMAND_BLOCK) expected_output = 'ACK' self.assertEqual(expected_output, actual_output) self.mock_chain_instance.validate_block.assert_called_once_with( {'data': 'Test Data'})
def test__given_command_processor__when_command_processor_invoked_with_add_peer__then_invoke_add_peer_on_chain_instance( self): command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.ADD_PEER_COMMAND) expected_output = 'ACK' self.mock_chain_instance.add_new_peer.assert_called_once_with( 'SAMPLE_PEER_ID', { 'host': '0.0.0.0', 'port': '1234' }) self.assertEqual(expected_output, actual_output)
def setUp(self): self.command_processor = CommandProcessor() command = "Create_parking_lot 5" self.command_processor.process(command) command = "Park KA-01 driver_age 21" output = self.command_processor.process(command) command = "Park KA-02 driver_age 18" output = self.command_processor.process(command) command = "Park KA-03 driver_age 18" output = self.command_processor.process(command) command = "Park KA-04 driver_age 21" output = self.command_processor.process(command)
def __init__(self, websocket_port, *args, **kwargs): """ Function for intializing the block chain server. Initializes the BlockChain as well as the HTTP server for interacting with the blockchain """ bc_logger('Setting up naive chain server') self.peer_id = str(uuid.uuid4()) self.age = datetime.datetime.now() self.websocket_port = websocket_port bc_logger('Intializing websocket RPC') self.initialize_blockhain_rpc() bc_logger('Intializing websocket RPC') bc_logger('Intializing protocol processing') self.protocol_processor = CommandProcessor(self) self.peer_list = [] self.peer_connect_dict = {} self.block_data = [] # replace with a thread safe implementation # will run this in the background as a future that never returns!! self.rpc_server.start_websocket() bc_logger('Node {} live on {}:{}'.format(self.peer_id, '0.0.0.0', self.websocket_port)) if kwargs.get('existing_peer'): bc_logger('Peer Discovered') epeer_id = kwargs.get('peer_id') epeer_host = kwargs.get('peer_host') epeer_port = kwargs.get('peer_port') self.join_existing_peer_on_startup(epeer_id, epeer_host, epeer_port) else: bc_logger( 'No Peer Specified. Intializing genesis block for standalone operation' ) self.configure_genesis() # will block on this self.intialize_http_server() self.http_server.start_server()
def __init__(self, config): """ Initialize :param config: configuration :type config: Config """ self.command_processor = CommandProcessor( self._command_handlers(config.command_handlers)) self.robot = Robot(config.apiai.client_access_token, config.apiai.language, self.command_processor.commands) self.speech_to_text = SpeechToText( config.speechkit.key, "", config.speechkit.recognition.language) self.text_to_speech = TextToSpeech( config.speechkit.synthesis.cache_size, config.speechkit.key, config.speechkit.synthesis.language, config.speechkit.synthesis.speaker, config.speechkit.synthesis.emotion, config.speechkit.synthesis.speed) self.record = SpeechCapture(config.record.silence_calculation_chunks, config.record.speech_level_coefficient, config.record.start_wait_chunks, config.record.finish_wait_chunks)
def test__given_command_processor__when_command_processor_invoked_with_new_peer_join_then_raise_websocket_exception__then_remove_added_from_block_chain( self, mock_websocket): calls_for_get_peer = [ mock.call('peer_id_1'), mock.call('peer_id_2'), mock.call('peer_id_3'), mock.call('SAMPLE_PEER_ID') ] calls_for_send_data_to_peer = [ mock.call('peer_id_1'), mock.call('peer_id_2'), mock.call('peer_id_3'), mock.call('SAMPLE_PEER_ID') ] mock_websocket.return_value = self.mock_websocket_instance mock_websocket.side_effect = websocket_client.WebSocketTimeoutException command_processor = CommandProcessor(self.mock_chain_instance) actual_output = command_processor.command_processor( TestCommandProcessor.NEW_PEER_JOIN) expected_output = 'ACK' self.assertEqual(expected_output, actual_output) self.mock_chain_instance.add_new_peer.assert_called_once_with( 'SAMPLE_PEER_ID', { 'host': '0.0.0.0', 'port': '1234' }) self.assertEqual(mock_websocket.call_count, 1) self.mock_chain_instance.get_peer_id_list.assert_called_once() self.mock_chain_instance.get_peer.assert_has_calls(calls_for_get_peer) self.mock_chain_instance.get_block_data.assert_called_once() self.mock_chain_instance.remove_peer.assert_called_once_with( 'SAMPLE_PEER_ID')
def __init__(self, client): self.manually_overriden = False self.configuration_manager = ConfigurationManager(self.CONFIGURATION_FILENAME) self.repost_manager = RepostManager(self.HASHES_FILENAME) self.command_processor = CommandProcessor(self) self.configuration_manager.load_configuration() self.TOKEN = self.configuration_manager.configuration['token'] self.MASTER_ADMIN_ID = self.configuration_manager.configuration['admin'] self.ABOUT_MESSAGE = self.configuration_manager.configuration['about'] self.client = client
def test_file_reading(self, mockPrint): command_processor = CommandProcessor() input_consumer = FileInputConsumer(command_processor) file_name = os.path.join(os.path.dirname(__file__), "./data/test1.txt") input_consumer.consume(file_name) mockPrint.write.assert_has_calls( [ call("Created parking of 6 slots"), call("\n"), call( 'Car with vehicle registration number "KA-01-HH-1234" has been parked at slot number 1' ), call("\n"), call( 'Car with vehicle registration number "PB-01-HH-1234" has been parked at slot number 2' ), call("\n"), call("1,2"), call("\n"), call( 'Car with vehicle registration number "PB-01-TG-2341" has been parked at slot number 3' ), call("\n"), call("2"), call("\n"), call( 'Slot number 2 vacated, the car with vehicle registration number "PB-01-HH-1234" left the space, the driver of the car was of age 21' ), call("\n"), call( 'Car with vehicle registration number "HR-29-TG-3098" has been parked at slot number 2' ), call("\n"), call(""), call("\n"), ] )
def main(stdscr): holdstdout = StdOutWrapper() sys.stdout = holdstdout sys.stderr = holdstdout #stdscr = curses.initscr() screen_size = stdscr.getmaxyx() height = screen_size[0] width = screen_size[1] hincrement = int(height / 3) wincrement = int(width / 3) upper_left = (0, 0) upper_middle = (0, wincrement) upper_right = (0, 2 * wincrement) middle_left = (hincrement, 0) middle_middle = (hincrement, wincrement) middle_right = (hincrement, 2 * wincrement) lower_left = (2 * hincrement, 0) lower_middle = (2 * hincrement, wincrement) #lower_right= (2 * hincrement, 2 * wincrement) # Skills | Spells | Loadout # HUD | Map | Inventory # Terminal | Status | Inventory # Terminal green curses.init_pair(1, 46, curses.COLOR_BLACK) # Dull red curses.init_pair(2, 196, curses.COLOR_BLACK) # Dull Teal curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK) # Black on Grey curses.init_pair(4, curses.COLOR_BLACK, 244) # bronze curses.init_pair(5, 208, curses.COLOR_BLACK) curses.init_pair(6, 208, 130) # steel curses.init_pair(7, 252, curses.COLOR_BLACK) curses.init_pair(8, 253, 247) # mithril curses.init_pair(9, 117, curses.COLOR_BLACK) curses.init_pair(10, 117, 33) # adamant curses.init_pair(11, 99, curses.COLOR_BLACK) curses.init_pair(12, 52, 99) # demon curses.init_pair(13, 92, curses.COLOR_BLACK) curses.init_pair(14, 52, 99) # spark curses.init_pair(15, 92, curses.COLOR_BLACK) curses.init_pair(16, 52, 99) # night curses.init_pair(17, 92, curses.COLOR_BLACK) curses.init_pair(18, 52, 99) # cooked meat curses.init_pair(19, 124, curses.COLOR_BLACK) # leather curses.init_pair(20, 130, curses.COLOR_BLACK) # oak curses.init_pair(21, 172, curses.COLOR_BLACK) # maple curses.init_pair(22, 167, curses.COLOR_BLACK) # willow curses.init_pair(23, 137, curses.COLOR_BLACK) # flax curses.init_pair(100, 100, curses.COLOR_BLACK) # gold curses.init_pair(253, 220, curses.COLOR_BLACK) # white curses.init_pair(254, 252, curses.COLOR_BLACK) # box color, dull grey curses.init_pair(255, 240, curses.COLOR_BLACK) terwin = curses.newwin(hincrement, wincrement, lower_left[0], lower_left[1]) terwin.attron(curses.color_pair(255)) terwin.box() ter_panel = curses.panel.new_panel(terwin) ter_panel.top() hudwin = curses.newwin(hincrement, wincrement, middle_left[0], middle_left[1]) hudwin.attron(curses.color_pair(255)) hudwin.box() hud_panel = curses.panel.new_panel(hudwin) hud_panel.top() invwin = curses.newwin(hincrement * 2, wincrement, middle_right[0], middle_right[1]) invwin.attron(curses.color_pair(255)) invwin.box() inv_panel = curses.panel.new_panel(invwin) inv_panel.top() stswin = curses.newwin(hincrement, wincrement, lower_middle[0], lower_middle[1]) stswin.attron(curses.color_pair(255)) stswin.box() sts_panel = curses.panel.new_panel(stswin) sts_panel.top() sklwin = curses.newwin(hincrement, wincrement, upper_left[0], upper_left[1]) sklwin.attron(curses.color_pair(255)) sklwin.box() skl_panel = curses.panel.new_panel(sklwin) skl_panel.top() eqpwin = curses.newwin(hincrement, wincrement, upper_right[0], upper_right[1]) eqpwin.attron(curses.color_pair(255)) eqpwin.box() eqp_panel = curses.panel.new_panel(eqpwin) eqp_panel.top() mapwin = curses.newwin(hincrement, wincrement, middle_middle[0], middle_middle[1]) mapwin.attron(curses.color_pair(255)) mapwin.box() map_panel = curses.panel.new_panel(mapwin) map_panel.top() splwin = curses.newwin(hincrement, wincrement, upper_middle[0], upper_middle[1]) splwin.attron(curses.color_pair(255)) splwin.box() spl_panel = curses.panel.new_panel(splwin) spl_panel.top() curses.start_color() curses.cbreak() curses.noecho() terwin.keypad(1) terwin.idcok(False) try: var_handler = VarHandler() command_processor = CommandProcessor(var_handler) var_handler.bind('command_processor', command_processor) io_handler = IOHandler(terwin, var_handler) var_handler.bind('io_handler', io_handler) hud_handler = HUDHandler(hudwin, var_handler) var_handler.bind('hud_handler', hud_handler) status_handler = StatusHandler(stswin) var_handler.bind('status_handler', status_handler) player = Player(sklwin, var_handler) var_handler.bind('player', player) inventory_handler = InventoryHandler(invwin, eqpwin, var_handler) var_handler.bind('inventory_handler', inventory_handler) location_handler = LocationHandler(mapwin, var_handler) var_handler.bind('location_handler', location_handler) time_handler = TimeHandler() var_handler.bind('time_handler', time_handler) spell_handler = SpellHander(splwin, var_handler) var_handler.bind('spell_handler', spell_handler) combat_handler = CombatHandler(var_handler) var_handler.bind('combat_handler', combat_handler) start = location_handler.spawn_location('entervale') location_handler.spawn_location('forest') start.move("mine") io_handler.output("Welcome to pyscape", curses.color_pair(3), curses.A_BOLD) hud_handler.text_update() hud_panel.top() inventory_handler.update_inv_window() curses.panel.update_panels() while True: curses.curs_set(1) input = io_handler.get_input("~~~~~~~:", curses.color_pair(1)) output = command_processor.receive_command(input) io_handler.output(output[0], output[1]) hud_handler.text_update() hud_panel.top() #inventory_handler.draw_bank() curses.panel.update_panels() except KeyboardInterrupt: terwin.addstr("exiting") exit(0) finally: terwin.keypad(0) curses.nocbreak() curses.echo() curses.endwin() sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ sys.stdout.write(holdstdout.get_text())
def setUp(self, daoMock, serviceMock): self.command_processor = CommandProcessor() self.parking_lot_service_mock = serviceMock.return_value
class Application: """ Application main class """ def __init__(self, config): """ Initialize :param config: configuration :type config: Config """ self.command_processor = CommandProcessor( self._command_handlers(config.command_handlers)) self.robot = Robot(config.apiai.client_access_token, config.apiai.language, self.command_processor.commands) self.speech_to_text = SpeechToText( config.speechkit.key, "", config.speechkit.recognition.language) self.text_to_speech = TextToSpeech( config.speechkit.synthesis.cache_size, config.speechkit.key, config.speechkit.synthesis.language, config.speechkit.synthesis.speaker, config.speechkit.synthesis.emotion, config.speechkit.synthesis.speed) self.record = SpeechCapture(config.record.silence_calculation_chunks, config.record.speech_level_coefficient, config.record.start_wait_chunks, config.record.finish_wait_chunks) def _handler(self, real_handler): return lambda args: real_handler(self, args) def _command_handlers(self, command_handlers): result = {} for command, handler in stdhandlers.items(): result[command] = self._handler(handler) for command, handler in command_handlers.items(): result[command] = self._handler(handler) return result def _process_answer(self, commands): finish, results = self.command_processor.process_commands(commands) if not finish: noempty_results = [ result for result in results if result is not None ] play_list(noempty_results) def welcome(self): """ Run robot welcome event """ success, session_id, answer_commands = self.robot.welcome() if success: self.speech_to_text.uuid = session_id self._process_answer(answer_commands) def query(self): """ Run speech request (if we'lll have it) """ print("Listening") silent, record = self.record.record_mp3() if silent: print("Silent") return success, text = self.speech_to_text.convert(record) if not success: print("Not recognized") return print("User : "******"Robot commands : " + json.dumps(commands)) if not success: return self._process_answer(commands) def main(self): self.welcome() while True: self.query()
def setUp(self): self.command_processor = CommandProcessor()
class UnitTestProcessMethod(TestCase): @patch("command_processor.ParkingLotService") @patch("command_processor.ParkingLotDao") def setUp(self, daoMock, serviceMock): self.command_processor = CommandProcessor() self.parking_lot_service_mock = serviceMock.return_value def test_init_command(self): command = "Create_parking_lot 7" self.parking_lot_service_mock.create_parking_lot_of_size = MagicMock( return_value=7) output = self.command_processor.process(command) self.parking_lot_service_mock.create_parking_lot_of_size.assert_called_once_with( 7) self.assertEqual(output, "Created parking of 7 slots") @patch("command_processor.Vehicle") @patch("command_processor.Driver") def test_park_command(self, driverMock, vehicleMock): command = "Park KA-01-HH-1234 driver_age 21" parked_slot_mock = MagicMock() parked_slot_mock.return_value.parked_vehicle.number = "KA-01-HH-1234" type(parked_slot_mock.return_value).number = PropertyMock( return_value=1) self.parking_lot_service_mock.park_vehicle = parked_slot_mock output = self.command_processor.process(command) driverMock.assert_called_once_with(21) vehicleMock.assert_called_once_with("KA-01-HH-1234", driverMock.return_value) self.parking_lot_service_mock.park_vehicle.assert_called_once_with( vehicleMock.return_value) self.assertEqual( output, 'Car with vehicle registration number "KA-01-HH-1234" has been parked at slot number 1', ) def helper_to_test_missing_command_args_error(self, command): with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Missing command arguments.") def helper_to_test_missing_operation_in_command_error(self, command): with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, command + " missing valid operation.") def test_error_thrown_on_invalid_command(self): command = "Create_parking_lot" self.helper_to_test_missing_command_args_error(command) command = "Create_parking_lot " self.helper_to_test_missing_command_args_error(command) command = "Park " self.helper_to_test_missing_command_args_error(command) command = "Park VIP-001 driver_age " self.helper_to_test_missing_command_args_error(command) command = "Park driver_age 21" self.helper_to_test_missing_command_args_error(command) command = "Invalidop 6" self.helper_to_test_missing_operation_in_command_error(command) command = "Create_parking_lot invalid_size" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual( e.msg, "invalid_size is not int. Slot size should be int.") command = "Park number_plate_sample driver_age -21" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "-100 is negative. Age should be positive.")
def main(): input_file = args[1] file_input_consumer = FileInputConsumer(CommandProcessor()) file_input_consumer.consume(input_file)
class IntergrationTestUnparkParkProcessMethod(TestCase): def setUp(self): self.command_processor = CommandProcessor() command = "Create_parking_lot 5" self.command_processor.process(command) command = "Park KA-01 driver_age 21" output = self.command_processor.process(command) command = "Park KA-02 driver_age 18" output = self.command_processor.process(command) command = "Park KA-03 driver_age 18" output = self.command_processor.process(command) command = "Park KA-04 driver_age 21" output = self.command_processor.process(command) def test_invalid_query(self): command = "Leave " with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Missing command arguments.") command = "Leave string" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "string is not int. Slot number should be int.") command = "Leave -2" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual( e.msg, "-5 is negative. Slot Number should be positive.") def test_valid_commands(self): command = "Leave 2" output = self.command_processor.process(command) self.assertEqual( output, 'Slot number 2 vacated, the car with vehicle registration number "KA-02" left the space, the driver of the car was of age 18', ) command = "Leave 3" output = self.command_processor.process(command) self.assertEqual( output, 'Slot number 3 vacated, the car with vehicle registration number "KA-03" left the space, the driver of the car was of age 18', ) command = "Leave 3" output = self.command_processor.process(command) self.assertEqual(output, "Slot already vacant") command = "Leave 6" output = self.command_processor.process(command) self.assertEqual(output, "Slot number not present.") command = "Park KA-05 driver_age 21" output = self.command_processor.process(command) self.assertEqual( output, 'Car with vehicle registration number "KA-05" has been parked at slot number 2', )
class IntergrationTestQueryCommandsProcessMethod(TestCase): def setUp(self): self.command_processor = CommandProcessor() command = "Create_parking_lot 5" self.command_processor.process(command) command = "Park KA-01 driver_age 21" output = self.command_processor.process(command) command = "Park KA-02 driver_age 18" output = self.command_processor.process(command) command = "Park KA-03 driver_age 18" output = self.command_processor.process(command) command = "Park KA-04 driver_age 21" output = self.command_processor.process(command) def test_invalid_query(self): command = "Slot_number_for_car_with_number " with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Missing command arguments.") command = "Slot_numbers_for_driver_of_age " with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Missing command arguments.") command = "Vehicle_registration_number_for_driver_of_age " with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "Missing command arguments.") command = "Slot_numbers_for_driver_of_age csd" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "csd is not int. Age should be int.") command = "Vehicle_registration_number_for_driver_of_age sdc" with self.assertRaises(MalformedCommandError) as e: output = self.command_processor.process(command) self.assertEqual(e.msg, "sdc is not int. Age should be int.") def test_valid_commands(self): command = "Slot_number_for_car_with_number KA-01" output = self.command_processor.process(command) self.assertEqual(output, "1") command = "Slot_number_for_car_with_number KA-02" output = self.command_processor.process(command) self.assertEqual(output, "2") command = "Slot_number_for_car_with_number KA-03" output = self.command_processor.process(command) self.assertEqual(output, "3") command = "Slot_number_for_car_with_number KA-04" output = self.command_processor.process(command) self.assertEqual(output, "4") command = "Slot_number_for_car_with_number KA-05" output = self.command_processor.process(command) self.assertEqual(output, "") command = "Slot_numbers_for_driver_of_age 18" output = self.command_processor.process(command) self.assertEqual(output, "2,3") command = "Slot_numbers_for_driver_of_age 21" output = self.command_processor.process(command) self.assertEqual(output, "1,4") command = "Slot_numbers_for_driver_of_age 14" output = self.command_processor.process(command) self.assertEqual(output, "") command = "Vehicle_registration_number_for_driver_of_age 14" output = self.command_processor.process(command) self.assertEqual(output, "") command = "Vehicle_registration_number_for_driver_of_age 21" output = self.command_processor.process(command) self.assertEqual(output, "KA-01,KA-04") command = "Vehicle_registration_number_for_driver_of_age 18" output = self.command_processor.process(command) self.assertEqual(output, "KA-02,KA-03")
class BlockChain(object): """ Blockchain server object using which will be responsible for starting the HTTP server as well adding more information to the blockchain """ def __init__(self, websocket_port, *args, **kwargs): """ Function for intializing the block chain server. Initializes the BlockChain as well as the HTTP server for interacting with the blockchain """ bc_logger('Setting up naive chain server') self.peer_id = str(uuid.uuid4()) self.age = datetime.datetime.now() self.websocket_port = websocket_port bc_logger('Intializing websocket RPC') self.initialize_blockhain_rpc() bc_logger('Intializing websocket RPC') bc_logger('Intializing protocol processing') self.protocol_processor = CommandProcessor(self) self.peer_list = [] self.peer_connect_dict = {} self.block_data = [] # replace with a thread safe implementation # will run this in the background as a future that never returns!! self.rpc_server.start_websocket() bc_logger('Node {} live on {}:{}'.format(self.peer_id, '0.0.0.0', self.websocket_port)) if kwargs.get('existing_peer'): bc_logger('Peer Discovered') epeer_id = kwargs.get('peer_id') epeer_host = kwargs.get('peer_host') epeer_port = kwargs.get('peer_port') self.join_existing_peer_on_startup(epeer_id, epeer_host, epeer_port) else: bc_logger( 'No Peer Specified. Intializing genesis block for standalone operation' ) self.configure_genesis() # will block on this self.intialize_http_server() self.http_server.start_server() def validate_blockchain(self): import hashlib for i in range(len(self.block_data)): hasher = hashlib.sha256() if i == 0: # genesis block, continue as # is continue prev_hash = self.block_data[i - 1].curr_hash current_block = self.block_data[i].data hasher.update(prev_hash.encode() + current_block.encode()) current_hash = hasher.hexdigest() if current_hash != self.block_data[i].curr_hash: return False return True def join_existing_peer_on_startup(self, peer_id, host, port): """ Send intialization request for data upload and connecting to other peers """ bc_logger('Joining remote peer') self.protocol_processor.add_new_peer(peer_id, host, port) command_dict = {} command_dict['CMD'] = 'NEW_PEER_JOIN' command_dict['peer_id'] = self.peer_id command_dict['peer_host'] = '0.0.0.0' command_dict['peer_port'] = self.websocket_port bc_logger('Intializing data sync peer') self.protocol_processor.write_to_peers([peer_id], json.dumps(command_dict)) def configure_genesis(self): """ Class function for configuring gensis """ genesis_block = Block(0, 'ioiiiuasyi891qbduquiuqwiqwiupwe', 'random') self.block_data.append(genesis_block) def create_sample_block_data(self, data): latest_block = self.block_data[-1] last_block = Block(latest_block.index + 1, latest_block.curr_hash, data) return last_block def add_block(self, data): latest_block = self.block_data[-1] last_block = Block(latest_block.index + 1, latest_block.curr_hash, data) self.block_data.append(last_block) return last_block def validate_block(self, block_data): block_data['data'] = json.loads(block_data.get('data')) latest_block = self.block_data[-1] compiled_block_data = Block(latest_block.index + 1, latest_block.curr_hash, block_data.get('data')) return block_data.get('curr_hash') == compiled_block_data.curr_hash def add_data(self, data): block = self.create_sample_block_data(data) consensus_result = self.protocol_processor.get_peer_agreement(({ 'CMD': 'VALIDATE_BLOCK', 'block_data': block.serialize() })) if not consensus_result: return False self.add_block(data) self.protocol_processor.write_to_peers( self.peer_connect_dict.keys(), json.dumps({ 'CMD': 'ADD_BLOCK', 'data': data })) return self.protocol_processor.get_peer_agreement(block.serialize()) def intialize_http_server(self): """ Initialize the HTTP server for handling incoming requests from the user """ self.http_server = NaiveChainHTTPServer(self, '0.0.0.0', int(self.websocket_port) + 1) def initialize_blockhain_rpc(self): """ Intialize block chain using web sockets """ # remote server for handling incoming requests self.rpc_server = WebSocketServer(self.websocket_port, self) def process_command(self, command): """ Class function for processing any incoming commands from other peers or nodes """ # get the command dict current_command = json.loads(command) return self.protocol_processor.command_processor(current_command) def process_data_upload(self, data): """ Class function for replicating and pre-processing data before adding it to the nodes master records """ #derp!!! return data