pkg/testinstance/postgres.go (3)

44-48: Use the existing ctx for Stop/Start

Minor clean-up for consistency.

-err = postgres.Stop(context.Background(), &stopTimeout)
+err = postgres.Stop(ctx, &stopTimeout)

-err = postgres.Start(context.Background())
+err = postgres.Start(ctx)

---

58-59: MappedPort should include protocol

Be explicit with “/tcp” to match the exposed port and avoid surprises on different testcontainers/go versions.

-port, err := postgres.MappedPort(ctx, "5432")
+port, err := postgres.MappedPort(ctx, "5432/tcp")

---

25-37: Add test-scoped container cleanup

Terminate the container via Ginkgo’s DeferCleanup to prevent orphaned containers when tests fail or panic.

 import (
+   ginkgo "github.com/onsi/ginkgo/v2"
 )

 postgres, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
   ...
 })
 Expect(err).ShouldNot(HaveOccurred())
+
+// Ensure container is torn down after the test scope
+ginkgo.DeferCleanup(func() {
+  _ = postgres.Terminate(ctx)
+})

internal/storage/postgres/watch_test.go (1)

59-61: Reduce flakiness by replacing sleeps with Eventually/Receive

Sleeping before writes and using long timeouts can cause flaky tests. Prefer Eventually on channels.

- time.Sleep(100 * time.Millisecond)
+ // Wait until watcher emits a change or error
+ Eventually(changes, 10*time.Second, 100*time.Millisecond).Should(Receive())

Also applies to: 94-100

internal/storage/postgres/dataReader_test.go (1)

73-79: Avoid shadowing the imported package name and reduce timestamp flakiness.

• The local var token shadows the imported package token; rename for clarity.
• 2ms sleep is tight and may flake under load; bump slightly.

Apply this diff:

-            token, err := dataWriter.Write(ctx, "t1", tuples, attributes)
+            snap, err := dataWriter.Write(ctx, "t1", tuples, attributes)
             Expect(err).ShouldNot(HaveOccurred())

-            mostRecentSnapshot = token
+            mostRecentSnapshot = snap

-            time.Sleep(time.Millisecond * 2)
+            time.Sleep(10 * time.Millisecond)

internal/storage/postgres/utils/version_test.go (1)

92-101: Consider limiting multi-version spins to keep CI fast.

Spinning 13/14/15/16 sequentially can be heavy. Optionally gate via a Ginkgo label or sample a single version when POSTGRES_VERSION is unset.

pkg/database/postgres/repair.go (2)

46-63: Populate result.Duration to reflect actual run time.

You already expose Duration; set it.

Apply this diff (and add time import):

 import (
     "context"
     "fmt"
     "log/slog"
+    "time"
 )
@@
 func (p *Postgres) Repair(ctx context.Context, config *RepairConfig) (*RepairResult, error) {
+    started := time.Now()
     if config == nil {
         config = DefaultRepairConfig()
     }
@@
-    return result, nil
+    result.Duration = time.Since(started).String()
+    return result, nil
 }

---

16-23: Config has unused fields (MaxRetries, RetryDelay).

Either wire them into advanceXIDCounterByDelta with simple retry/backoff or drop them to avoid dead config.

internal/storage/postgres/gc/gc_test.go (1)

52-53: Speed up tests by shrinking GC window.

A 5s window + sleeps slows CI. Consider a smaller window and matching sleep.

Example diff:

-        Window(5*time.Second),
+        Window(200*time.Millisecond),
@@
-            time.Sleep(5 * time.Second) // Pause for 5 seconds
+            time.Sleep(250 * time.Millisecond) // window + small buffer
@@
-            time.Sleep(5 * time.Second) // Pause for 5 seconds
+            time.Sleep(250 * time.Millisecond) // window + small buffer

Also applies to: 180-182, 305-307

pkg/database/postgres/repair_test.go (2)

70-78: Make cleanup assertions explicit.

Checking Terminate/Close results helps surface cleanup failures.

Apply this diff:

-        if db != nil {
-            db.Close()
-        }
-        if container != nil {
-            ctx := context.Background()
-            container.Terminate(ctx)
-        }
+        if db != nil {
+            Expect(db.Close()).ShouldNot(HaveOccurred())
+        }
+        if container != nil {
+            ctx := context.Background()
+            Expect(container.Terminate(ctx)).ShouldNot(HaveOccurred())
+        }

---

181-189: Tiny nit: multi-line VALUES indentation.

Purely stylistic; consider compact formatting to reduce vertical space.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro