def test_active_games(db): g1 = GameFactory(stage='playing') g2 = GameFactory(stage='playing') RoomUserFactory(room=g1.room, user=g1.black_user) RoomUserFactory(room=g1.room, user=g1.white_user) RoomUserFactory(room=g2.room, user=g2.black_user) RoomUserFactory(room=g2.room, user=g2.white_user) assert Game.active_games(db).count() == 2
def test_popular_games_not_private(db): demo = DemoGameFactory(room__users_max=10) game = GameFactory(room__users_max=11) GameFactory(is_private=True, room__users_max=12) svc = DashboardService(db) popular = svc.execute('popular_games') assert len(popular) == 2 assert popular[0]['id'] == game.id assert popular[1]['id'] == demo.id
def test_popular_games_age(db): demo = DemoGameFactory(room__users_max=10) game = GameFactory(room__users_max=11) GameFactory(created_at=datetime.utcnow() - timedelta(days=30), room__users_max=12) svc = DashboardService(db) popular = svc.execute('popular_games') assert len(popular) == 2 assert popular[0]['id'] == game.id assert popular[1]['id'] == demo.id
def test_handicap_white_loss(db): game_normal = GameFactory( stage='finished', result='B+R', black_user__rating=1700, white_user__rating=1700) game_hc = GameFactory(stage='finished', result='B+R', black_user__rating=1500, white_user__rating=1700) game_hc.board.handicap = 2 game_hc.apply_board_change() svc = RatingService(db) svc.update_ratings(game_normal) svc.update_ratings(game_hc) assert game_normal.white_user.rating == game_hc.white_user.rating
def test_toggle_marked_dead(db, socket): game = GameFactory(stage='counting') svc = GameService(db, socket, game.black_user) svc.user = game.black_user svc.socket.subscribe('game_update/'+str(game.id)) game.board.play(30) game.apply_board_change() svc.execute('toggle_marked_dead', {'game_id': game.id, 'coord': 30}) assert game.board.is_marked_dead(30) assert len(svc.socket.sent_messages) == 1 assert svc.socket.sent_messages[0]['method'] == 'game_update'
def test_resume_from_counting(db, socket): game = GameFactory(stage='counting') game.board.play(PASS) game.board.play(PASS) game.apply_board_change() socket.subscribe('game_update/'+str(game.id)) svc = GameService(db, socket, game.black_user) svc.execute('resume_from_counting', {'game_id': game.id}) assert game.stage == 'playing' assert not game.board.both_passed assert len(socket.sent_messages) == 1 assert socket.sent_messages[0]['method'] == 'game_update'
def test_resign_counting(db, socket): game = GameFactory(stage='counting') svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': RESIGN}) assert game.stage == 'finished'
def test_toggle_marked_dead_finished(db, socket): game = GameFactory(stage='finished') svc = GameService(db, socket, game.black_user) svc.user = game.black_user with pytest.raises(InvalidStageError): svc.execute('toggle_marked_dead', {'game_id': game.id, 'coord': 30})
def test_apply_rating_periods(db): p1 = Player(1450, 200) p2 = Player(1650, 100) missed_p1 = 20 missed_p2 = 100 for _ in range(missed_p1): p1.update_rating() for _ in range(missed_p2): p2.update_rating() p1.add_result(Result(WIN, p2.rating, p2.deviation, p2.volatility)) p2.add_result(Result(LOSS, p1.rating, p1.deviation, p1.volatility)) p1.update_rating() p2.update_rating() game = GameFactory(stage='finished', result='B+R', black_user__rating=1450, white_user__rating=1650) game.black_user.rating_data.deviation = 200 game.black_user.apply_rating_data_change() game.black_user.last_rating_update_at = datetime.utcnow( ) - settings.RATING_PERIOD_DURATION*missed_p1 game.white_user.rating_data.deviation = 100 game.white_user.apply_rating_data_change() game.white_user.last_rating_update_at = datetime.utcnow( ) - settings.RATING_PERIOD_DURATION*missed_p2 svc = RatingService(db) svc.update_ratings(game) assert game.black_user.rating == p1.rating assert game.white_user.rating == p2.rating
def test_confirm_score_finished(db, socket): game = GameFactory(stage='finished', result='B+1.5') svc = GameService(db, socket, game.black_user) svc.user = game.black_user with pytest.raises(InvalidStageError): svc.execute('confirm_score', {'game_id': game.id, 'result': 'B+1.5'})
def test_open_room_logs(db, socket): game = GameFactory() svc = GameService(db, socket) svc.execute('open_game', {'game_id': game.id}) assert len(list(filter(lambda l: l['method'] == 'room_logs', socket.sent_messages))) == 1
def test_sgf(self): game = GameFactory() res = self.fetch('/api/games/%s/sgf' % game.id) self.assertEqual(res.code, 200) assert res.body.decode() == game_to_sgf(game)
def test_move_current_color(db, socket): game = GameFactory() svc = GameService(db, socket, game.white_user) with pytest.raises(InvalidPlayerError): svc.execute('move', {'game_id': game.id, 'move': 30}) assert game.board.at(30) == EMPTY
def test_start_delay(db, socket): game = GameFactory(timing__start_at=datetime.utcnow() + timedelta(seconds=10)) svc = GameService(db, socket, game.black_user) with pytest.raises(GameHasNotStartedError): svc.execute('move', {'game_id': game.id, 'move': 30}) assert game.board.at(30) == EMPTY
def test_move_finished(db, socket): game = GameFactory(stage='finished') svc = GameService(db, socket, game.black_user) with pytest.raises(InvalidStageError): svc.execute('move', {'game_id': game.id, 'move': 30}) assert game.board.at(30) == EMPTY
def test_resume_from_counting_time(db, socket): game = GameFactory(stage='counting') svc = GameService(db, socket, game.black_user) game.timing.timing_updated_at = datetime.utcnow() - timedelta(minutes=10) svc.execute('resume_from_counting', {'game_id': game.id}) assert (game.timing.timing_updated_at - datetime.utcnow()).total_seconds() < 3
def test_resign(db, socket, board): game = GameFactory(stage='counting', board=board) svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': RESIGN}) assert game.stage == 'finished' assert game.result == 'W+R'
def test_move(db, socket): game = GameFactory() svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': 30}) assert game.board.at(30) == BLACK assert game.board.current == WHITE
def test_game_finished_correspondence(db, socket, mails): game = GameFactory(is_correspondence=True, black_user__is_online=False, white_user__is_online=False) svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': RESIGN}) assert len(mails) == 2 assert mails[0]['template'] == 'correspondence/game_finished.txt' assert mails[1]['template'] == 'correspondence/game_finished.txt' assert {mails[0]['to'], mails[1]['to']} == {game.black_user.email, game.white_user.email}
def test_resume_counting_invalid_player(db, socket): user = UserFactory() game = GameFactory(stage='counting') svc = GameService(db, socket, user) with pytest.raises(InvalidPlayerError): svc.execute('resume_from_counting', {'game_id': game.id}) assert game.stage == 'counting'
def test_open_room(db, socket): game = GameFactory() user = UserFactory() svc = GameService(db, socket, user) svc.execute('open_game', {'game_id': game.id}) assert len(user.rooms) == 1 assert user.rooms[0].room.game == game
def test_games_display_names(db, socket): black = GameFactory(black_display='TestUser') white = GameFactory(white_display='ATestUser2') demo = GameFactory(demo_owner_display='BTestUser3') GameFactory(black_display='nomatch', white_display='nomatch', demo_owner_display='nomatch') svc = SearchService(db, socket) data = svc.execute('games', {'query': 'testuser'}) assert data.get('page') == 1 assert data.get('total_pages') == 1 assert data.get('total_results') == 3 assert len(data['results']) == 3 assert data['results'][0]['id'] == demo.id assert data['results'][1]['id'] == white.id assert data['results'][2]['id'] == black.id
def test_game_finished_user_status(db, socket): game = GameFactory() socket.subscribe('user_status') svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': RESIGN}) assert len(socket.sent_messages) == 2 assert socket.sent_messages[0]['method'] == 'user_status' assert socket.sent_messages[1]['method'] == 'user_status'
def test_stages_playing_counting(db, socket): game = GameFactory() svc = GameService(db, socket, game.black_user) svc.user = game.black_user svc.execute('move', {'game_id': game.id, 'move': PASS}) assert game.stage == 'playing' svc.user = game.white_user svc.execute('move', {'game_id': game.id, 'move': PASS}) assert game.stage == 'counting'
def test_open_game_private_not_player(db, socket): game = GameFactory(is_private=True) socket.subscribe('game_started') random_user = UserFactory() svc = GameService(db, socket, random_user) with pytest.raises(NotAllowedError) as exinfo: svc.execute('open_game', {'game_id': game.id}) assert 'this game is private' in str(exinfo.value)
def test_update_ratings_aborted(db): game = GameFactory(stage='finished', result='aborted', black_user__rating=1500, white_user__rating=1500) svc = RatingService(db) svc.update_ratings(game) assert len(game.black_user.rating_data.results) == 0 assert game.black_user.rating == 1500 assert len(game.white_user.rating_data.results) == 0 assert game.white_user.rating == 1500
def test_correspondence_settings(db, socket, mails): game = GameFactory(is_correspondence=True, black_user__correspondence_emails=False, black_user__is_online=False, white_user__correspondence_emails=True, white_user__is_online=False) svc = CorrespondenceService(db, socket) svc.notify_automatch_started(game) assert len(mails) == 1 assert mails[0]['to'] == game.white_user.email
def test_timing(db, socket): game = GameFactory(timing__timing_updated_at=datetime.utcnow()-timedelta(seconds=9), timing__system='fischer', timing__overtime=timedelta(seconds=15), timing__black_main=timedelta(seconds=10), timing__black_overtime=timedelta()) svc = GameService(db, socket, game.black_user) svc.execute('move', {'game_id': game.id, 'move': 30}) # Because of slow CI runners this test cannot be exact. assert 16 - game.timing.black_main.total_seconds() < 3
def test_resume_all_games_cap(db): GameFactory(stage='playing', timing__system='fischer', timing__capped=True, timing__main=timedelta(minutes=1), timing__black_main=timedelta(minutes=2), timing__white_main=timedelta(minutes=3)) svc = GameService(db) svc.resume_all_games() timing = db.query(Timing).first() assert timing.black_main == timing.main_cap assert timing.white_main == timing.main_cap
def test_open_game_private_as_player(db, socket): game = GameFactory(is_private=True) socket.subscribe('game_started') svc = GameService(db, socket, game.black_user) svc.execute('open_game', {'game_id': game.id}) assert socket.is_subscribed('game_data/'+str(game.id)) assert socket.is_subscribed('game_update/'+str(game.id)) assert socket.is_subscribed('game_info/'+str(game.id)) assert socket.is_subscribed('demo_current_node_id/'+str(game.id)) assert socket.is_subscribed('room_message/'+str(game.room_id)) assert socket.is_subscribed('room_user/'+str(game.room_id)) assert socket.is_subscribed('room_user_left/'+str(game.room_id))