dsquery: fix test_*errors

Author: peekjef72

grafana_client/elements/datasource.py

@@ -307,6 +307,78 @@ def series(self, datasource_id, match, start, end, access="proxy"):
         r = self.client.POST(post_series_path, data={"match[]": match, "start": start, "end": end})
         return r
 
+    def smartquery_old(self, datasource: Union[DatasourceIdentifier, Dict], expression: str, store: Optional[str] = None):
+        """
+        Send a query to the designated data source and return its response.
+
+        TODO: This is by far not complete. The `query_factory` function has to
+              be made more elaborate in order to query different data source
+              types.
+        """
+
+        if isinstance(datasource, DatasourceIdentifier):
+            datasource = self.get(datasource)
+
+        datasource_id = datasource["id"]
+        datasource_type = datasource["type"]
+        datasource_dialect = datasource.get("jsonData", {}).get("version", "InfluxQL")
+        access_type = datasource["access"]
+
+        # Sanity checks.
+        if not expression:
+            raise ValueError("Expression must be given")
+
+        # Build the query payload. Each data source has different query attributes.
+        query = query_factory(datasource, expression, store)
+
+        logger.info(f"Submitting query: {query}")
+
+        # Compute request method, body, and endpoint.
+        send_request = self.client.POST
+
+        # Certain data sources like InfluxDB 1.x, still use the `/datasources/proxy` route.
+        if datasource_type == "influxdb" and datasource_dialect == "InfluxQL":
+            url = f"/datasources/proxy/{datasource_id}/query"
+            if store is not None:
+                url += f"?db={store}"
+            payload = {"q": query["q"]}
+            request_kwargs = {"data": payload}
+
+        elif datasource_type == "graphite":
+            url = f"/datasources/proxy/{datasource_id}/render"
+            request_kwargs = {"data": query}
+
+        # This case is very special. It is used for Elasticsearch and Testdata.
+        elif expression.startswith("url://"):
+            url = expression.replace("url://", "")
+            url = url.format(
+                datasource_id=datasource.get("id"),
+                datasource_uid=datasource.get("uid"),
+                database_name=datasource.get("database"),
+            )
+            request_kwargs = {}
+            send_request = self.client.GET
+
+        # For all others, use the generic data source communication endpoint.
+        elif access_type in ["server", "proxy"]:
+            url = "/ds/query"
+            payload = {"queries": [query]}
+            request_kwargs = {"json": payload}
+
+        else:
+            raise NotImplementedError(f"Unable to submit query to data source with access type '{access_type}'")
+
+        # Submit query.
+        try:
+            r = send_request(url, **request_kwargs)
+            # logger.debug(f"Response from generic data source query: {r}")
+            return r
+        except (GrafanaClientError, GrafanaServerError) as ex:
+            logger.error(
+                f"Querying data source failed. id={datasource_id}, type={datasource_type}. "
+                f"Reason: {ex}. Response: {ex.response or '<empty>'}"
+            )
+            raise
 #**********************************************************************************
     def smartquery(self, datasource: Union[DatasourceIdentifier, Dict], expression: str, attrs: Optional[dict] = None, request: Optional[dict] = None):
         """
@@ -332,11 +404,10 @@ def smartquery(self, datasource: Union[DatasourceIdentifier, Dict], expression:
             model = {
                 "refId": "test",
             }
-            if expression is not None:
-                if attrs is not None:
-                    model.update(attrs)
-                if attrs is None or ( attrs is not None and 'query' not in attrs):
-                    model['query'] = expression
+            if expression is not None and ( attrs is None or (attrs is not None and 'query' not in attrs)):
+                model['query'] = expression
+            if attrs is not None:
+                model.update(attrs)
             request = query_factory(datasource, model)
 
         # Compute request method, body, and endpoint.
@@ -359,15 +430,15 @@ def smartquery(self, datasource: Union[DatasourceIdentifier, Dict], expression:
             request_kwargs = {"data": request["data"]}
 
         # This case is very special. It is used for Elasticsearch and Testdata.
-        # elif expression.startswith("url://"):
-        #     url = expression.replace("url://", "")
-        #     url = url.format(
-        #         datasource_id=datasource.get("id"),
-        #         datasource_uid=datasource.get("uid"),
-        #         database_name=datasource.get("database"),
-        #     )
-        #     request_kwargs = {}
-        #     send_request = self.client.GET
+        elif expression.startswith("url://"):
+            url = expression.replace("url://", "")
+            url = url.format(
+                datasource_id=datasource.get("id"),
+                datasource_uid=datasource.get("uid"),
+                database_name=datasource.get("database"),
+            )
+            request_kwargs = {}
+            send_request = self.client.GET
 
         # For all others, use the generic data source communication endpoint.
         elif access_type in ["server", "proxy"]: