fix(telega): build the server image locally to meet tdlib 1.8.66HEADmain

MELPA's 2026-08-18 telega raised telega-tdlib-min-version to 1.8.66. The pinned upstream image ships 1.8.64, so telega killed its own server on every launch. Upstream's only 1.8.66 image won't start: it's missing libglycin (zevlg/telega.el#596).

docker/telega-server/Dockerfile derives from that upstream image, pinned by digest, and adds the one missing package. make telega-image builds it as cj/telega-server:1.8.66-glycin, cj/telega-docker-image defaults to that tag, and a test holds the two equal. cj/telega now refuses to launch with a make telega-image hint when the image isn't built, since docker would otherwise try to pull a local-only tag from the registry. setup-telega.sh points at the make target instead of M-x telega-server-build.

I chose the local build over pinning the telega package back to 20260706.2147. The derived image satisfies both machines' floors. package.el can't pin a version and MELPA serves only its latest build, so nothing would enforce the package pin. When #596 is fixed upstream the pin returns to a registry digest and the Dockerfile goes.

3 files changed, 136 insertions, 13 deletions

diff --git a/tests/test-setup-telega.bats b/tests/test-setup-telega.bats
index 3282b9e1..518ecc7b 100644
--- a/tests/test-setup-telega.bats
+++ b/tests/test-setup-telega.bats
@@ -57,11 +57,11 @@ setup() {
 
 # --------------------------- pull_or_announce_image -----------------------
 
-@test "pull_or_announce_image: announces the in-Emacs build when no image is set" {
+@test "pull_or_announce_image: points at make telega-image when no image is set" {
     TELEGA_DOCKER_IMAGE=""
     run pull_or_announce_image
     [ "$status" -eq 0 ]
-    [[ "$output" == *"M-x telega-server-build"* ]]
+    [[ "$output" == *"make telega-image"* ]]
 }
 
 @test "pull_or_announce_image: pulls when TELEGA_DOCKER_IMAGE is set" {
diff --git a/tests/test-telega-config--docker-pin.el b/tests/test-telega-config--docker-pin.el
index 894dbfdd..8f5b62bd 100644
--- a/tests/test-telega-config--docker-pin.el
+++ b/tests/test-telega-config--docker-pin.el
@@ -5,9 +5,15 @@
 ;;
 ;; telega infers its image from `telega-tdlib-min-version' and only pins to a
 ;; version tag when min and max versions are equal and the version ends in
-;; ".0".  This config has min "1.8.64" and max nil, so the inference always
+;; ".0".  This config has min "1.8.66" and max nil, so the inference always
 ;; falls through to "zevlg/telega-server:latest" -- a moving tag that can
 ;; swap the server out from under a fixed elisp version without notice.
+;;
+;; Since 2026-08-25 the pin names an image built locally from
+;; docker/telega-server/Dockerfile (upstream's image is missing a shared
+;; library, zevlg/telega.el#596).  Three files have to agree on that image:
+;; the defcustom default, the Makefile's build tag, and the Dockerfile's
+;; digest-pinned base.  The tests below hold them together.
 
 ;;; Code:
 
@@ -17,6 +23,18 @@
 (add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
 (require 'telega-config)
 
+(defun test-telega-config--file-string (relative)
+  "Return the contents of RELATIVE under `user-emacs-directory'."
+  (with-temp-buffer
+    (insert-file-contents (expand-file-name relative user-emacs-directory))
+    (buffer-string)))
+
+(defun test-telega-config--pin-default ()
+  "Return the defcustom's shipped default, not the live value.
+Customizing the pin (including to nil) is not a test failure; only
+changing the shipped default is."
+  (eval (car (get 'cj/telega-docker-image 'standard-value)) t))
+
 ;; -- cj/--telega-docker-pinned-image -----------------------------------------
 
 (ert-deftest test-telega-config-pin-returns-configured-reference ()
@@ -77,17 +95,118 @@ name, so this stays a reversible setting."
   "Normal: the advice is a named function so it can be removed by reference."
   (should (fboundp 'cj/--telega-docker-image-name)))
 
-(ert-deftest test-telega-config-pin-default-is-a-digest-reference ()
-  "Normal: the shipped default pins by digest, not by a floating tag.
-A tag pin (:latest, or even a version tag upstream can re-push) still
-moves; a digest names one immutable image.
-
-Reads the defcustom's standard value rather than the live variable, so
-customizing the pin (including to nil, handing the choice back to telega)
-is not a test failure -- only changing the shipped default is."
-  (let ((default (eval (car (get 'cj/telega-docker-image 'standard-value)) t)))
+;; -- the shipped default and the files it depends on -------------------------
+
+(ert-deftest test-telega-config-pin-default-matches-makefile-build-tag ()
+  "Normal: the default pin is exactly the tag `make telega-image' builds.
+The image is built locally, so the pin is a tag rather than a registry
+digest.  The Makefile owns the tag; the defcustom must name the same one
+or a fresh machine builds an image telega never looks for."
+  (let ((makefile (test-telega-config--file-string "Makefile")))
+    (should (string-match "^TELEGA_IMAGE[ \t]*[?:]?=[ \t]*\\([^ \t\n]+\\)" makefile))
+    (should (equal (test-telega-config--pin-default)
+                   (match-string 1 makefile)))))
+
+(ert-deftest test-telega-config-pin-default-is-a-local-tag-not-a-digest ()
+  "Boundary: the default is a plain tag, with no registry digest suffix.
+A locally built image has no RepoDigest, so a digest reference here could
+never resolve."
+  (let ((default (test-telega-config--pin-default)))
     (should (stringp default))
-    (should (string-match-p "@sha256:[0-9a-f]\\{64\\}\\'" default))))
+    (should (string-match-p "\\`[a-z0-9./-]+:[A-Za-z0-9._-]+\\'" default))
+    (should-not (string-match-p "@sha256:" default))))
+
+(ert-deftest test-telega-config-dockerfile-pins-base-image-by-digest ()
+  "Normal: the Dockerfile's base is an immutable upstream digest.
+This is where the digest guarantee the old pin gave now lives.  A tag in
+the FROM line would let upstream swap the base under a rebuild."
+  (let ((dockerfile (test-telega-config--file-string "docker/telega-server/Dockerfile")))
+    (should (string-match-p
+             "^FROM zevlg/telega-server@sha256:[0-9a-f]\\{64\\}[ \t]*$"
+             dockerfile))))
+
+(ert-deftest test-telega-config-dockerfile-adds-the-missing-library ()
+  "Normal: the Dockerfile installs libglycin, the whole reason it exists.
+Upstream's image fails to start without it (zevlg/telega.el#596)."
+  (let ((dockerfile (test-telega-config--file-string "docker/telega-server/Dockerfile")))
+    (should (string-match-p "^RUN apk add .*libglycin" dockerfile))))
+
+;; -- cj/--telega-docker-image-present-p (the docker boundary) ----------------
+;; Exercised against a fake `docker' executable on a private exec-path rather
+;; than by mocking `call-process' (a subr; see the native-comp mocking gotcha).
+
+(defun test-telega-config--with-fake-docker (exit-code thunk)
+  "Call THUNK with a fake `docker' on `exec-path' that exits EXIT-CODE."
+  (let* ((dir (make-temp-file "fake-docker-" t))
+         (script (expand-file-name "docker" dir)))
+    (unwind-protect
+        (progn
+          (with-temp-file script
+            (insert (format "#!/bin/sh\nexit %d\n" exit-code)))
+          (set-file-modes script #o700)
+          (let ((exec-path (list dir)))
+            (funcall thunk)))
+      (delete-directory dir t))))
+
+(ert-deftest test-telega-config-image-present-p-true-when-inspect-succeeds ()
+  "Normal: `docker image inspect' exiting 0 means the image is present."
+  (test-telega-config--with-fake-docker 0
+    (lambda () (should (cj/--telega-docker-image-present-p "cj/telega-server:x")))))
+
+(ert-deftest test-telega-config-image-present-p-nil-when-inspect-fails ()
+  "Boundary: a non-zero exit (no such image) reads as not present."
+  (test-telega-config--with-fake-docker 1
+    (lambda () (should-not (cj/--telega-docker-image-present-p "cj/telega-server:x")))))
+
+(ert-deftest test-telega-config-image-present-p-nil-without-docker ()
+  "Error: with no docker on `exec-path', the helper returns nil instead of
+signalling, so the launcher can still route the user to the make target."
+  (let ((exec-path nil))
+    (should-not (cj/--telega-docker-image-present-p "cj/telega-server:x"))))
+
+;; -- cj/telega refuses to launch against a missing local image ---------------
+
+(ert-deftest test-telega-config-missing-image-message-names-image-and-target ()
+  "Normal: the message names the missing image and the make target that builds it."
+  (let ((msg (cj/--telega-missing-image-message "cj/telega-server:x")))
+    (should (string-match-p "cj/telega-server:x" msg))
+    (should (string-match-p "make telega-image" msg))))
+
+(ert-deftest test-telega-config-launcher-errors-when-pinned-image-is-absent ()
+  "Error: with a pin set and no such image, `cj/telega' stops with the make hint.
+Without this, docker fails to pull a local-only tag and the error names a
+registry the image was never meant to come from."
+  (let ((cj/telega-docker-image "cj/telega-server:x")
+        (launched nil))
+    (cl-letf (((symbol-function 'locate-library) (lambda (&rest _) "telega.el"))
+              ((symbol-function 'cj/--telega-docker-image-present-p) (lambda (_) nil))
+              ((symbol-function 'telega) (lambda (&rest _) (setq launched t))))
+      (let ((err (should-error (cj/telega) :type 'user-error)))
+        (should (string-match-p "make telega-image" (cadr err))))
+      (should-not launched))))
+
+(ert-deftest test-telega-config-launcher-runs-when-pinned-image-is-present ()
+  "Normal: with the pinned image present, `cj/telega' launches telega."
+  (let ((cj/telega-docker-image "cj/telega-server:x")
+        (launched nil))
+    (cl-letf (((symbol-function 'locate-library) (lambda (&rest _) "telega.el"))
+              ((symbol-function 'cj/--telega-docker-image-present-p) (lambda (_) t))
+              ((symbol-function 'telega) (lambda (&rest _) (setq launched t))))
+      (cj/telega)
+      (should launched))))
+
+(ert-deftest test-telega-config-launcher-skips-image-check-without-a-pin ()
+  "Boundary: with no pin, telega infers and pulls its own image; no check runs."
+  (let ((cj/telega-docker-image nil)
+        (checked nil)
+        (launched nil))
+    (cl-letf (((symbol-function 'locate-library) (lambda (&rest _) "telega.el"))
+              ((symbol-function 'cj/--telega-docker-image-present-p)
+               (lambda (_) (setq checked t) nil))
+              ((symbol-function 'telega) (lambda (&rest _) (setq launched t))))
+      (cj/telega)
+      (should-not checked)
+      (should launched))))
 
 (provide 'test-telega-config--docker-pin)
 ;;; test-telega-config--docker-pin.el ends here
diff --git a/tests/test-telega-config.el b/tests/test-telega-config.el
index d8aaeb4d..54a601c9 100644
--- a/tests/test-telega-config.el
+++ b/tests/test-telega-config.el
@@ -45,6 +45,10 @@ stub's cryptic load-file failure."
   (let (called)
     (cl-letf (((symbol-function 'featurep)
                (lambda (sym &optional _sub) (eq sym 'telega)))
+              ;; The pinned image is a local build; treat it as present so
+              ;; this test stays about delegation, not the image check.
+              ((symbol-function 'cj/--telega-docker-image-present-p)
+               (lambda (_) t))
               ((symbol-function 'telega)
                (lambda (&rest _) (setq called t))))
       (cj/telega))