setup()

Complexity

Conditions

4

Size

Total Lines

17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	transport()	0	3	1

"""
This module is the 'top level' configuration for all the unit tests.

'Real world' fixtures are put here.
If a test suite needs specific mocked versions of dependencies,
these should be put in the ``conftest.py'' relative to it.
"""

import asyncio

import logging
import subprocess

The import subprocess seems to be unused.

import sys

The import sys seems to be unused.

from server.config import DB_SERVER, DB_LOGIN, DB_PORT, DB_PASSWORD

import pytest
from unittest import mock
from trueskill import Rating

The import trueskill could not be resolved.

logging.getLogger().setLevel(logging.DEBUG)

import os

The import os seems to be unused.

def async_test(f):
    def wrapper(*args, **kwargs):
        coro = asyncio.coroutine(f)
        future = coro(*args, **kwargs)
        loop = asyncio.get_event_loop()

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

        loop.run_until_complete(future)
    return wrapper


def pytest_pycollect_makeitem(collector, name, obj):
    if name.startswith('test_') and asyncio.iscoroutinefunction(obj):
        return list(collector._genfunctions(name, obj))

It seems like _genfunctions was declared protected and should not be accessed from this context.

def pytest_addoption(parser):
    parser.addoption('--noslow', action='store_true', default=False,
                     help="Don't run slow tests")
    parser.addoption('--aiodebug', action='store_true', default=False,
                     help='Enable asyncio debugging')
    parser.addoption('--mysql_host', action='store', default=DB_SERVER, help='mysql host to use for test database')
    parser.addoption('--mysql_username', action='store', default=DB_LOGIN, help='mysql username to use for test database')

This line is too long as per the coding-style (122/120).

    parser.addoption('--mysql_password', action='store', default=DB_PASSWORD, help='mysql password to use for test database')

This line is too long as per the coding-style (125/120).

    parser.addoption('--mysql_database', action='store', default='faf_test', help='mysql database to use for tests')
    parser.addoption('--mysql_port',     action='store', default=int(DB_PORT), help='mysql port to use for tests')


def pytest_configure(config):
    if config.getoption('--aiodebug'):
        logging.getLogger('quamash').setLevel(logging.DEBUG)
        logging.captureWarnings(True)
    else:
        logging.getLogger('quamash').setLevel(logging.INFO)


def pytest_runtest_setup(item):
    """
    Skip tests if they are marked slow, and --noslow is given on the commandline
    :param item:
    :return:
    """
    if getattr(item.obj, 'slow', None) and item.config.getvalue('noslow'):
        pytest.skip("slow test")

def pytest_pyfunc_call(pyfuncitem):
    testfn = pyfuncitem.obj

    if not asyncio.iscoroutinefunction(testfn):
        return

    funcargs = pyfuncitem.funcargs
    testargs = {}
    for arg in pyfuncitem._fixtureinfo.argnames:

It seems like _fixtureinfo was declared protected and should not be accessed from this context.

        testargs[arg] = funcargs[arg]
    loop = testargs.get('loop', asyncio.get_event_loop())

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

    loop.set_debug(True)
    coro = asyncio.wait_for(testfn(**testargs), 5)

    try:
        loop.run_until_complete(coro)
    except RuntimeError as err:
        logging.error(err)
        raise err
    return True

@pytest.fixture(scope='session', autouse=True)
def loop(request):

The argument request seems to be unused.

    import server
    server.stats = mock.MagicMock()
    return asyncio.get_event_loop()

@pytest.fixture
def sqlquery():
    query = mock.MagicMock()
    query.exec_ = lambda: 0
    query.size = lambda: 0
    query.lastInsertId = lambda: 1
    query.prepare = mock.MagicMock()
    query.addBindValue = lambda v: None
    return query

@pytest.fixture
def mock_db_pool(loop, db_pool, autouse=True):

The argument autouse seems to be unused.

The argument loop seems to be unused.

db_pool is re-defining a name which is already available in the outer-scope (previously defined on line 110).

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

    return db_pool

@pytest.fixture(scope='session')
def db_pool(request, loop):

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

    import server

    def opt(val):
        return request.config.getoption(val)
    host, user, pw, db, port = opt('--mysql_host'), opt('--mysql_username'), opt('--mysql_password'), opt('--mysql_database'), opt('--mysql_port')

This line is too long as per the coding-style (146/120).

    pool_fut = asyncio.async(server.db.connect(loop=loop,
                                               host=host,
                                               user=user,
                                               password=pw or None,
                                               port=port,
                                               db=db))
    pool = loop.run_until_complete(pool_fut)


    def fin():
        pool.close()
        loop.run_until_complete(pool.wait_closed())
    request.addfinalizer(fin)

    return pool

@pytest.fixture
def transport():
    return mock.Mock(spec=asyncio.Transport)

@pytest.fixture
def game(players):

players is re-defining a name which is already available in the outer-scope (previously defined on line 168).

    from server.games import Game
    from server.abc.base_game import InitMode

The name abc does not seem to exist in module server.

The import server.abc.base_game could not be resolved.

    mock_parent = mock.Mock()
    game = mock.create_autospec(spec=Game(1, mock_parent, mock.Mock()))

game is re-defining a name which is already available in the outer-scope (previously defined on line 137).

    players.hosting.getGame = mock.Mock(return_value=game)
    players.joining.getGame = mock.Mock(return_value=game)
    players.peer.getGame = mock.Mock(return_value=game)
    game.hostPlayer = players.hosting
    game.init_mode = InitMode.NORMAL_LOBBY
    game.name = "Some game name"
    game.id = 1
    return game

@pytest.fixture
def create_player():
    from server.players import Player, PlayerState
    def make(login='', id=0, port=6112, state=PlayerState.HOSTING, ip='127.0.0.1', global_rating=Rating(1500, 250), ladder_rating=Rating(1500, 250)):

This line is too long as per the coding-style (149/120).

This seems to re-define the built-in id.

        p = mock.create_autospec(spec=Player(login))
        p.global_rating = global_rating
        p.ladder_rating = ladder_rating
        p.ip = ip
        p.game_port = port
        p.state = state
        p.id = id
        p.login = login
        p.address_and_port = "{}:{}".format(ip, port)
        return p
    return make

@pytest.fixture
def players(create_player):

create_player is re-defining a name which is already available in the outer-scope (previously defined on line 152).

    from server.players import PlayerState
    return mock.Mock(
        hosting=create_player(login='Paula_Bean', id=1, port=6112, state=PlayerState.HOSTING),
        peer=create_player(login='That_Guy', id=2, port=6112, state=PlayerState.JOINING),
        joining=create_player(login='James_Kirk', id=3, port=6112, state=PlayerState.JOINING)
    )

@pytest.fixture
def player_service(loop, players, db_pool):

db_pool is re-defining a name which is already available in the outer-scope (previously defined on line 110).

players is re-defining a name which is already available in the outer-scope (previously defined on line 168).

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

The argument loop seems to be unused.

The argument players seems to be unused.

    from server import PlayerService
    return PlayerService(db_pool)

@pytest.fixture
def game_service(loop, player_service, game_stats_service):

game_stats_service is re-defining a name which is already available in the outer-scope (previously defined on line 202).

player_service is re-defining a name which is already available in the outer-scope (previously defined on line 177).

loop is re-defining a name which is already available in the outer-scope (previously defined on line 90).

The argument loop seems to be unused.

    from server import GameService
    return GameService(player_service, game_stats_service)

@pytest.fixture
def api_accessor():
    from server.api.api_accessor import ApiAccessor

The name api does not seem to exist in module server.

The import server.api.api_accessor could not be resolved.

    return ApiAccessor()

@pytest.fixture
def event_service(api_accessor):

api_accessor is re-defining a name which is already available in the outer-scope (previously defined on line 187).

    from server.stats.event_service import EventService

Unable to import 'server.stats.event_service' (invalid syntax (<string>, line 41))

    return EventService(api_accessor)

@pytest.fixture
def achievement_service(api_accessor):

api_accessor is re-defining a name which is already available in the outer-scope (previously defined on line 187).

    from server.stats.achievement_service import AchievementService

Unable to import 'server.stats.achievement_service' (invalid syntax (<string>, line 69))

    return AchievementService(api_accessor)

@pytest.fixture
def game_stats_service(event_service, achievement_service):

achievement_service is re-defining a name which is already available in the outer-scope (previously defined on line 197).

event_service is re-defining a name which is already available in the outer-scope (previously defined on line 192).

    from server.stats.game_stats_service import GameStatsService

Unable to import 'server.stats.game_stats_service' (invalid syntax (<string>, line 15))

    return GameStatsService(event_service, achievement_service)