test: ensure Prometheus queries can be rendered (#762)

Author: Proximyst

tests/acceptance/pdf_test.go tests/acceptance/basic_render_test.gotests/acceptance/pdf_test.go renamed to tests/acceptance/basic_render_test.go

@@ -1,10 +1,12 @@
 package acceptance
 
 import (
-	"bytes"
-	_ "embed"
+	"embed"
+	"fmt"
 	"io"
+	"io/fs"
 	"os"
+	"path"
 	"strings"
 	"testing"
 	"time"
@@ -169,11 +171,8 @@ type Grafana struct {
 	HTTPEndpoint string
 }
 
-//go:embed fixtures/dashboards-provisioner.yaml
-var dashboardsProvisioner []byte
-
-//go:embed fixtures/all-panels.json
-var allPanelsDashboard []byte
+//go:embed fixtures
+var fixturesFS embed.FS
 
 func StartGrafana(tb testing.TB, options ...ContainerOption) *Grafana {
 	tb.Helper()
@@ -188,21 +187,11 @@ func StartGrafana(tb testing.TB, options ...ContainerOption) *Grafana {
 			Image: "docker.io/grafana/grafana-enterprise:main",
 			WaitingFor: wait.ForAll(
 				wait.ForHTTP("/healthz").WithPort(httpPort).WithAllowInsecure(true),
-				wait.ForLog("finished to provision dashboards"), // from the provisioning files we add
+				wait.ForLog("inserting datasource from configuration"), // from the provisioning files we add
+				wait.ForLog("finished to provision dashboards"),        // from the provisioning files we add
 			),
 			ExposedPorts: []string{"3000/tcp"},
-			Files: []testcontainers.ContainerFile{
-				{
-					Reader:            bytes.NewReader(dashboardsProvisioner),
-					ContainerFilePath: "/etc/grafana/provisioning/dashboards/dashboards.yaml",
-					FileMode:          0o777,
-				},
-				{
-					Reader:            bytes.NewReader(allPanelsDashboard),
-					ContainerFilePath: "/usr/share/grafana/dashboards/all-panels.json",
-					FileMode:          0o777,
-				},
-			},
+			Files:        createGrafanaProvisioningFiles(tb),
 		},
 	}
 	for _, f := range options {
@@ -221,3 +210,87 @@ func StartGrafana(tb testing.TB, options ...ContainerOption) *Grafana {
 		HTTPEndpoint: endpoint,
 	}
 }
+
+func createGrafanaProvisioningFiles(tb testing.TB) []testcontainers.ContainerFile {
+	tb.Helper()
+
+	files, err := fsToContainerFiles(embedFSSub(tb, fixturesFS, "fixtures/dashboards"), ".", "/usr/share/grafana/dashboards")
+	require.NoError(tb, err, "could not create container files from embedded dashboards")
+
+	provisioningFiles, err := fsToContainerFiles(embedFSSub(tb, fixturesFS, "fixtures/provisioning"), ".", "/etc/grafana/provisioning")
+	require.NoError(tb, err, "could not create container files from embedded provisioning datasources")
+	files = append(files, provisioningFiles...)
+
+	return files
+}
+
+type embedFS interface {
+	fs.FS
+	fs.ReadDirFS
+	fs.ReadFileFS
+}
+
+func embedFSSub(tb testing.TB, f embedFS, dir string) embedFS {
+	sub, err := fs.Sub(f, dir)
+	require.NoError(tb, err, "could not get sub fs for dir %q", dir)
+	if efs, ok := sub.(embedFS); ok {
+		return efs
+	}
+	require.Fail(tb, "sub fs is not an embedFS", "got type %T", sub)
+	panic("unreachable")
+}
+
+func fsToContainerFiles(fs embedFS, baseSrc, baseDst string) ([]testcontainers.ContainerFile, error) {
+	var files []testcontainers.ContainerFile
+
+	entries, err := fs.ReadDir(baseSrc)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read embedded dir %q: %w", baseSrc, err)
+	}
+	for _, f := range entries {
+		if f.IsDir() {
+			subFiles, err := fsToContainerFiles(fs, path.Join(baseSrc, f.Name()), path.Join(baseDst, f.Name()))
+			if err != nil {
+				return nil, fmt.Errorf("failed to join with subdir %q: %w", f.Name(), err)
+			}
+			files = append(files, subFiles...)
+			continue
+		}
+
+		file, err := fs.Open(path.Join(baseSrc, f.Name()))
+		if err != nil {
+			return nil, fmt.Errorf("failed to read file %q: %w", path.Join(baseSrc, f.Name()), err)
+		}
+
+		files = append(files, testcontainers.ContainerFile{
+			Reader:            file,
+			ContainerFilePath: path.Join(baseDst, f.Name()),
+			FileMode:          0o777,
+		})
+	}
+
+	return files, nil
+}
+
+func StartPrometheus(tb testing.TB, options ...ContainerOption) {
+	tb.Helper()
+
+	req := testcontainers.GenericContainerRequest{
+		Logger:  log.TestLogger(tb),
+		Started: true,
+		ContainerRequest: testcontainers.ContainerRequest{
+			Image: "prom/prometheus:latest",
+			WaitingFor: wait.ForAll(
+				wait.ForHTTP("/-/healthy"),
+				wait.ForLog("Server is ready"),
+			),
+		},
+	}
+	for _, f := range options {
+		f(tb, &req)
+	}
+
+	container, err := testcontainers.GenericContainer(tb.Context(), req)
+	require.NoError(tb, err, "could not start service container?")
+	testcontainers.CleanupContainer(tb, container)
+}

tests/acceptance/dockerinfra_test.go

@@ -0,0 +1,150 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": {
+          "type": "grafana",
+          "uid": "-- Grafana --"
+        },
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": 2,
+  "links": [],
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${prom}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "barWidthFactor": 0.6,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": 0
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "hideZeros": false,
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "12.2.0-92405",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${prom}"
+          },
+          "editorMode": "code",
+          "expr": "1",
+          "legendFormat": "__auto",
+          "range": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Prometheus: 1",
+      "type": "timeseries"
+    }
+  ],
+  "preload": false,
+  "schemaVersion": 41,
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "current": {
+          "text": "Prometheus",
+          "value": "prometheus"
+        },
+        "name": "prom",
+        "options": [],
+        "query": "prometheus",
+        "refresh": 1,
+        "regex": "",
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "Provisioned Prometheus testing",
+  "uid": "provisioned-prom-testing",
+  "version": 2
+}

tests/acceptance/fixtures/all-panels.json …ance/fixtures/dashboards/all-panels.jsontests/acceptance/fixtures/all-panels.json renamed to tests/acceptance/fixtures/dashboards/all-panels.json tests/acceptance/fixtures/all-panels.json renamed to tests/acceptance/fixtures/dashboards/all-panels.json

@@ -0,0 +1,15 @@
+apiVersion: 1
+
+datasources:
+  - name: Prometheus
+    type: prometheus
+    access: proxy
+    url: http://prometheus:9090
+    isDefault: true
+    uid: prometheus
+    editable: false
+    jsonData:
+      httpMethod: POST
+      prometheusType: Prometheus
+      prometheusVersion: '3.3.0'
+      timeInterval: 10s

tests/acceptance/fixtures/dashboards/prometheus-dashboard.json

@@ -86,4 +86,60 @@ func TestRenderingGrafana(t *testing.T) {
 			require.NoError(t, err, "could not update fixture file")
 		}
 	})
+
+	t.Run("render prometheus dashboard", func(t *testing.T) {
+		t.Parallel()
+
+		net, err := network.New(t.Context())
+		require.NoError(t, err, "could not create Docker network")
+		testcontainers.CleanupNetwork(t, net)
+
+		StartPrometheus(t, WithNetwork(net, "prometheus"))
+		svc := StartImageRenderer(t, WithNetwork(net, "gir"))
+		_ = StartGrafana(t,
+			WithNetwork(net, "grafana"),
+			WithEnv("GF_FEATURE_TOGGLES_ENABLE", "renderAuthJWT"),
+			WithEnv("GF_RENDERING_SERVER_URL", "http://gir:8081/render"),
+			WithEnv("GF_RENDERING_CALLBACK_URL", "http://grafana:3000/"),
+			WithEnv("GF_LOG_FILTERS", "debug"),
+			WithEnv("GF_RENDERING_RENDERER_TOKEN", rendererAuthToken))
+
+		req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, svc.HTTPEndpoint+"/render", nil)
+		require.NoError(t, err, "could not construct HTTP request to Grafana")
+		req.Header.Set("Accept", "image/png")
+		req.Header.Set("X-Auth-Token", "-")
+		query := req.URL.Query()
+		query.Set("url", "http://grafana:3000/d/provisioned-prom-testing?render=1&from=1699333200000&to=1699344000000&kiosk=true")
+		query.Set("encoding", "png")
+		query.Set("width", "1400")
+		query.Set("height", "800")
+		query.Set("renderKey", renderKey)
+		query.Set("domain", "grafana")
+		req.URL.RawQuery = query.Encode()
+
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err, "could not send HTTP request to Grafana")
+		require.Equal(t, http.StatusOK, resp.StatusCode, "unexpected HTTP status code from Grafana")
+
+		const fixturePath = "fixtures/render-prometheus.png"
+		fixture, err := os.Open(fixturePath)
+		require.NoError(t, err, "could not read fixture file")
+		fixtureImg, err := png.Decode(fixture)
+		require.NoError(t, err, "could not decode fixture PNG image")
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err, "could not read response body")
+		bodyImg, err := png.Decode(bytes.NewReader(body))
+		require.NoError(t, err, "could not decode response PNG image")
+
+		assert.Equal(t, bodyImg.Bounds().Max.X, 1400, "rendered image has wrong width")
+		assert.Equal(t, bodyImg.Bounds().Max.Y, 800, "rendered image has wrong height")
+
+		diff, err := CountPixelDifferences(fixtureImg, bodyImg)
+		const pixelThreshold = 15_000
+		ok := assert.NoError(t, err, "could not diff images") && assert.LessOrEqual(t, diff, uint64(pixelThreshold), "rendered image has changed significantly")
+		if !ok && os.Getenv("UPDATE_FIXTURES") == "true" {
+			err := os.WriteFile(fixturePath, body, 0o644)
+			require.NoError(t, err, "could not update fixture file")
+		}
+	})
 }