chore: Integration test with images

Author: dcelasun

.github/workflows/publish.yaml

@@ -9,41 +9,68 @@ on:
 env:
   REGISTRY: ghcr.io
   IMAGE_NAME: ${{ github.repository }}
+  OCR_TEST_IMAGE: meter-reader-ocr-test
 
 permissions:
   contents: write
   packages: write
   pull-requests: write
 
 jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    steps:
+      - uses: googleapis/release-please-action@v4
+        id: release
+        with:
+          release-type: simple
+
   test:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
           go-version-file: go.mod
 
-      - name: Run tests
+      - name: Unit tests
         run: go test -race -v ./...
 
-  release-please:
-    needs: test
+  integration-test:
     runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-      tag_name: ${{ steps.release.outputs.tag_name }}
     steps:
-      - uses: googleapis/release-please-action@v4
-        id: release
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
         with:
-          release-type: simple
+          go-version-file: go.mod
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build OCR test image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile.test
+          load: true
+          tags: ${{ env.OCR_TEST_IMAGE }}
+          cache-from: type=gha,scope=ocr-test
+          cache-to: type=gha,scope=ocr-test,mode=max
+
+      - name: Integration tests
+        run: go test -v -run TestIntegration -timeout 600s ./...
 
   build-and-push:
-    needs: [release-please, test]
+    needs: [release-please, test, integration-test]
     if: needs.release-please.outputs.release_created == 'true' || github.event_name == 'workflow_dispatch'
     runs-on: ubuntu-latest
     steps:

Dockerfile.test

@@ -0,0 +1,28 @@
+FROM python:3.13-slim-bookworm
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgomp1 libglib2.0-0 libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Pin paddlepaddle to 3.2.2 — later 3.x versions have a CPU inference bug:
+# https://github.com/PaddlePaddle/Paddle/issues/77340
+RUN python3 -m venv /app/venv \
+    && /app/venv/bin/pip install --no-cache-dir \
+        paddlepaddle==3.2.2 \
+        -i https://www.paddlepaddle.org.cn/packages/stable/cpu/ \
+    && /app/venv/bin/pip install --no-cache-dir paddleocr
+
+# Pre-download models by doing a dummy inference
+COPY ocr.py /app/ocr.py
+RUN apt-get update && apt-get install -y --no-install-recommends wget \
+    && wget -q -O /tmp/test.png https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/general_ocr_002.png \
+    && /app/venv/bin/python3 /app/ocr.py /tmp/test.png > /dev/null 2>&1 \
+    && rm /tmp/test.png \
+    && apt-get purge -y wget && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK=True
+
+ENTRYPOINT ["/app/venv/bin/python3", "/app/ocr.py"]

integration_test.go

@@ -0,0 +1,113 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"testing"
+)
+
+const ocrTestImage = "meter-reader-ocr-test"
+
+func TestIntegrationOCR(t *testing.T) {
+	if _, err := exec.LookPath("docker"); err != nil {
+		t.Skip("skipping: docker not found")
+	}
+	if entries, _ := filepath.Glob("testdata/*.jpg"); len(entries) == 0 {
+		t.Skip("skipping: no testdata/*.jpg files found")
+	}
+
+	// Build or reuse the OCR test image.
+	check := exec.Command("docker", "image", "inspect", ocrTestImage)
+	if err := check.Run(); err != nil {
+		t.Log("building Docker image for OCR integration tests (this may take a few minutes on first run)...")
+		cmd := exec.Command("docker", "build", "-f", "Dockerfile.test", "-t", ocrTestImage, ".")
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			t.Fatalf("failed to build test image: %v", err)
+		}
+	} else {
+		t.Log("using existing Docker image:", ocrTestImage)
+	}
+
+	cropCfg := &cropConfig{X0: 850, Y0: 630, X1: 1470, Y1: 795}
+	matchRe := regexp.MustCompile(`^000\d+$`)
+	fixRules := parseOCRFixRules("^300=000,^800=000,^900=000")
+	masks := parseMaskRegions(
+		"405,21,451,43,457,27,499,45,507,29,550,47,68,125,136,163",
+		"8a9986,8a9986,8a9986,cef2ce",
+	)
+	divisor := 1000.0
+
+	tests := []struct {
+		file string
+		want float64
+	}{
+		{"testdata/0.jpg", 355.797},
+		{"testdata/1.jpg", 355.914},
+		{"testdata/2.jpg", 355.920},
+	}
+
+	for _, tt := range tests {
+		t.Run(filepath.Base(tt.file), func(t *testing.T) {
+			imageData, err := os.ReadFile(tt.file)
+			if err != nil {
+				t.Fatalf("read image: %v", err)
+			}
+
+			processed, err := cropImage(imageData, cropCfg)
+			if err != nil {
+				t.Fatalf("crop: %v", err)
+			}
+
+			processed, err = maskImage(processed, masks)
+			if err != nil {
+				t.Fatalf("mask: %v", err)
+			}
+
+			tmpDir := t.TempDir()
+			tmpFile := filepath.Join(tmpDir, "image.jpg")
+			if err := os.WriteFile(tmpFile, processed, 0644); err != nil {
+				t.Fatalf("write temp file: %v", err)
+			}
+
+			cmd := exec.Command("docker", "run", "--rm",
+				"-v", tmpDir+":/data:ro",
+				ocrTestImage,
+				"/data/image.jpg",
+			)
+			var stdout, stderr bytes.Buffer
+			cmd.Stdout = &stdout
+			cmd.Stderr = &stderr
+			if err := cmd.Run(); err != nil {
+				t.Fatalf("docker run: %v\nstderr: %s", err, stderr.String())
+			}
+
+			var ocrOut ocrOutput
+			if err := json.Unmarshal(stdout.Bytes(), &ocrOut); err != nil {
+				t.Fatalf("parse OCR output: %v (raw: %s)", err, stdout.String())
+			}
+
+			reading := extractReading(ocrOut.Texts, matchRe, fixRules)
+			if reading == "" {
+				t.Fatalf("no reading extracted from texts: %v", ocrOut.Texts)
+			}
+
+			raw, err := strconv.ParseFloat(reading, 64)
+			if err != nil {
+				t.Fatalf("parse reading %q: %v", reading, err)
+			}
+
+			got := raw / divisor
+			if math.Abs(got-tt.want) > 0.001 {
+				t.Errorf("reading = %.3f, want %.3f (raw=%s, texts=%v)", got, tt.want, reading, ocrOut.Texts)
+			}
+		})
+	}
+}