def test_delete_user_multiple_entries(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.WHITE
create_user(session_id, board, color)
# Create another user
session_id2 = get_random_session_id()
board2 = chess.Board()
color2 = chess.BLACK
board2.push_san("e4")
board2.push_san("d5")
create_user(session_id2, board2, color2)
# Delete first user
delete_user(session_id)
assert exists_in_db(session_id) is False
# Verify that no other changes were made
assert UserModel.query.count() == 1
assert get_user(session_id2) == User(board2, color2)
def test_create_user_multiple_entries(context):
session_id1 = get_random_session_id()
board1 = chess.Board()
board1.push_san("Nf3")
color1 = chess.BLACK
session_id2 = get_random_session_id()
board2 = chess.Board()
board2.push_san("e4")
board2.push_san("e5")
color2 = chess.WHITE
# Inserting one at a time
create_user(session_id1, board1, color1)
# Only one entry should be present
assert UserModel.query.count() == 1
assert UserModel.query.get(session_id1) is not None
# Insert second entry
create_user(session_id2, board2, color2)
assert UserModel.query.count() == 2
assert UserModel.query.get(session_id1) is not None
assert UserModel.query.get(session_id2) is not None
def test_start_game_random(self, mocker):
mock_create_user = mocker.patch("chess_server.main.create_user")
mock_get_response = mocker.patch(
"chess_server.main.get_response_for_google",
return_value=self.result,
)
mock_random = mocker.patch("chess_server.main.random.choice",
side_effect=random.choice)
mocker.patch(
"chess_server.main.Mediator.play_engine_move_and_get_speech",
return_value=self.engine_reply,
)
session_id = get_random_session_id()
color = "random"
value = start_game_and_get_response(session_id, color)
mock_create_user.assert_called_with(session_id,
board=chess.Board(),
color=mock.ANY)
mock_random.assert_any_call([chess.WHITE, chess.BLACK])
mock_get_response.assert_called_once()
# Assert that color was announced
kwarg_tts = mock_get_response.call_args[1]["textToSpeech"]
assert "white" in kwarg_tts or "black" in kwarg_tts
assert value == self.result
def test_start_game_black(self, mocker):
mock_create_user = mocker.patch("chess_server.main.create_user")
mock_play_engine = mocker.patch(
"chess_server.main.Mediator.play_engine_move_and_get_speech",
return_value=self.engine_reply,
)
mock_get_response = mocker.patch(
"chess_server.main.get_response_for_google",
return_value=self.result,
)
session_id = get_random_session_id()
color = "black"
value = start_game_and_get_response(session_id, color)
mock_create_user.assert_called_with(session_id,
board=chess.Board(),
color=chess.BLACK)
mock_play_engine.assert_called_once_with(session_id=session_id)
mock_get_response.assert_called_once()
# Assert that color and engine's move were announced
assert color in mock_get_response.call_args[1]["textToSpeech"]
assert (self.engine_reply
in mock_get_response.call_args[1]["textToSpeech"])
assert value == self.result
def test_update_user_entry_does_not_exist(context):
session_id = get_random_session_id()
board = chess.Board()
board.push_san("e4")
board.push_san("e5")
# Create another random entry
session_id2 = get_random_session_id()
board2 = chess.Board()
color2 = chess.BLACK
create_user(session_id2, board2, color2)
with pytest.raises(Exception, match="Entry not found."):
update_user(session_id, board)
def setup_method(self):
self.session_id = get_random_session_id()
self.image = Image(url="http://testserver/img.png",
accessibilityText="Hello World")
self.card = BasicCard(image=self.image,
formattedText="spam ham and eggs")
self.result = {"spam": "eggs"}
def test_play_engine_move_and_get_speech(self, mock_get_user,
mock_update_user, mock_lts):
self.mediator.engine = self.mock_engine
session_id = get_random_session_id()
move = self.board.parse_san("e4")
lan = self.board.lan(move)
mock_get_user.return_value = self.user
mock_lts.return_value = "test reply"
self.mock_engine.play.return_value = chess.engine.PlayResult(
move=move, ponder=None)
with mock.patch.object(self.board, "push") as mock_push:
with mock.patch.object(self.board, "lan", return_value=lan):
value = self.mediator.play_engine_move_and_get_speech(
session_id)
mock_get_user.assert_called_with(
session_id) # User object was retrieved
self.mock_engine.play.assert_called() # Engine was used
mock_push.assert_called_with(move) # Move was played
mock_update_user.assert_called_with(session_id,
self.board) # DB was updated
self.assertEqual(value, "test reply") # Correctly reply was given
def test_get_user(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.BLACK
create_user(session_id, board, color)
assert get_user(session_id) == User(board, color)
def setup_method(self):
self.session_id = get_random_session_id()
self.user = User(board=chess.Board(), color=chess.WHITE)
self.result = {"foo": "bar"}
self.image = Image(url="http://testserver/img.png",
accessibilityText="Hello World")
self.card = BasicCard(image=self.image,
formattedText="spam ham and eggs")
def test_get_user_when_multiple_entries_exist(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.WHITE
# Make some moves
board.push_san("Nc3")
board.push_san("d5")
board.push_san("d4")
create_user(session_id, board, color)
# Another entry
session_id2 = get_random_session_id()
board2 = chess.Board()
color2 = chess.WHITE
create_user(session_id2, board2, color2)
assert get_user(session_id) == User(board, color)
def test_play_lan_illegal_move(self, mock_get_user, mock_update_user):
session_id = get_random_session_id()
lan = "e2xe1" # Illegal move
mock_get_user.return_value = self.user
value = self.mediator.play_lan(session_id, lan)
mock_get_user.assert_called_with(session_id) # User object retrieved
mock_update_user.asert_not_called() # DB not updated
self.assertFalse(value) # Correct value returned
def test_create_user(context):
# Creating a random session id of length 36
session_id = get_random_session_id()
# Generate arguments for create_user
board = chess.Board()
color = chess.WHITE
create_user(session_id, board, color)
# Only one user was created
assert UserModel.query.count() == 1
assert UserModel.query.get(session_id) is not None
def test_update_user_multiple_entries(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.WHITE
create_user(session_id, board, color)
# Create second user
session_id2 = get_random_session_id()
board2 = chess.Board()
color2 = chess.BLACK
board2.push_san("e4")
board2.push_san("e5")
create_user(session_id2, board2, color2)
board.push_san("g4")
update_user(session_id, board)
assert get_user(session_id) == User(board, color)
# Ensure that other entry has not been modified
assert get_user(session_id2) == User(board2, color2)
def test_update_user(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.BLACK
create_user(session_id, board, color)
# Now update it with some moves
board.push_san("Nf3")
board.push_san("d5")
update_user(session_id, board)
assert get_user(session_id) == User(board, color)
def setup_method(self):
self.session_id = get_random_session_id()
self.result = {"foo": "bar"}
self.engine_reply = "spam ham and eggs"
self.image = Image(url="http://testserver/img.png",
accessibilityText="Hello World")
self.card = BasicCard(image=self.image,
formattedText="spam ham and eggs")
self.result_unfinished = None
self.result_win = RESPONSES["result_win"]
self.result_lose = RESPONSES["result_lose"]
self.result_draw = RESPONSES["result_draw"]
def test_create_user_when_entry_with_key_already_exists(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.WHITE
create_user(session_id, board, color)
board.push_san("Nf3")
board.push_san("c6")
# Now trying to create another entry with same session_id
with pytest.raises(
Exception, match=f"Entry with key {session_id} already exists."
):
create_user(session_id, board, color)
def test_delete_user(context):
session_id = get_random_session_id()
board = chess.Board()
color = chess.BLACK
create_user(session_id, board, color)
# Verify that the user has been created
assert get_user(session_id) == User(board, color)
delete_user(session_id)
# Verify that deletion is successful
assert exists_in_db(session_id) is False
# Verify that no other operation has been performed
assert UserModel.query.count() == 0
def test_play_lan_success(self, mock_get_user, mock_update_user):
session_id = get_random_session_id()
move = self.board.parse_san("Nf3")
lan = self.board.lan(move)
mock_get_user.return_value = self.user
with mock.patch.object(self.board, "push") as mock_push:
# The board method which finally makes the move is `Board.push`
# even though the method being called directly is `Board.push_san`
value = self.mediator.play_lan(session_id, lan)
mock_get_user.assert_called_with(session_id) # User object retrieved
mock_push.assert_called_with(move) # Move played
mock_update_user.assert_called_with(session_id,
self.board) # DB updated
self.assertTrue(value) # Correct value returned
def setup_method(self):
self.session_id = get_random_session_id()
self.result = {"spam": "eggs"}
self.engine_reply = "engine reply"
def setup_method(self):
self.session_id = get_random_session_id()
self.error_msg = "Example error"
def setup_method(self):
self.session_id = get_random_session_id()
self.user = User(board=chess.Board(), color=chess.WHITE)
self.user.board.push_san("e4")
self.user.board.push_san("e5")
def setup_method(self):
self.session_id = get_random_session_id()
def test_get_user_entry_does_not_exist(context):
session_id = get_random_session_id()
# Skipping create_user() step
with pytest.raises(Exception, match="Entry not found."):
get_user(session_id)
def setup_method(self):
self.session_id = get_random_session_id()
self.file_content = b"file content"
def setup_method(self):
self.session_id = get_random_session_id()
self.result = {"foo": "bar"}
