test: reach full coverage and remove dead query branches

Author: ciembor

src/infrastructure/serialization/scheme-query.js

@@ -62,32 +62,11 @@ function sameValue(first, second) {
     );
   }
 
-  if (
-    first &&
-    second &&
-    typeof first === 'object' &&
-    typeof second === 'object'
-  ) {
-    const firstKeys = Object.keys(first);
-    const secondKeys = Object.keys(second);
-
-    return (
-      firstKeys.length === secondKeys.length &&
-      firstKeys.every((key) => first[key] === second[key])
-    );
-  }
-
   return first === second;
 }
 
 function serializeRoundedNumber(value, maxDecimals) {
-  const roundedValue = Number(value.toFixed(maxDecimals));
-
-  if (Object.is(roundedValue, -0)) {
-    return '0';
-  }
-
-  return String(roundedValue);
+  return String(Number(value.toFixed(maxDecimals)));
 }
 
 function serializeQuantizedNumber(value, { step, maxDecimals }) {
@@ -148,7 +127,7 @@ function serializeSchemeQueryValue(key, value) {
         serializePickerNumber(value[2]),
       ].join(',');
     default:
-      return Array.isArray(value) ? value.join(',') : String(value);
+      return String(value);
   }
 }
 
@@ -176,11 +155,7 @@ function applyPresetDegreesIfMissing(scheme, hasDegreesParam) {
     return;
   }
 
-  const presetDegrees = degreesForColorMode(scheme.colorMode, scheme.hueDistance);
-
-  if (presetDegrees) {
-    scheme.degrees = presetDegrees;
-  }
+  scheme.degrees = degreesForColorMode(scheme.colorMode, scheme.hueDistance);
 }
 
 function normalizeColorMode(scheme) {

tests/domain/scheme/color-mode.test.js

@@ -28,6 +28,7 @@ describe('ColorMode', () => {
     expect(normalizeHueForColorMode(210, 'duotone')).toBe(30);
     expect(normalizeHueForColorMode(100, 'tricolor')).toBe(-20);
     expect(normalizeHueForColorMode(75, 'hexachrome')).toBe(15);
+    expect(normalizeHueForColorMode('oops', 'duotone')).toBe(0);
   });
 
   it('accepts aliases and validates known color modes', () => {

tests/domain/scheme/color-scheme-calculator.test.js

@@ -201,6 +201,25 @@ describe('calculateSchemeColors', () => {
     expect(colorHex(result.foreground)).toBe(colorHex(overlayColor));
   });
 
+  it('tints only achromatic colors when the dye scope is achromatic', () => {
+    const result = calculateSchemeColors(createScheme({
+      dyeScope: 'achromatic',
+      dyeColor: {
+        hue: 180,
+        saturation: 100,
+        lightness: 50,
+        alpha: 1,
+      },
+    }));
+
+    const overlayColor = Color({ h: 180, s: 100, l: 50 });
+
+    expect(colorHex(result.black)).toBe(colorHex(overlayColor));
+    expect(colorHex(result.white)).toBe(colorHex(overlayColor));
+    expect(colorHex(result.red)).toBe(colorHex(Color({ h: 345, s: 50, l: 50 })));
+    expect(colorHex(result.cyan)).toBe(colorHex(Color({ h: 165, s: 50, l: 50 })));
+  });
+
   it('resolves legacy special color names and custom special colors', () => {
     const customForegroundColor = {
       hue: 210,
@@ -220,4 +239,31 @@ describe('calculateSchemeColors', () => {
       l: customForegroundColor.lightness,
     })));
   });
+
+  it('falls back to black and white when custom or unknown special colors cannot be resolved', () => {
+    const result = calculateSchemeColors(createScheme({
+      dyeColor: null,
+      background: 'custom',
+      customBackgroundColor: null,
+      foreground: 'unknown',
+      customForegroundColor: null,
+    }));
+
+    expect(colorHex(result.background)).toBe(colorHex(result.black));
+    expect(colorHex(result.foreground)).toBe(colorHex(result.white));
+  });
+
+  it('treats invalid saturation and lightness ranges as zero adjustments', () => {
+    const baseline = calculateSchemeColors(createScheme({
+      saturationRange: 0,
+      lightnessRange: 0,
+    }));
+    const invalidRanges = calculateSchemeColors(createScheme({
+      saturationRange: 'oops',
+      lightnessRange: Number.POSITIVE_INFINITY,
+    }));
+
+    expect(colorHex(invalidRanges.yellow)).toBe(colorHex(baseline.yellow));
+    expect(colorHex(invalidRanges.brightBlue)).toBe(colorHex(baseline.brightBlue));
+  });
 });

tests/domain/scheme/scheme-state.test.js

@@ -43,6 +43,16 @@ describe('scheme-state', () => {
     expect(normalizeSchemeRanges(undefined)).toBeUndefined();
   });
 
+  it('defaults hue distance while normalizing ranges when it is missing', () => {
+    const scheme = createDefaultScheme();
+
+    scheme.hueDistance = undefined;
+
+    normalizeSchemeRanges(scheme);
+
+    expect(scheme.hueDistance).toBe(DEFAULT_HUE_DISTANCE);
+  });
+
   it('applies preset color mode invariants to the scheme', () => {
     const scheme = createDefaultScheme();
 
@@ -69,6 +79,11 @@ describe('scheme-state', () => {
     expect(scheme.degrees).toEqual(original.degrees);
   });
 
+  it('returns false when applying a color mode to a nullish scheme', () => {
+    expect(applyColorModeToScheme(null, 'duotone')).toBe(false);
+    expect(applyColorModeToScheme(undefined, 'duotone')).toBe(false);
+  });
+
   it('updates hue distance and recalculates preset degrees', () => {
     const scheme = createDefaultScheme();
 

tests/infrastructure/browser/scheme-url-sync.test.js

@@ -82,6 +82,20 @@ describe('SchemeUrlSync', () => {
     expect(resolveInitialSchemeSearch('?utm_source=readme', null)).toBe('?utm_source=readme');
   });
 
+  it('normalizes current search strings that omit the leading question mark', () => {
+    expect(resolveInitialSchemeSearch('utm_source=readme', null)).toBe('?utm_source=readme');
+  });
+
+  it('ignores persisted search read errors and keeps the current URL search', () => {
+    const storage = {
+      getItem: vi.fn(() => {
+        throw new Error('storage unavailable');
+      }),
+    };
+
+    expect(resolveInitialSchemeSearch('?utm_source=readme', storage)).toBe('?utm_source=readme');
+  });
+
   it('falls back to persisted scheme params and preserves unrelated URL params', () => {
     const storage = {
       getItem: vi.fn(() => '?hue=45&dyeScope=all'),
@@ -91,6 +105,14 @@ describe('SchemeUrlSync', () => {
       .toBe('?utm_source=readme&hue=45&dyeScope=all');
   });
 
+  it('ignores persisted search values that do not contain any actual params', () => {
+    const storage = {
+      getItem: vi.fn(() => '?'),
+    };
+
+    expect(resolveInitialSchemeSearch('', storage)).toBe('');
+  });
+
   it('hydrates the store from persisted search when the URL has no scheme params', () => {
     const pinia = createPinia();
     const storage = {
@@ -122,6 +144,76 @@ describe('SchemeUrlSync', () => {
     );
   });
 
+  it('hydrates from the string overload using browser fallbacks in non-browser tests', () => {
+    const pinia = createPinia();
+
+    const schemeStore = hydrateSchemeStoreFromLocation(pinia, '?hue=12&dyeScope=all');
+
+    expect(schemeStore.scheme.hue).toBe(12);
+    expect(schemeStore.scheme.dyeScope).toBe('all');
+  });
+
+  it('hydrates from global browser objects when options are omitted', () => {
+    const pinia = createPinia();
+    const originalWindow = globalThis.window;
+    const hadWindow = Object.prototype.hasOwnProperty.call(globalThis, 'window');
+    const history = {
+      state: { from: 'browser' },
+      replaceState: vi.fn(),
+    };
+
+    globalThis.window = {
+      location: {
+        pathname: '/4bit/',
+        search: '',
+        hash: '#preview',
+      },
+      history,
+      localStorage: {
+        getItem: vi.fn(() => '?hue=33'),
+      },
+    };
+
+    try {
+      const schemeStore = hydrateSchemeStoreFromLocation(pinia);
+
+      expect(schemeStore.scheme.hue).toBe(33);
+      expect(history.replaceState).toHaveBeenCalledWith(
+        history.state,
+        '',
+        '/4bit/?hue=33#preview'
+      );
+    } finally {
+      if (hadWindow) {
+        globalThis.window = originalWindow;
+      } else {
+        delete globalThis.window;
+      }
+    }
+  });
+
+  it('does not replace history during hydration when the URL already matches', () => {
+    const pinia = createPinia();
+    const history = {
+      state: { from: 'test' },
+      replaceState: vi.fn(),
+    };
+    const location = {
+      pathname: '/4bit/',
+      search: '?hue=12',
+      hash: '#preview',
+    };
+
+    hydrateSchemeStoreFromLocation(pinia, {
+      search: '?hue=12',
+      storage: null,
+      location,
+      history,
+    });
+
+    expect(history.replaceState).not.toHaveBeenCalled();
+  });
+
   it('persists the current scheme search for future visits', () => {
     const scheme = createDefaultScheme();
     scheme.hue = 10;
@@ -180,4 +272,47 @@ describe('SchemeUrlSync', () => {
       '/4bit/?hue=10'
     );
   });
+
+  it('does not replace history when the current URL already matches the scheme', () => {
+    const scheme = createDefaultScheme();
+    scheme.hue = 10;
+    const history = {
+      state: null,
+      replaceState: vi.fn(),
+    };
+
+    new SchemeUrlSync({
+      schemeStore: { scheme },
+      location: {
+        pathname: '/4bit/',
+        search: '?hue=10',
+        hash: '',
+      },
+      history,
+      storage: null,
+    }).updateLocation(scheme);
+
+    expect(history.replaceState).not.toHaveBeenCalled();
+  });
+
+  it('keeps the URL empty for the default scheme when no extra params are present', () => {
+    const scheme = createDefaultScheme();
+    const history = {
+      state: null,
+      replaceState: vi.fn(),
+    };
+
+    new SchemeUrlSync({
+      schemeStore: { scheme },
+      location: {
+        pathname: '/4bit/',
+        search: '',
+        hash: '',
+      },
+      history,
+      storage: null,
+    }).updateLocation(scheme);
+
+    expect(history.replaceState).not.toHaveBeenCalled();
+  });
 });

tests/infrastructure/serialization/scheme-exports-shared.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import {
+  normalColorName,
+  paletteColorNames,
+} from '../../../src/infrastructure/serialization/scheme-exports/shared';
+
+describe('scheme-exports/shared', () => {
+  it('keeps standard color names unchanged', () => {
+    expect(normalColorName('red')).toBe('red');
+    expect(normalColorName('brightBlue')).toBe('blue');
+  });
+
+  it('builds a palette with standard colors before bright colors', () => {
+    expect(paletteColorNames().slice(0, 4)).toEqual(['black', 'red', 'green', 'yellow']);
+    expect(paletteColorNames().slice(-4)).toEqual([
+      'brightBlue',
+      'brightMagenta',
+      'brightCyan',
+      'brightWhite',
+    ]);
+  });
+});

tests/infrastructure/serialization/scheme-query.test.js

@@ -121,6 +121,31 @@ describe('scheme-query', () => {
     expect(readSchemeFromSearch(`?${params.toString()}`)).toEqual(scheme);
   });
 
+  it('serializes negative near-zero picker values as 0 instead of -0', () => {
+    const scheme = createDefaultScheme();
+
+    scheme.dyeColor = {
+      hue: 180,
+      saturation: -0.0000000001,
+      lightness: 50,
+      alpha: 0.25,
+    };
+
+    const params = new URLSearchParams(buildSchemeSearch(scheme).slice(1));
+
+    expect(params.get('dyeColor')).toBe('180,0,50,0.25');
+  });
+
+  it('serializes non-finite values verbatim instead of crashing quantization', () => {
+    const scheme = createDefaultScheme();
+
+    scheme.hue = Number.POSITIVE_INFINITY;
+
+    const params = new URLSearchParams(buildSchemeSearch(scheme).slice(1));
+
+    expect(params.get('hue')).toBe('Infinity');
+  });
+
   it('keeps comma-separated numeric lists readable in the generated URL', () => {
     const scheme = createDefaultScheme();
 
@@ -136,6 +161,19 @@ describe('scheme-query', () => {
     expect(search).not.toContain('%2C');
   });
 
+  it('keeps explicit degrees when the declared color mode no longer matches a preset', () => {
+    const scheme = createDefaultScheme();
+
+    scheme.colorMode = 'duotone';
+    scheme.hueDistance = 18;
+    scheme.degrees = [0, 1, 2, 3, 4, 5];
+
+    const params = new URLSearchParams(buildSchemeSearch(scheme).slice(1));
+
+    expect(params.get('colorMode')).toBeNull();
+    expect(params.get('degrees')).toBe('0,1,2,3,4,5');
+  });
+
   it('ignores malformed values and falls back to defaults for those fields', () => {
     const scheme = readSchemeFromSearch(
       '?hue=oops&degrees=1,2,3&dyeColor=1,2,3&foreground=invalid&customForegroundColor=4,5'