Ejemplo n.º 1
0
def test_custom_headers(httpserver: HTTPServer):
    headers_with_values_in_direct_order = {'Custom': 'Scheme key0="value0", key1="value1"'}
    httpserver.expect_request(uri='/', headers=headers_with_values_in_direct_order).respond_with_data('OK')
    response = requests.get(httpserver.url_for('/'), headers=headers_with_values_in_direct_order)
    assert response.status_code == 200
    assert response.text == 'OK'

    # By default different order of items in header value dicts means different header values
    headers_with_values_in_modified_order = {'Custom': 'Scheme key1="value1", key0="value0"'}
    response = requests.get(httpserver.url_for('/'), headers=headers_with_values_in_modified_order)
    assert response.status_code == 500

    # Define header_value_matcher that ignores the order of items in header value dict
    def custom_header_value_matcher(actual: str, expected: str) -> bool:
        actual_scheme, _, actual_dict_str = actual.partition(' ')
        expected_scheme, _, expected_dict_str = expected.partition(' ')
        actual_dict = parse_dict_header(actual_dict_str)
        expected_dict = parse_dict_header(expected_dict_str)
        return actual_scheme == expected_scheme and actual_dict == expected_dict

    matchers = HeaderValueMatcher.DEFAULT_MATCHERS.copy()  # type: ignore
    matchers['Custom'] = custom_header_value_matcher
    header_value_matcher = HeaderValueMatcher(matchers)

    httpserver.handlers.clear()
    httpserver.expect_request(
        uri='/',
        headers=headers_with_values_in_direct_order,
        header_value_matcher=header_value_matcher
    ).respond_with_data('OK')
    response = requests.get(httpserver.url_for('/'), headers=headers_with_values_in_modified_order)
    assert response.status_code == 200
    assert response.text == 'OK'
Ejemplo n.º 2
0
def test_get_session_info(httpserver: HTTPServer):
  expected_json = {
    "info": {
        "authenticated": "cookie",
        "authentication_db": "_users",
        "authentication_handlers": [
            "cookie",
            "default"
        ]
    },
    "ok": True,
    "userCtx": {
        "name": "root",
        "roles": [
            "_admin"
        ]
    }
  }

  httpserver.expect_request("/_session",  method="POST").respond_with_json(expected_json, headers={'Set-Cookie': 'AuthSession=cm9vdDo1MEJCRkYwMjq0LO0ylOIwShrgt8y-UkhI-c6BGw; Version=1; Path=/; HttpOnly'})
  httpserver.expect_oneshot_request("/_session", method="GET").respond_with_json(expected_json, headers={'Set-Cookie': 'AuthSession=cm9vdDo1MEJCRkYwMjq0LO0ylOIwShrgt8y-UkhI-c6BGw; Version=1; Path=/; HttpOnly'})
  couch = CouchDB(username="******", password="******", host="http://127.0.0.1", port=8000, auto_connect=True)
  response = couch.session.get_session_info()
  assert response == expected_json

  httpserver.expect_oneshot_request("/_session", method="GET").respond_with_json(expected_json, headers={'Set-Cookie': 'AuthSession=cm9vdDo1MEJCRkYwMjq0LO0ylOIwShrgt8y-UkhI-c6BGw; Version=1; Path=/; HttpOnly'})
  response = couch.session.renew_session()
  assert response == expected_json


  for code in [401]:
    httpserver.expect_oneshot_request("/_session",  method="GET").respond_with_json({}, status=code)
    response = couch.session.get_session_info()
    assert isinstance(response, CouchError) is True
Ejemplo n.º 3
0
def _build_server(tmpdir, host):
    ca = trustme.CA()
    ca_cert_path = str(tmpdir / "ca.pem")
    ca.cert_pem.write_to_path(ca_cert_path)

    server_cert = ca.issue_cert(host)
    context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
    server_crt = server_cert.cert_chain_pems[0]
    server_key = server_cert.private_key_pem
    with server_crt.tempfile() as crt_file, server_key.tempfile() as key_file:
        context.load_cert_chain(crt_file, key_file)

    server = HTTPServer(ssl_context=context)
    # Fake what the client expects from Elasticsearch
    server.expect_request("/").respond_with_json(
        headers={
            "x-elastic-product": "Elasticsearch",
        },
        response_json={"version": {
            "number": "8.0.0",
        }},
    )
    server.start()

    yield server, ca, ca_cert_path

    server.clear()
    if server.is_running():
        server.stop()
Ejemplo n.º 4
0
def test_get_packt_free_ebook(httpserver: HTTPServer, resources: Resources):
    # GIVEN
    PRODUCT_ID = "android-2099"
    TITLE = "Android 2099"
    ONE_LINER = "Good practices with Miguel O’Hara"
    COVER_IMAGE = "//test.jpg"

    path_offers = "/free-learning-v1/offers"
    Resources._BOOK_URL_OFFERS = httpserver.url_for(path_offers)
    httpserver.expect_request(path_offers, "GET").respond_with_json(
        {"data": [{
            "productId": PRODUCT_ID
        }]})

    path_summary = "/products/{}/summary"
    Resources._BOOK_URL_SUMMARY = httpserver.url_for(path_summary)
    httpserver.expect_request(path_summary.format(PRODUCT_ID),
                              "GET").respond_with_json({
                                  "title":
                                  TITLE,
                                  "oneLiner":
                                  ONE_LINER,
                                  "coverImage":
                                  COVER_IMAGE
                              })

    # WHEN
    book = resources.get_packt_free_book()

    # THEN
    assert book["name"] == TITLE
    assert book["summary"] == ONE_LINER
    assert book["cover"] == COVER_IMAGE
    assert book["expires"] > 0
Ejemplo n.º 5
0
def test_read_private_addres(reader_class: Type[FeedReader], httpserver: HTTPServer):
    httpserver.expect_request("/private-address").respond_with_json(0)
    url = httpserver.url_for("/private-address")
    with reader_class() as reader:
        response = reader.read(url)
        assert response.status == FeedResponseStatus.PRIVATE_ADDRESS_ERROR
        assert not response.content
Ejemplo n.º 6
0
def test_find_not_found(httpserver: HTTPServer):
    httpserver.expect_request('/404').respond_with_data('Not Found', status=404)
    start_url = httpserver.url_for('/404')
    finder, messages = _create_finder(start_url)
    with finder:
        found = finder.find()
        assert not found, f'messages={messages}'
Ejemplo n.º 7
0
def test_Identify_ExceedQueueSize_Flushed(httpserver: HTTPServer):
    httpserver.expect_request(re.compile('/users/track')).respond_with_data()
    p = BrazePlugin(
        'My-Key',
        BrazeOptions(base_url=httpserver.url_for(''),
                     flush_queue_size=2,
                     flush_interval=timedelta_max))
    p.load(plugin_load_options)
    p.identify("user-1", identify_properties)
    p.identify("user-2", identify_properties)
    time.sleep(time_short)
    requests = _get_cleaned_requests(httpserver)
    assert requests == [
        {
            'attributes': [
                {
                    'external_id': 'user-1',
                    'item1': 'identify',
                    'item2': 2
                },
                {
                    'external_id': 'user-2',
                    'item1': 'identify',
                    'item2': 2
                },
            ],
        },
    ]
    p.shutdown()
Ejemplo n.º 8
0
def test_get_node_server_stat(httpserver: test_server.HTTPServer):
    expected_json = {
        "value": {
            "min": 0,
            "max": 0,
            "arithmetic_mean": 0,
            "geometric_mean": 0,
            "harmonic_mean": 0,
            "median": 0,
            "variance": 0,
            "standard_deviation": 0,
            "skewness": 0,
            "kurtosis": 0,
            "percentile": [[50, 0], [75, 0], [90, 0], [95, 0], [99, 0], [999, 0]],
            "histogram": [[0, 0]],
            "n": 0
        },
        "type": "histogram",
        "desc": "length of a request inside CouchDB without MochiWeb"
    }

    httpserver.expect_request("/_node/_local/_stats/couchdb/request_time", method="GET").respond_with_json(expected_json)
    response = couch.server.node_stat(uri_segments={'node_name': '_local', 'stat': 'couchdb/request_time'})
    assert response == expected_json

    response = couch.server.node_stat()
    assert response == expected_json
def test_get_refresh_token(httpserver: HTTPServer, auth_token: Token):
    response_json: dict = {
        "access_token": "ACCESS_TOKEN_TO_STORE",
        "token_type": "bearer",
        "expires_in": 3600,
        "refresh_token": "TOKEN_USED_TO_REFRESH_AUTHORIZATION"
    }

    # create a invalid http request
    httpserver.expect_oneshot_request("/HttpNoSuccess")

    # refresh token with an error
    with pytest.raises(HttpNoSuccess):
        auth_token.get_refresh_token(post_url=httpserver.url_for("/refresh"))

    # set up the server to serve /refresh with the json
    httpserver.expect_request("/refresh").respond_with_json(response_json)

    # refresh token
    auth_token.get_refresh_token(post_url=httpserver.url_for("/refresh"))

    # assert if token was refreshed
    assert auth_token.access_token == response_json["access_token"]
    assert auth_token.refresh_token == response_json["refresh_token"]

    sleep(1)

    # assert if token was saved
    auth_token_2: Optional[Token] = Token.get_token()
    assert isinstance(auth_token_2, Token)
    assert auth_token_2.access_token == auth_token.access_token
    assert auth_token_2.refresh_token == auth_token.refresh_token
Ejemplo n.º 10
0
def test_get_database_updates(httpserver: test_server.HTTPServer):
    expected_json = {
        "results": [
            {
                "db_name": "mailbox",
                "type": "created",
                "seq": "1-g1AAAAFReJzLYWBg4MhgTmHgzcvPy09JdcjLz8gvLskBCjMlMiTJ____PyuDOZExFyjAnmJhkWaeaIquGIf2JAUgmWQPMiGRAZcaB5CaePxqEkBq6vGqyWMBkgwNQAqobD4h"},
            {
                "db_name": "mailbox",
                "type": "deleted",
                "seq": "2-g1AAAAFReJzLYWBg4MhgTmHgzcvPy09JdcjLz8gvLskBCjMlMiTJ____PyuDOZEpFyjAnmJhkWaeaIquGIf2JAUgmWQPMiGRAZcaB5CaePxqEkBq6vGqyWMBkgwNQAqobD4hdQsg6vYTUncAou4-IXUPIOpA7ssCAIFHa60"
            }
        ],
        "last_seq": "2-g1AAAAFReJzLYWBg4MhgTmHgzcvPy09JdcjLz8gvLskBCjMlMiTJ____PyuDOZEpFyjAnmJhkWaeaIquGIf2JAUgmWQPMiGRAZcaB5CaePxqEkBq6vGqyWMBkgwNQAqobD4hdQsg6vYTUncAou4-IXUPIOpA7ssCAIFHa60"
    }

    httpserver.expect_oneshot_request("/_db_updates", method="POST").respond_with_json(expected_json)
    response = couch.server.database_updates()
    assert response == expected_json

    httpserver.expect_oneshot_request("/_db_updates", method="POST").respond_with_json({}, status=401)
    response = couch.server.database_updates()
    assert isinstance(response, couchapy.CouchError) is True
    assert response.status_code == 401

    httpserver.expect_request("/_db_updates", method="POST").respond_with_json({})
    for k in AllowedKeys.SERVER__DB_UPDATES__PARAMS:
        response = couch.server.database_updates(params={k: ['test']})
        assert isinstance(response, couchapy.CouchError) is False

    with pytest.raises(couchapy.InvalidKeysException):
        couch.server.database_updates(params={'nonexisting_key': ''})
Ejemplo n.º 11
0
def test_error_dereferencing(api, users, location, es,
                             httpserver: pytest_httpserver.HTTPServer):
    with api.test_request_context():
        record = SWORDDeposit.create({})
        object_version = ObjectVersion.create(bucket=record.bucket,
                                              key="some-file.txt")
        TagManager(object_version).update({
            ObjectTagKey.ByReferenceURL:
            httpserver.url_for("some-file.txt"),
            # This one should get removed after dereferencing
            ObjectTagKey.ByReferenceNotDeleted:
            "true",
            ObjectTagKey.Packaging:
            PackagingFormat.SimpleZip,
        })

        httpserver.expect_request("/some-file.txt").respond_with_data(
            b"", status=HTTPStatus.GONE)

        db.session.refresh(object_version)

        with pytest.raises(urllib.error.HTTPError):
            tasks.dereference_object(record.id, object_version.version_id)

        db.session.refresh(object_version)

        tags = TagManager(object_version)
        assert tags.get(ObjectTagKey.FileState) == FileState.Error
def podcastURL(httpserver: HTTPServer):
    with open('test/bbc-world-news.xml', 'r') as fd:
        httpserver.expect_request('/bbc-world-news.rss') \
                    .respond_with_data(fd.read(), content_type='application/rss+xml')
    httpserver.expect_request('/invalid') \
                    .respond_with_data(b'', status=404)
    return httpserver.url_for('/bbc-world-news.rss')
Ejemplo n.º 13
0
def test_authorization_headers(httpserver: HTTPServer):
    headers_with_values_in_direct_order = {
        'Authorization': ('Digest username="******",'
                          'realm="*****@*****.**",'
                          'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",'
                          'uri="/dir/index.html",'
                          'qop=auth,'
                          'nc=00000001,'
                          'cnonce="0a4f113b",'
                          'response="6629fae49393a05397450978507c4ef1",'
                          'opaque="5ccc069c403ebaf9f0171e9517f40e41"')
    }
    httpserver.expect_request(uri='/', headers=headers_with_values_in_direct_order).respond_with_data('OK')
    response = requests.get(httpserver.url_for('/'), headers=headers_with_values_in_direct_order)
    assert response.status_code == 200
    assert response.text == 'OK'

    headers_with_values_in_modified_order = {
        'Authorization': ('Digest qop=auth,'
                          'username="******",'
                          'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",'
                          'uri="/dir/index.html",'
                          'nc=00000001,'
                          'realm="*****@*****.**",'
                          'response="6629fae49393a05397450978507c4ef1",'
                          'cnonce="0a4f113b",'
                          'opaque="5ccc069c403ebaf9f0171e9517f40e41"')
    }
    response = requests.get(httpserver.url_for('/'), headers=headers_with_values_in_modified_order)
    assert response.status_code == 200
    assert response.text == 'OK'
Ejemplo n.º 14
0
def test_get_uptime(httpserver: HTTPServer):
    expected_json = {"uptime": 259, "memory": 1000}

    httpserver.expect_request("/_node/_local/_system",
                              method="GET").respond_with_json(expected_json)
    response = couch.server.get_uptime(uri_segments={'node_name': '_local'})
    assert response == expected_json['uptime']
Ejemplo n.º 15
0
def test_restart_node(httpserver: HTTPServer):
    expected_json = {}

    httpserver.expect_request("/_node/_local/_restart",
                              method="POST").respond_with_json(expected_json)
    response = couch.server.restart_node(uri_segments={'node_name': '_local'})
    assert isinstance(response, CouchError) is False
Ejemplo n.º 16
0
def test_build_fake(app, httpserver: HTTPServer):
    base_url = "/snapshots/targets/testtarget/testsubtarget"
    upstream_path = Path(
        "./tests/upstream/snapshots/targets/testtarget/testsubtarget/")
    expected_file_requests = [
        "sha256sums.sig",
        "sha256sums",
        "openwrt-imagebuilder-testtarget-testsubtarget.Linux-x86_64.tar.xz",
    ]

    for f in expected_file_requests:
        httpserver.expect_request(f"{base_url}/{f}").respond_with_data(
            (upstream_path / f).read_bytes())

    request_data = dict(
        version_data={
            "branch": "master",
            "path": "snapshots",
            "pubkey":
            "RWSrHfFmlHslUcLbXFIRp+eEikWF9z1N77IJiX5Bt/nJd1a/x+L+SU89",
        },
        target="testtarget/testsubtarget",
        store_path=app.config["STORE_PATH"],
        cache_path=app.config["CACHE_PATH"],
        upstream_url="http://localhost:8001",
        version="SNAPSHOT",
        profile="testprofile",
        packages=["test1", "test2"],
    )
    result = build(request_data)
    assert result["id"] == "testprofile"
Ejemplo n.º 17
0
def test_mixpanel(httpserver: HTTPServer):
    httpserver.expect_request(re.compile('/(track|engage)')).respond_with_json({'status': 1})

    options = MixpanelOptions(
        api_host=httpserver.url_for('').rstrip('/'),
    )
    p = MixpanelPlugin('My-Key', options)

    assert p.id() == 'mixpanel'
    p.load(PluginLoadOptions(environment=Environment.DEVELOPMENT, logger=Logger.NONE))
    p.identify("user-1", Properties(item1='value1', item2=2))
    p.alias("user-1", "prev-user-1")
    p.track("user-2", Event('event-1', Properties(item1='value1', item2=1)))
    p.track("user-2", Event('event-2', Properties(item1='value2', item2=2)))
    p.flush()
    p.track("user-2", Event('event-3', Properties(item1='value3', item2=3)))
    p.track("user-2", Event('event-4', Properties(item1='value4', item2=4)))
    p.track("user-1", Event('event-5', Properties(item1='value5', item2=5)))
    p.shutdown()

    time.sleep(0.1)
    requests = _get_cleaned_requests(httpserver)
    httpserver.stop()

    assert requests == [
        {'event': 'event-1',
         'properties': {'distinct_id': 'user-2',
                        'item1': 'value1',
                        'item2': 1,
                        'mp_lib': 'python',
                        'token': 'My-Key'}},
        {'event': 'event-2',
         'properties': {'distinct_id': 'user-2',
                        'item1': 'value2',
                        'item2': 2,
                        'mp_lib': 'python',
                        'token': 'My-Key'}},
        {'$distinct_id': 'user-1',
         '$set': {'item1': 'value1', 'item2': 2},
         '$token': 'My-Key'},
        {'event': 'event-3',
         'properties': {'distinct_id': 'user-2',
                        'item1': 'value3',
                        'item2': 3,
                        'mp_lib': 'python',
                        'token': 'My-Key'}},
        {'event': 'event-4',
         'properties': {'distinct_id': 'user-2',
                        'item1': 'value4',
                        'item2': 4,
                        'mp_lib': 'python',
                        'token': 'My-Key'}},
        {'event': 'event-5',
         'properties': {'distinct_id': 'user-1',
                        'item1': 'value5',
                        'item2': 5,
                        'mp_lib': 'python',
                        'token': 'My-Key'}}
    ]
def test_json_matcher_with_none(httpserver: HTTPServer):
    httpserver.expect_request("/foo",
                              json=None).respond_with_data("Hello world!")
    resp = requests.get(httpserver.url_for("/foo"),
                        data=json.dumps(None),
                        headers={"content-type": "application/json"})
    assert resp.status_code == 200
    assert resp.text == "Hello world!"
def test_querystring_str(httpserver: HTTPServer):
    httpserver.expect_request(
        "/foobar", query_string="foo=bar",
        method="GET").respond_with_data("example_response")
    response = requests.get(httpserver.url_for("/foobar?foo=bar"))
    httpserver.check_assertions()
    assert response.text == "example_response"
    assert response.status_code == 200
Ejemplo n.º 20
0
def test_read_status(reader_class: Type[FeedReader], httpserver: HTTPServer, status: int):
    options = dict(allow_non_webpage=True, allow_private_address=True)
    local_resp = WerkzeugResponse(str(status), status=status)
    httpserver.expect_request("/status").respond_with_response(local_resp)
    url = httpserver.url_for("/status")
    with reader_class(**options) as reader:
        response = reader.read(url)
        assert response.status == status
        assert response.content == str(status).encode()
Ejemplo n.º 21
0
def test_get_doc_info(httpserver: HTTPServer):
    expected = 'revidhere'

    httpserver.expect_request("/_local/testdoc",
                              method="HEAD").respond_with_json(
                                  {}, headers={'ETag': 'revidhere'})
    response = couch.db.get_doc_info(uri_segments={'docid': 'testdoc'})

    assert response == expected
Ejemplo n.º 22
0
def test_dns_service_urllib3_private(httpserver: HTTPServer):
    httpserver.expect_request('/200').respond_with_data('200')
    url = httpserver.url_for('/200')
    # expect OK when use standard requests Session
    assert requests.get(url).ok
    # expect raise PrivateAddressError when use DNSService
    with pytest.raises(PrivateAddressError):
        with _requests_session() as sess:
            sess.get(url)
Ejemplo n.º 23
0
def test_request_post_case_insensitive_method(httpserver: HTTPServer):
    httpserver.expect_request(
        "/foobar", data='{"request": "example"}',
        method="post").respond_with_data("example_response")
    response = requests.post(httpserver.url_for("/foobar"),
                             json={"request": "example"})
    httpserver.check_assertions()
    assert response.text == "example_response"
    assert response.status_code == 200
Ejemplo n.º 24
0
def test_auto_renew_session_terminates_on_instance_destruction(httpserver: HTTPServer):
  expected_json = {"ok": True, "name": "root", "roles": ["_admin"]}

  httpserver.expect_request("/_session",  method="POST").respond_with_json(expected_json, headers={'Set-Cookie': 'AuthSession=cm9vdDo1MEJCRkYwMjq0LO0ylOIwShrgt8y-UkhI-c6BGw; Version=1; Path=/; HttpOnly'})

  for k in range(1, 50):
    couch = CouchDB(username="******", password="******", host="http://127.0.0.1", port=8000, auto_connect=True, keep_alive=300)
    assert couch.session._keep_alive == 300
    del couch  # brittle means of getting the code coverage on destructor.
Ejemplo n.º 25
0
def test_replicate(httpserver: test_server.HTTPServer):
    expected_json = {
        "history": [
            {
                "doc_write_failures": 0,
                "docs_read": 10,
                "docs_written": 10,
                "end_last_seq": 28,
                "end_time": "Sun, 11 Aug 2013 20:38:50 GMT",
                "missing_checked": 10,
                "missing_found": 10,
                "recorded_seq": 28,
                "session_id": "142a35854a08e205c47174d91b1f9628",
                "start_last_seq": 1,
                "start_time": "Sun, 11 Aug 2013 20:38:50 GMT"
            },
            {
                "doc_write_failures": 0,
                "docs_read": 1,
                "docs_written": 1,
                "end_last_seq": 1,
                "end_time": "Sat, 10 Aug 2013 15:41:54 GMT",
                "missing_checked": 1,
                "missing_found": 1,
                "recorded_seq": 1,
                "session_id": "6314f35c51de3ac408af79d6ee0c1a09",
                "start_last_seq": 0,
                "start_time": "Sat, 10 Aug 2013 15:41:54 GMT"
            }
        ],
        "ok": True,
        "replication_id_version": 3,
        "session_id": "142a35854a08e205c47174d91b1f9628",
        "source_last_seq": 28
    }

    httpserver.expect_oneshot_request("/_replicate", method="POST").respond_with_json(expected_json)
    response = couch.server.replicate()
    assert response == expected_json

    for code in [202]:
        httpserver.expect_oneshot_request("/_replicate", method="POST").respond_with_json({}, status=code)
        response = couch.server.replicate()
        assert isinstance(response, couchapy.CouchError) is False

    for code in [400, 401, 404, 500]:
        httpserver.expect_oneshot_request("/_replicate", method="POST").respond_with_json({}, status=code)
        response = couch.server.replicate()
        assert isinstance(response, couchapy.CouchError) is True

    httpserver.expect_request("/_replicate", method="POST").respond_with_json({})
    for k in AllowedKeys.SERVER__REPLICATE__DATA:
        response = couch.server.replicate(data={k: ['test']})
        assert isinstance(response, couchapy.CouchError) is False

    with pytest.raises(couchapy.InvalidKeysException):
        couch.server.replicate(data={'nonexisting_key': ''})
def test_json_matcher_without_content_type(httpserver: HTTPServer):
    httpserver.expect_request("/foo", json={
        "foo": "bar"
    }).respond_with_data("Hello world!")
    assert requests.get(httpserver.url_for("/foo"), json={
        "foo": "bar"
    }).status_code == 200
    assert requests.get(httpserver.url_for("/foo"),
                        data=json.dumps({"foo": "bar"})).status_code == 200
Ejemplo n.º 27
0
def test_read_non_webpage(reader_class: Type[FeedReader], httpserver: HTTPServer, mime_type: str):
    options = dict(allow_private_address=True)
    local_resp = WerkzeugResponse(b'xxxxxxxx', mimetype=mime_type)
    httpserver.expect_request("/non-webpage").respond_with_response(local_resp)
    url = httpserver.url_for("/non-webpage")
    with reader_class(**options) as reader:
        response = reader.read(url)
        assert response.status == FeedResponseStatus.CONTENT_TYPE_NOT_SUPPORT_ERROR
        assert not response.content
Ejemplo n.º 28
0
def test_object_with_eq(httpserver: HTTPServer):
    httpserver.expect_request(PrefixMatchEq("/foo")).respond_with_json(
        {"foo": "bar"})
    assert requests.get(httpserver.url_for("/foo")).json() == {"foo": "bar"}
    assert requests.get(httpserver.url_for("/foobar")).json() == {"foo": "bar"}
    assert requests.get(httpserver.url_for("/foobaz")).json() == {"foo": "bar"}

    assert requests.get(httpserver.url_for("/barfoo")).status_code == 500

    assert len(httpserver.assertions) == 1
Ejemplo n.º 29
0
async def test_do_get_404(httpserver: pytest_httpserver.HTTPServer):
    httpserver.expect_request('/404.html').\
        respond_with_data('Not Found', content_type='text/html', status=404)

    async with http.new_client() as session:
        response, error = await http.get(session,
                                         httpserver.url_for('/404.html'))

    assert response.text == 'Not Found'
    assert error == 'HTTP status code 404'
Ejemplo n.º 30
0
async def test_do_get_ok(httpserver: pytest_httpserver.HTTPServer):
    httpserver.expect_request('/index.html').\
        respond_with_data('OK', content_type='text/html')

    async with http.new_client() as session:
        response, error = await http.get(session,
                                         httpserver.url_for('/index.html'))

    assert response.text == 'OK'
    assert error is None