@taicode/common-base 1.2.0 → 1.4.0

package/output/ring-cache/ring-cache.test.js

@@ -0,0 +1,195 @@
+/**
+ * RingCache 测试文件
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { RingCache } from './ring-cache';
+describe('RingCache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new RingCache({ capacity: 3 });
+    });
+    describe('基础功能', () => {
+        it('应该正确初始化', () => {
+            expect(cache.getSize()).toBe(0);
+            expect(cache.getCapacity()).toBe(3);
+            expect(cache.isEmpty()).toBe(true);
+            expect(cache.isFull()).toBe(false);
+        });
+        it('应该正确添加条目', () => {
+            const entry = cache.add('test1');
+            expect(entry.data).toBe('test1');
+            expect(entry.id).toBeDefined();
+            expect(entry.timestamp).toBeInstanceOf(Date);
+            expect(cache.getSize()).toBe(1);
+            expect(cache.isEmpty()).toBe(false);
+        });
+        it('应该正确处理容量限制', () => {
+            cache.add('test1');
+            cache.add('test2');
+            cache.add('test3');
+            expect(cache.getSize()).toBe(3);
+            expect(cache.isFull()).toBe(true);
+            // 添加第4个条目，应该覆盖第1个
+            cache.add('test4');
+            expect(cache.getSize()).toBe(3);
+            expect(cache.isFull()).toBe(true);
+            const all = cache.getAll();
+            expect(all.map(e => e.data)).toEqual(['test2', 'test3', 'test4']);
+        });
+    });
+    describe('获取功能', () => {
+        beforeEach(() => {
+            cache.add('first');
+            cache.add('second');
+            cache.add('third');
+        });
+        it('应该正确获取所有条目', () => {
+            const all = cache.getAll();
+            expect(all.length).toBe(3);
+            expect(all.map(e => e.data)).toEqual(['first', 'second', 'third']);
+        });
+        it('应该正确获取最近的条目', () => {
+            const recent = cache.getRecent(2);
+            expect(recent.length).toBe(2);
+            expect(recent.map(e => e.data)).toEqual(['second', 'third']);
+        });
+        it('应该正确获取最旧的条目', () => {
+            const oldest = cache.getOldest(2);
+            expect(oldest.length).toBe(2);
+            expect(oldest.map(e => e.data)).toEqual(['first', 'second']);
+        });
+        it('应该正确处理边界情况', () => {
+            expect(cache.getRecent(0)).toEqual([]);
+            expect(cache.getRecent(10)).toHaveLength(3);
+            expect(cache.getOldest(0)).toEqual([]);
+            expect(cache.getOldest(10)).toHaveLength(3);
+        });
+    });
+    describe('搜索功能', () => {
+        beforeEach(() => {
+            cache.add('apple');
+            cache.add('banana');
+            cache.add('apricot');
+        });
+        it('应该正确搜索条目', () => {
+            const results = cache.search(entry => entry.data.startsWith('ap'));
+            expect(results.length).toBe(2);
+            expect(results.map(e => e.data)).toEqual(['apple', 'apricot']);
+        });
+        it('应该支持时间范围搜索', () => {
+            const now = new Date();
+            const future = new Date(now.getTime() + 1000);
+            const results = cache.getByTimeRange(now, future);
+            expect(results.length).toBe(3);
+        });
+    });
+    describe('统计功能', () => {
+        it('应该正确返回空缓存的统计信息', () => {
+            const stats = cache.getStats();
+            expect(stats.size).toBe(0);
+            expect(stats.capacity).toBe(3);
+            expect(stats.isFull).toBe(false);
+            expect(stats.oldestTimestamp).toBeUndefined();
+            expect(stats.newestTimestamp).toBeUndefined();
+            expect(stats.totalAdded).toBe(0);
+        });
+        it('应该正确返回有数据的统计信息', () => {
+            cache.add('test1');
+            cache.add('test2');
+            const stats = cache.getStats();
+            expect(stats.size).toBe(2);
+            expect(stats.capacity).toBe(3);
+            expect(stats.isFull).toBe(false);
+            expect(stats.oldestTimestamp).toBeInstanceOf(Date);
+            expect(stats.newestTimestamp).toBeInstanceOf(Date);
+            expect(stats.totalAdded).toBe(2);
+        });
+        it('应该正确跟踪总添加数', () => {
+            // 添加超过容量的条目
+            cache.add('1');
+            cache.add('2');
+            cache.add('3');
+            cache.add('4');
+            cache.add('5');
+            const stats = cache.getStats();
+            expect(stats.size).toBe(3);
+            expect(stats.totalAdded).toBe(5);
+        });
+    });
+    describe('清空和导出功能', () => {
+        beforeEach(() => {
+            cache.add('test1');
+            cache.add('test2');
+        });
+        it('应该正确清空缓存', () => {
+            cache.clear();
+            expect(cache.getSize()).toBe(0);
+            expect(cache.isEmpty()).toBe(true);
+            expect(cache.getStats().totalAdded).toBe(0);
+        });
+        it('应该正确导出为数组', () => {
+            const array = cache.toArray();
+            expect(array).toEqual(['test1', 'test2']);
+        });
+        it('应该正确导出为JSON', () => {
+            const json = cache.toJSON();
+            const parsed = JSON.parse(json);
+            expect(parsed).toHaveLength(2);
+            expect(parsed[0].data).toBe('test1');
+            expect(parsed[1].data).toBe('test2');
+        });
+    });
+    describe('迭代器功能', () => {
+        it('应该支持for...of语法', () => {
+            cache.add('a');
+            cache.add('b');
+            cache.add('c');
+            const results = [];
+            for (const entry of cache) {
+                results.push(entry.data);
+            }
+            expect(results).toEqual(['a', 'b', 'c']);
+        });
+    });
+    describe('边界条件', () => {
+        it('应该拒绝无效的容量', () => {
+            expect(() => new RingCache({ capacity: 0 })).toThrow('Capacity must be greater than 0');
+            expect(() => new RingCache({ capacity: -1 })).toThrow('Capacity must be greater than 0');
+        });
+        it('应该正确处理空缓存的操作', () => {
+            const emptyCache = new RingCache();
+            expect(emptyCache.getAll()).toEqual([]);
+            expect(emptyCache.getRecent(1)).toEqual([]);
+            expect(emptyCache.getOldest(1)).toEqual([]);
+            expect(emptyCache.toArray()).toEqual([]);
+        });
+        it('应该正确处理单个容量的缓存', () => {
+            const singleCache = new RingCache({ capacity: 1 });
+            singleCache.add('first');
+            expect(singleCache.getAll().map(e => e.data)).toEqual(['first']);
+            singleCache.add('second');
+            expect(singleCache.getAll().map(e => e.data)).toEqual(['second']);
+        });
+    });
+    describe('复杂数据类型', () => {
+        it('应该支持对象数据', () => {
+            const objectCache = new RingCache();
+            const obj1 = { name: 'test1', value: 1 };
+            const obj2 = { name: 'test2', value: 2 };
+            objectCache.add(obj1);
+            objectCache.add(obj2);
+            const all = objectCache.getAll();
+            expect(all[0].data).toEqual(obj1);
+            expect(all[1].data).toEqual(obj2);
+        });
+        it('应该支持搜索对象属性', () => {
+            const objectCache = new RingCache();
+            objectCache.add({ name: 'apple', type: 'fruit' });
+            objectCache.add({ name: 'carrot', type: 'vegetable' });
+            objectCache.add({ name: 'banana', type: 'fruit' });
+            const fruits = objectCache.search(entry => entry.data.type === 'fruit');
+            expect(fruits.length).toBe(2);
+            expect(fruits.map(e => e.data.name)).toEqual(['apple', 'banana']);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-base",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "author": "Alain",
   "license": "ISC",
   "description": "",