Exemple #1
0
def test_all_of_ignore_name():
    class A(object):
        name = "long_name"
        value = "val"
        t = "ololo"

    assert_that(all_of(A), only_contains(("t", "ololo"), ))
Exemple #2
0
def test_all_of_ignore_name():
    class A(object):
        name = "long_name"
        value = "val"
        t = "ololo"

    assert_that(all_of(A), only_contains(("t", "ololo"),))
Exemple #3
0
def pytest_addoption(parser):
    parser.getgroup("reporting").addoption('--alluredir',
                                           action="store",
                                           dest="allurereportdir",
                                           metavar="DIR",
                                           default=None,
                                           help="Generate Allure report in the specified directory (may not exist)")

    severities = [v for (_, v) in all_of(Severity)]

    def severity_type(string):
        entries = [x.strip() for x in string.split(',')]

        for entry in entries:
            if entry not in severities:
                raise argparse.ArgumentTypeError('Illegal severity value [%s], only values from [%s] are allowed.' % (entry, ', '.join(severities)))

        return entries

    parser.getgroup("general").addoption('--allure_severities',
                                         action="store",
                                         dest="allureseverities",
                                         metavar="SEVERITIES_LIST",
                                         default=None,
                                         type=severity_type,
                                         help="""Comma-separated list of severity names.
                                         Tests only with these severities will be run.
                                         Possible values are:%s.""" % ', '.join(severities))
def pytest_addoption(parser):
    parser.getgroup("reporting").addoption('--alluredir',
                                           action="store",
                                           dest="allurereportdir",
                                           metavar="DIR",
                                           default=None,
                                           help="Generate Allure report in the specified directory (may not exist)")

    severities = [v for (_, v) in all_of(Severity)]

    def severity_type(string):
        entries = [x.strip() for x in string.split(',')]

        for entry in entries:
            if entry not in severities:
                raise argparse.ArgumentTypeError('Illegal severity value [%s], only values from [%s] are allowed.' % (entry, ', '.join(severities)))

        return entries

    parser.getgroup("general").addoption('--allure_severities',
                                         action="store",
                                         dest="allureseverities",
                                         metavar="SEVERITIES_LIST",
                                         default=None,
                                         type=severity_type,
                                         help="""Comma-separated list of severity names.
                                         Tests only with these severities will be run.
                                         Possible values are:%s.""" % ', '.join(severities))
def pytest_addoption(parser):
    parser.getgroup("reporting").addoption('--alluredir',
                                           action="store",
                                           dest="allurereportdir",
                                           metavar="DIR",
                                           default=None,
                                           help="Generate Allure report in the specified directory (may not exist)")

    severities = [v for (_, v) in all_of(Severity)]

    def label_type(name, legal_values=set()):
        """
        argparse-type factory for labelish things.
        processed value is set of tuples (name, value).
        :param name: of label type (for future TestLabel things)
        :param legal_values: a `set` of values that are legal for this label, if any limit whatsoever
        :raises ArgumentTypeError: if `legal_values` are given and there are values that fall out of that
        """
        def a_label_type(string):
            atoms = set(string.split(','))
            if legal_values and not atoms < legal_values:
                raise argparse.ArgumentTypeError('Illegal {} values: {}, only [{}] are allowed'.format(name, ', '.join(atoms - legal_values), ', '.join(legal_values)))

            return set((name, v) for v in atoms)

        return a_label_type

    parser.getgroup("general").addoption('--allure_severities',
                                         action="store",
                                         dest="allureseverities",
                                         metavar="SEVERITIES_SET",
                                         default={},
                                         type=label_type(name=Label.SEVERITY, legal_values=set(severities)),
                                         help="""Comma-separated list of severity names.
                                         Tests only with these severities will be run.
                                         Possible values are:%s.""" % ', '.join(severities))

    parser.getgroup("general").addoption('--allure_features',
                                         action="store",
                                         dest="allurefeatures",
                                         metavar="FEATURES_SET",
                                         default={},
                                         type=label_type(name=Label.FEATURE),
                                         help="""Comma-separated list of feature names.
                                         Run tests that have at least one of the specified feature labels.""")

    parser.getgroup("general").addoption('--allure_stories',
                                         action="store",
                                         dest="allurestories",
                                         metavar="STORIES_SET",
                                         default={},
                                         type=label_type(name=Label.STORY),
                                         help="""Comma-separated list of story names.
                                         Run tests that have at least one of the specified story labels.""")
def pytest_addoption(parser):
    parser.getgroup("reporting").addoption('--alluredir',
                                           action="store",
                                           dest="allurereportdir",
                                           metavar="DIR",
                                           default=None,
                                           help="Generate Allure report in the specified directory (may not exist)")

    severities = [v for (_, v) in all_of(Severity)]

    def severity_label_type(string):
        entries = LabelsList([TestLabel(name=Label.SEVERITY, value=x) for x in string.split(',')])

        for entry in entries:
            if entry.value not in severities:
                raise argparse.ArgumentTypeError('Illegal severity value [%s], only values from [%s] are allowed.' % (entry.value, ', '.join(severities)))

        return entries

    def features_label_type(string):
        return LabelsList([TestLabel(name=Label.FEATURE, value=x) for x in string.split(',')])

    def stories_label_type(string):
        return LabelsList([TestLabel(name=Label.STORY, value=x) for x in string.split(',')])

    parser.getgroup("general").addoption('--allure_severities',
                                         action="store",
                                         dest="allureseverities",
                                         metavar="SEVERITIES_LIST",
                                         default=LabelsList(),
                                         type=severity_label_type,
                                         help="""Comma-separated list of severity names.
                                         Tests only with these severities will be run.
                                         Possible values are:%s.""" % ', '.join(severities))

    parser.getgroup("general").addoption('--allure_features',
                                         action="store",
                                         dest="allurefeatures",
                                         metavar="FEATURES_LIST",
                                         default=LabelsList(),
                                         type=features_label_type,
                                         help="""Comma-separated list of feature names.
                                         Run tests that have at least one of the specified feature labels.""")

    parser.getgroup("general").addoption('--allure_stories',
                                         action="store",
                                         dest="allurestories",
                                         metavar="STORIES_LIST",
                                         default=LabelsList(),
                                         type=stories_label_type,
                                         help="""Comma-separated list of story names.
                                         Run tests that have at least one of the specified story labels.""")
Exemple #7
0

@pytest.mark.parametrize('package', ['pytest.allure', 'allure'])
def test_smoke(report_for, package):
    report = report_for("""
    import pytest
    import allure

    def test_x():
        %s.attach('Foo', 'Bar')
    """ % package)

    assert_that(report.findall('test-cases/test-case/attachments/attachment'), contains(has_property('attrib', has_entries(title='Foo'))))


@pytest.mark.parametrize('a_type', map(lambda x: x[0], all_of(AttachmentType)))
def test_attach_types(report_for, a_type):
    report = report_for("""
    import allure as A

    def test_x():
        A.attach('Foo', 'Bar', A.attach_type.%s)
    """ % a_type)

    assert_that(report.find('.//attachment').attrib, has_entries(title='Foo', type=getattr(AttachmentType, a_type).mime_type))


class TestContents:

    @pytest.fixture
    def attach_contents(self, report_for, reportdir):
Exemple #8
0
@pytest.mark.parametrize('package', ['pytest.allure', 'allure'])
def test_smoke(report_for, package):
    report = report_for("""
    import pytest
    import allure

    def test_x():
        %s.attach('Foo', 'Bar')
    """ % package)

    assert_that(report.findall('test-cases/test-case/attachments/attachment'),
                contains(has_property('attrib', has_entries(title='Foo'))))


@pytest.mark.parametrize('a_type', map(lambda x: x[0], all_of(AttachmentType)))
def test_attach_types(report_for, a_type):
    report = report_for("""
    import allure as A

    def test_x():
        A.attach('Foo', 'Bar', A.attach_type.%s)
    """ % a_type)

    assert_that(
        report.find('.//attachment').attrib,
        has_entries(title='Foo',
                    type=getattr(AttachmentType, a_type).mime_type))


class TestContents:
Exemple #9
0
def pytest_addoption(parser):
    parser.getgroup("reporting").addoption(
        '--alluredir',
        action="store",
        dest="allurereportdir",
        metavar="DIR",
        default=None,
        help="Generate Allure report in the specified directory (may not exist)"
    )

    severities = [v for (_, v) in all_of(Severity)]

    def severity_label_type(string):
        entries = LabelsList([
            TestLabel(name=Label.SEVERITY, value=x) for x in string.split(',')
        ])

        for entry in entries:
            if entry.value not in severities:
                raise argparse.ArgumentTypeError(
                    'Illegal severity value [%s], only values from [%s] are allowed.'
                    % (entry.value, ', '.join(severities)))

        return entries

    def features_label_type(string):
        return LabelsList([
            TestLabel(name=Label.FEATURE, value=x) for x in string.split(',')
        ])

    def stories_label_type(string):
        return LabelsList(
            [TestLabel(name=Label.STORY, value=x) for x in string.split(',')])

    parser.getgroup("general").addoption(
        '--allure_severities',
        action="store",
        dest="allureseverities",
        metavar="SEVERITIES_LIST",
        default=LabelsList(),
        type=severity_label_type,
        help="""Comma-separated list of severity names.
                                         Tests only with these severities will be run.
                                         Possible values are:%s.""" %
        ', '.join(severities))

    parser.getgroup("general").addoption(
        '--allure_features',
        action="store",
        dest="allurefeatures",
        metavar="FEATURES_LIST",
        default=LabelsList(),
        type=features_label_type,
        help="""Comma-separated list of feature names.
                                         Run tests that have at least one of the specified feature labels."""
    )

    parser.getgroup("general").addoption(
        '--allure_stories',
        action="store",
        dest="allurestories",
        metavar="STORIES_LIST",
        default=LabelsList(),
        type=stories_label_type,
        help="""Comma-separated list of story names.
                                         Run tests that have at least one of the specified story labels."""
    )
    return has_properties(attrib=all_of(has_entry('name', 'severity'),
                                        has_entry('value', value)))


def has_test_with_severity(test_name, severity_level):
    return has_label(test_name,
                     label_value=severity_level,
                     label_name='severity')


@pytest.mark.parametrize('mark_way', [
    '@pytest.allure.%s',
    '@pytest.allure.severity(pytest.allure.severity_level.%s)'
],
                         ids=['Short', 'Full'])
@pytest.mark.parametrize('name,value', utils.all_of(Severity))
def test_method_severity(report_for, name, value, mark_way):
    report = report_for("""
    import pytest

    %s
    def test_foo():
        pass
    """ % (mark_way % name))

    assert_that(report.findall(".//test-case/labels/label"),
                contains(severity_element(value)))


def test_class_severity(report_for):
    """
Exemple #11
0
from .matchers import has_label


def severity_element(value):
    return has_properties(attrib=all_of(has_entry('name', 'severity'),
                                        has_entry('value', value)))


def has_test_with_severity(test_name, severity_level):
    return has_label(test_name, label_value=severity_level, label_name='severity')


@pytest.mark.parametrize('mark_way', ['@pytest.allure.%s',
                                      '@pytest.allure.severity(pytest.allure.severity_level.%s)'
                                      ], ids=['Short', 'Full'])
@pytest.mark.parametrize('name,value', utils.all_of(Severity))
def test_method_severity(report_for, name, value, mark_way):
    report = report_for("""
    import pytest

    %s
    def test_foo():
        pass
    """ % (mark_way % name))

    assert_that(report, has_test_with_severity('test_foo', value))


def test_class_severity(report_for):
    """
    Checks that severity markers for tests override ones for class