Esempio n. 1
0
def test_extended_validator():
    p = Path("a", {}, extended=["full", "meta"])

    assert ExtendedValidator().validate(path=p, extended="full") is None
    assert ExtendedValidator().validate(path=p, extended="meta") is None

    with pytest.raises(ArgumentError):
        ExtendedValidator().validate(path=p, extended="xyz")

    p = Path("a", {})

    with pytest.raises(ArgumentError):
        ExtendedValidator().validate(path=p, extended="full")
Esempio n. 2
0
def test_take():
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    client = mk_mock_client({"pag_on": [data, 200]}, paginated=["pag_on"])
    executor = Executor(client)
    p_pag = Path("pag_on", [int], pagination=True)

    it = executor.run(path=p_pag, per_page=2)
    assert it.has_next()
    assert isinstance(next(it), int)
    assert next(it) == 2
    assert it.has_next()

    assert it.take(3) == [3, 4, 5]
    assert it.has_next()

    with pytest.raises(ArgumentError):
        it.take(-5)

    assert it.take(0) == []
    assert it.take() == [6, 7]  # per_page setting
    assert it.has_next()

    assert it.take_all() == [8, 9, 10]
    assert not it.has_next()

    with pytest.raises(StopIteration):
        next(it)

    assert it.take(2) == it.take_all() == []
Esempio n. 3
0
def test_chaining():
    data = list(range(300))
    client = mk_mock_client({"pag_on": [data, 200]}, paginated=["pag_on"])
    executor = Executor(client)
    p_pag = Path("pag_on", [int], pagination=True)

    assert executor.run(path=p_pag, per_page=2).take_all() == data
    assert executor.run(path=p_pag,
                        per_page=2).prefetch_all().take_all() == data
Esempio n. 4
0
def test_prefetch_off():
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    client = mk_mock_client({"pag_on": [data, 200]}, paginated=["pag_on"])
    executor = Executor(client)
    p_pag = Path("pag_on", [int], pagination=True)

    assert get_last_req(client.http) is None
    req = executor.run(path=p_pag, page=2, per_page=3)
    assert get_last_req(client.http) is None
    list(req)
    assert get_last_req(client.http) is not None
Esempio n. 5
0
def test_optional_args_validator():
    p = Path("a/?b/?c/?d", {})

    assert OptionalArgsValidator().validate(path=p) is None
    assert OptionalArgsValidator().validate(path=p, b="b", c="c") is None

    with pytest.raises(ArgumentError):
        OptionalArgsValidator().validate(path=p, c="c")

    with pytest.raises(ArgumentError):
        OptionalArgsValidator().validate(path=p, b="b", d="d")
Esempio n. 6
0
def test_pagination():
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    client = mk_mock_client({
        "pag_off": [data, 200],
        "pag_on": [data, 200]
    },
                            paginated=["pag_on"])
    executor = Executor(client)

    p_nopag = Path("pag_off", [int])
    p_pag = Path("pag_on", [int], pagination=True)

    res_nopag = executor.run(path=p_nopag).parsed
    res_pag = executor.run(path=p_pag, page=2, per_page=3)

    assert isinstance(res_nopag, list)
    assert res_nopag == data

    assert isinstance(res_pag, PaginationIterator)
    assert list(executor.run(path=p_pag, page=2,
                             per_page=4)) == [5, 6, 7, 8, 9, 10]
Esempio n. 7
0
def test_required_args_validator():
    p = Path("a/!b/!c/?d", {})

    assert RequiredArgsValidator().validate(path=p, b="b", c="c") is None

    with pytest.raises(ArgumentError):
        RequiredArgsValidator().validate(path=p, c="c")

    with pytest.raises(ArgumentError):
        RequiredArgsValidator().validate(path=p, b="b")

    with pytest.raises(ArgumentError):
        RequiredArgsValidator().validate(path=p, d="d")
Esempio n. 8
0
def test_per_arg_validator():
    b_validator = PerArgValidator("b", lambda b: b in ["abc", "xyz"])
    c_validator = PerArgValidator("c", lambda c: "x" in c)
    p = Path("a/!b/?c", {}, validators=[b_validator, c_validator])

    assert b_validator.validate(path=p, b="xyz") is None

    with pytest.raises(ArgumentError):
        b_validator.validate(path=p, b="any")

    assert c_validator.validate(path=p, b="xyz") is None
    assert c_validator.validate(path=p, b="any") is None

    with pytest.raises(ArgumentError):
        c_validator.validate(path=p, b="any", c="y")
Esempio n. 9
0
def test_prefetch_on():
    data = list(range(10**3))
    client = mk_mock_client({"pag_on": [data, 200]}, paginated=["pag_on"])
    executor = Executor(client)
    p_pag = Path("pag_on", [int], pagination=True)

    # prefetch
    assert get_last_req(client.http) is None
    req = executor.run(path=p_pag, page=2, per_page=3)
    assert get_last_req(client.http) is None
    req.prefetch_all()
    assert get_last_req(client.http) is not None

    # reset history
    client.http._requests.req_stack = []
    assert get_last_req(client.http) is None

    # execute prefetched -> assert no new requests
    list(req)
    assert get_last_req(client.http) is None
Esempio n. 10
0
def test_filters_validator():
    p = Path("a", {}, filters={"query", "genres", "years", "ratings"})

    assert FiltersValidator().validate(path=p) is None
    assert FiltersValidator().validate(path=p, query="xyz") is None
    assert FiltersValidator().validate(path=p, genres="xyz") is None
    assert FiltersValidator().validate(path=p, genres=["xyz", "abc"]) is None
    assert FiltersValidator().validate(path=p, years=2015) is None
    assert FiltersValidator().validate(path=p, years="2015") is None
    assert FiltersValidator().validate(path=p, years="2013-2015") is None
    assert FiltersValidator().validate(path=p, ratings="5-100") is None

    should_raise = {
        "languages": ["xyz"],
        "query": [["abc", "xyz"]],
        "years": ["500-2015", "2014-2015-2016", "-2015", "20132015", 0.5],
        "genres": [{"abc"}, ["abc", 123]],
        "ratings": ["20"],
    }

    for k, v_list in should_raise.items():
        for v in v_list:
            with pytest.raises(ArgumentError):
                FiltersValidator().validate(path=p, **{k: v})