@wibly/internal-manifest 0.1.1

package/src/manifest.test.ts

@@ -0,0 +1,351 @@
+import { describe, expect, it } from 'vitest';
+
+import { cloneFixture, validManifestFixture } from './fixtures.js';
+import {
+  ContentRatingSchema,
+  InferenceEnvelopeSchema,
+  ManifestIdSchema,
+  ManifestSchema,
+  PersonaBindingSchema,
+  PersonaIdSchema,
+  PortalMetadataSchema,
+  PromptSlotsSchema,
+  PromptSlotValueSchema,
+} from './manifest.js';
+
+describe('ManifestIdSchema / PersonaIdSchema', () => {
+  it('accepts a well-formed exp_ id', () => {
+    expect(ManifestIdSchema.safeParse('exp_abc123_-').success).toBe(true);
+  });
+
+  it('rejects a bare nanoid (missing prefix)', () => {
+    expect(ManifestIdSchema.safeParse('abc123').success).toBe(false);
+  });
+
+  it('rejects the wrong prefix', () => {
+    expect(ManifestIdSchema.safeParse('tnt_abc123').success).toBe(false);
+  });
+
+  it('accepts a per_ persona id', () => {
+    expect(PersonaIdSchema.safeParse('per_abc123').success).toBe(true);
+  });
+
+  it('rejects a non-per_ persona id', () => {
+    expect(PersonaIdSchema.safeParse('plr_abc123').success).toBe(false);
+  });
+});
+
+describe('PersonaBindingSchema', () => {
+  it('accepts a well-formed binding', () => {
+    expect(
+      PersonaBindingSchema.safeParse({ role: 'host', personaId: 'per_abc' })
+        .success,
+    ).toBe(true);
+  });
+
+  it('rejects an empty role', () => {
+    expect(
+      PersonaBindingSchema.safeParse({ role: '', personaId: 'per_abc' })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects a malformed personaId', () => {
+    expect(
+      PersonaBindingSchema.safeParse({ role: 'host', personaId: 'abc' })
+        .success,
+    ).toBe(false);
+  });
+});
+
+describe('InferenceEnvelopeSchema', () => {
+  const baseline = {
+    maxLlmCallsPerSession: 10,
+    maxTokensInPerCall: 1024,
+    maxTokensOutPerCall: 512,
+    maxTtsSecondsPerSession: 60,
+    qualityTiers: ['standard'],
+  };
+
+  it('accepts a complete envelope', () => {
+    expect(InferenceEnvelopeSchema.safeParse(baseline).success).toBe(true);
+  });
+
+  it('rejects a zero call budget (the inference envelope is non-zero rule)', () => {
+    expect(
+      InferenceEnvelopeSchema.safeParse({ ...baseline, maxLlmCallsPerSession: 0 })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects a zero token-in cap', () => {
+    expect(
+      InferenceEnvelopeSchema.safeParse({ ...baseline, maxTokensInPerCall: 0 })
+        .success,
+    ).toBe(false);
+  });
+
+  it('allows zero TTS seconds (no-TTS Experience)', () => {
+    expect(
+      InferenceEnvelopeSchema.safeParse({
+        ...baseline,
+        maxTtsSecondsPerSession: 0,
+      }).success,
+    ).toBe(true);
+  });
+
+  it('rejects an empty quality-tier set', () => {
+    expect(
+      InferenceEnvelopeSchema.safeParse({ ...baseline, qualityTiers: [] })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects an unknown quality tier', () => {
+    expect(
+      InferenceEnvelopeSchema.safeParse({
+        ...baseline,
+        qualityTiers: ['ultra'],
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe('PromptSlotValueSchema / PromptSlotsSchema', () => {
+  it('accepts a literal string slot', () => {
+    expect(PromptSlotValueSchema.safeParse('hi there').success).toBe(true);
+  });
+
+  it('accepts a templated slot with vars', () => {
+    expect(
+      PromptSlotValueSchema.safeParse({
+        template: 'You have {count} cards',
+        vars: ['count'],
+      }).success,
+    ).toBe(true);
+  });
+
+  it('accepts a templated slot without vars', () => {
+    expect(
+      PromptSlotValueSchema.safeParse({ template: 'Welcome' }).success,
+    ).toBe(true);
+  });
+
+  it('rejects a templated slot with empty vars array (use a literal instead)', () => {
+    expect(
+      PromptSlotValueSchema.safeParse({ template: 'Welcome', vars: [] })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects a callTypes key outside the known callKind set', () => {
+    expect(
+      PromptSlotsSchema.safeParse({
+        experienceSystem: 'sys',
+        callTypes: { unknown_kind: 'hello' },
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe('ContentRatingSchema', () => {
+  it('accepts none / consumer', () => {
+    expect(
+      ContentRatingSchema.safeParse({
+        tier: 'none',
+        audiences: ['consumer'],
+      }).success,
+    ).toBe(true);
+  });
+
+  it('rejects an empty audience set', () => {
+    expect(
+      ContentRatingSchema.safeParse({ tier: 'none', audiences: [] }).success,
+    ).toBe(false);
+  });
+
+  it('rejects an unknown tier', () => {
+    expect(
+      ContentRatingSchema.safeParse({ tier: 'r-rated', audiences: ['consumer'] })
+        .success,
+    ).toBe(false);
+  });
+});
+
+describe('PortalMetadataSchema (chunk B11)', () => {
+  const baseline = {
+    heroImageUrl: 'https://assets.wibly.example/hero.png',
+    sampleRoundDescription: 'One brief paragraph.',
+    occasionTags: ['party'],
+  } as const;
+
+  it('accepts the baseline (required-only) shape', () => {
+    expect(PortalMetadataSchema.safeParse(baseline).success).toBe(true);
+  });
+
+  it('accepts gameplay images and video', () => {
+    expect(
+      PortalMetadataSchema.safeParse({
+        ...baseline,
+        gameplayImages: [
+          {
+            title: 'Round one',
+            imageUrl: 'https://assets.wibly.example/round1.png',
+          },
+        ],
+        gameplayVideo: {
+          title: 'Trailer',
+          videoUrl: 'https://assets.wibly.example/trailer.mp4',
+        },
+        personaPreviewAudioUrl: 'https://assets.wibly.example/persona.mp3',
+      }).success,
+    ).toBe(true);
+  });
+
+  it('rejects a missing heroImageUrl', () => {
+    const fixture: Record<string, unknown> = { ...baseline };
+    delete fixture.heroImageUrl;
+    expect(PortalMetadataSchema.safeParse(fixture).success).toBe(false);
+  });
+
+  it('rejects a heroImageUrl that is not a URL', () => {
+    expect(
+      PortalMetadataSchema.safeParse({ ...baseline, heroImageUrl: 'not a url' })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects a missing sampleRoundDescription', () => {
+    const fixture: Record<string, unknown> = { ...baseline };
+    delete fixture.sampleRoundDescription;
+    expect(PortalMetadataSchema.safeParse(fixture).success).toBe(false);
+  });
+
+  it('rejects an empty sampleRoundDescription', () => {
+    expect(
+      PortalMetadataSchema.safeParse({ ...baseline, sampleRoundDescription: '' })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects an empty occasionTags array', () => {
+    expect(
+      PortalMetadataSchema.safeParse({ ...baseline, occasionTags: [] }).success,
+    ).toBe(false);
+  });
+
+  it('rejects an unknown occasion tag', () => {
+    expect(
+      PortalMetadataSchema.safeParse({
+        ...baseline,
+        occasionTags: ['hen_party'],
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe('ManifestSchema — required fields', () => {
+  it('accepts the baseline fixture', () => {
+    const result = ManifestSchema.safeParse(validManifestFixture);
+    expect(result.success).toBe(true);
+  });
+
+  // One test per top-level required field, removed in isolation.
+  const REQUIRED_FIELDS = [
+    'id',
+    'version',
+    'name',
+    'description',
+    'creator',
+    'createdAt',
+    'personaBindings',
+    'inferenceEnvelope',
+    'stateSchema',
+    'workflow',
+    'concurrentOpportunities',
+    'scoring',
+    'lifecyclePolicies',
+    'promptSlots',
+    'fallbackResponses',
+    'widgetDependencies',
+    'contentRating',
+    'portalMetadata',
+  ] as const;
+
+  for (const field of REQUIRED_FIELDS) {
+    it(`rejects a manifest missing '${field}' with a useful located error`, () => {
+      const fixture: Record<string, unknown> = cloneFixture();
+      delete fixture[field];
+      const result = ManifestSchema.safeParse(fixture);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(
+          result.error.issues.some((issue) => issue.path[0] === field),
+        ).toBe(true);
+      }
+    });
+  }
+});
+
+describe('ManifestSchema — bundle reservations (Chunk B18)', () => {
+  it('accepts the baseline fixture without bundle fields', () => {
+    const result = ManifestSchema.safeParse(validManifestFixture);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.bundleCompatible).toBeUndefined();
+      expect(result.data.bundleScopedDimensions).toBeUndefined();
+    }
+  });
+
+  it('accepts bundle fields and applies defaults on parse', () => {
+    const fixture = {
+      ...cloneFixture(),
+      bundleCompatible: true,
+      bundleScopedDimensions: ['score'],
+      bundleWriteDimensions: ['notes'],
+      bundleContextSlots: { theme: 'party' },
+    };
+    const result = ManifestSchema.safeParse(fixture);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.bundleCompatible).toBe(true);
+      expect(result.data.bundleScopedDimensions).toEqual(['score']);
+      expect(result.data.bundleWriteDimensions).toEqual(['notes']);
+      expect(result.data.bundleContextSlots).toEqual({ theme: 'party' });
+    }
+  });
+
+  it('rejects a non-array bundleScopedDimensions', () => {
+    const fixture: Record<string, unknown> = cloneFixture();
+    fixture.bundleScopedDimensions = 'not-an-array';
+    expect(ManifestSchema.safeParse(fixture).success).toBe(false);
+  });
+});
+
+describe('ManifestSchema — optional fields', () => {
+  it('accepts a manifest with `tenant` set to null (first-party Experience)', () => {
+    const fixture = cloneFixture();
+    fixture.tenant = null;
+    expect(ManifestSchema.safeParse(fixture).success).toBe(true);
+  });
+
+  it('accepts a manifest with `tenant` omitted', () => {
+    const fixture: Record<string, unknown> = cloneFixture();
+    delete fixture.tenant;
+    expect(ManifestSchema.safeParse(fixture).success).toBe(true);
+  });
+
+  it('rejects a malformed `tenant` id', () => {
+    const fixture = cloneFixture() as { tenant?: unknown };
+    fixture.tenant = 'not-a-tenant-id';
+    expect(ManifestSchema.safeParse(fixture).success).toBe(false);
+  });
+});
+
+describe('ManifestSchema — createdAt format', () => {
+  it('rejects a non-ISO-8601 createdAt', () => {
+    const fixture = cloneFixture();
+    fixture.createdAt = 'last Tuesday';
+    expect(ManifestSchema.safeParse(fixture).success).toBe(false);
+  });
+});