parso/conftest.py

import re
import tempfile
import shutil
import logging
import sys
import os

import pytest

import parso
from parso import cache
from parso.utils import parse_version_string


collect_ignore = ["setup.py"]

@pytest.fixture(scope='session')
def clean_parso_cache():
    """
    Set the default cache directory to a temporary directory during tests.

    Note that you can't use built-in `tmpdir` and `monkeypatch`
    fixture here because their scope is 'function', which is not used
    in 'session' scope fixture.

    This fixture is activated in ../pytest.ini.
    """
    old = cache._default_cache_path
    tmp = tempfile.mkdtemp(prefix='parso-test-')
    cache._default_cache_path = tmp
    yield
    cache._default_cache_path = old
    shutil.rmtree(tmp)


def pytest_addoption(parser):
    parser.addoption("--logging", "-L", action='store_true',
                     help="Enables the logging output.")


def pytest_generate_tests(metafunc):
    if 'normalizer_issue_case' in metafunc.fixturenames:
        base_dir = os.path.join(os.path.dirname(__file__), 'test', 'normalizer_issue_files')

        cases = list(colllect_normalizer_tests(base_dir))
        metafunc.parametrize(
            'normalizer_issue_case',
            cases,
            ids=[c.name for c in cases]
        )
    elif 'each_version' in metafunc.fixturenames:
        metafunc.parametrize(
            'each_version',
            ['2.6', '2.7', '3.3', '3.4', '3.5', '3.6'],
        )
    elif 'each_py2_version' in metafunc.fixturenames:
        metafunc.parametrize(
            'each_py2_version',
            ['2.6', '2.7'],
        )
    elif 'each_py3_version' in metafunc.fixturenames:
        metafunc.parametrize(
            'each_py3_version',
            ['3.3', '3.4', '3.5', '3.6'],
        )


class NormalizerIssueCase(object):
    """
    Static Analysis cases lie in the static_analysis folder.
    The tests also start with `#!`, like the goto_definition tests.
    """
    def __init__(self, path):
        self.path = path
        self.name = os.path.basename(path)
        match = re.search(r'python([\d.]+)\.py', self.name)
        self.python_version = match and match.group(1)


def colllect_normalizer_tests(base_dir):
    for f_name in os.listdir(base_dir):
        if f_name.endswith(".py"):
            path = os.path.join(base_dir, f_name)
            yield NormalizerIssueCase(path)


def pytest_configure(config):
    if config.option.logging:
        root = logging.getLogger()
        root.setLevel(logging.DEBUG)

        ch = logging.StreamHandler(sys.stdout)
        ch.setLevel(logging.DEBUG)
        #formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        #ch.setFormatter(formatter)

        root.addHandler(ch)


@pytest.fixture
def each_py3_version():
    return '3.3', '3.4', '3.5', '3.6'


@pytest.fixture
def each_py2_version():
    return '2.6', '2.7'


def _parse(code, version=None):
    code = code + "\n\n"
    grammar = parso.load_grammar(version=version)
    return grammar.parse(code, error_recovery=False)


def _invalid_syntax(code, version=None, **kwargs):
    with pytest.raises(parso.ParserSyntaxError):
        module = _parse(code, version=version, **kwargs)
        # For debugging
        print(module.children)


class Checker():
    def __init__(self, version, is_passing):
        self._version = version
        self._is_passing = is_passing

    def parse(self, code):
        func = _parse if self._is_passing else _invalid_syntax
        return func(code, version=self._version)

@pytest.fixture
def works_in_py2(each_version):
    return Checker(each_version, each_version.startswith('2'))


@pytest.fixture
def works_ge_py3(each_version):
    version_info = parse_version_string(each_version)
    return Checker(each_version, version_info >= (3, 0))


@pytest.fixture
def works_ge_py35(each_version):
    """
    Works only greater equal Python 3.3.
    """
    version_info = parse_version_string(each_version)
    return Checker(each_version, version_info >= (3, 5))