def setUp(self):
set_config('quarto_game_store', tempfile.mkdtemp())
game_server = GameServer(configuration)
game_wrapper.set_game_server(game_server)
game_wrapper.set_flask_app(app)
game_wrapper.set_socket_io(socketio)
self.app = app.test_client()
def setUp(self, _, __):
self._server = GameServer(HOST, PORT)
class TestGameServer(unittest.TestCase):
@unittest.mock.patch('socket.socket.bind')
@unittest.mock.patch('socket.socket.listen')
def setUp(self, _, __):
self._server = GameServer(HOST, PORT)
def test_is_active_player(self):
expected_value = True
actual_value = self._server._is_active_player(0)
assert expected_value == actual_value
def test_is_active_player_false(self):
expected_value = False
actual_value = self._server._is_active_player(1)
assert expected_value == actual_value
@unittest.mock.patch('socket.socket.accept',
return_value=(socket.socket(), None))
@unittest.mock.patch('socket.socket.setblocking')
def test_accept_new_connection(self, patched_blocking, patched_accept):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._accept_new_connection(sock)
assert len(self._server._inputs) == 2
assert len(self._server._message_queues.keys()) == 1
@unittest.mock.patch.object(GameServer,
'_parse_command',
return_value='response')
def test_read_client_data(self, patched_parse):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._message_queues[sock] = queue.Queue()
data = b'input'
self._server._read_client_data(sock, data)
patched_parse.assert_called_once()
assert sock in self._server._outputs
@unittest.mock.patch.object(GameServer,
'_parse_command',
return_value='response')
@unittest.mock.patch.object(GameServer, '_start_game')
def test_read_client_data_starts_game(self, patched_start_game,
patched_parse):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._message_queues[sock] = queue.Queue()
self._server._connected_clients = 2
data = b'input'
self._server._read_client_data(sock, data)
patched_parse.assert_called_once()
patched_start_game.assert_called_once()
assert sock in self._server._outputs
@unittest.mock.patch('socket.socket.close')
@unittest.mock.patch.object(GameServer, '_end_game_if_started')
def test_disconnect_client(self, patched_end_game_if_started,
patched_close):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock)
self._server._message_queues[sock] = queue.Queue()
self._server._disconnect_client(sock)
patched_close.assert_called_once()
patched_end_game_if_started.assert_called_once()
@unittest.mock.patch('socket.socket.close')
@unittest.mock.patch.object(GameServer, '_end_game_if_started')
def test_disconnect_client_removed_from_output(self,
patched_end_game_if_started,
patched_close):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock)
self._server._outputs.append(sock)
self._server._message_queues[sock] = queue.Queue()
self._server._disconnect_client(sock)
patched_close.assert_called_once()
patched_end_game_if_started.assert_called_once()
assert sock not in self._server._outputs
@unittest.mock.patch('socket.socket.close')
@unittest.mock.patch.object(GameServer, '_end_game_if_started')
def test_handle_client_exception(self, patched_end_game_if_started,
patched_close):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock)
self._server._message_queues[sock] = queue.Queue()
self._server._handle_client_exception(sock)
patched_close.assert_called_once()
patched_end_game_if_started.assert_called_once()
@unittest.mock.patch('socket.socket.close')
@unittest.mock.patch.object(GameServer, '_end_game_if_started')
def test_handle_client_exception_removed_from_outputs(
self, patched_end_game_if_started, patched_close):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock)
self._server._outputs.append(sock)
self._server._message_queues[sock] = queue.Queue()
self._server._handle_client_exception(sock)
patched_close.assert_called_once()
patched_end_game_if_started.assert_called_once()
assert sock not in self._server._outputs
def test_shut_down(self):
self._server._shut_down()
assert len(self._server._inputs) == 0
@unittest.mock.patch('queue.Queue.put')
def test_end_game_if_started(self, patched_put):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_two = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock_one)
self._server._inputs.append(sock_two)
self._server._message_queues[sock_one] = queue.Queue()
self._server._message_queues[sock_two] = queue.Queue()
self._server._game_started = True
self._server._end_game_if_started(sock_one)
patched_put.assert_called_once()
@unittest.mock.patch('queue.Queue.put')
def test_end_game_if_started_game_not_started(self, patched_put):
self._server._end_game_if_started(None)
patched_put.assert_not_called()
@unittest.mock.patch.object(GameServer, '_help_text')
def test_parse_command_help(self, patched_help_text):
test_name = 'Name'
test_command = 'help'
self._server._client_names[0] = test_name
test_input = f'{test_name},{test_command}'
self._server._parse_command(test_input, None)
patched_help_text.assert_called_once()
@unittest.mock.patch.object(GameBoard,
'game_board',
new_callable=unittest.mock.PropertyMock)
def test_parse_command_board_game_not_started(self, patched_game_board):
test_name = 'Name'
test_command = 'board'
self._server._client_names[0] = test_name
test_input = f'{test_name},{test_command}'
self._server._parse_command(test_input, None)
patched_game_board.assert_not_called()
@unittest.mock.patch.object(GameBoard,
'game_board',
new_callable=unittest.mock.PropertyMock)
def test_parse_command_board_game_started(self, patched_game_board):
test_name = 'Name'
test_command = 'board'
self._server._client_names[0] = test_name
self._server._game_started = True
test_input = f'{test_name},{test_command}'
self._server._parse_command(test_input, None)
patched_game_board.assert_called_once()
def test_parse_command_turn(self):
test_name = 'Name'
test_command = 'turn'
self._server._client_names[0] = test_name
self._server._game_started = True
test_input = f'{test_name},{test_command}'
output = self._server._parse_command(test_input, None)
assert output == 'It is Names turn.'
def test_parse_command_digit_not_active_player(self):
test_name = 'Name'
test_command = '1'
self._server._client_names[1] = test_name
self._server._game_started = False
test_input = f'{test_name},{test_command}'
output = self._server._parse_command(test_input, None)
assert output == 'Please wait for your turn.'
def test_parse_command_digit_game_not_started(self):
test_name = 'Name'
test_command = '1'
self._server._client_names[0] = test_name
self._server._game_started = False
test_input = f'{test_name},{test_command}'
output = self._server._parse_command(test_input, None)
assert output == 'Game has not started.'
def test_parse_command_digit_game_invalid_number(self):
test_name = 'Name'
test_command = '0'
self._server._client_names[0] = test_name
self._server._game_started = True
test_input = f'{test_name},{test_command}'
output = self._server._parse_command(test_input, None)
assert output == "That's an invalid number. Try again."
@unittest.mock.patch.object(GameServer, '_manage_piece_drop')
def test_parse_command_digit_game_success(self, patched_manage_piece_drop):
test_name = 'Name'
test_command = '1'
self._server._client_names[0] = test_name
self._server._game_started = True
test_input = f'{test_name},{test_command}'
self._server._parse_command(test_input, None)
patched_manage_piece_drop.assert_called_once()
def test_parse_command_disconnect(self):
test_command = 'disconnect'
output = self._server._parse_command(test_command, None)
assert output == 'Disconnecting...'
@unittest.mock.patch.object(GameServer, '_name_new_client')
def test_parse_command_name_success(self, patched_name_new_client):
test_name = 'Name'
self._server._parse_command(test_name, None)
patched_name_new_client.assert_called_once()
def test_parse_command_name_server_full(self):
test_name = 'Name'
self._server._connected_clients = 2
output = self._server._parse_command(test_name, None)
assert output == 'Server is full.'
def test_parse_command_invalid(self):
test_name = 'Name'
test_command = 'invalid'
self._server._client_names[0] = test_name
test_input = f'{test_name},{test_command}'
output = self._server._parse_command(test_input, None)
assert output == 'Invalid command, try again.'
def test_cannot_send_to_sock_false(self):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_two = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expected_result = False
actual_result = self._server._cannot_send_to_sock(sock_one, sock_two)
assert expected_result == actual_result
def test_cannot_send_to_sock_true(self):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
expected_result = True
actual_result = self._server._cannot_send_to_sock(sock_one, sock_one)
assert expected_result == actual_result
def test_change_active_player(self):
expected_result = 1
self._server._change_active_player()
assert expected_result == self._server._active_player
def test_start_game(self):
expected_active_player = 0
expected_game_started = True
self._server._start_game()
assert expected_active_player == self._server._active_player
assert expected_game_started == self._server._game_started
@unittest.mock.patch('queue.Queue.put')
def test_send_loss(self, patched_put):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_two = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock_one)
self._server._inputs.append(sock_two)
self._server._message_queues[sock_one] = queue.Queue()
self._server._message_queues[sock_two] = queue.Queue()
self._server._send_loss(sock_one)
patched_put.assert_called_once()
@unittest.mock.patch('queue.Queue.put')
def test_send_loss_no_clients_to_send_to(self, patched_put):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock_one)
self._server._message_queues[sock_one] = queue.Queue()
self._server._send_loss(sock_one)
patched_put.assert_not_called()
@unittest.mock.patch('queue.Queue.put')
def test_send_board_to_other_player(self, patched_put):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_two = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock_one)
self._server._inputs.append(sock_two)
self._server._message_queues[sock_one] = queue.Queue()
self._server._message_queues[sock_two] = queue.Queue()
self._server._send_board_to_other_player(sock_one)
patched_put.assert_called_once()
@unittest.mock.patch('queue.Queue.put')
def test_send_board_to_other_player_no_other_player(self, patched_put):
sock_one = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._server._inputs.append(sock_one)
self._server._message_queues[sock_one] = queue.Queue()
self._server._send_board_to_other_player(sock_one)
patched_put.assert_not_called()
@app.route("/api/v1/game/quarto/<game_uuid>/join", methods=["POST"])
def join_game(game_uuid):
player_name = _get_required_param('player_name')
app.game_server.join_game(game_uuid, player_name)
return jsonify({'message': 'ok'})
@app.route("/api/v1/game/quarto/<game_uuid>/pick", methods=["POST"])
def pick_piece(game_uuid):
player_name = _get_required_param('player_name')
number = _get_required_param('number', int)
app.game_server.picking_move(game_uuid, player_name, number)
return jsonify({'message': 'ok'})
@app.route("/api/v1/game/quarto/<game_uuid>/place", methods=["POST"])
def place_piece(game_uuid):
player_name = _get_required_param('player_name')
x = _get_required_param('x', int)
y = _get_required_param('y', int)
app.game_server.placement_move(game_uuid, player_name, x, y)
return jsonify({'message': 'ok'})
if __name__ == "__main__":
set_game_server(GameServer(configuration))
app.run(debug=True)
x = _get_required_param('x', int, data=json)
y = _get_required_param('y', int, data=json)
game_wrapper.place_piece(game_uuid, player_name, x, y)
@socketio.on('pick_piece')
def handle_pick_piece(json):
game_uuid = _get_required_param('game_uuid', data=json)
player_name = _get_required_param('player_name', data=json)
number = _get_required_param('number', int, data=json)
game_wrapper.pick_piece(game_uuid, player_name, number)
@socketio.on('join_lobby')
def handle_join_lobby(json):
name = _get_required_param('name', data=json)
@socketio.on_error()
def error_handler(e):
print('There was an error', str(e))
if __name__ == "__main__":
game_server = GameServer(configuration)
game_wrapper.set_game_server(game_server)
game_wrapper.set_flask_app(app)
game_wrapper.set_socket_io(socketio)
socketio.run(app)
def setUp(self):
set_config('quarto_game_store', tempfile.mkdtemp())
game_server = GameServer(configuration)
set_game_server(game_server)
self.app = app.test_client()
def __init__(self, port=9617, timeout=None): GameServer.__init__(self, MyGame=Bingo, port=port, timeout=timeout)
class TestGameServer(unittest.TestCase):
def setUp(self):
set_config('quarto_game_store', tempfile.mkdtemp())
self.game_server = GameServer(configuration)
def test_create_game(self):
game_uuid, game = self.game_server.create_game('paul')
self.assertTrue(
os.path.exists(
os.path.join(
get_config('quarto_game_store'),
game_uuid
)
)
)
def test_get_game_does_not_exist(self):
with self.assertRaises(GameNotFound):
self.game_server.load_game('bob')
def test_get_game_exists(self):
game_uuid, game = self.game_server.create_game('paul')
game2 = self.game_server.load_game(game_uuid)
self.assertEqual(
game.to_dict(),
game2.to_dict()
)
def test_join_game(self):
game_uuid, game = self.game_server.create_game('paul')
game = self.game_server.join_game(game_uuid, 'sam')
self.assertEqual(
game.player_b.name, 'sam'
)
def test_join_game_full(self):
game_uuid, game = self.game_server.create_game('paul')
self.game_server.join_game(game_uuid, 'sam')
with self.assertRaises(Exception):
self.game_server.join_game(game_uuid, 'bob')
def test_join_game_already_joined(self):
game_uuid, game = self.game_server.create_game('paul')
with self.assertRaises(Exception):
self.game_server.join_game(game_uuid, 'paul')
def test_pick_piece_ok(self):
game_uuid, game = self.game_server.create_game('paul')
self.game_server.join_game(game_uuid, 'sam')
self.game_server.picking_move(
game_uuid, 'paul', 1
)
def test_pick_piece_game_not_ready(self):
game_uuid, game = self.game_server.create_game('paul')
with self.assertRaises(Exception):
self.game_server.picking_move(
game_uuid, 'paul', 1
)
def test_pick_piece_wrong_player(self):
game_uuid, game = self.game_server.create_game('paul')
self.game_server.join_game(game_uuid, 'sam')
with self.assertRaises(Exception):
self.game_server.picking_move(
game_uuid, 'sam', 1
)
with self.assertRaises(Exception):
self.game_server.picking_move(
game_uuid, 'bob', 1
)
def test_pick_piece_doesnt_exist(self):
game_uuid, game = self.game_server.create_game('paul')
self.game_server.join_game(game_uuid, 'sam')
with self.assertRaises(Exception):
self.game_server.picking_move(
game_uuid, 'paul', 16
)
def test_pick_piece_already_picked(self):
game_uuid, game = self.game_server.create_game('paul')
self.game_server.join_game(game_uuid, 'sam')
self.game_server.picking_move(
game_uuid, 'paul', 15
)
self.game_server.placement_move(
game_uuid, 'sam', 0, 0
)
with self.assertRaises(Exception):
self.game_server.picking_move(
game_uuid, 'sam', 15
)
def setUp(self):
set_config('quarto_game_store', tempfile.mkdtemp())
self.game_server = GameServer(configuration)
from server.game_server import GameServer
if __name__ == "__main__":
server = GameServer()
server.start()