Exemplo n.º 1
0
def test_scenario_not_found(request):
    """Test the situation when scenario is not found."""
    with pytest.raises(exceptions.ScenarioNotFound) as exc_info:
        scenario('not_found.feature', 'NOT FOUND')
    assert six.text_type(exc_info.value).startswith(
        'Scenario "NOT FOUND" in feature "[Empty]" in {feature_path}'.format(
            feature_path=request.fspath.join('..', 'not_found.feature')))
Exemplo n.º 2
0
def test_scenario_not_found(request):
    """Test the situation when scenario is not found."""

    with pytest.raises(exceptions.ScenarioNotFound):
        scenario(
            'not_found.feature',
            'NOT FOUND'
        )
Exemplo n.º 3
0
def test_verbose_output(request):
    """Test verbose output of failed feature scenario"""
    with pytest.raises(FeatureError) as excinfo:
        scenario('when_after_then.feature', 'When after then')

    msg, line_number, line = excinfo.value.args

    assert line_number == 5
    assert line == 'When I do it again'
Exemplo n.º 4
0
def test_scenario_not_found(request):
    """Test the situation when scenario is not found."""
    with pytest.raises(exceptions.ScenarioNotFound) as exc_info:
        scenario(
            'not_found.feature',
            'NOT FOUND'
        )
    assert six.text_type(exc_info.value).startswith(
        'Scenario "NOT FOUND" in feature "[Empty]" in {feature_path}'
        .format(feature_path=request.fspath.join('..', 'not_found.feature')))
Exemplo n.º 5
0
def test_verbose_output():
    """Test verbose output of failed feature scenario."""
    with pytest.raises(exceptions.FeatureError) as excinfo:
        scenario('when_after_then.feature', 'When after then')

    msg, line_number, line, file = excinfo.value.args

    assert line_number == 5
    assert line == 'When I do it again'
    assert file == os.path.join(os.path.dirname(__file__), 'when_after_then.feature')
    assert line in str(excinfo.value)
def test_feature_path(request, scenario_name):
    """Test feature base dir."""
    sc = scenario('steps.feature', scenario_name)
    with pytest.raises(IOError) as exc:
        sc(request)

    assert os.path.join('/does/not/exist/', 'steps.feature') in str(exc.value)
Exemplo n.º 7
0
def test_multiple_given(request):
    """Using the same given fixture raises an error."""
    test = scenario(
        'args_steps.feature',
        'Using the same given fixture raises an error',
    )
    with pytest.raises(GivenAlreadyUsed):
        test(request)
Exemplo n.º 8
0
def test_scenario_not_decorator(request):
    """Test scenario function is used not as decorator."""
    func = scenario(
        'comments.feature',
        'Strings that are not comments')

    with pytest.raises(exceptions.ScenarioIsDecoratorOnly):
        func(request)
Exemplo n.º 9
0
def test_scenario_not_found(request):
    """Test the situation when scenario is not found."""
    test_not_found = scenario(
        'not_found.feature',
        'NOT FOUND'
    )

    with pytest.raises(ScenarioNotFound):
        test_not_found(request)
Exemplo n.º 10
0
def test_verbose_output(request):
    """Test verbose output of failed feature scenario"""
    sc = scenario('wrong.feature', 'When after then')
    with pytest.raises(FeatureError) as excinfo:
        sc(request)

    msg, line_number, line = excinfo.value.args

    assert line_number == 4
    assert line == 'When I do it again'
Exemplo n.º 11
0
def test_scenario_not_decorator(request):
    """Test scenario function is used not as decorator."""
    func = scenario('comments.feature', 'Strings that are not comments')

    with pytest.raises(exceptions.ScenarioIsDecoratorOnly):
        func(request)
import pytest
from pytest_bdd import scenario, given, when, then


@pytest.fixture
def pytestbdd_close_browser():
    """Close browser fixture."""
    return False


test_successful_login = scenario(
    'auth/admin_login.feature',
    'Successful login',
)


@given('I\'m an admin user')
def admin_user(user):
    return user


@when('I go to the admin login page')
def go_to_login_page(browser):
    browser.visit('http://127.0.0.1:5000')


@when('I fill in the login credentials')
def fill_in_login_credentials(browser, user, password):
    browser.fill('username', user.username)
    browser.fill('password', password)
Exemplo n.º 13
0
from pytest_bdd import scenario, given, when, then

test_steps = scenario('steps.feature', 'Executed step by step')


@given('I have a foo fixture with value "foo"')
def foo():
    return 'foo'


@given('there is a list')
def results():
    return []


@when('I append 1 to the list')
def append_1(results):
    results.append(1)


@when('I append 2 to the list')
def append_2(results):
    results.append(2)


@when('I append 3 to the list')
def append_3(results):
    results.append(3)


@then('foo should have value "foo"')
Exemplo n.º 14
0
import re
from urlparse import urljoin

from pytest_bdd import when, scenario

test_sucsessful_login = scenario(
    "auth/login.feature",
    "Successful login",
)

test_invalid_username = scenario(
    "auth/login.feature",
    "Invalid username",
)

test_ivalid_password = scenario(
    "auth/login.feature",
    "Invalid password",
)


@when("I go to login page")
def go_to_login_page(browser):
    browser.visit(urljoin(browser.url, "/login"))


@when(re.compile('I enter "(?P<username>\w+)" username'))
def enter_username(browser, username):
    browser.fill("username", username)

Exemplo n.º 15
0
"""Step arguments tests."""

import functools
import re
import pytest
from pytest_bdd import scenario, given, when, then
from pytest_bdd.scenario import GivenAlreadyUsed


test_steps = scenario(
    'args_steps.feature',
    'Every step takes a parameter with the same name',
)

sc = functools.partial(scenario, 'when_arguments.feature')
test_argument_in_when_step_1 = sc('Argument in when, step 1')
test_argument_in_when_step_2 = sc('Argument in when, step 2')


@pytest.fixture
def values():
    return ['1', '2', '1', '0', '999999']


@given(re.compile(r'I have (?P<euro>\d+) Euro'))
def i_have(euro, values):
    assert euro == values.pop(0)


@when(re.compile(r'I pay (?P<euro>\d+) Euro'))
def i_pay(euro, values, request):
Exemplo n.º 16
0
def test_wrong(request, feature, scenario_name):
    """Test wrong feature scenarios."""

    sc = scenario(feature, scenario_name)
    with pytest.raises(FeatureError):
        sc(request)
Exemplo n.º 17
0
"""Test step alias when decorated multiple times."""

from pytest_bdd import scenario, given, when, then


test_steps = scenario('alias.feature', 'Multiple decorated aliases should work')


@given('Given I have an empty list')
def results():
    return []


@given('I have foo (which is 1) in my list')
@given('I have bar (alias of foo) in my list')
def foo(results):
    results.append(1)


@when('I do crash (which is 2)')
@when('I do boom (alias of crash)')
def crash(results):
    results.append(2)


@then('my list should be [1, 2, 2]')
def check_results(results):
    """Fixture is evaluated only once, so the list will be [1, 2, 2]"""
    assert results == [1, 2, 2]
Exemplo n.º 18
0
from pytest_bdd import scenario, given, when, then


test_google_ngrams_build = scenario(
    'google_ngrams.feature',
    'Build a vector space from coocurrence matrix',
)

test_google_ngrams_tf_idf = scenario(
    'google_ngrams.feature',
    'Apply tf-id weighting to the co-occurrence matrix',
)


test_google_ngrams_line_normalize = scenario(
    'google_ngrams.feature',
    'Line-normalize the co-occurrence matrix',
)


test_google_ngrams_nmf = scenario(
    'google_ngrams.feature',
    'Reduce the co-occurrence matrix using NMF',
)


@when('I build a co-occurrence matrix')
def build_cooccurrence_matrix(dispatcher, cooccurrence_dir_path, store_path, context_path, targets_path):
    assert dispatcher.dispatch(
        'google-ngrams cooccurrence '
        '--context {context_path} '
Exemplo n.º 19
0
import re
from urlparse import urljoin

from pytest_bdd import when, scenario


test_sucsessful_login = scenario(
    "auth/login.feature",
    "Successful login",
)

test_invalid_username = scenario(
    "auth/login.feature",
    "Invalid username",
)

test_ivalid_password = scenario(
    "auth/login.feature",
    "Invalid password",
)


@when("I go to login page")
def go_to_login_page(browser):
    browser.visit(urljoin(browser.url, "/login"))


@when(re.compile('I enter "(?P<username>\w+)" username'))
def enter_username(browser, username):
    browser.fill("username", username)
Exemplo n.º 20
0
"""Test step alias when decorated multiple times."""

from pytest_bdd import scenario, given, when, then

test_steps = scenario('alias.feature',
                      'Multiple given alias is not evaluated multiple times')


@given('Given I have an empty list')
def results():
    return []


@given('I have foo (which is 1) in my list')
@given('I have bar (alias of foo) in my list')
def foo(results):
    results.append(1)


@when('I do crash (which is 2)')
@when('I do boom (alias of crash)')
def crash(results):
    results.append(2)


@then('my list should be [1, 2, 2]')
def check_results(results):
    """Fixtures are not evaluated multiple times, so the list will be [1, 2, 2]"""
    assert results == [1, 2, 2]
Exemplo n.º 21
0
from pytest_bdd import scenario, when, then

test_entry_is_displayed = scenario(
    "entry/entry.feature",
    "Entry is displayed",
)

test_no_form_for_visitors = scenario(
    "entry/entry.feature",
    "No form for visitors",
)

test_create_entry = scenario(
    "entry/entry.feature",
    "Create an entry",
)


@then("I should see my entry")
def should_see_entry(browser, title):
    assert browser.is_text_present(title)


@then("I shouldn't see an entry form")
def shoudnt_see_entry_form(browser):
    assert not browser.find_by_css(".add-entry")


@when("I enter entry title")
def enter_entry_title(browser, title):
    browser.fill('title', title)
Exemplo n.º 22
0
from pytest_bdd import scenario, given, then


test_steps = scenario(
    'args.feature',
    'Executed with steps matching step definitons with arguments',
)


@given('I have a foo fixture with value "foo"')
def foo():
    return 'foo'


@given('there is a list')
def results():
    return []


@then('foo should have value "foo"')
def foo_is_foo(foo):
    assert foo == 'foo'


@then('the list should be [1, 2, 3]')
def check_results(results):
    assert results == [1, 2, 3]
Exemplo n.º 23
0
from pytest_bdd import scenario, given, when, then

test_google_ngrams_build = scenario(
    'google_ngrams.feature',
    'Build a vector space from coocurrence matrix',
)

test_google_ngrams_tf_idf = scenario(
    'google_ngrams.feature',
    'Apply tf-id weighting to the co-occurrence matrix',
)

test_google_ngrams_line_normalize = scenario(
    'google_ngrams.feature',
    'Line-normalize the co-occurrence matrix',
)

test_google_ngrams_nmf = scenario(
    'google_ngrams.feature',
    'Reduce the co-occurrence matrix using NMF',
)


@when('I build a co-occurrence matrix')
def build_cooccurrence_matrix(dispatcher, cooccurrence_dir_path, store_path,
                              context_path, targets_path):
    assert dispatcher.dispatch('google-ngrams cooccurrence '
                               '--context {context_path} '
                               '--targets {targets_path} '
                               '-i {cooccurrence_dir_path} '
                               '-o {output_path} '
Exemplo n.º 24
0
from pytest_bdd import scenario, given, when, then


test_steps = scenario('steps.feature', 'Executed step by step')


@given('I have a foo fixture with value "foo"')
def foo():
    return 'foo'


@given('there is a list')
def results():
    return []


@when('I append 1 to the list')
def append_1(results):
    results.append(1)


@when('I append 2 to the list')
def append_2(results):
    results.append(2)


@when('I append 3 to the list')
def append_3(results):
    results.append(3)

Exemplo n.º 25
0
import pytest

from pytest_bdd import given, then, scenario
from pytest_bdd.steps import StepError


@given('I have foo')
def foo():
    return 'foo'

given('I have alias for foo', fixture='foo')
given('I have an alias to the root fixture', fixture='root')

test_given_with_fixture = scenario('given.feature', 'Test reusing local fixture')

test_root_alias = scenario('given.feature', 'Test reusing root fixture')


@then('foo should be "foo"')
def foo_is_foo(foo):
    assert foo == 'foo'


@then('root should be "root"')
def root_is_root(root):
    assert root == 'root'


def test_decorate_with_fixture():
    """Test given can't be used as decorator when the fixture is specified."""
Exemplo n.º 26
0
def test_wrong_type_order(request, scenario_name):
    """Test wrong step type order."""
    sc = scenario('wrong_type_order.feature', scenario_name)
    with pytest.raises(StepTypeError) as excinfo:
        sc(request)
    excinfo  # TODO: assert the exception args from parameters
Exemplo n.º 27
0
from pytest_bdd import scenario, given, when, then


test_steps = scenario('regex.feature', 'Executed with steps matching regex step definitons')


@given('I have a foo fixture with value "foo"')
def foo():
    return 'foo'


@given('there is a list')
def results():
    return []


@when('I append (?P<n>\d+) to the list')
def append_to_list(results, n):
    results.append(int(n))


@then('foo should have value "foo"')
def foo_is_foo(foo):
    assert foo == 'foo'


@then('the list should be [1, 2, 3]')
def check_results(results):
    assert results == [1, 2, 3]
Exemplo n.º 28
0
"""Test step alias when decorated multiple times."""

from pytest_bdd import scenario, given, when, then


test_steps = scenario('alias.feature', 'Multiple given alias is not evaluated multiple times')


@given('I have an empty list')
def results():
    return []


@given('I have foo (which is 1) in my list')
@given('I have bar (alias of foo) in my list')
def foo(results):
    results.append(1)


@when('I do crash (which is 2)')
@when('I do boom (alias of crash)')
def crash(results):
    results.append(2)


@then('my list should be [1, 2, 2]')
def check_results(results):
    """Fixtures are not evaluated multiple times, so the list will be [1, 2, 2]"""
    assert results == [1, 2, 2]
Exemplo n.º 29
0
def test_feature_path(request, scenario_name):
    """Test feature base dir."""
    with pytest.raises(IOError) as exc:
        scenario("steps.feature", scenario_name)
    assert os.path.join("/does/not/exist/", "steps.feature") in str(exc.value)
Exemplo n.º 30
0
def test_wrong(request, scenario_name):
    """Test wrong feature scenarios."""

    sc = scenario('wrong.feature', scenario_name)
    with pytest.raises(FeatureError):
        sc(request)
Exemplo n.º 31
0
from pytest_bdd.steps import when

from pytest_bdd import given, then, scenario

test_reuse = scenario(
    'reuse.feature',
    'Given and when using the same fixture should not evaluate it twice',
)


@given('I have an empty list')
def empty_list():
    return []


@given('I have a fixture (appends 1 to a list)')
def appends_1(empty_list):
    empty_list.append(1)
    return empty_list

given('I have a fixture (appends 1 to a list) in reuse syntax', fixture='appends_1')


@when('I use this fixture')
def use_fixture(appends_1):
    pass


@then('my list should be [1]')
def list_should_be_1(appends_1):
    assert appends_1 == [1]