def test_check_guess(self):
with app.test_client() as client:
with client.session_transaction() as session:
session['answered'] = ['word']
session['game_board'] = Boggle().make_board()
theboard = session['game_board']
resp = client.get("/")
self.assertEqual(resp.status_code, 200)
# self.assertEqual(Boggle.check_guess(Boggle(),'of'), 'not-on-board') cant know in any instance what the board actually is
self.assertEqual(Boggle.check_guess(Boggle(), 'asfgh', theboard), 'not-word')
def check_valid():
"""Check if a word is valid on the board"""
word = request.args['word']
board = session['board']
size = session.get('size')
if not size:
result = Boggle().check_valid_word(board, word)
else:
result = Boggle(size).check_valid_word(board, word)
return jsonify({'result': result})
def index(board=None):
board = Board().create()
session['board'] = board
boggle = Boggle(board, dictionary)
session['comp_words'] = boggle.find_words()
session['user_words'] = []
return render_template('index.html', board=session['board'])
def setUp(self):
self.boggle_game = Boggle()
self.board = [['L','A','T','E', 'R'],
['F','Z','N','O','K'],
['L','R','T','E', 'P'],
['L','A','T','E','R'],
['L','A','T','E','V']]
def test_find_word_complex(self):
size = 6
b = Boggle(size)
board = b.create_empty_board(size)
for row in range(size):
for col in range(size):
board[row][col] = 'X'.encode()
board[0][0] = 'X'.encode()
board[0][1] = 'B'.encode()
board[0][2] = 'E'.encode()
board[0][3] = 'D'.encode()
board[1][0] = 'E'.encode()
board[1][1] = 'O'.encode()
board[1][2] = 'R'.encode()
board[1][3] = 'C'.encode()
board[2][0] = 'M'.encode()
board[2][1] = 'W'.encode()
board[2][2] = 'R'.encode()
board[2][3] = 'E'.encode()
board[3][0] = 'S'.encode()
board[3][1] = 'C'.encode()
board[3][2] = 'A'.encode()
board[3][3] = 'Q'.encode()
b.print_board()
result = b.find_word('SCARECROW')
print("Result is: {}".format(result))
def test_check_points(self):
with app.test_client() as client:
with client.session_transaction() as change_session:
change_session['answered'] = ['word']
change_session['point_total'] = 0
resp = client.get("/")
self.assertEqual(resp.status_code, 200)
self.assertEqual(Boggle.check_points(Boggle(),'word', 'ok'), 4)
def reset_game():
"""Clear Session | Reset Game"""
global boggle_game
session.clear()
boggle_game = Boggle()
return redirect("/")
def test_check_valid_word(self):
"""Test invalid word on the board"""
with app.test_client() as client:
resp = client.get("/4")
word = "ant"
board = session["board"]
self.assertEqual(resp.status_code, 200)
self.assertEqual(Boggle().check_valid_word(board, word, 4), "not-on-board")
def test_handle_stats(self):
with app.test_client() as client:
with client.session_transaction() as change_session:
change_session['game_board'] = Boggle().make_board()
resp = client.post('/statistics', json={'score': 5})
data = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertTrue(data == 'Thanks for the statistics')
def test_false_word():
board = [['x', 'q', 'a', 'e'], ['z', 'o', 't', 's'], ['i', 'n', 'd', 'l'],
['y', 'r', 'u', 'k']]
def word_lower(word):
return word.lower()
dictionary = map(word_lower, ['SETS'])
boggle = Boggle(board, dictionary)
assert len(boggle.find_words()) == 0
def test_boggle_2():
board = [['f', 'y', 'c', 'l'], ['i', 'o', 'm', 'g'], ['o', 'r', 'i', 'l'],
['h', 'j', 'h', 'u']]
dictionary = [
'coif', 'coil', 'coir', 'corm', 'firm', 'giro', 'glim', 'hoof', 'iglu',
'limo', 'limy', 'miri', 'moil', 'moor', 'rimy', 'roil', 'hello',
'goodbye'
]
boggle = Boggle(board, dictionary)
assert len(boggle.find_words()) == 16
def test_check(self):
with app.test_client() as client:
boggle_game_test = Boggle()
with client.session_transaction() as session:
session['answered'] = ['word']
session['game_board'] = boggle_game_test.make_board()
resp = client.get('/check?Guess=word')
jason = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('msg', jason)
def test_check_word(self):
boggle_game = Boggle()
with app.test_client() as client:
with client.session_transaction() as change_session:
change_session['board'] = boggle_game.make_board()
change_session['score'] = 7
res = client.get('/check-word?word=mario')
self.assertEqual(res.status_code, 200)
def display_board():
"""Show board"""
size = session.get('size')
print(f'size is {size}')
# check the value of the size
if size:
boggle_game = Boggle(size)
else:
boggle_game = Boggle(5)
print(f'boggle game current size is {boggle_game.size}')
board = boggle_game.make_board()
# add board into session
session['board'] = board
size = session.get('size')
if not size:
size = 5
return render_template('home.html', board=board, size=size)
def test_boggle_get_route(self):
with app.test_client() as client:
with client.session_transaction() as session:
boggle_game = Boggle()
session['board'] = boggle_game.make_board()
resp = client.get('/boggle')
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('<td>', html)
self.assertIn(
'<form id="guess-form" action="/boggle" method="POST">', html)
def test_boggle():
board = [['x', 'q', 'a', 'e'], ['z', 'o', 't', 's'], ['i', 'n', 'd', 'l'],
['y', 'r', 'u', 'k']]
def word_lower(word):
return word.lower()
dictionary = map(word_lower, [
'XQAESLKURYIZ', 'DNOT', 'NIZOTS', 'KUDL', 'STONI', 'SEAT', 'ONIYR',
'ZONIY', 'MY', 'SEAN', 'SETS', 'TOO', 'DOT'
])
boggle = Boggle(board, dictionary)
assert len(boggle.find_words()) == 8
def test_find_word_simple(self):
size = 4
b = Boggle(size)
board = b.create_empty_board(size)
for row in range(size):
for col in range(size):
board[row][col] = 'A'.encode()
result = b.find_word('AAA')
print("Result is: {}".format(result))
result = b.find_word('XYZ')
print("Result is: {}".format(result))
def test_find_word(self):
"""Testing the findword page"""
with app.test_client() as client:
boggle_game = Boggle()
board = boggle_game.make_board()
with client.session_transaction() as change_session:
change_session['board'] = board
res = client.get("/find?word=word")
html = res.get_data(as_text=True)
self.assertEqual(res.status_code , 200)
self.assertEqual(res.content_type , "application/json")
self.assertIn(boggle_game.check_valid_word(board , "word") , html)
def boggle_play():
global boggle_game
"""Makes and inits the board to begin game play"""
time = int(request.args['length'])
width = int(request.args['width'])
height = int(request.args['height'])
boggle_game = Boggle(width, height)
boggle_board = boggle_game.make_board()
session['board'] = boggle_board
games = session.get('game_nums', 0)
high_score = session.get('game_nums', 0)
print(session)
return render_template('play.html', boggle_board=boggle_board, games=games, high_score=high_score, time=time)
def test_end_game(self):
"""Testing the endgame page"""
with app.test_client() as client:
boggle_game = Boggle()
board = boggle_game.make_board()
with client.session_transaction() as change_session:
change_session['board'] = board
res = client.post("/end" , data=json.dumps({"score" : 10}), content_type='application/json')
html = res.get_data(as_text=True)
self.assertEqual(res.status_code , 200)
self.assertEqual(res.content_type , "application/json")
scores = session["scores"]
self.assertEqual(scores[0]["score"] , 10)
self.assertIn("10" , html)
def test_handle_guess(self):
# May fail sometimes due to the letters on the board being random
with app.test_client() as client:
with client.session_transaction() as change_session:
change_session['game_board'] = Boggle().make_board()
resp = client.post('/submit-guess', json = {'guess': 'butter'})
data = resp.get_json()
self.assertEqual(data['result'], 'not-on-board')
self.assertEqual(resp.status_code, 200)
resp = client.post('/submit-guess', json = {'guess': 'a3424njndsjf323'})
data = resp.get_json()
self.assertEqual(data['result'], 'not-a-word')
self.assertEqual(resp.status_code, 200)
resp = client.post('/submit-guess', json = {'guess': 'b'})
data = resp.get_json()
self.assertEqual(data['result'], 'ok')
self.assertEqual(resp.status_code, 200)
def test_find_word_slightly_complex(self):
size = 4
b = Boggle(size)
board = b.create_empty_board(size)
for row in range(size):
for col in range(size):
board[row][col] = 'A'.encode()
board[1][0] = 'B'.encode()
board[1][1] = 'M'.encode()
board[1][2] = 'C'.encode()
board[1][3] = 'K'.encode()
b.print_board()
result = b.find_word('BMCK')
print("Result is: {}".format(result))
result = b.find_word('KCMB')
print("Result is: {}".format(result))
result = b.find_word('KBCM')
print("Result is: {}".format(result))
def setUp(self):
self.board = Boggle('./4x4_board.txt')
def setUp(self):
self.game = Boggle()
from unittest import TestCase
from app import app
from flask import session, jsonify
from boggle import Boggle
import time
app.config['TESTING']=True
app.config['DEBUG_TB_HOSTS']=['dont-show-debug-toolbar']
b_board = Boggle()
class FlaskTests(TestCase):
"""Tests for view functions / features!"""
def test_make_board(self):
self.assertIsInstance(b_board.make_board(),list,"not a list")
def test_root_route(self):
with app.test_client() as test_server:
resp=test_server.get('/')
html=resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('Drag your pointer', html)
def test_start_timer(self):
with app.test_client() as test_server:
resp=test_server.get('/start-timer')
html=resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 302)
def __init__(self, parent, loading):
QtWidgets.QWidget.__init__(self, parent)
self.boggle = Boggle()
if loading:
self.boggle.boggleBoard = loading
self.setup()
def run(n,
pool,
board_id=None,
processors=5,
chunk_size=500,
batch_size=2000,
outname="2003super5x5",
save=True):
"""
Solves several generated boggle configs
:param method: solving method
:param n: number of boards to run
:param board: name of board to use
:return: n board layouts, n heatmaps by points, n lists of worded solutions
"""
if board_id is None:
board = Boggle()
else:
board = Boggle(board=board_id)
board.width = 5
max_words_per_board = 1200 # store maximum number of valid entries per board
solver = Solver() # Load solver
max_word_length = solver.d.max_length
# produce array of batch sizes
batches = [batch_size] * (n // batch_size)
if n % batch_size > 0: batches += [n % batch_size]
# initialise data storage arrays
layouts = np.empty((n, board.width, board.width),
dtype="<U1") # list of each board
solutions = np.empty(
(n, max_words_per_board),
dtype=f"|S{max_word_length}") # list of valid words for each board
points = np.zeros((n, 5, 5),
dtype=np.uint64) # point distribution across each board
with tqdm(total=n) as progress:
for b, batch_size in enumerate(batches):
batch_layouts = [board.gen() for i in range(batch_size)]
batch_sols = pool.map(solver.solve,
batch_layouts,
chunksize=chunk_size)
# compute and save data
for i_inbatch, sol in enumerate(batch_sols):
i = b * batch_size + i_inbatch # overall idx
for word in sol:
val = len(word) - 3
all_coords = set([
tuple(coord) for route in sol[word] for coord in route
]) # all UNIQUE coords in routes
for coord in all_coords:
x, y = coord
points[i, y, x] += val
layouts[i] = [list(r) for r in batch_layouts[i_inbatch]]
solutions[i][:len(sol.keys())] = list(sol.keys())
progress.update(batch_size)
if save:
out = dict(layouts=layouts, solutions=solutions, points=points)
np.savez_compressed(os.path.join("results", outname),
width=5,
height=5,
**out)
from unittest import TestCase
from app import app
from flask import session, request
from boggle import Boggle
app.config["TESTING"] = True
board = Boggle().make_board()
class FlaskTests(TestCase):
# TODO -- write tests for every view function / feature!
def test_start_page(self):
"""
1. Test we can get to root of website
2. Test session board is initialized
3. Test session score is initialized to 0
4. Test session played is initialized to 0
"""
with app.test_client() as client:
resp = client.get("/")
self.assertEqual(resp.status_code, 200)
self.assertIsNotNone(session["board"])
self.assertEqual(session["score"] ,0)
self.assertEqual(session["played"], 0)
def test_post_guess(self):
"""
Test for guess submission
Build session with board value
from flask import Flask, request, session, render_template, jsonify
from flask_debugtoolbar import DebugToolbarExtension
from boggle import Boggle
app = Flask(__name__)
app.config['SECRET_KEY'] = "oh-so-secret"
debug = DebugToolbarExtension(app)
boggle_game = Boggle()
@app.route('/')
def load_game():
board = boggle_game.make_board()
session['game'] = board
return render_template('index.html', board=board)
# route to check guess
@app.route('/check-word')
def check_word_guess():
word = request.args.get('word')
result = boggle_game.check_valid_word(session['game'], word)
return jsonify(result=result)
# route to update stats: highscore and total number of games played
def test_check_in_words(self):
self.assertTrue(Boggle.check_in_words(Boggle(), 'word'))
self.assertFalse(Boggle.check_in_words(Boggle(),'nottheword'))
self.assertFalse(Boggle.check_in_words(Boggle(), 68))
