sumulige-claude 1.1.2 → 1.2.0

package/tests/quality-rules.test.js

@@ -0,0 +1,619 @@
+/**
+ * Quality Rules 模块单元测试
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('Quality Rules Module', () => {
+  const { RuleRegistry, registry } = require('../lib/quality-rules');
+
+  // Create temporary test files
+  const tempDir = path.join(os.tmpdir(), 'smc-rules-test-' + Date.now());
+  const testJsFile = path.join(tempDir, 'test.js');
+  const testPyFile = path.join(tempDir, 'test.py');
+  const testMdFile = path.join(tempDir, 'test.md');
+  const testJsonFile = path.join(tempDir, 'test.json');
+  const largeJsFile = path.join(tempDir, 'large.js');
+  const emptyJsFile = path.join(tempDir, 'empty.js');
+  const rulesJsonFile = path.join(tempDir, 'rules.json');
+  const rulesYamlFile = path.join(tempDir, 'rules.yaml');
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Create test files with various content
+    fs.writeFileSync(testJsFile, 'console.log("hello");\nconsole.log("world");\nconst x = 1;\n');
+    fs.writeFileSync(testPyFile, '# Python file\nprint("hello")');
+    fs.writeFileSync(testMdFile, '# Title\n\nContent here\n');
+    fs.writeFileSync(testJsonFile, '{"key": "value"}');
+
+    // Create a large JavaScript file (over 800 lines)
+    const lines = ['// Large file'];
+    for (let i = 0; i < 850; i++) {
+      lines.push(`const line${i} = ${i};`);
+    }
+    fs.writeFileSync(largeJsFile, lines.join('\n'));
+
+    // Create an empty file
+    fs.writeFileSync(emptyJsFile, '\n\n');
+
+    // Create custom rules JSON file
+    fs.writeFileSync(rulesJsonFile, JSON.stringify({
+      rules: [
+        {
+          id: 'custom-rule-1',
+          name: 'Custom Rule 1',
+          severity: 'error',
+          enabled: true,
+          description: 'A custom rule',
+          check: () => ({ pass: true, skip: true })
+        }
+      ]
+    }));
+
+    // Create custom rules YAML file
+    fs.writeFileSync(rulesYamlFile, `
+rules:
+  - id: custom-yaml-rule
+    name: Custom YAML Rule
+    severity: warn
+    enabled: true
+    description: A custom YAML rule
+`);
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('RuleRegistry', () => {
+    let customRegistry;
+
+    beforeEach(() => {
+      customRegistry = new RuleRegistry();
+    });
+
+    describe('register', () => {
+      it('should register a new rule', () => {
+        const rule = customRegistry.register('test-rule', {
+          name: 'Test Rule',
+          severity: 'warn',
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.id).toBe('test-rule');
+        expect(rule.name).toBe('Test Rule');
+        expect(rule.severity).toBe('warn');
+        expect(rule.enabled).toBe(true);
+      });
+
+      it('should use id as default name', () => {
+        const rule = customRegistry.register('no-name', {
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.name).toBe('no-name');
+      });
+
+      it('should use default severity', () => {
+        const rule = customRegistry.register('default-severity', {
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.severity).toBe('warn');
+      });
+
+      it('should enable rule by default', () => {
+        const rule = customRegistry.register('enabled-default', {
+          enabled: undefined,
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.enabled).toBe(true);
+      });
+
+      it('should allow explicit disable', () => {
+        const rule = customRegistry.register('disabled-rule', {
+          enabled: false,
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.enabled).toBe(false);
+      });
+
+      it('should store config object', () => {
+        const rule = customRegistry.register('config-rule', {
+          config: { maxLines: 100 },
+          check: () => ({ pass: true })
+        });
+
+        expect(rule.config).toEqual({ maxLines: 100 });
+      });
+
+      it('should return registered rule', () => {
+        const registered = customRegistry.register('return-test', {
+          name: 'Return Test',
+          check: () => ({ pass: true })
+        });
+
+        expect(registered).toBeDefined();
+        expect(registered.id).toBe('return-test');
+      });
+    });
+
+    describe('get', () => {
+      beforeEach(() => {
+        customRegistry.register('get-test', {
+          name: 'Get Test',
+          check: () => ({ pass: true })
+        });
+      });
+
+      it('should get existing rule', () => {
+        const rule = customRegistry.get('get-test');
+
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('get-test');
+        expect(rule.name).toBe('Get Test');
+      });
+
+      it('should return null for non-existent rule', () => {
+        const rule = customRegistry.get('does-not-exist');
+
+        expect(rule).toBeNull();
+      });
+    });
+
+    describe('has', () => {
+      beforeEach(() => {
+        customRegistry.register('has-test', {
+          check: () => ({ pass: true })
+        });
+      });
+
+      it('should return true for existing rule', () => {
+        expect(customRegistry.has('has-test')).toBe(true);
+      });
+
+      it('should return false for non-existent rule', () => {
+        expect(customRegistry.has('does-not-exist')).toBe(false);
+      });
+    });
+
+    describe('getAll', () => {
+      beforeEach(() => {
+        customRegistry.register('rule-1', {
+          severity: 'error',
+          enabled: true,
+          category: 'code-style',
+          check: () => ({ pass: true })
+        });
+        customRegistry.register('rule-2', {
+          severity: 'warn',
+          enabled: false,
+          category: 'code-style',
+          check: () => ({ pass: true })
+        });
+        customRegistry.register('rule-3', {
+          severity: 'warn',
+          enabled: true,
+          category: 'quality',
+          check: () => ({ pass: true })
+        });
+      });
+
+      it('should return all rules when no filter provided', () => {
+        const rules = customRegistry.getAll();
+
+        expect(rules.length).toBeGreaterThan(0);
+      });
+
+      it('should filter by severity', () => {
+        const errorRules = customRegistry.getAll({ severity: 'error' });
+
+        expect(errorRules.length).toBeGreaterThan(0);
+        expect(errorRules.every(r => r.severity === 'error')).toBe(true);
+      });
+
+      it('should filter by enabled status', () => {
+        const enabledRules = customRegistry.getAll({ enabled: true });
+        const disabledRules = customRegistry.getAll({ enabled: false });
+
+        expect(enabledRules.every(r => r.enabled === true)).toBe(true);
+        expect(disabledRules.every(r => r.enabled === false)).toBe(true);
+      });
+
+      it('should filter by category', () => {
+        const styleRules = customRegistry.getAll({ category: 'code-style' });
+
+        expect(styleRules.every(r => r.category === 'code-style')).toBe(true);
+      });
+
+      it('should combine multiple filters', () => {
+        const rules = customRegistry.getAll({
+          enabled: true,
+          severity: 'warn'
+        });
+
+        expect(rules.every(r => r.enabled === true && r.severity === 'warn')).toBe(true);
+      });
+    });
+
+    describe('setEnabled', () => {
+      it('should enable a disabled rule', () => {
+        customRegistry.register('to-enable', {
+          enabled: false,
+          check: () => ({ pass: true })
+        });
+
+        customRegistry.setEnabled('to-enable', true);
+        const rule = customRegistry.get('to-enable');
+
+        expect(rule.enabled).toBe(true);
+      });
+
+      it('should disable an enabled rule', () => {
+        customRegistry.register('to-disable', {
+          enabled: true,
+          check: () => ({ pass: true })
+        });
+
+        customRegistry.setEnabled('to-disable', false);
+        const rule = customRegistry.get('to-disable');
+
+        expect(rule.enabled).toBe(false);
+      });
+
+      it('should do nothing for non-existent rule', () => {
+        expect(() => {
+          customRegistry.setEnabled('non-existent', true);
+        }).not.toThrow();
+      });
+    });
+
+    describe('updateConfig', () => {
+      it('should update rule config', () => {
+        customRegistry.register('config-update', {
+          config: { maxLines: 100 },
+          check: () => ({ pass: true })
+        });
+
+        customRegistry.updateConfig('config-update', { maxLines: 200, newSize: 500 });
+        const rule = customRegistry.get('config-update');
+
+        expect(rule.config.maxLines).toBe(200);
+        expect(rule.config.newSize).toBe(500);
+      });
+
+      it('should merge configs', () => {
+        customRegistry.register('merge-config', {
+          config: { a: 1, b: 2 },
+          check: () => ({ pass: true })
+        });
+
+        customRegistry.updateConfig('merge-config', { b: 3, c: 4 });
+        const rule = customRegistry.get('merge-config');
+
+        expect(rule.config.a).toBe(1);
+        expect(rule.config.b).toBe(3);
+        expect(rule.config.c).toBe(4);
+      });
+
+      it('should do nothing for non-existent rule', () => {
+        expect(() => {
+          customRegistry.updateConfig('non-existent', {});
+        }).not.toThrow();
+      });
+    });
+
+    describe('loadFromFile', () => {
+      it('should load rules from JSON file', () => {
+        customRegistry.loadFromFile(rulesJsonFile);
+
+        expect(customRegistry.has('custom-rule-1')).toBe(true);
+        const rule = customRegistry.get('custom-rule-1');
+        expect(rule.name).toBe('Custom Rule 1');
+        expect(rule.severity).toBe('error');
+      });
+
+      it('should update existing rule from file', () => {
+        customRegistry.register('custom-rule-1', {
+          name: 'Original Name',
+          severity: 'warn',
+          check: () => ({ pass: true })
+        });
+
+        customRegistry.loadFromFile(rulesJsonFile);
+
+        const rule = customRegistry.get('custom-rule-1');
+        expect(rule.name).toBe('Custom Rule 1');
+        expect(rule.severity).toBe('error');
+      });
+
+      it('should do nothing for non-existent file', () => {
+        expect(() => {
+          customRegistry.loadFromFile('/does/not/exist.json');
+        }).not.toThrow();
+      });
+
+      it('should load rules from YAML file (if yaml available)', () => {
+        const hasYaml = (() => {
+          try {
+            require('yaml');
+            return true;
+          } catch {
+            return false;
+          }
+        })();
+
+        customRegistry.loadFromFile(rulesYamlFile);
+
+        if (hasYaml) {
+          expect(customRegistry.has('custom-yaml-rule')).toBe(true);
+        }
+        // If yaml not available, just verify it doesn't crash
+      });
+    });
+  });
+
+  describe('Global Registry', () => {
+    it('should export global registry instance', () => {
+      expect(registry).toBeDefined();
+      expect(registry instanceof RuleRegistry).toBe(true);
+    });
+
+    it('should export convenience functions', () => {
+      const {
+        register,
+        get,
+        has,
+        getAll,
+        setEnabled,
+        updateConfig,
+        loadFromFile
+      } = require('../lib/quality-rules');
+
+      expect(typeof register).toBe('function');
+      expect(typeof get).toBe('function');
+      expect(typeof has).toBe('function');
+      expect(typeof getAll).toBe('function');
+      expect(typeof setEnabled).toBe('function');
+      expect(typeof updateConfig).toBe('function');
+      expect(typeof loadFromFile).toBe('function');
+    });
+  });
+
+  describe('Built-in Rules', () => {
+    describe('file-size-limit', () => {
+      const rule = registry.get('file-size-limit');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('file-size-limit');
+      });
+
+      it('should pass small files', () => {
+        const result = rule.check(testJsFile, rule.config);
+        expect(result.pass).toBe(true);
+      });
+
+      it('should fail files exceeding size limit', () => {
+        // Create a large temporary file
+        const largeFile = path.join(tempDir, 'large-size.js');
+        const largeContent = 'x'.repeat(900000); // ~900KB
+        fs.writeFileSync(largeFile, largeContent);
+
+        const result = rule.check(largeFile, { maxSize: 800 * 1024 });
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('exceeds limit');
+
+        fs.unlinkSync(largeFile);
+      });
+    });
+
+    describe('line-count-limit', () => {
+      const rule = registry.get('line-count-limit');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('line-count-limit');
+      });
+
+      it('should pass files under limit', () => {
+        const result = rule.check(testJsFile, rule.config);
+        expect(result.pass).toBe(true);
+      });
+
+      it('should fail files exceeding line limit', () => {
+        const result = rule.check(largeJsFile, { maxLines: 800 });
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('exceeds line limit');
+      });
+    });
+
+    describe('no-console-logs', () => {
+      const rule = registry.get('no-console-logs');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('no-console-logs');
+      });
+
+      it('should detect console.log statements', () => {
+        const result = rule.check(testJsFile);
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('console statement');
+      });
+
+      it('should skip non-JS files', () => {
+        const result = rule.check(testMdFile);
+
+        expect(result.pass).toBe(true);
+        expect(result.skip).toBe(true);
+      });
+    });
+
+    describe('todo-comments', () => {
+      const rule = registry.get('todo-comments');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('todo-comments');
+      });
+
+      it('should find TODO comments', () => {
+        const todoFile = path.join(tempDir, 'todo.js');
+        fs.writeFileSync(todoFile, '// TODO: fix this\n// FIXME: later\n');
+
+        const result = rule.check(todoFile);
+
+        expect(result.pass).toBe(true); // TODO is just informational
+        expect(result.message).toContain('TODO');
+      });
+
+      it('should skip non-code files', () => {
+        const result = rule.check(testJsonFile);
+
+        expect(result.pass).toBe(true);
+        expect(result.skip).toBe(true);
+      });
+    });
+
+    describe('directory-depth', () => {
+      const rule = registry.get('directory-depth');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('directory-depth');
+      });
+
+      it('should pass normal depth paths', () => {
+        const result = rule.check(testJsFile, { maxDepth: 10 });
+
+        expect(result.pass).toBe(true);
+      });
+
+      it('should fail deep paths', () => {
+        const deepPath = '/a/b/c/d/e/f/g/h/i/j/k/l/file.js';
+        const result = rule.check(deepPath, { maxDepth: 6 });
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('depth');
+      });
+    });
+
+    describe('no-empty-files', () => {
+      const rule = registry.get('no-empty-files');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('no-empty-files');
+      });
+
+      it('should pass files with content', () => {
+        const result = rule.check(testJsFile, rule.config);
+
+        expect(result.pass).toBe(true);
+      });
+
+      it('should fail empty or near-empty files', () => {
+        const result = rule.check(emptyJsFile, { minLines: 3 });
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('line');
+      });
+    });
+
+    describe('no-trailing-whitespace', () => {
+      const rule = registry.get('no-trailing-whitespace');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('no-trailing-whitespace');
+      });
+
+      it('should pass files without trailing whitespace', () => {
+        const cleanFile = path.join(tempDir, 'clean.js');
+        fs.writeFileSync(cleanFile, 'const x = 1;\nconst y = 2;\n');
+
+        const result = rule.check(cleanFile);
+
+        expect(result.pass).toBe(true);
+      });
+
+      it('should detect trailing whitespace', () => {
+        const dirtyFile = path.join(tempDir, 'dirty.js');
+        fs.writeFileSync(dirtyFile, 'const x = 1;   \nconst y = 2;\t\n');
+
+        const result = rule.check(dirtyFile);
+
+        expect(result.pass).toBe(false);
+        expect(result.message).toContain('Trailing whitespace');
+        expect(result.autoFix).toBe(true);
+      });
+
+      it('should skip non-text files', () => {
+        const result = rule.check(testJsonFile);
+
+        // JSON is not in the check list, so it should be skipped
+        expect(result.pass).toBe(true);
+      });
+    });
+
+    describe('function-length', () => {
+      const rule = registry.get('function-length');
+
+      it('should exist', () => {
+        expect(rule).toBeDefined();
+        expect(rule.id).toBe('function-length');
+      });
+
+      it('should be disabled by default', () => {
+        expect(rule.enabled).toBe(false);
+      });
+
+      it('should skip non-JS files', () => {
+        const result = rule.check(testPyFile);
+
+        expect(result.pass).toBe(true);
+        expect(result.skip).toBe(true);
+      });
+    });
+  });
+
+  describe('Rule Execution', () => {
+    it('should handle non-existent files by throwing or returning error', () => {
+      const rule = registry.get('line-count-limit');
+
+      // The rule will try to read the file, which will throw
+      expect(() => {
+        rule.check('/does/not/exist.js');
+      }).toThrow();
+    });
+
+    it('should handle various file extensions', () => {
+      const consoleRule = registry.get('no-console-logs');
+
+      // Should check JS files
+      let result = consoleRule.check(testJsFile);
+      expect(result.pass).toBe(false); // Has console.log
+
+      // Should check TS files
+      const tsFile = path.join(tempDir, 'test.ts');
+      fs.writeFileSync(tsFile, 'console.log("test");');
+      result = consoleRule.check(tsFile);
+      expect(result.pass).toBe(false);
+
+      // Should skip markdown
+      result = consoleRule.check(testMdFile);
+      expect(result.skip).toBe(true);
+    });
+  });
+});

package/tests/version-check.test.js

@@ -0,0 +1,75 @@
+/**
+ * Version Check 模块单元测试
+ */
+
+describe('Version Check Module', () => {
+  const versionCheck = require('../lib/version-check');
+
+  describe('compareVersions', () => {
+    it('should return -1 when v1 < v2', () => {
+      expect(versionCheck.compareVersions('1.0.0', '1.0.1')).toBe(-1);
+      expect(versionCheck.compareVersions('1.0.0', '1.1.0')).toBe(-1);
+      expect(versionCheck.compareVersions('1.0.0', '2.0.0')).toBe(-1);
+      expect(versionCheck.compareVersions('0.9.0', '1.0.0')).toBe(-1);
+    });
+
+    it('should return 0 when versions are equal', () => {
+      expect(versionCheck.compareVersions('1.0.0', '1.0.0')).toBe(0);
+      expect(versionCheck.compareVersions('2.5.10', '2.5.10')).toBe(0);
+    });
+
+    it('should return 1 when v1 > v2', () => {
+      expect(versionCheck.compareVersions('1.0.1', '1.0.0')).toBe(1);
+      expect(versionCheck.compareVersions('1.1.0', '1.0.0')).toBe(1);
+      expect(versionCheck.compareVersions('2.0.0', '1.0.0')).toBe(1);
+    });
+
+    it('should handle different length versions', () => {
+      expect(versionCheck.compareVersions('1.0', '1.0.0')).toBe(0);
+      expect(versionCheck.compareVersions('1.0.0', '1.0')).toBe(0);
+      expect(versionCheck.compareVersions('1.0', '1.0.1')).toBe(-1);
+      expect(versionCheck.compareVersions('1.0.1', '1.0')).toBe(1);
+    });
+
+    it('should handle pre-release tags', () => {
+      // Pre-release tags are stripped, so these compare equal
+      expect(versionCheck.compareVersions('1.0.0', '1.0.0-alpha')).toBe(0);
+    });
+  });
+
+  describe('getCurrentVersion', () => {
+    it('should return current version from package.json', () => {
+      const version = versionCheck.getCurrentVersion();
+      expect(typeof version).toBe('string');
+      expect(version).toMatch(/^\d+\.\d+\.\d+/);
+    });
+
+    it('should export CURRENT_VERSION constant', () => {
+      expect(versionCheck.CURRENT_VERSION).toBeDefined();
+      expect(typeof versionCheck.CURRENT_VERSION).toBe('string');
+    });
+
+    it('should have consistent current version', () => {
+      expect(versionCheck.getCurrentVersion()).toBe(versionCheck.CURRENT_VERSION);
+    });
+  });
+
+  describe('exports', () => {
+    it('should export all functions', () => {
+      expect(versionCheck.checkUpdate).toBeDefined();
+      expect(versionCheck.getCurrentVersion).toBeDefined();
+      expect(versionCheck.compareVersions).toBeDefined();
+      expect(versionCheck.getLastCheckTime).toBeDefined();
+      expect(versionCheck.saveLastCheckTime).toBeDefined();
+      expect(versionCheck.CURRENT_VERSION).toBeDefined();
+    });
+
+    it('should export correct types', () => {
+      expect(typeof versionCheck.checkUpdate).toBe('function');
+      expect(typeof versionCheck.getCurrentVersion).toBe('function');
+      expect(typeof versionCheck.compareVersions).toBe('function');
+      expect(typeof versionCheck.getLastCheckTime).toBe('function');
+      expect(typeof versionCheck.saveLastCheckTime).toBe('function');
+    });
+  });
+});