test(features): R50 — repo contract suites assert span shape per method

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

packages/auth/src/__contracts__/users-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { IUsersRepository } from "../application/repositories/users.repository.interface.js";
 import { userFactory } from "../__factories__/user.factory.js";
@@ -6,7 +6,7 @@ import { userFactory } from "../__factories__/user.factory.js";
 export const usersRepositoryContract =
   defineContractSuite<IUsersRepository>(
     "IUsersRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: IUsersRepository;
 
       beforeEach(async () => {
@@ -52,5 +52,40 @@ export const usersRepositoryContract =
         expect(created.id).toBe(seed.id);
         expect(created.username).toBe("carol");
       });
+
+      describe("span emission (R50)", () => {
+        it("getUser emits users.getUser span with id attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getUser("nonexistent");
+          const span = tracer.findSpan("users.getUser");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe("nonexistent");
+        });
+
+        it("getUserByUsername emits users.getUserByUsername span", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getUserByUsername("alice");
+          const span = tracer.findSpan("users.getUserByUsername");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+        });
+
+        it("createUser emits users.createUser span with id attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          const seed = userFactory.build({ username: "span-test-user" });
+          await repo.createUser(seed);
+          const span = tracer.findSpan("users.createUser");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe(seed.id);
+        });
+      });
     },
   );

packages/auth/src/infrastructure/repositories/users.repository.mock.test.ts

@@ -1,8 +1,13 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockUsersRepository } from "@/infrastructure/repositories/users.repository.mock";
 import { usersRepositoryContract } from "@/__contracts__/users-repository.contract";
 
 describe("MockUsersRepository", () => {
+  const tracer = new RecordingTracer();
   // Start with empty store so contract tests run from a clean slate.
-  usersRepositoryContract.run(() => new MockUsersRepository([]));
+  usersRepositoryContract.run(
+    () => new MockUsersRepository([], tracer),
+    { tracer: () => tracer },
+  );
 });

packages/auth/src/infrastructure/repositories/users.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, vi, beforeEach } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { UsersRepository } from "@/infrastructure/repositories/users.repository";
 import { usersRepositoryContract } from "@/__contracts__/users-repository.contract";
 import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
@@ -48,15 +49,20 @@ function buildPayloadStub() {
 
 describe("UsersRepository", () => {
   describe("contract", () => {
+    const tracer = new RecordingTracer();
+
     beforeEach(() => {
       vi.clearAllMocks();
     });
 
-    usersRepositoryContract.run(async () => {
+    usersRepositoryContract.run(
+      async () => {
         const stub = buildPayloadStub();
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new UsersRepository(stubPayloadConfig);
+        return new UsersRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 });

packages/blog/src/__contracts__/articles-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { IArticlesRepository } from "../application/repositories/articles.repository.interface.js";
 import { articleFactory } from "../__factories__/article.factory.js";
@@ -6,7 +6,7 @@ import { articleFactory } from "../__factories__/article.factory.js";
 export const articlesRepositoryContract =
   defineContractSuite<IArticlesRepository>(
     "IArticlesRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: IArticlesRepository;
 
       beforeEach(async () => {
@@ -116,5 +116,65 @@ export const articlesRepositoryContract =
         });
         expect(result).toBeUndefined();
       });
+
+      describe("span emission (R50)", () => {
+        it("getArticles emits articles.getArticles span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getArticles({ limit: 5 });
+          const span = tracer.findSpan("articles.getArticles");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.limit).toBe(5);
+        });
+
+        it("getArticle emits articles.getArticle span with id attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getArticle("nonexistent");
+          const span = tracer.findSpan("articles.getArticle");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe("nonexistent");
+        });
+
+        it("getArticleBySlug emits articles.getArticleBySlug span with slug attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getArticleBySlug("nonexistent");
+          const span = tracer.findSpan("articles.getArticleBySlug");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.slug).toBe("nonexistent");
+        });
+
+        it("createArticle emits articles.createArticle span", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          const seed = articleFactory.build();
+          await repo.createArticle(seed);
+          const span = tracer.findSpan("articles.createArticle");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.slug).toBe(seed.slug);
+        });
+
+        it("updateArticle emits articles.updateArticle span", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          const seed = articleFactory.build();
+          const created = await repo.createArticle(seed);
+          await repo.updateArticle(created.id, { title: "Updated" });
+          const span = tracer.findSpan("articles.updateArticle");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe(created.id);
+        });
+      });
     },
   );

packages/blog/src/infrastructure/repositories/articles.repository.mock.test.ts

@@ -1,7 +1,12 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockArticlesRepository } from "@/infrastructure/repositories/articles.repository.mock";
 import { articlesRepositoryContract } from "@/__contracts__/articles-repository.contract";
 
 describe("MockArticlesRepository", () => {
-  articlesRepositoryContract.run(() => new MockArticlesRepository());
+  const tracer = new RecordingTracer();
+  articlesRepositoryContract.run(
+    () => new MockArticlesRepository(tracer),
+    { tracer: () => tracer },
+  );
 });

packages/blog/src/infrastructure/repositories/articles.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { ArticlesRepository } from "@/infrastructure/repositories/articles.repository";
 import { articlesRepositoryContract } from "@/__contracts__/articles-repository.contract";
 import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
@@ -102,12 +103,16 @@ vi.mock("payload", () => ({
 
 describe("ArticlesRepository", () => {
   describe("contract", () => {
-    articlesRepositoryContract.run(async () => {
+    const tracer = new RecordingTracer();
+    articlesRepositoryContract.run(
+      async () => {
         const stub = buildPayloadStub();
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new ArticlesRepository(stubPayloadConfig);
+        return new ArticlesRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 
   // -------------------------------------------------------------------------

packages/marketing-pages/src/__contracts__/pages-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { IPagesRepository } from "../application/repositories/pages.repository.interface.js";
 import type { Page } from "../entities/models/page.js";
@@ -47,7 +47,7 @@ export const CONTRACT_PAGES_SEED: Page[] = [
 export const pagesRepositoryContract =
   defineContractSuite<IPagesRepository>(
     "IPagesRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: IPagesRepository;
 
       beforeEach(async () => {
@@ -95,5 +95,29 @@ export const pagesRepositoryContract =
           expect(page.status).toBe("draft");
         }
       });
+
+      describe("span emission (R50)", () => {
+        it("getPageBySlug emits pages.getPageBySlug span with slug attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getPageBySlug("about");
+          const span = tracer.findSpan("pages.getPageBySlug");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.slug).toBe("about");
+        });
+
+        it("getPages emits pages.getPages span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getPages({ status: "published" });
+          const span = tracer.findSpan("pages.getPages");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.status).toBe("published");
+        });
+      });
     },
   );

packages/marketing-pages/src/__contracts__/site-settings-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { ISiteSettingsRepository } from "../application/repositories/site-settings.repository.interface.js";
 
@@ -11,7 +11,7 @@ import type { ISiteSettingsRepository } from "../application/repositories/site-s
 export const siteSettingsRepositoryContract =
   defineContractSuite<ISiteSettingsRepository>(
     "ISiteSettingsRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: ISiteSettingsRepository;
 
       beforeEach(async () => {
@@ -34,5 +34,17 @@ export const siteSettingsRepositoryContract =
             typeof settings.siteDescription === "string",
         ).toBe(true);
       });
+
+      describe("span emission (R50)", () => {
+        it("getSiteSettings emits site-settings.getSiteSettings span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getSiteSettings();
+          const span = tracer.findSpan("site-settings.getSiteSettings");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+        });
+      });
     },
   );

packages/marketing-pages/src/infrastructure/repositories/pages.repository.mock.test.ts

@@ -1,4 +1,5 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
 import {
   pagesRepositoryContract,
@@ -6,7 +7,11 @@ import {
 } from "@/__contracts__/pages-repository.contract";
 
 describe("MockPagesRepository", () => {
+  const tracer = new RecordingTracer();
   // Pre-seed with the contract fixtures so the contract assertions find what
   // they expect (an "about" published page and a "draft-page" draft page).
-  pagesRepositoryContract.run(() => new MockPagesRepository(CONTRACT_PAGES_SEED));
+  pagesRepositoryContract.run(
+    () => new MockPagesRepository(CONTRACT_PAGES_SEED, tracer),
+    { tracer: () => tracer },
+  );
 });

packages/marketing-pages/src/infrastructure/repositories/pages.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { PagesRepository } from "@/infrastructure/repositories/pages.repository";
 import {
   pagesRepositoryContract,
@@ -73,11 +74,15 @@ vi.mock("payload", () => ({
 
 describe("PagesRepository", () => {
   describe("contract", () => {
-    pagesRepositoryContract.run(async () => {
+    const tracer = new RecordingTracer();
+    pagesRepositoryContract.run(
+      async () => {
         const stub = buildPayloadPagesStub(CONTRACT_PAGES_SEED);
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new PagesRepository(stubPayloadConfig);
+        return new PagesRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 });

packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.mock.test.ts

@@ -1,7 +1,12 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
 import { siteSettingsRepositoryContract } from "@/__contracts__/site-settings-repository.contract";
 
 describe("MockSiteSettingsRepository", () => {
-  siteSettingsRepositoryContract.run(() => new MockSiteSettingsRepository());
+  const tracer = new RecordingTracer();
+  siteSettingsRepositoryContract.run(
+    () => new MockSiteSettingsRepository(tracer),
+    { tracer: () => tracer },
+  );
 });

packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { SiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository";
 import { siteSettingsRepositoryContract } from "@/__contracts__/site-settings-repository.contract";
 import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
@@ -30,11 +31,15 @@ vi.mock("payload", () => ({
 
 describe("SiteSettingsRepository", () => {
   describe("contract", () => {
-    siteSettingsRepositoryContract.run(async () => {
+    const tracer = new RecordingTracer();
+    siteSettingsRepositoryContract.run(
+      async () => {
         const stub = buildSiteSettingsStub();
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new SiteSettingsRepository(stubPayloadConfig);
+        return new SiteSettingsRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 });

packages/media/src/__contracts__/media-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { IMediaRepository } from "../application/repositories/media.repository.interface.js";
 import { mediaFactory } from "../__factories__/media.factory.js";
@@ -6,7 +6,7 @@ import { mediaFactory } from "../__factories__/media.factory.js";
 export const mediaRepositoryContract =
   defineContractSuite<IMediaRepository>(
     "IMediaRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: IMediaRepository;
 
       beforeEach(async () => {
@@ -57,5 +57,40 @@ export const mediaRepositoryContract =
         const result = await repo.getMedia("");
         expect(result).toBeUndefined();
       });
+
+      describe("span emission (R50)", () => {
+        it("getMedia emits media.getMedia span with id attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getMedia("nonexistent");
+          const span = tracer.findSpan("media.getMedia");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe("nonexistent");
+        });
+
+        it("listMedia emits media.listMedia span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.listMedia({ limit: 10 });
+          const span = tracer.findSpan("media.listMedia");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.limit).toBe(10);
+        });
+
+        it("deleteMedia emits media.deleteMedia span with id attribute", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.deleteMedia("nonexistent");
+          const span = tracer.findSpan("media.deleteMedia");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+          expect(span!.attributes.id).toBe("nonexistent");
+        });
+      });
     },
   );

packages/media/src/infrastructure/repositories/media.repository.mock.test.ts

@@ -1,7 +1,12 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockMediaRepository } from "@/infrastructure/repositories/media.repository.mock";
 import { mediaRepositoryContract } from "@/__contracts__/media-repository.contract";
 
 describe("MockMediaRepository", () => {
-  mediaRepositoryContract.run(() => new MockMediaRepository());
+  const tracer = new RecordingTracer();
+  mediaRepositoryContract.run(
+    () => new MockMediaRepository(tracer),
+    { tracer: () => tracer },
+  );
 });

packages/media/src/infrastructure/repositories/media.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MediaRepository } from "@/infrastructure/repositories/media.repository";
 import { mediaRepositoryContract } from "@/__contracts__/media-repository.contract";
 import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
@@ -58,12 +59,16 @@ vi.mock("payload", () => ({
 
 describe("MediaRepository", () => {
   describe("contract", () => {
-    mediaRepositoryContract.run(async () => {
+    const tracer = new RecordingTracer();
+    mediaRepositoryContract.run(
+      async () => {
         const stub = buildPayloadStub();
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new MediaRepository(stubPayloadConfig);
+        return new MediaRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 
   // -------------------------------------------------------------------------

packages/navigation/src/__contracts__/header-repository.contract.ts

@@ -1,4 +1,4 @@
-import { it, expect, beforeEach } from "vitest";
+import { it, expect, beforeEach, describe } from "vitest";
 import { defineContractSuite } from "@repo/core-testing/contract";
 import type { IHeaderRepository } from "../application/repositories/header.repository.interface.js";
 import type { Header } from "../entities/models/header.js";
@@ -25,7 +25,7 @@ export const CONTRACT_HEADER_SEED: Header = {
 export const headerRepositoryContract =
   defineContractSuite<IHeaderRepository>(
     "IHeaderRepository",
-    ({ buildSubject }) => {
+    ({ buildSubject, getTracer }) => {
       let repo: IHeaderRepository;
 
       beforeEach(async () => {
@@ -71,5 +71,17 @@ export const headerRepositoryContract =
           header.logoId === undefined || typeof header.logoId === "string",
         ).toBe(true);
       });
+
+      describe("span emission (R50)", () => {
+        it("getHeader emits header.getHeader span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getHeader();
+          const span = tracer.findSpan("header.getHeader");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+        });
+      });
     },
   );

packages/navigation/src/infrastructure/repositories/header.repository.mock.test.ts

@@ -1,7 +1,12 @@
 import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { MockHeaderRepository } from "@/infrastructure/repositories/header.repository.mock";
 import { headerRepositoryContract, CONTRACT_HEADER_SEED } from "@/__contracts__/header-repository.contract";
 
 describe("MockHeaderRepository", () => {
-  headerRepositoryContract.run(() => new MockHeaderRepository(CONTRACT_HEADER_SEED));
+  const tracer = new RecordingTracer();
+  headerRepositoryContract.run(
+    () => new MockHeaderRepository(CONTRACT_HEADER_SEED, tracer),
+    { tracer: () => tracer },
+  );
 });

packages/navigation/src/infrastructure/repositories/header.repository.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
 import { HeaderRepository } from "@/infrastructure/repositories/header.repository";
 import { headerRepositoryContract, CONTRACT_HEADER_SEED } from "@/__contracts__/header-repository.contract";
 import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
@@ -25,12 +26,16 @@ vi.mock("payload", () => ({
 
 describe("HeaderRepository", () => {
   describe("contract", () => {
-    headerRepositoryContract.run(async () => {
+    const tracer = new RecordingTracer();
+    headerRepositoryContract.run(
+      async () => {
         const stub = buildHeaderStub();
         const { getPayload } = await import("payload");
         (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
-      return new HeaderRepository(stubPayloadConfig);
+        return new HeaderRepository(stubPayloadConfig, tracer);
-    });
+      },
+      { tracer: () => tracer },
+    );
   });
 
   // ---------------------------------------------------------------------------