chore: Improve test coverage

Author: jkuelz

src/shared/declaration/__tests__/transformer.test.ts

@@ -0,0 +1,59 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { describe, test, expect } from 'vitest';
+import { MinimalTransformer } from '../transformer';
+import Stylesheet, { Rule, Declaration } from '../stylesheet';
+
+describe('MinimalTransformer', () => {
+  test('removes empty global selector rules', () => {
+    const stylesheet = new Stylesheet();
+    const rootRule = new Rule(':root');
+    rootRule.appendDeclaration(new Declaration('--color', 'blue'));
+    stylesheet.appendRuleWithPath(rootRule, []);
+
+    const childRule = new Rule('body');
+    childRule.appendDeclaration(new Declaration('--color', 'blue'));
+    stylesheet.appendRuleWithPath(childRule, [rootRule]);
+
+    const transformer = new MinimalTransformer();
+    const result = transformer.transform(stylesheet);
+
+    expect(result.getAllRules().length).toBe(1);
+    expect(result.findRule(':root')).toBeDefined();
+    expect(result.findRule('body')).toBeUndefined();
+  });
+
+  test('keeps non-empty global selector rules', () => {
+    const stylesheet = new Stylesheet();
+    const rootRule = new Rule(':root');
+    rootRule.appendDeclaration(new Declaration('--color', 'blue'));
+    stylesheet.appendRuleWithPath(rootRule, []);
+
+    const childRule = new Rule('html');
+    childRule.appendDeclaration(new Declaration('--color', 'red'));
+    stylesheet.appendRuleWithPath(childRule, [rootRule]);
+
+    const transformer = new MinimalTransformer();
+    const result = transformer.transform(stylesheet);
+
+    expect(result.getAllRules().length).toBe(2);
+    expect(result.findRule('html')?.size()).toBe(1);
+  });
+
+  test('removes empty non-global selector rules', () => {
+    const stylesheet = new Stylesheet();
+    const rootRule = new Rule(':root');
+    rootRule.appendDeclaration(new Declaration('--color', 'blue'));
+    stylesheet.appendRuleWithPath(rootRule, []);
+
+    const childRule = new Rule('.child');
+    childRule.appendDeclaration(new Declaration('--color', 'blue'));
+    stylesheet.appendRuleWithPath(childRule, [rootRule]);
+
+    const transformer = new MinimalTransformer();
+    const result = transformer.transform(stylesheet);
+
+    expect(result.getAllRules().length).toBe(1);
+    expect(result.findRule('.child')).toBeUndefined();
+  });
+});

src/shared/theme/__tests__/builder.test.ts

@@ -78,3 +78,19 @@ test('theme adds reference tokens', () => {
     colorWarning400: '#ff9900',
   });
 });
+
+test('theme adds reference tokens with mode', () => {
+  builder.addReferenceTokens(
+    {
+      color: {
+        primary: { 500: { default: '#0073bb', optional: '#66b3ff' } },
+      },
+    },
+    mode
+  );
+
+  const theme = builder.build();
+
+  expect(theme.tokens.colorPrimary500).toEqual({ default: '#0073bb', optional: '#66b3ff' });
+  expect(theme.tokenModeMap.colorPrimary500).toBe('mode');
+});

src/shared/theme/__tests__/process.test.ts

@@ -11,6 +11,12 @@ vi.mock('../color-generation/hct-utils', () => ({
   hexToHct: vi.fn((hex: string) => ({ hue: 180, chroma: 50, tone: 50 })),
   hctToHex: vi.fn(() => '#008080'),
   createHct: vi.fn((hue: number, chroma: number, tone: number) => ({ hue, chroma, tone })),
+  Hct: class Hct {
+    constructor(public hue: number, public chroma: number, public tone: number) {}
+    static from(hue: number, chroma: number, tone: number) {
+      return new Hct(hue, chroma, tone);
+    }
+  },
 }));
 
 describe('processReferenceTokens', () => {
@@ -166,4 +172,32 @@ describe('processColorPaletteInput', () => {
 
     expect(result).toEqual({});
   });
+
+  test('processes mode-based seed input', () => {
+    const input = {
+      seed: {
+        light: '#0073bb',
+        dark: '#66b3ff',
+      },
+    };
+
+    const result = processColorPaletteInput('primary', input);
+
+    // Should generate palette with mode values
+    expect(result[500]).toEqual({ light: '#008080', dark: '#008080' });
+  });
+
+  test('skips non-string seed values in mode objects', () => {
+    const input = {
+      seed: {
+        light: '#0073bb',
+        dark: null as any,
+      },
+    };
+
+    const result = processColorPaletteInput('primary', input);
+
+    // Should only process light mode
+    expect(result[500]).toEqual({ light: '#008080' });
+  });
 });

src/shared/theme/__tests__/resolve.test.ts

@@ -8,8 +8,10 @@ import {
   themesWithCircularDependencies,
   themeWithNonExistingToken,
   themeWithTokenWithoutModeResolution,
+  colorMode,
 } from '../../../__fixtures__/common';
-import { resolveTheme, resolveThemeWithPaths } from '../resolve';
+import { resolveTheme, resolveThemeWithPaths, resolveContext } from '../resolve';
+import { Theme, Context } from '../interfaces';
 
 describe('resolve', () => {
   test('resolves theme to full resolution', () => {
@@ -43,3 +45,100 @@ describe('resolve', () => {
     );
   });
 });
+
+describe('resolveContext', () => {
+  test('resolves context without defaultMode', () => {
+    const theme: Theme = {
+      id: 'test',
+      selector: 'body',
+      tokens: { color: 'blue' },
+      tokenModeMap: {},
+      contexts: {},
+      modes: {},
+    };
+
+    const context: Context = {
+      id: 'ctx',
+      selector: '.ctx',
+      tokens: { color: 'red' },
+    };
+
+    const result = resolveContext(theme, context);
+    expect(result.color).toBe('red');
+  });
+
+  test('resolves context with defaultMode', () => {
+    const theme: Theme = {
+      id: 'test',
+      selector: 'body',
+      tokens: { color: { light: 'purple', dark: 'blue' } },
+      tokenModeMap: { color: 'color' },
+      contexts: {},
+      modes: { color: colorMode },
+    };
+
+    const context: Context = {
+      id: 'ctx',
+      selector: '.ctx',
+      tokens: {},
+      defaultMode: 'dark',
+    };
+
+    const result = resolveContext(theme, context);
+    expect(result.color).toEqual({ light: 'purple', dark: 'blue' });
+  });
+
+  test('resolves context with defaultMode but mode not found', () => {
+    const theme: Theme = {
+      id: 'test',
+      selector: ':root',
+      tokens: { color: 'blue' },
+      tokenModeMap: {},
+      contexts: {},
+      modes: { color: colorMode },
+    };
+
+    const context: Context = {
+      id: 'ctx',
+      selector: '.ctx',
+      tokens: {},
+      defaultMode: 'nonexistent',
+    };
+
+    const result = resolveContext(theme, context);
+    expect(result.color).toBe('blue');
+  });
+
+  test('collects reference tokens when resolving context with defaultMode', () => {
+    const theme: Theme = {
+      id: 'test',
+      selector: ':root',
+      tokens: {
+        colorPrimary500: { light: '#0073bb', dark: '#66b3ff' },
+        colorNeutral500: '#888888',
+        buttonBackground: '{colorPrimary500}',
+      },
+      tokenModeMap: { colorPrimary500: 'color' },
+      referenceTokens: {
+        color: {
+          primary: { 500: { light: '#0073bb', dark: '#66b3ff' } },
+          neutral: { 500: '#888888' },
+        },
+      },
+      contexts: {},
+      modes: { color: colorMode },
+    };
+
+    const context: Context = {
+      id: 'ctx',
+      selector: '.ctx',
+      tokens: { buttonBackground: '{colorNeutral500}' },
+      defaultMode: 'light',
+    };
+
+    resolveContext(theme, context);
+
+    expect(context.tokens.colorPrimary500).toBe('#0073bb');
+    expect(context.tokens.buttonBackground).toBe('{colorNeutral500}');
+  });
+});