async def test_request_success(
     self,
     event_loop: asyncio.AbstractEventLoop,
     httpserver: HTTPServer,
     influxdb_writer: InfluxDBWriter,
     log_records: LogRecordsType,
     mocker: MockerFixture,
 ) -> None:
     httpserver.expect_oneshot_request(
         "/influx/api/v2/write",
         method="POST",
         data="measurement,tag=tagval field=1.0 ",
         query_string={"bucket": "test_db", "precision": "s"},
     ).respond_with_json({}, status=204)
     task = event_loop.create_task(influxdb_writer.task())
     influxdb_writer.put(mocker.Mock())
     await asyncio.sleep(0.1)
     httpserver.check_assertions()
     assert not any(r.levelno == logging.ERROR for r in log_records())
     task.cancel()
     with contextlib.suppress(asyncio.CancelledError):
         await task
예제 #2
0
def test_constructor_with_params(httpserver: test_server.HTTPServer):
    json_response = {"ok": True, "name": "root", "roles": ["_admin"]}

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

    couch = couchapy.CouchDB(custom_headers={"header_key": "header_value"},
                             session_timeout=60,
                             keep_alive=True,
                             host="https://localhost",
                             port=6984,
                             name="someadmin",
                             password="******",
                             admin_party=True,
                             auto_connect=False)

    assert 'header_key' in couch.custom_headers and couch.custom_headers[
        'header_key'] == 'header_value'
    assert couch.session_timeout == 60
    assert couch.keep_alive is True
    assert couch.host == "https://localhost"
    assert couch.port == 6984
    assert couch.name == "someadmin"
    assert couch.password == "somepassword"
    assert couch._admin_party is True
    assert couch.session.auth_token is None

    couch = couchapy.CouchDB(custom_headers={"header_key": "header_value"},
                             session_timeout=60,
                             port=8000,
                             keep_alive=True,
                             name="someadmin",
                             password="******",
                             auto_connect=True)

    assert couch._auto_renew_worker is not None
예제 #3
0
def test_get_replicator_docs(httpserver: test_server.HTTPServer):
    expected_json = {
        "docs": [
            {
                "database": "other/_replicator",
                "doc_id": "cdyno-0000001-0000002",
                "error_count": 0,
                "id": "e327d79214831ca4c11550b4a453c9ba+continuous",
                "info": None,
                "last_updated": "2017-04-29T05:01:37Z",
                "node": "[email protected]",
                "proxy": None,
                "source": "http://myserver.com/foo",
                "start_time": "2017-04-29T05:01:37Z",
                "state": "running",
                "target": "http://*****:*****@localhost:15984/cdyno-0000002/"
            }
        ],
        "offset": 0,
        "total_rows": 1
    }

    httpserver.expect_oneshot_request("/_scheduler/docs/other/_replicator", method="GET").respond_with_json(expected_json)
    response = couch.server.replicator_docs(uri_segments={'db': 'other'})
    assert response == expected_json

    for code in [401]:
        httpserver.expect_oneshot_request("/_scheduler/docs/other/_replicator", method="GET").respond_with_json({}, status=code)
        response = couch.server.replicator_docs(uri_segments={'db': 'other'})
        assert isinstance(response, couchapy.CouchError) is True

    httpserver.expect_request("/_scheduler/docs/other/_replicator", method="GET").respond_with_json({})
    for k in AllowedKeys.SERVER__SCHEDULER_DOCS__PARAMS:
        response = couch.server.replicator_docs(uri_segments={'db': 'other'}, params={k: ['test']})
        assert isinstance(response, couchapy.CouchError) is False

    with pytest.raises(couchapy.InvalidKeysException):
        couch.server.replicator_docs(uri_segments={'db': 'other'}, params={'nonexisting_key': ''})
예제 #4
0
def test_set_config(httpserver: HTTPServer):
    expected_json = {'data': "5984"}

    httpserver.expect_oneshot_request(
        "/_node/_local/_config/httpd/port",
        method="PUT").respond_with_json(expected_json)
    response = couch.server.set_config(uri_segments={
        'node_name': '_local',
        'key': 'httpd/port'
    },
                                       data="5984")
    assert response == expected_json

    for code in [400, 401, 500]:
        httpserver.expect_oneshot_request("/_node/_local/_config/httpd/port",
                                          method="PUT").respond_with_json(
                                              expected_json, status=code)
        response = couch.server.set_config(uri_segments={
            'node_name': '_local',
            'key': 'httpd/port'
        },
                                           data="5984")
        assert isinstance(response, CouchError) is True
예제 #5
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': ''})
예제 #6
0
def test_get_replicator_doc(httpserver: test_server.HTTPServer):
    expected_json = {
        "database": "other/_replicator",
        "doc_id": "cdyno-0000001-0000002",
        "error_count": 0,
        "id": "e327d79214831ca4c11550b4a453c9ba+continuous",
        "info": None,
        "last_updated": "2017-04-29T05:01:37Z",
        "node": "[email protected]",
        "proxy": None,
        "source": "http://myserver.com/foo",
        "start_time": "2017-04-29T05:01:37Z",
        "state": "running",
        "target": "http://*****:*****@localhost:15984/cdyno-0000002/"
    }

    httpserver.expect_oneshot_request("/_scheduler/docs/other/_replicator/replication-doc-id", method="GET").respond_with_json(expected_json)
    response = couch.server.replicator_doc(uri_segments={'db': 'other', 'docid': 'replication-doc-id'})
    assert response == expected_json

    for code in [401]:
        httpserver.expect_oneshot_request("/_scheduler/docs/other/_replicator/replication-doc-id", method="GET").respond_with_json({}, status=code)
        response = couch.server.replicator_doc(uri_segments={'db': 'other', 'docid': 'replication-doc-id'})
        assert isinstance(response, couchapy.CouchError) is True
예제 #7
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 = couchapy.CouchDB(name="test",
                             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, couchapy.error.CouchError) is True
예제 #8
0
def test_generate_uiids(httpserver: HTTPServer):
    expected_json = {
        "uuids": [
            "75480ca477454894678e22eec6002413",
            "75480ca477454894678e22eec600250b",
            "75480ca477454894678e22eec6002c41",
            "75480ca477454894678e22eec6003b90",
            "75480ca477454894678e22eec6003fca",
            "75480ca477454894678e22eec6004bef",
            "75480ca477454894678e22eec600528f",
            "75480ca477454894678e22eec6005e0b",
            "75480ca477454894678e22eec6006158",
            "75480ca477454894678e22eec6006161"
        ]
    }

    httpserver.expect_oneshot_request(
        "/_uuids", method="GET").respond_with_json(expected_json)
    response = couch.server.generate_uuids()
    assert response == expected_json['uuids']

    expected_json = {"uuids": ["75480ca477454894678e22eec6002413"]}
    httpserver.expect_oneshot_request(
        "/_uuids", method="GET").respond_with_json(expected_json)
    response = couch.server.generate_uuids()
    assert response == expected_json['uuids'][0]

    for code in [400]:
        httpserver.expect_oneshot_request(
            "/_uuids", method="GET").respond_with_json(expected_json,
                                                       status=code)
        response = couch.server.generate_uuids()
        assert isinstance(response, CouchError) is True

    httpserver.expect_request("/_uuids",
                              method="GET").respond_with_json(expected_json)
    for k in AllowedKeys.SERVER__UUIDS__PARAMS:
        response = couch.server.generate_uuids(params={k: ['test']})
        assert isinstance(response, CouchError) is False

    with pytest.raises(InvalidKeysException):
        couch.server.generate_uuids(params={'nonexisting_key': ''})
예제 #9
0
    def test_device_twin(
        self,
        azure_user: User,
        httpserver: HTTPServer,
        httpserver_ssl_context: ssl.SSLContext,
    ):
        """Test device state synchronization with IoT Hub Device Twin"""
        dev = self._prepare_device(azure_user, httpserver,
                                   httpserver_ssl_context)
        self._check_if_device_status_is_set_to_value(azure_user, httpserver,
                                                     dev.id, "enabled")

        # get the all device states (device twins)
        if self.azure_iot_hub_mock:
            httpserver.expect_oneshot_request(
                re.compile("^/devices"),
                method="GET",
                query_string="api-version=2021-04-12",
            ).respond_with_json(self._prepare_iot_hub_upsert_device_response())
        rsp = self.api_azure.with_auth(azure_user.token).call(
            "GET", iot.URL_DEVICE_STATE(dev.id))
        assert rsp.status_code == 200
        states = rsp.json()
        assert len(states.keys()) == 1
        integration_id = list(states.keys())[0]
        assert "desired" in states[integration_id]
        assert "reported" in states[integration_id]

        # set the device state (device twin)
        if self.azure_iot_hub_mock:
            httpserver.expect_oneshot_request(
                re.compile("^/twins"),
                method="GET",
                query_string="api-version=2021-04-12",
            ).respond_with_json(self._prepare_iot_hub_upsert_device_response())
            httpserver.expect_oneshot_request(
                re.compile("^/twins"),
                method="PUT",
                query_string="api-version=2021-04-12",
            ).respond_with_data(status=200)
        twin = {
            "desired": {
                "key": "value"
            },
        }
        rsp = (self.api_azure.with_auth(azure_user.token).with_header(
            "Content-Type", "application/json").call(
                "PUT",
                iot.URL_DEVICE_STATE(dev.id) + "/" + integration_id, twin))
        assert rsp.status_code == 200
        state = rsp.json()
        assert "desired" in state
        assert "reported" in states[integration_id]
        assert state["desired"]["key"] == "value"

        # get the device state (device twin)
        if self.azure_iot_hub_mock:
            httpserver.expect_oneshot_request(
                re.compile("^/twins"),
                method="GET",
                query_string="api-version=2021-04-12",
            ).respond_with_json(self._prepare_iot_hub_upsert_device_response())
        rsp = self.api_azure.with_auth(azure_user.token).call(
            "GET",
            iot.URL_DEVICE_STATE(dev.id) + "/" + integration_id)
        assert rsp.status_code == 200
        state = rsp.json()
        assert "desired" in state
        assert "reported" in states[integration_id]
        assert state["desired"]["key"] == "value"
예제 #10
0
def test_iteratively_retry(httpserver: HTTPServer):
    logger = CustomLogger()
    p = IterativelyPlugin(
        'My-Key', httpserver.url_for('/track'),
        IterativelyOptions(
            flush_queue_size=3,
            flush_interval=timedelta(seconds=1),
            retry_options=IterativelyRetryOptions(
                max_retries=3,
                delay_initial=timedelta(seconds=0.1),
                delay_maximum=timedelta(seconds=0.5)),
        ))
    expected_request = {'objects': [post_track_1_expected_request]}

    try:
        p.load(
            PluginLoadOptions(environment=Environment.DEVELOPMENT,
                              logger=logger))

        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data(status=429)
        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data(status=501)
        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data()
        p.post_track(*post_track_1_args)
        p.flush()
        time.sleep(2)
        requests = _get_cleaned_requests(httpserver)
        assert requests == [
            expected_request, expected_request, expected_request
        ]
        assert logger.log_lines == []

        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data(status=429)
        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data(status=501)
        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data(status=504)
        httpserver.expect_oneshot_request(
            re.compile('/track')).respond_with_data()
        p.post_track(*post_track_1_args)
        p.flush()
        time.sleep(2)
        requests = _get_cleaned_requests(httpserver)
        assert requests == [
            expected_request,
            expected_request,
            expected_request,
            expected_request,
            expected_request,
            expected_request,
        ]
        assert logger.log_lines == [
            'Error. Failed to upload events. Maximum attempts exceeded.'
        ]
    finally:
        p.shutdown()
        httpserver.stop()
예제 #11
0
def _setup_oneshot(server: HTTPServer):
    server.expect_request("/permanent").respond_with_data("OK permanent")
    server.expect_oneshot_request("/oneshot1").respond_with_data("OK oneshot1")
    server.expect_oneshot_request("/oneshot2").respond_with_data("OK oneshot2")
예제 #12
0
def test_get_database_names_without_params(httpserver: test_server.HTTPServer):
    expected_json = ["_users", "contacts", "docs", "invoices", "locations"]
    httpserver.expect_oneshot_request("/_all_dbs", method="GET").respond_with_json(expected_json)
    response = couch.server.database_names()
    assert response == expected_json
예제 #13
0
def test_get_databases_without_params(httpserver: test_server.HTTPServer):
    expected_json = []
    httpserver.expect_oneshot_request("/_dbs_info", method="POST").respond_with_json(expected_json)
    response = couch.server.databases()
    assert response == expected_json
예제 #14
0
def test_get_server_config(httpserver: HTTPServer):
    expected_json = {
        "attachments": {
            "compressible_types":
            "text/*, application/javascript, application/json,  application/xml",
            "compression_level": "8"
        },
        "couchdb": {
            "users_db_suffix": "_users",
            "database_dir": "/var/lib/couchdb",
            "delayed_commits": "true",
            "max_attachment_chunk_size": "4294967296",
            "max_dbs_open": "100",
            "os_process_timeout": "5000",
            "uri_file": "/var/lib/couchdb/couch.uri",
            "util_driver_dir":
            "/usr/lib64/couchdb/erlang/lib/couch-1.5.0/priv/lib",
            "view_index_dir": "/var/lib/couchdb"
        },
        "chttpd": {
            "backlog": "512",
            "bind_address": "0.0.0.0",
            "docroot": "./share/www",
            "port": "5984",
            "require_valid_user": "******",
            "socket_options": "[{sndbuf, 262144}, {nodelay, true}]",
            "server_options": "[{recbuf, undefined}]"
        },
        "httpd": {
            "allow_jsonp": "false",
            "authentication_handlers":
            "{couch_httpd_auth, cookie_authentication_handler}, {couch_httpd_auth, default_authentication_handler}",
            "bind_address": "192.168.0.2",
            "max_connections": "2048",
            "port": "5984",
            "secure_rewrites": "true"
        },
        "log": {
            "writer": "file",
            "file": "/var/log/couchdb/couch.log",
            "include_sasl": "true",
            "level": "info"
        },
        "query_server_config": {
            "reduce_limit": "true"
        },
        "replicator": {
            "max_http_pipeline_size": "10",
            "max_http_sessions": "10"
        },
        "stats": {
            "rate": "1000",
            "samples": "[0, 60, 300, 900]"
        },
        "uuids": {
            "algorithm": "utc_random"
        }
    }

    httpserver.expect_oneshot_request(
        "/_node/_local/_config", method="GET").respond_with_json(expected_json)
    response = couch.server.get_server_config(
        uri_segments={'node_name': '_local'})
    assert response == expected_json

    for code in [401]:
        httpserver.expect_oneshot_request("/_node/_local/_config",
                                          method="GET").respond_with_json(
                                              {}, status=code)
        response = couch.server.get_server_config(
            uri_segments={'node_name': '_local'})
        assert isinstance(response, CouchError) is True