def test_board_gets_updated_and_shows_win(self):
easy_win = {1: "o", 2: "o"}
WIN_MOVE = 3
board = BaseBoard(3)
generator = MoveGenerator(board)
self.assertEqual(WIN_MOVE, generator.next_move(easy_win))
self.assertEqual({1: "o", 2: "o", 3: "o"}, board.state())
def test_board_gets_updated_and_shows_win(self):
easy_win = {1:"o", 2:"o"}
WIN_MOVE = 3
board = BaseBoard(3)
generator = MoveGenerator(board)
self.assertEqual(WIN_MOVE, generator.next_move(easy_win))
self.assertEqual( {1:"o",2:"o",3:"o"}, board.state())
def test_response_contains_updated_game_information(self):
data = {"board": {1:"o", 2:"o",5:"x"},
"depth": 20}
response = ResponseHandler(MoveGenerator()).response(data)
self.assertEqual(3,response["ai_move"])
self.assertEqual("o",response["winner_after_ai_move"])
self.assertEqual(None,response["winner_on_board"])
def test_responder_hands_what_it_got_from_receive_to_handler(self):
self.transmitter.receive = mock.MagicMock(
return_value="for the handler")
handler = ResponseHandler(MoveGenerator())
handler.response = mock.Mock()
responder = Responder(self.transmitter, handler)
responder.respond()
handler.response.assert_called_with("for the handler")
def test_returns_board_with_obvious_move(self):
transmitter = mock.Mock()
transmitter.receive = mock.MagicMock(
return_value=self.easy_win_possible)
generator = MoveGenerator()
handler = ResponseHandler(generator)
responder = Responder(transmitter, handler)
responder.respond()
transmitter.send.called_with({
"winner_after_ai_move": "o",
"ai_move": 3
})
def test_it_hooks_into_socket_sends_and_receives(self):
transmitter = JsonTransmitter(self.connection_socket)
handler = ResponseHandler(MoveGenerator())
responder = Responder(transmitter, handler)
game_info = json.dumps({"board": {1: "o", 3: "o"}, "depth": 20})
self.sock.send(game_info)
responder.respond()
data_received = self.sock.recv(1024)
updated_game = json.loads(data_received)
WIN_MOVE = 2
self.assertEqual(WIN_MOVE, updated_game["ai_move"])
self.assertEqual("o", updated_game["winner_after_ai_move"])
self.assertEqual(None, updated_game["winner_on_board"])
def test_integration_of_parts(self):
DUMB_AI_DEPTH = 1
data_from_transmitter_receive = {
"board": {
1: "x",
2: "x"
},
"depth": DUMB_AI_DEPTH
}
SMART_MOVE = 3
transmitter = mock.Mock()
transmitter.receive = mock.MagicMock(
return_value=data_from_transmitter_receive)
handler = ResponseHandler(MoveGenerator())
responder = Responder(transmitter, handler)
responder.respond()
self.assertNotEqual(SMART_MOVE,
transmitter.send.call_args[0][0]["ai_move"])
self.assertEqual(
None, transmitter.send.call_args[0][0]["winner_after_ai_move"])
def test_board_winner_called(self):
board = mock.Mock()
board.winner = mock.MagicMock(return_value="o")
generator = MoveGenerator(board)
self.assertEqual("o",generator.winner())
board.winner.assert_called_once_with()
def test_generator_calls_winner_when_expected(self):
generator = MoveGenerator()
board_state = {9:"x", 5:"o", 6:"x"}
self.assertEqual(3, generator.next_move(board_state))
self.assertEqual(None,generator.winner())
def test_minimax_next_move_called(self):
board = {1:"o",2:"o"}
generator = MoveGenerator()
self.assertEqual(3,generator.next_move(board))
def test_board_winner_called(self):
board = mock.Mock()
board.winner = mock.MagicMock(return_value="o")
generator = MoveGenerator(board)
self.assertEqual("o", generator.winner())
board.winner.assert_called_once_with()
def test_winner_of_returns_correct_winner(self):
board_state = {1: "x", 2: "x", 3: "x"}
self.assertEqual("x", MoveGenerator().winner_of(board_state))
def test_generator_calls_winner_when_expected(self):
generator = MoveGenerator()
board_state = {9: "x", 5: "o", 6: "x"}
self.assertEqual(3, generator.next_move(board_state))
self.assertEqual(None, generator.winner())
def test_minimax_next_move_called(self):
board = {1: "o", 2: "o"}
generator = MoveGenerator()
self.assertEqual(3, generator.next_move(board))
from move_generator import MoveGenerator
from response_handler import ResponseHandler
from response_thread import ResponseThread
command_line_parser = OptionParser()
command_line_parser.add_option("-p", "--port",
type="int", dest="port",
help="Port for the server to run on")
command_line_parser.set_defaults(port=5000)
(options, args) = command_line_parser.parse_args()
server = ServerSocket("localhost", options.port)
print "Server starting on port %d..." % options.port
server.initialize_and_listen_for_connections()
while True:
try:
connection_socket = server.accept_connection_and_return_socket()
transmitter = JsonTransmitter(connection_socket)
move_generator = MoveGenerator()
handler = ResponseHandler(move_generator)
responder = Responder(transmitter, handler)
ResponseThread(responder).start()
except KeyboardInterrupt:
print "\nShutting down server..."
break
def test_handler_defaults_difficulty_if_depth_not_set(self):
data = {"board": {1:"x",2:"x",5:"o"}}
handler = ResponseHandler(MoveGenerator())
response = handler.response(data)
self.assertEqual(3,response["ai_move"])
def test_handler_raises_error_with_non_int_difficulties(self):
board_state = {1: "x", 2: "x", 5: "o"}
difficulty = "supercalifragilisticexpialidocious"
generator = MoveGenerator()
self.assertRaises(MustBeInt, generator.next_move, board_state,
difficulty)