✅ add testcase and fix typo #294

Author: trydofor

layers/common/tests/ClassThrown.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+
+describe('ClassThrown helpers', () => {
+  it('creates NavigateThrown with route payload', () => {
+    const route = { name: 'home' };
+    const thrown = new NavigateThrown(route);
+    expect(thrown.name).toBe('NavigateThrown');
+    expect(thrown.route).toBe(route);
+  });
+
+  it('creates IgnoredThrown with custom message', () => {
+    const thrown = new IgnoredThrown('skip this');
+    expect(thrown.name).toBe('IgnoredThrown');
+    expect(thrown.message).toBe('skip this');
+  });
+
+  it('creates DataThrown with arbitrary payload', () => {
+    const payload = { foo: 'bar' };
+    const thrown = new DataThrown('custom', payload);
+    expect(thrown.name).toBe('DataThrown');
+    expect(thrown.type).toBe('custom');
+    expect(thrown.data).toBe(payload);
+  });
+
+  it('wraps notify data in NotifyThrown', () => {
+    const notifyFromString = new NotifyThrown({ message: 'warning', notifyLevel: GlobalNotifyLevel.Warning });
+    expect(notifyFromString.notify).toMatchObject({ message: 'warning', notifyLevel: GlobalNotifyLevel.Warning });
+
+    const notifyFromObject = new NotifyThrown({
+      message: 'ok',
+      notifyLevel: GlobalNotifyLevel.Success,
+      notifyStyle: GlobalNotifyStyle.Toast,
+    });
+    expect(notifyFromObject.notify).toMatchObject({
+      message: 'ok',
+      notifyLevel: GlobalNotifyLevel.Success,
+      notifyStyle: GlobalNotifyStyle.Toast,
+    });
+  });
+
+  it('creates NoticeThrown from arrays and varargs', () => {
+    const noticeA = { message: 'A' } as I18nNotice;
+    const noticeB = { message: 'B' } as I18nNotice;
+
+    const fromArray = new NoticeThrown([noticeA, noticeB]);
+    expect(fromArray.notices).toEqual([noticeA, noticeB]);
+
+    const fromArgs = new NoticeThrown(noticeA, noticeB);
+    expect(fromArgs.notices).toEqual([noticeA, noticeB]);
+  });
+});

layers/common/tests/UseLocalizeMessage.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { defineComponent } from 'vue';
+import { createI18n } from 'vue-i18n';
+import { mount } from '@vue/test-utils';
+
+describe('useLocalizeMessage', () => {
+  it('localizes message using vue-i18n context', () => {
+    const i18n = createI18n({
+      legacy: false,
+      locale: 'en-US',
+      messages: {
+        'en-US': {
+          greet: 'Hello {0}',
+          world: 'World',
+        },
+      },
+    });
+
+    const TestComponent = defineComponent({
+      setup(_props, { expose }) {
+        const localize = useLocalizeMessage();
+        expose({ localize });
+        return () => null;
+      },
+    });
+
+    const wrapper = mount(TestComponent, {
+      global: {
+        plugins: [i18n],
+      },
+    });
+
+    const localize = (wrapper.vm as unknown as { localize: ReturnType<typeof useLocalizeMessage> }).localize;
+    const result = localize({ i18nCode: 'greet', i18nArgs: ['world'], message: 'fallback' }, true);
+
+    expect(result).toBe('Hello World');
+  });
+
+  it('returns fallback when translation code missing', () => {
+    const i18n = createI18n({ legacy: false, locale: 'en-US', messages: { 'en-US': {} } });
+
+    const TestComponent = defineComponent({
+      setup(_props, { expose }) {
+        const localize = useLocalizeMessage();
+        expose({ localize });
+        return () => null;
+      },
+    });
+
+    const wrapper = mount(TestComponent, {
+      global: {
+        plugins: [i18n],
+      },
+    });
+
+    const localize = (wrapper.vm as unknown as { localize: ReturnType<typeof useLocalizeMessage> }).localize;
+    expect(localize(undefined, 'default')).toBe('default');
+  });
+});

layers/common/tests/UseUniqueKey.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { defineComponent, h } from 'vue';
+import { mount } from '@vue/test-utils';
+
+const UniqueComponent = defineComponent({
+  setup(_props, { expose }) {
+    const unique = useUniqueKey();
+    expose({ unique });
+    return () => h('div');
+  },
+});
+
+describe('useUniqueKey', () => {
+  it('generates deterministic keys based on component uid and md5 hash', () => {
+    const wrapper = mount(UniqueComponent);
+    const unique = (wrapper.vm as unknown as { unique: (...args: unknown[]) => string }).unique;
+
+    const key = unique('foo', 123, { nested: true });
+    const uid = (wrapper.vm as SafeAny).$?.uid ?? wrapper.vm.$.uid;
+    expect(key.startsWith(`${uid}-`)).toBe(true);
+
+    // same args produce identical hash, different args produce different hash
+    expect(unique('foo', 123, { nested: true })).toBe(key);
+    expect(unique('foo', 456)).not.toBe(key);
+  });
+
+  it('throws when used outside of component setup', () => {
+    expect(() => useUniqueKey()).toThrowError('useUniqueKey must be used within a Vue component setup');
+  });
+});

layers/common/tests/common-blob.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+
+describe('common-blob utilities', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('delegates to navigator.msSaveOrOpenBlob when available', () => {
+    const blob = new Blob(['hello']);
+    const navigatorStub = window.navigator as Navigator & { msSaveOrOpenBlob?: (blob: Blob, name?: string) => void };
+    navigatorStub.msSaveOrOpenBlob = vi.fn();
+
+    saveBlobFile({ name: 'hello.txt', blob });
+
+    expect(navigatorStub.msSaveOrOpenBlob).toHaveBeenCalledWith(blob, 'hello.txt');
+    delete navigatorStub.msSaveOrOpenBlob;
+  });
+
+  it('creates anchor element and revokes url for Blob', () => {
+    const blob = new Blob(['world']);
+    const appendSpy = vi.spyOn(document.body, 'appendChild');
+    const removeSpy = vi.spyOn(document.body, 'removeChild');
+    vi.spyOn(document, 'createElement');
+    const dispatchSpy = vi.spyOn(HTMLAnchorElement.prototype, 'dispatchEvent');
+    const objectUrlSpy = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:mock');
+    const revokeSpy = vi.spyOn(URL, 'revokeObjectURL');
+
+    saveBlobFile(blob, 'fallback.txt');
+
+    expect(objectUrlSpy).toHaveBeenCalledWith(blob);
+    expect(appendSpy).toHaveBeenCalled();
+    expect(dispatchSpy).toHaveBeenCalled();
+
+    vi.runAllTimers();
+
+    expect(removeSpy).toHaveBeenCalled();
+    expect(revokeSpy).toHaveBeenCalledWith('blob:mock');
+  });
+
+  it('supports legacy MouseEvent fallback when constructor throws', () => {
+    const originalMouseEvent = globalThis.MouseEvent;
+    const mouseEventSpy = vi.fn(() => {
+      throw new Error('unsupported');
+    });
+    globalThis.MouseEvent = mouseEventSpy as unknown as typeof MouseEvent;
+
+    const originalCreateEvent = document.createEvent.bind(document);
+    const createEventSpy = vi.spyOn(document, 'createEvent').mockImplementation((type: string) => {
+      const event = originalCreateEvent(type) as MouseEvent & { initMouseEvent?: (...args: unknown[]) => void };
+      if (type === 'MouseEvent' && typeof event.initMouseEvent !== 'function') {
+        event.initMouseEvent = vi.fn();
+      }
+      return event;
+    });
+
+    const objectUrlSpy = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:legacy');
+    const revokeSpy = vi.spyOn(URL, 'revokeObjectURL');
+
+    saveBlobFile(new Blob(['legacy']), 'legacy.txt');
+
+    expect(mouseEventSpy).toHaveBeenCalled();
+    expect(createEventSpy).toHaveBeenCalledWith('MouseEvent');
+
+    vi.runAllTimers();
+
+    expect(objectUrlSpy).toHaveBeenCalled();
+    expect(revokeSpy).toHaveBeenCalledWith('blob:legacy');
+
+    createEventSpy.mockRestore();
+    globalThis.MouseEvent = originalMouseEvent;
+  });
+
+  it('parses filenames from Content-Disposition header', () => {
+    expect(parseContentDispositionFilename('attachment; filename="report.txt"')).toBe('report.txt');
+    expect(parseContentDispositionFilename('attachment; filename="fallback.txt"; filename*=UTF-8\'\'%E4%B8%AD%E6%96%87.txt')).toBe('中文.txt');
+    expect(parseContentDispositionFilename('attachment')).toBeUndefined();
+  });
+
+  it('detects blob-like objects', () => {
+    const fakeBlob = { arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)), text: () => Promise.resolve('') };
+    expect(isBlobLike(new Blob(['data']))).toBe(true);
+    expect(isBlobLike(fakeBlob)).toBe(true);
+    expect(isBlobLike({})).toBe(false);
+  });
+});

layers/common/tests/common-notify.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+
+describe('common notify helpers', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('handles unlimited stacked notifications', () => {
+    const calls: Array<{ index: number; data: string }> = [];
+    const notify = createStackedNotify<string>((index, data, close) => {
+      calls.push({ index, data });
+      close();
+    });
+
+    notify('first');
+    vi.runOnlyPendingTimers();
+    notify('second');
+    vi.runOnlyPendingTimers();
+
+    expect(calls).toEqual([
+      { index: 0, data: 'first' },
+      { index: 0, data: 'second' },
+    ]);
+  });
+
+  it('queues stacked notifications when all slots are busy', () => {
+    const calls: string[] = [];
+    const closers: Array<() => void> = [];
+    const notify = createStackedNotify<string>((index, data, close) => {
+      calls.push(`${index}:${data}`);
+      closers.push(() => close());
+    }, 2);
+
+    for (let i = 0; i < 5; i++) {
+      notify(`job-${i}`);
+    }
+
+    notify('queued');
+    expect(calls).toHaveLength(5);
+
+    closers[0]!();
+    vi.runOnlyPendingTimers();
+
+    expect(calls).toHaveLength(6);
+    expect(calls.at(-1)).toMatch(/\d:queued/);
+  });
+
+  it('processes notifications sequentially', () => {
+    const calls: string[] = [];
+    const notify = createSingledNotify<string>((data, close) => {
+      calls.push(data);
+      close();
+    });
+
+    notify('a');
+    notify('b');
+
+    expect(calls).toEqual(['a']);
+    vi.runOnlyPendingTimers();
+    expect(calls).toEqual(['a', 'b']);
+  });
+
+  it('toggles refs and callbacks correctly', () => {
+    const modal = ref(false);
+    const callback = vi.fn<(open: boolean, payload?: string) => void>();
+    const optional = vi.fn<(open: boolean, payload?: number) => void>();
+
+    const toggled = createToggledNotify<{
+      modal: typeof modal;
+      callback: (open: boolean, payload?: string) => void;
+      optional: (open: boolean, payload?: number) => void;
+    }>();
+
+    toggled.init('modal', modal);
+    toggled.init('callback', callback);
+    toggled.init('optional', optional, true);
+
+    toggled.open('modal');
+    expect(modal.value).toBe(true);
+
+    toggled.toggle('modal');
+    expect(modal.value).toBe(false);
+
+    toggled.openExclusive('callback', 'payload');
+    expect(callback).toHaveBeenLastCalledWith(true, 'payload');
+
+    toggled.open('optional', 42);
+    expect(optional).toHaveBeenLastCalledWith(true, 42);
+
+    toggled.closeAll();
+    expect(callback).toHaveBeenLastCalledWith(false, undefined);
+    expect(optional).toHaveBeenLastCalledWith(false, undefined);
+  });
+
+  it('creates app notify with default warning level', () => {
+    const { eventBus, newThrown } = createAppNotify('toast', GlobalNotifyStyle.Toast);
+
+    const notifyFromString = newThrown('be careful');
+    expect(notifyFromString).toBeInstanceOf(NotifyThrown);
+    expect(notifyFromString.notify).toMatchObject({
+      message: 'be careful',
+      notifyLevel: GlobalNotifyLevel.Warning,
+      notifyStyle: GlobalNotifyStyle.Toast,
+    });
+
+    const notifyFromObject = newThrown({
+      message: 'ok',
+      notifyLevel: GlobalNotifyLevel.Success,
+    });
+    expect(notifyFromObject.notify).toMatchObject({
+      message: 'ok',
+      notifyLevel: GlobalNotifyLevel.Success,
+      notifyStyle: GlobalNotifyStyle.Toast,
+    });
+
+    expect(typeof eventBus.emit).toBe('function');
+    expect(typeof eventBus.on).toBe('function');
+  });
+});