更新 .gitignore 文件，调整覆盖率目录；重构 MemoizeDict 测试用例，优化数据处理逻辑

Author: yanhao98

.gitignore

@@ -2,7 +2,7 @@
 node_modules
 dist
 
-/coverage
+/src/coverage
 /src/client/shared.ts
 /src/node/shared.ts
 *.log

src/index.test.ts

@@ -1,14 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { nextTick } from 'vue';
-import { MemoizeDict } from './index';
+import { MemoizeDict } from '.';
 
-// TODO: 需要重写。
 describe('MemoizeDict', () => {
+
   type DictData = {
     id: number;
     label: string;
     parent: number;
   };
+
   const mockData = [
     { id: 1, label: 'Item 1', parent: 0 },
     { id: 2, label: 'Item 2', parent: 1 },
@@ -17,6 +17,17 @@ describe('MemoizeDict', () => {
 
   const dataFunc = vi.fn();
 
+  beforeEach(() => {
+    dataFunc.mockReset();
+    dataFunc.mockImplementation((dictName: string) => {
+      return new Promise<DictData[]>((resolve) => {
+        setTimeout(() => {
+          resolve(mockData);
+        }, 100);
+      });
+    })
+  });
+
   const memoizeDict = new MemoizeDict({
     fieldNames: {
       label: 'label',
@@ -27,37 +38,23 @@ describe('MemoizeDict', () => {
       {
         get: (_, key: string) => ({
           data: async () => {
-            return dataFunc(key)
+            return dataFunc(key);
           },
         }),
       }
     ),
   });
 
-  beforeEach(() => {
-    dataFunc.mockReset();
-    dataFunc.mockImplementation((dictName: string) => {
-      return new Promise<DictData[]>((resolve) => {
-        setTimeout(() => {
-          resolve(mockData);
-        }, 100);
-      });
-    })
-  });
-
   it('get()', async () => {
     expect(memoizeDict.get('test')).toBeUndefined();
-    expect(dataFunc).toBeCalledTimes(1);
     expect(dataFunc).toHaveBeenCalledWith('test');
-
-    await nextTick();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    expect(
-      memoizeDict.get('test')
-    ).toBe(mockData);
+    expect(dataFunc).toBeCalledTimes(1);
+    await new Promise((resolve) => setTimeout(resolve, 101));
+    expect(memoizeDict.get('test')).toBe(mockData);
     expect(dataFunc).toBeCalledTimes(1);
   });
 
+
   it('tree()', async () => {
     expect(
       memoizeDict.tree('test')
@@ -86,13 +83,15 @@ describe('MemoizeDict', () => {
     expect(dataFunc).toBeCalledTimes(0);
   });
 
+
   it('item()', async () => {
     expect(
       memoizeDict.item('test', 2)
     ).toEqual({ id: 2, label: 'Item 2', parent: 1 });
     expect(dataFunc).toBeCalledTimes(0);
   });
 
+
   it('label()', async () => {
     expect(
       memoizeDict.label('test', 2)
@@ -114,21 +113,18 @@ describe('MemoizeDict', () => {
     expect(dataFunc).toBeCalledTimes(0);
   });
 
+
+
   it('fetch()', async () => {
-    expect(
-      await memoizeDict.fetch('test')
-    ).toBe(mockData);
+    expect(await memoizeDict.fetch('test')).toBe(mockData);
     expect(dataFunc).toBeCalledTimes(0);
   });
 
   it('load()', async () => {
-    expect(
-      await memoizeDict.load('test')
-    ).toBe(mockData);
+    expect(await memoizeDict.load('test')).toBe(mockData);
     expect(dataFunc).toBeCalledTimes(1);
   });
 
-
   it('clear()', async () => {
     memoizeDict.get('test-1');
     memoizeDict.get('test-2');
@@ -143,24 +139,28 @@ describe('MemoizeDict', () => {
     expect(dataFunc).toBeCalledTimes(4);
   });
 
+
   it('delete()', async () => {
     memoizeDict.delete('test')
     expect(memoizeDict.get('test')).toBeUndefined();
     expect(dataFunc).toBeCalledTimes(1);
     await new Promise((resolve) => setTimeout(resolve, 101));
-    expect(
-      memoizeDict.get('test')
-    ).toBe(mockData);
+    expect(memoizeDict.get('test')).toBe(mockData);
   });
 
+
+
 });
 
+
+
 describe('特殊情况的处理', () => {
   const mockData = [
     { label: 'Item 1', value: 1, parent: 0 },
     { label: 'Item 2', value: 2, parent: 1 },
     { label: 'Item 3', value: 3, parent: 1 },
-    { label: 'Item 999', value: 999, parent: 999 },
+    { label: 'Item 999', value: 999, parent: 998 },
+    { label: 'Item 888', value: 888, parent: 888 },
   ]
   const memoizeDict = new MemoizeDict({
     // fieldNames:{
@@ -185,58 +185,51 @@ describe('特殊情况的处理', () => {
 
   it('data 不是异步函数', async () => {
     memoizeDict.tree('test');
-    await nextTick();
-    expect(
-      memoizeDict.get('test')
-    ).toEqual(mockData);
+    await new Promise((resolve) => setTimeout(resolve, 101));
+    expect(memoizeDict.get('test')).toEqual(mockData);
   });
 
   it('fieldNames 未定义', async () => {
-    expect(
-      memoizeDict.treeLabel('test', 2)
-    ).toBe('Item 1-Item 2');
+    expect(memoizeDict.treeLabel('test', 2)).toBe('Item 1-Item 2');
+  });
+
+  it('dictName 不存在', async () => {
+    expect(() => memoizeDict.fetch('test-1')).toThrowError('config not found: test-1');
   });
 
   it('label() 传的值不存在', async () => {
-    expect(
-      memoizeDict.label('test', 99)
-    ).toBe('99');
+    expect(memoizeDict.label('test', 99)).toBe('99');
   });
 
   it('label() 不传值', async () => {
-    expect(
-      memoizeDict.label('test', undefined as any)
-    ).toBe('');
+    expect(memoizeDict.label('test', undefined as any)).toBe('');
   });
 
   it('labels() 不传值', async () => {
-    expect(
-      memoizeDict.labels('test', undefined as any)
-    ).toEqual([]);
+    expect(memoizeDict.labels('test', undefined as any)).toEqual([]);
   });
 
   it('treeLabel() 不传值', async () => {
-    expect(
-      memoizeDict.treeLabel('test', undefined as any)
-    ).toBe('');
+    expect(memoizeDict.treeLabel('test', undefined as any)).toBe('');
   });
 
+
   it('treeLabel() 传的值父级不存在', async () => {
-    expect(
-      memoizeDict.treeLabel('test', 999)
-    ).toBe('Item 999');
+    await memoizeDict.fetch('test');
+    expect(memoizeDict.treeLabel('test', 999)).toBe('Item 999');
   })
 
+  it('treeLabel() 的item的parent等于自己', async () => {
+    await memoizeDict.fetch('test');
+    expect(memoizeDict.treeLabel('test', 888)).toBe('Item 888');
+  });
+
   it('treeLabel() 传的值不存在', async () => {
-    expect(
-      memoizeDict.treeLabel('test', 99)
-    ).toBe('99');
+    expect(memoizeDict.treeLabel('test', 99)).toBe('99');
   });
 
   it('values() 不传数组', async () => {
-    expect(
-      memoizeDict.labels('test', 2 as any)
-    ).toEqual(2);
+    expect( memoizeDict.labels('test', 2 as any) ).toEqual(2);
     expect(console.error).toBeCalledTimes(1);
   });
 });

src/index.ts

@@ -2,6 +2,16 @@
 
 import { computedAsync, useMemoize } from "@vueuse/core";
 
+// TODO: rslib
+// TODO: createMemoizeDict
+// function createMemoizeDict() {
+//   return {
+//     data: xx,
+//     toTree: xx,
+//     fetch: xx,
+//     load: xx,
+//   }
+// }
 
 export class MemoizeDict<DictItem = Record<string, unknown>> {
   private options;
@@ -98,7 +108,7 @@ export class MemoizeDict<DictItem = Record<string, unknown>> {
     let fullLabel = this.label(dictName, value);
     let currentItem = item;
 
-    while (currentItem[this._parentFieldName]) {
+    while (currentItem[this._parentFieldName] && currentItem[this._parentFieldName] !== currentItem[this._valueFieldName]) {
       const parentItem = this.find(dictName, currentItem[this._parentFieldName]);
       if (!parentItem) break;
       fullLabel = `${this.label(dictName, parentItem[this._labelFieldName])}-${fullLabel}`;
@@ -107,10 +117,6 @@ export class MemoizeDict<DictItem = Record<string, unknown>> {
 
     return fullLabel
   }
-  public fullLabel(...args: Parameters<typeof this.treeLabel>) {
-    return this.treeLabel(...args);
-  }
-
 
   private _fetch(dictName: string): Promise<DictItem[]> & { __computedAsyncRef__?: ReturnType<typeof computedAsync<DictItem[]>> } {
     const config = this.options.config[dictName];