test(scale-to-zero): cover the 6 patch-coverage-flagged changed lines

The patch-coverage gate (100% of changed lines) flagged 6 uncovered lines added
by the scale-to-zero feature commits:

- config.go 517-518: the DEPLOY_SCALE_TO_ZERO_ENABLED=true branch — add
  TestLoad_DeployScaleToZeroEnabled (truthy + falsy table, mirrors the
  DeploySourceGitEnabled test) and register the key in allKeys().
- deploy_wake.go 57-58 / 67 / 101-105: the requireTeam-error arm, the generic
  GetDeploymentByAppID driver-error (503 fetch_failed) arm, and the post-write
  re-read-failure fallback (scale+DB already succeeded → 200, not 5xx). Add
  TestWake_RequireTeamFails, TestWake_FetchDriverError503,
  TestWake_ReReadFailureFallsBack + a no-auth app helper.
- deployment.go 591-592 / 610-611 / 626-627: the fmt.Errorf error returns of
  MarkDeploymentScaledToZero / WakeDeployment / SetDeploymentAlwaysOn. Add
  sqlmock-driven *_DriverError tests (the happy + CAS/RowsAffected paths are
  already covered by the real-DB tests).

Test-only; no production code change. Flag remains default-OFF.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mastermanas805

internal/config/config_test.go

@@ -63,6 +63,7 @@ func allKeys() []string {
 		"METRICS_TOKEN", "DASHBOARD_BASE_URL", "API_PUBLIC_URL",
 		"DELETION_CONFIRMATION_TTL_MINUTES", "FAMILY_BINDINGS_ENABLED",
 		"DEPLOY_SOURCE_IMAGE_ENABLED", "DEPLOY_SOURCE_GIT_ENABLED",
+		"DEPLOY_SCALE_TO_ZERO_ENABLED",
 		"GITHUB_APP_ENABLED", "GITHUB_APP_ID", "GITHUB_APP_SLUG", "GITHUB_APP_PRIVATE_KEY",
 		"GITHUB_APP_WEBHOOK_SECRET", "GITHUB_APP_CLIENT_ID", "GITHUB_APP_CLIENT_SECRET",
 		"BREVO_WEBHOOK_SECRET", "SES_SNS_SUBSCRIPTION_ARN",
@@ -387,6 +388,21 @@ func TestLoad_DeploySourceGitEnabled(t *testing.T) {
 	}
 }
 
+func TestLoad_DeployScaleToZeroEnabled(t *testing.T) {
+	for _, val := range []string{"true", "1", "yes", "TRUE", "  Yes  "} {
+		applyBaselineEnv(t, map[string]string{"DEPLOY_SCALE_TO_ZERO_ENABLED": val})
+		if !Load().DeployScaleToZeroEnabled {
+			t.Errorf("DEPLOY_SCALE_TO_ZERO_ENABLED=%q should enable", val)
+		}
+	}
+	for _, val := range []string{"false", "0", "no", "maybe", ""} {
+		applyBaselineEnv(t, map[string]string{"DEPLOY_SCALE_TO_ZERO_ENABLED": val})
+		if Load().DeployScaleToZeroEnabled {
+			t.Errorf("DEPLOY_SCALE_TO_ZERO_ENABLED=%q should stay disabled", val)
+		}
+	}
+}
+
 func TestLoad_GitHubAppEnabled(t *testing.T) {
 	// When enabling the App, Load() fails closed unless the webhook secret +
 	// private key + app id are present (review HIGH-1), so set them here.

internal/handlers/deploy_wake_mock_test.go

@@ -124,6 +124,118 @@ func wakeDeploymentRow(id, teamID uuid.UUID, appID, providerID string, scaledToZ
 	)
 }
 
+// wakeMockAppNoAuth is wakeMockApp without the team-injecting middleware, so
+// requireTeam sees an empty team_id and the handler returns 401. Used to cover
+// the `team, err := h.requireTeam(c); if err != nil { return err }` arm.
+func wakeMockAppNoAuth(t *testing.T, db *sql.DB) *fiber.App {
+	t.Helper()
+	mr, err := miniredis.Run()
+	require.NoError(t, err)
+	t.Cleanup(mr.Close)
+	rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
+	t.Cleanup(func() { _ = rdb.Close() })
+
+	h := &DeployHandler{
+		db:           db,
+		rdb:          rdb,
+		cfg:          &config.Config{DeployScaleToZeroEnabled: true, Environment: "test"},
+		compute:      &wakeRecordingProvider{},
+		planRegistry: plans.Default(),
+	}
+	app := fiber.New(fiber.Config{
+		ErrorHandler: func(c *fiber.Ctx, err error) error {
+			if errors.Is(err, ErrResponseWritten) {
+				return nil
+			}
+			code := fiber.StatusInternalServerError
+			if e, ok := err.(*fiber.Error); ok {
+				code = e.Code
+			}
+			return c.Status(code).JSON(fiber.Map{"ok": false, "error": "internal_error"})
+		},
+	})
+	app.Post("/deploy/:id/wake", h.Wake)
+	return app
+}
+
+// TestWake_RequireTeamFails covers the requireTeam error arm: no team_id in
+// Locals → 401 before any scale or DB work.
+func TestWake_RequireTeamFails(t *testing.T) {
+	db, _, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	app := wakeMockAppNoAuth(t, db)
+	req := httptest.NewRequest(http.MethodPost, "/deploy/app-noauth/wake", nil)
+	resp, err := app.Test(req, 2000)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusUnauthorized {
+		t.Fatalf("no-auth wake = %d, want 401", resp.StatusCode)
+	}
+}
+
+// TestWake_FetchDriverError503 covers the generic GetDeploymentByAppID driver
+// error arm (NOT sql.ErrNoRows) → 503 fetch_failed.
+func TestWake_FetchDriverError503(t *testing.T) {
+	db, mock, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	app, teamID := wakeMockApp(t, db, &wakeRecordingProvider{})
+	expectTeamLookupOK(mock, teamID, "hobby")
+	mock.ExpectQuery(`FROM deployments WHERE app_id = \$1`).
+		WithArgs("app-drv").
+		WillReturnError(errors.New("deployments table exploded"))
+
+	req := httptest.NewRequest(http.MethodPost, "/deploy/app-drv/wake", nil)
+	resp, err := app.Test(req, 2000)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusServiceUnavailable {
+		t.Fatalf("fetch-driver-error wake = %d, want 503", resp.StatusCode)
+	}
+}
+
+// TestWake_ReReadFailureFallsBack covers the post-write re-read failure arm:
+// scale + WakeDeployment already succeeded, so a failing GetDeploymentByID must
+// NOT fail the wake — the handler falls back to the pre-read row with
+// ScaledToZero cleared and still returns 200.
+func TestWake_ReReadFailureFallsBack(t *testing.T) {
+	db, mock, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	prov := &wakeRecordingProvider{}
+	app, teamID := wakeMockApp(t, db, prov)
+	id := uuid.New()
+
+	expectTeamLookupOK(mock, teamID, "hobby")
+	mock.ExpectQuery(`FROM deployments WHERE app_id = \$1`).
+		WithArgs("app-reread").
+		WillReturnRows(wakeDeploymentRow(id, teamID, "app-reread", "app-reread", true))
+	mock.ExpectExec(`UPDATE deployments`).
+		WithArgs(id).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+	// Re-read fails → handler must fall back, NOT 5xx.
+	mock.ExpectQuery(`FROM deployments WHERE id = \$1`).
+		WithArgs(id).
+		WillReturnError(errors.New("re-read exploded"))
+
+	req := httptest.NewRequest(http.MethodPost, "/deploy/app-reread/wake", nil)
+	resp, err := app.Test(req, 2000)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		t.Fatalf("re-read-failure wake = %d, want 200 (fallback); body: %s", resp.StatusCode, string(body))
+	}
+	if len(prov.scaleCalls) != 1 {
+		t.Errorf("expected one Scale call before re-read, got %v", prov.scaleCalls)
+	}
+	require.NoError(t, mock.ExpectationsWereMet())
+}
+
 func TestWake_HappyPath(t *testing.T) {
 	db, mock, err := sqlmock.New()
 	require.NoError(t, err)

internal/models/deployment_scale_test.go

@@ -11,9 +11,11 @@ package models_test
 
 import (
 	"context"
+	"errors"
 	"testing"
 	"time"
 
+	sqlmock "github.com/DATA-DOG/go-sqlmock"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -22,6 +24,60 @@ import (
 	"instant.dev/internal/testhelpers"
 )
 
+// errScaleDriver is the sentinel sqlmock returns for the driver-error arms of
+// the scale-to-zero model writes. Named so the wrapped %w error is searchable.
+var errScaleDriver = errors.New("mock: deployments UPDATE exploded")
+
+// TestMarkDeploymentScaledToZero_DriverError pins the error return (the
+// fmt.Errorf wrap) when the UPDATE itself fails — distinct from a 0-row CAS
+// miss, which is not an error.
+func TestMarkDeploymentScaledToZero_DriverError(t *testing.T) {
+	db, mock, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	id := uuid.New()
+	mock.ExpectExec(`UPDATE deployments`).WithArgs(id).WillReturnError(errScaleDriver)
+
+	n, err := models.MarkDeploymentScaledToZero(context.Background(), db, id)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, errScaleDriver)
+	assert.Equal(t, int64(0), n)
+	require.NoError(t, mock.ExpectationsWereMet())
+}
+
+// TestWakeDeployment_DriverError pins WakeDeployment's error return.
+func TestWakeDeployment_DriverError(t *testing.T) {
+	db, mock, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	id := uuid.New()
+	mock.ExpectExec(`UPDATE deployments`).WithArgs(id).WillReturnError(errScaleDriver)
+
+	n, err := models.WakeDeployment(context.Background(), db, id)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, errScaleDriver)
+	assert.Equal(t, int64(0), n)
+	require.NoError(t, mock.ExpectationsWereMet())
+}
+
+// TestSetDeploymentAlwaysOn_DriverError pins SetDeploymentAlwaysOn's error return.
+func TestSetDeploymentAlwaysOn_DriverError(t *testing.T) {
+	db, mock, err := sqlmock.New()
+	require.NoError(t, err)
+	defer db.Close()
+
+	id := uuid.New()
+	mock.ExpectExec(`UPDATE deployments`).WithArgs(id, true).WillReturnError(errScaleDriver)
+
+	n, err := models.SetDeploymentAlwaysOn(context.Background(), db, id, true)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, errScaleDriver)
+	assert.Equal(t, int64(0), n)
+	require.NoError(t, mock.ExpectationsWereMet())
+}
+
 func TestCreateDeployment_SeedsScaleToZeroDefaults(t *testing.T) {
 	requireDB(t)
 	db, cleanDB := testhelpers.SetupTestDB(t)