influxdb3-python 0.5.0__tar.gz → 0.6.1__tar.gz

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.5.0
+Version: 0.6.1
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.5.0
+Version: 0.6.1
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb3_python.egg-info/SOURCES.txt

@@ -9,11 +9,13 @@ influxdb3_python.egg-info/top_level.txt
 influxdb_client_3/__init__.py
 influxdb_client_3/py.typed
 influxdb_client_3/read_file.py
+influxdb_client_3/version.py
+influxdb_client_3/query/__init__.py
+influxdb_client_3/query/query_api.py
 influxdb_client_3/write_client/__init__.py
 influxdb_client_3/write_client/configuration.py
 influxdb_client_3/write_client/extras.py
 influxdb_client_3/write_client/rest.py
-influxdb_client_3/write_client/version.py
 influxdb_client_3/write_client/_sync/__init__.py
 influxdb_client_3/write_client/_sync/api_client.py
 influxdb_client_3/write_client/_sync/rest.py
@@ -40,9 +42,12 @@ influxdb_client_3/write_client/service/_base_service.py
 influxdb_client_3/write_client/service/signin_service.py
 influxdb_client_3/write_client/service/signout_service.py
 influxdb_client_3/write_client/service/write_service.py
+tests/test_api_client.py
 tests/test_dataframe_serializer.py
+tests/test_date_helper.py
 tests/test_deep_merge.py
 tests/test_influxdb_client_3.py
 tests/test_influxdb_client_3_integration.py
 tests/test_merge_options.py
+tests/test_point.py
 tests/test_query.py

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb_client_3/__init__.py

@@ -1,9 +1,9 @@
-import json
 import urllib.parse
 
 import pyarrow as pa
-from pyarrow.flight import FlightClient, Ticket, FlightCallOptions
+import importlib.util
 
+from influxdb_client_3.query.query_api import QueryApi as _QueryApi
 from influxdb_client_3.read_file import UploadFile
 from influxdb_client_3.write_client import InfluxDBClient as _InfluxDBClient, WriteOptions, Point
 from influxdb_client_3.write_client.client.exceptions import InfluxDBError
@@ -11,12 +11,7 @@ from influxdb_client_3.write_client.client.write_api import WriteApi as _WriteAp
     PointSettings
 from influxdb_client_3.write_client.domain.write_precision import WritePrecision
 
-try:
-    import polars as pl
-
-    polars = True
-except ImportError:
-    polars = False
+polars = importlib.util.find_spec("polars") is not None
 
 
 def write_client_options(**kwargs):
@@ -143,11 +138,15 @@ class InfluxDBClient3:
             **kwargs)
 
         self._write_api = _WriteApi(influxdb_client=self._client, **self._write_client_options)
-        self._flight_client_options = flight_client_options or {}
 
         if query_port_overwrite is not None:
             port = query_port_overwrite
-        self._flight_client = FlightClient(f"grpc+tls://{hostname}:{port}", **self._flight_client_options)
+        if scheme == 'https':
+            connection_string = f"grpc+tls://{hostname}:{port}"
+        else:
+            connection_string = f"grpc+tcp://{hostname}:{port}"
+        self._query_api = _QueryApi(connection_string=connection_string, token=token,
+                                    flight_client_options=flight_client_options)
 
     def write(self, record=None, database=None, **kwargs):
         """
@@ -245,48 +244,14 @@ class InfluxDBClient3:
             database = self._database
 
         try:
-            # Create an authorization header
-            optargs = {
-                "headers": [(b"authorization", f"Bearer {self._token}".encode('utf-8'))],
-                "timeout": 300
-            }
-            opts = _merge_options(optargs, exclude_keys=['query_parameters'], custom=kwargs)
-            _options = FlightCallOptions(**opts)
-
-            #
-            # Ticket data
-            #
-            ticket_data = {
-                "database": database,
-                "sql_query": query,
-                "query_type": language
-            }
-            # add query parameters
-            query_parameters = kwargs.get("query_parameters", None)
-            if query_parameters:
-                ticket_data["params"] = query_parameters
-
-            ticket = Ticket(json.dumps(ticket_data).encode('utf-8'))
-            flight_reader = self._flight_client.do_get(ticket, _options)
-
-            mode_func = {
-                "all": flight_reader.read_all,
-                "pandas": flight_reader.read_pandas,
-                "polars": lambda: pl.from_arrow(flight_reader.read_all()),
-                "chunk": lambda: flight_reader,
-                "reader": flight_reader.to_reader,
-                "schema": lambda: flight_reader.schema
-
-            }.get(mode, flight_reader.read_all)
-
-            return mode_func() if callable(mode_func) else mode_func
-        except Exception as e:
+            return self._query_api.query(query=query, language=language, mode=mode, database=database, **kwargs)
+        except InfluxDBError as e:
             raise e
 
     def close(self):
         """Close the client and clean up resources."""
         self._write_api.close()
-        self._flight_client.close()
+        self._query_api.close()
         self._client.close()
 
     def __enter__(self):

influxdb3_python-0.6.1/influxdb_client_3/query/__init__.py

@@ -0,0 +1 @@
+"""Package for query module."""

influxdb3_python-0.6.1/influxdb_client_3/query/query_api.py

@@ -0,0 +1,104 @@
+"""Query data in InfluxDB 3."""
+
+# coding: utf-8
+import json
+
+from pyarrow.flight import FlightClient, Ticket, FlightCallOptions, FlightStreamReader
+from influxdb_client_3.version import USER_AGENT
+
+
+class QueryApi(object):
+    """
+    Implementation for '/api/v2/query' endpoint.
+
+    Example:
+        .. code-block:: python
+
+            from influxdb_client import InfluxDBClient
+
+
+            # Initialize instance of QueryApi
+            with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") as client:
+                query_api = client.query_api()
+    """
+
+    def __init__(self,
+                 connection_string,
+                 token,
+                 flight_client_options) -> None:
+        """
+        Initialize defaults.
+
+        :param connection_string: Flight/gRPC connection string
+        :param token: access token
+        :param flight_client_options: Flight client options
+        """
+        self._token = token
+        self._flight_client_options = flight_client_options or {}
+        self._flight_client_options["generic_options"] = [
+            ("grpc.secondary_user_agent", USER_AGENT)
+        ]
+        self._flight_client = FlightClient(connection_string, **self._flight_client_options)
+
+    def query(self, query: str, language: str, mode: str, database: str, **kwargs):
+        """Query data from InfluxDB.
+
+        :param query: The query to execute on the database.
+        :param language: The query language.
+        :param mode: The mode to use for the query.
+                     It should be one of "all", "pandas", "polars", "chunk", "reader" or "schema".
+        :param database: The database to query from.
+        :param kwargs: Additional arguments to pass to the ``FlightCallOptions headers``.
+                       For example, it can be used to set up per request headers.
+        :keyword query_parameters: The query parameters to use in the query.
+                                   It should be a ``dictionary`` of key-value pairs.
+        :return: The query result in the specified mode.
+        """
+        from influxdb_client_3 import polars as has_polars, _merge_options as merge_options
+        try:
+            # Create an authorization header
+            optargs = {
+                "headers": [(b"authorization", f"Bearer {self._token}".encode('utf-8'))],
+                "timeout": 300
+            }
+            opts = merge_options(optargs, exclude_keys=['query_parameters'], custom=kwargs)
+            _options = FlightCallOptions(**opts)
+
+            #
+            # Ticket data
+            #
+            ticket_data = {
+                "database": database,
+                "sql_query": query,
+                "query_type": language
+            }
+            # add query parameters
+            query_parameters = kwargs.get("query_parameters", None)
+            if query_parameters:
+                ticket_data["params"] = query_parameters
+
+            ticket = Ticket(json.dumps(ticket_data).encode('utf-8'))
+            flight_reader = self._do_get(ticket, _options)
+
+            mode_funcs = {
+                "all": flight_reader.read_all,
+                "pandas": flight_reader.read_pandas,
+                "chunk": lambda: flight_reader,
+                "reader": flight_reader.to_reader,
+                "schema": lambda: flight_reader.schema
+            }
+            if has_polars:
+                import polars as pl
+                mode_funcs["polars"] = lambda: pl.from_arrow(flight_reader.read_all())
+            mode_func = mode_funcs.get(mode, flight_reader.read_all)
+
+            return mode_func() if callable(mode_func) else mode_func
+        except Exception as e:
+            raise e
+
+    def _do_get(self, ticket: Ticket, options: FlightCallOptions = None) -> FlightStreamReader:
+        return self._flight_client.do_get(ticket, options)
+
+    def close(self):
+        """Close the Flight client."""
+        self._flight_client.close()

{influxdb3_python-0.5.0/influxdb_client_3/write_client → influxdb3_python-0.6.1/influxdb_client_3}/version.py

@@ -1,3 +1,4 @@
 """Version of the Client that is used in User-Agent header."""
 
-VERSION = '1.38.0dev0'
+VERSION = '0.6.1'
+USER_AGENT = f'influxdb3-python/{VERSION}'

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb_client_3/write_client/__init__.py

@@ -27,5 +27,5 @@ from influxdb_client_3.write_client.service.signout_service import SignoutServic
 from influxdb_client_3.write_client.domain.write_precision import WritePrecision
 
 from influxdb_client_3.write_client.configuration import Configuration
-from influxdb_client_3.write_client.version import VERSION
+from influxdb_client_3.version import VERSION
 __version__ = VERSION

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb_client_3/write_client/_sync/api_client.py

@@ -76,8 +76,8 @@ class ApiClient(object):
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        from influxdb_client_3.write_client.version import VERSION
-        self.user_agent = f'influxdb-client-python/{VERSION}'
+        from influxdb_client_3.version import USER_AGENT
+        self.user_agent = USER_AGENT
 
     def __del__(self):
         """Dispose pools."""

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb_client_3/write_client/client/util/date_utils.py

@@ -2,6 +2,7 @@
 import datetime
 import threading
 from datetime import timezone as tz
+from sys import version_info
 
 from dateutil import parser
 
@@ -90,7 +91,10 @@ def get_date_helper() -> DateHelper:
                     import ciso8601
                     _date_helper.parse_date = ciso8601.parse_datetime
                 except ModuleNotFoundError:
-                    _date_helper.parse_date = parser.parse
+                    if (version_info.major, version_info.minor) >= (3, 11):
+                        _date_helper.parse_date = datetime.datetime.fromisoformat
+                    else:
+                        _date_helper.parse_date = parser.parse
                 date_helper = _date_helper
 
     return date_helper

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/influxdb_client_3/write_client/client/write/point.py

@@ -10,7 +10,7 @@ from numbers import Integral
 from influxdb_client_3.write_client.client.util.date_utils import get_date_helper
 from influxdb_client_3.write_client.domain.write_precision import WritePrecision
 
-EPOCH = datetime.utcfromtimestamp(0).replace(tzinfo=timezone.utc)
+EPOCH = datetime.fromtimestamp(0, tz=timezone.utc)
 
 DEFAULT_WRITE_PRECISION = WritePrecision.NS
 

influxdb3_python-0.6.1/tests/test_api_client.py

@@ -0,0 +1,71 @@
+import unittest
+from unittest import mock
+
+from influxdb_client_3.write_client._sync.api_client import ApiClient
+from influxdb_client_3.write_client.configuration import Configuration
+from influxdb_client_3.write_client.service import WriteService
+from influxdb_client_3.version import VERSION
+
+
+_package = "influxdb3-python"
+_sentHeaders = {}
+
+
+def mock_rest_request(method,
+                      url,
+                      query_params=None,
+                      headers=None,
+                      body=None,
+                      post_params=None,
+                      _preload_content=True,
+                      _request_timeout=None,
+                      **urlopen_kw):
+    class MockResponse:
+        def __init__(self, data, status_code):
+            self.data = data
+            self.status_code = status_code
+
+        def data(self):
+            return self.data
+
+    global _sentHeaders
+    _sentHeaders = headers
+
+    return MockResponse(None, 200)
+
+
+class ApiClientTests(unittest.TestCase):
+
+    def test_default_headers(self):
+        global _package
+        conf = Configuration()
+        client = ApiClient(conf,
+                           header_name="Authorization",
+                           header_value="Bearer TEST_TOKEN")
+        self.assertIsNotNone(client.default_headers["User-Agent"])
+        self.assertIsNotNone(client.default_headers["Authorization"])
+        self.assertEqual(f"{_package}/{VERSION}", client.default_headers["User-Agent"])
+        self.assertEqual("Bearer TEST_TOKEN", client.default_headers["Authorization"])
+
+    @mock.patch("influxdb_client_3.write_client._sync.rest.RESTClientObject.request",
+                side_effect=mock_rest_request)
+    def test_call_api(self, mock_post):
+        global _package
+        global _sentHeaders
+        _sentHeaders = {}
+
+        conf = Configuration()
+        client = ApiClient(conf,
+                           header_name="Authorization",
+                           header_value="Bearer TEST_TOKEN")
+        service = WriteService(client)
+        service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14")
+        self.assertEqual(4, len(_sentHeaders.keys()))
+        self.assertIsNotNone(_sentHeaders["Accept"])
+        self.assertEqual("application/json", _sentHeaders["Accept"])
+        self.assertIsNotNone(_sentHeaders["Content-Type"])
+        self.assertEqual("text/plain", _sentHeaders["Content-Type"])
+        self.assertIsNotNone(_sentHeaders["Authorization"])
+        self.assertEqual("Bearer TEST_TOKEN", _sentHeaders["Authorization"])
+        self.assertIsNotNone(_sentHeaders["User-Agent"])
+        self.assertEqual(f"{_package}/{VERSION}", _sentHeaders["User-Agent"])

influxdb3_python-0.6.1/tests/test_date_helper.py

@@ -0,0 +1,21 @@
+import unittest
+from datetime import datetime, timezone
+
+from dateutil import tz
+
+from influxdb_client_3.write_client.client.util.date_utils import DateHelper, get_date_helper
+
+
+class TestDateHelper(unittest.TestCase):
+
+    def test_to_utc(self):
+        date = get_date_helper().to_utc(datetime(2021, 4, 29, 20, 30, 10, 0))
+        self.assertEqual(datetime(2021, 4, 29, 20, 30, 10, 0, timezone.utc), date)
+
+    def test_to_utc_different_timezone(self):
+        date = DateHelper(timezone=tz.gettz('ETC/GMT+2')).to_utc(datetime(2021, 4, 29, 20, 30, 10, 0))
+        self.assertEqual(datetime(2021, 4, 29, 22, 30, 10, 0, timezone.utc), date)
+
+    def test_parse(self):
+        date = get_date_helper().parse_date("2021-03-20T15:59:10.607352Z")
+        self.assertEqual(datetime(2021, 3, 20, 15, 59, 10, 607352, timezone.utc), date)

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/tests/test_influxdb_client_3.py

@@ -8,11 +8,11 @@ class TestInfluxDBClient3(unittest.TestCase):
 
     @patch('influxdb_client_3._InfluxDBClient')
     @patch('influxdb_client_3._WriteApi')
-    @patch('influxdb_client_3.FlightClient')
-    def setUp(self, mock_flight_client, mock_write_api, mock_influx_db_client):
+    @patch('influxdb_client_3._QueryApi')
+    def setUp(self, mock_query_api, mock_write_api, mock_influx_db_client):
         self.mock_influx_db_client = mock_influx_db_client
         self.mock_write_api = mock_write_api
-        self.mock_flight_client = mock_flight_client
+        self.mock_query_api = mock_query_api
         self.client = InfluxDBClient3(
             host="localhost",
             org="my_org",
@@ -25,7 +25,7 @@ class TestInfluxDBClient3(unittest.TestCase):
         self.assertEqual(self.client._database, "my_db")
         self.assertEqual(self.client._client, self.mock_influx_db_client.return_value)
         self.assertEqual(self.client._write_api, self.mock_write_api.return_value)
-        self.assertEqual(self.client._flight_client, self.mock_flight_client.return_value)
+        self.assertEqual(self.client._query_api, self.mock_query_api.return_value)
 
 
 if __name__ == '__main__':

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/tests/test_influxdb_client_3_integration.py

@@ -39,6 +39,7 @@ class TestInfluxDBClient3Integration(unittest.TestCase):
 
         df = self.client.query(sql, mode="pandas", query_parameters={'type': 'used', 'test_id': test_id})
 
+        self.assertIsNotNone(df)
         self.assertEqual(1, len(df))
         self.assertEqual(test_id, df['test_id'][0])
         self.assertEqual(123.0, df['value'][0])

{influxdb3_python-0.5.0 → influxdb3_python-0.6.1}/tests/test_merge_options.py

@@ -3,7 +3,7 @@ import unittest
 import influxdb_client_3
 
 
-class MergeOptionsTests(unittest.TestCase):
+class TestMergeOptions(unittest.TestCase):
 
     def test_merge_with_empty_custom(self):
         defaults = {"a": 1, "b": 2}

influxdb3_python-0.6.1/tests/test_point.py

@@ -0,0 +1,14 @@
+import datetime
+import unittest
+
+from influxdb_client_3.write_client.client.write.point import EPOCH, Point
+
+
+class TestPoint(unittest.TestCase):
+
+    def test_epoch(self):
+        self.assertEqual(EPOCH, datetime.datetime(1970, 1, 1, 0, 0, tzinfo=datetime.timezone.utc))
+
+    def test_point(self):
+        point = Point.measurement("h2o").tag("location", "europe").field("level", 2.2).time(1_000_000)
+        self.assertEqual('h2o,location=europe level=2.2 1000000', point.to_line_protocol())

influxdb3_python-0.6.1/tests/test_query.py

@@ -0,0 +1,152 @@
+import unittest
+import struct
+from unittest.mock import Mock, ANY
+
+from pyarrow import (
+    array,
+    Table
+)
+
+from pyarrow.flight import (
+    FlightServerBase,
+    FlightUnauthenticatedError,
+    GeneratorStream,
+    ServerMiddleware,
+    ServerMiddlewareFactory,
+    ServerAuthHandler,
+    Ticket
+)
+
+from influxdb_client_3 import InfluxDBClient3
+from influxdb_client_3.version import USER_AGENT
+
+
+def case_insensitive_header_lookup(headers, lkey):
+    """Lookup the value of a given key in the given headers.
+       The lkey is case-insensitive.
+    """
+    for key in headers:
+        if key.lower() == lkey.lower():
+            return headers.get(key)
+
+
+class NoopAuthHandler(ServerAuthHandler):
+    """A no-op auth handler - as seen in pyarrow tests"""
+
+    def authenticate(self, outgoing, incoming):
+        """Do nothing"""
+
+    def is_valid(self, token):
+        """
+        Return an empty string
+        N.B. Returning None causes Type error
+        :param token:
+        :return:
+        """
+        return ""
+
+
+_req_headers = {}
+
+
+class HeaderCheckServerMiddlewareFactory(ServerMiddlewareFactory):
+    """Factory to create HeaderCheckServerMiddleware and check header values"""
+    def start_call(self, info, headers):
+        auth_header = case_insensitive_header_lookup(headers, "Authorization")
+        values = auth_header[0].split(' ')
+        if values[0] != 'Bearer':
+            raise FlightUnauthenticatedError("Token required")
+        global _req_headers
+        _req_headers = headers
+        return HeaderCheckServerMiddleware(values[1])
+
+
+class HeaderCheckServerMiddleware(ServerMiddleware):
+    """
+    Middleware needed to catch request headers via factory
+    N.B. As found in pyarrow tests
+    """
+    def __init__(self, token, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.token = token
+
+    def sending_headers(self):
+        return {'authorization': 'Bearer ' + self.token}
+
+
+class HeaderCheckFlightServer(FlightServerBase):
+    """Mock server handle gRPC do_get calls"""
+    def do_get(self, context, ticket):
+        """Return something to avoid needless errors"""
+        data = [
+            array([b"Vltava", struct.pack('<i', 105), b"FM"])
+        ]
+        table = Table.from_arrays(data, names=['a'])
+        return GeneratorStream(
+            table.schema,
+            self.number_batches(table),
+            options={})
+
+    @staticmethod
+    def number_batches(table):
+        for idx, batch in enumerate(table.to_batches()):
+            buf = struct.pack('<i', idx)
+            yield batch, buf
+
+
+def test_influx_default_query_headers():
+    with HeaderCheckFlightServer(
+            auth_handler=NoopAuthHandler(),
+            middleware={"check": HeaderCheckServerMiddlewareFactory()}) as server:
+        global _req_headers
+        _req_headers = {}
+        client = InfluxDBClient3(
+            host=f'http://localhost:{server.port}',
+            org='test_org',
+            databse='test_db',
+            token='TEST_TOKEN'
+        )
+        client.query('SELECT * FROM test')
+        assert len(_req_headers) > 0
+        assert _req_headers['authorization'][0] == "Bearer TEST_TOKEN"
+        assert _req_headers['user-agent'][0].find(USER_AGENT) > -1
+        _req_headers = {}
+
+
+class TestQuery(unittest.TestCase):
+
+    def setUp(self):
+        self.client = InfluxDBClient3(
+            host="localhost",
+            org="my_org",
+            database="my_db",
+            token="my_token"
+        )
+
+    def test_query_without_parameters(self):
+        mock_do_get = Mock()
+        self.client._query_api._do_get = mock_do_get
+
+        self.client.query('SELECT * FROM measurement')
+
+        expected_ticket = Ticket(
+            '{"database": "my_db", '
+            '"sql_query": "SELECT * FROM measurement", '
+            '"query_type": "sql"}'.encode('utf-8')
+        )
+
+        mock_do_get.assert_called_once_with(expected_ticket, ANY)
+
+    def test_query_with_parameters(self):
+        mock_do_get = Mock()
+        self.client._query_api._do_get = mock_do_get
+
+        self.client.query('SELECT * FROM measurement WHERE time > $time', query_parameters={"time": "2021-01-01"})
+
+        expected_ticket = Ticket(
+            '{"database": "my_db", '
+            '"sql_query": "SELECT * FROM measurement WHERE time > $time", '
+            '"query_type": "sql", "params": {"time": "2021-01-01"}}'.encode('utf-8')
+        )
+
+        mock_do_get.assert_called_once_with(expected_ticket, ANY)

influxdb3_python-0.5.0/tests/test_query.py

@@ -1,53 +0,0 @@
-import unittest
-from unittest.mock import Mock, patch, ANY
-
-from pyarrow.flight import Ticket
-
-from influxdb_client_3 import InfluxDBClient3
-
-
-class QueryTests(unittest.TestCase):
-
-    @patch('influxdb_client_3._InfluxDBClient')
-    @patch('influxdb_client_3._WriteApi')
-    @patch('influxdb_client_3.FlightClient')
-    def setUp(self, mock_flight_client, mock_write_api, mock_influx_db_client):
-        self.mock_influx_db_client = mock_influx_db_client
-        self.mock_write_api = mock_write_api
-        self.mock_flight_client = mock_flight_client
-        self.client = InfluxDBClient3(
-            host="localhost",
-            org="my_org",
-            database="my_db",
-            token="my_token"
-        )
-        self.client._flight_client = mock_flight_client
-        self.client._write_api = mock_write_api
-
-    def test_query_without_parameters(self):
-        mock_do_get = Mock()
-        self.client._flight_client.do_get = mock_do_get
-
-        self.client.query('SELECT * FROM measurement')
-
-        expected_ticket = Ticket(
-            '{"database": "my_db", '
-            '"sql_query": "SELECT * FROM measurement", '
-            '"query_type": "sql"}'.encode('utf-8')
-        )
-
-        mock_do_get.assert_called_once_with(expected_ticket, ANY)
-
-    def test_query_with_parameters(self):
-        mock_do_get = Mock()
-        self.client._flight_client.do_get = mock_do_get
-
-        self.client.query('SELECT * FROM measurement WHERE time > $time', query_parameters={"time": "2021-01-01"})
-
-        expected_ticket = Ticket(
-            '{"database": "my_db", '
-            '"sql_query": "SELECT * FROM measurement WHERE time > $time", '
-            '"query_type": "sql", "params": {"time": "2021-01-01"}}'.encode('utf-8')
-        )
-
-        mock_do_get.assert_called_once_with(expected_ticket, ANY)