feat: detect empty describe

Author: marabesi

detector/src/languages/TypescriptSmells.ts

@@ -3,6 +3,7 @@ import * as ts from 'typescript';
 import { Smell, SmellsFinder } from "../types";
 import { SmellsBuilder } from '../smells-builder';
 
+
 export class TypescriptSmells implements SmellsFinder {
 
   constructor(private readonly ast: ts.SourceFile) { }
@@ -110,12 +111,15 @@ export class TypescriptSmells implements SmellsFinder {
       );
     }
 
+    const emptyDescribe = this.findEmptyDescribes(ast);
+
     const result = ifs.concat(forOfs)
       .concat(forIns)
       .concat(fors)
       .concat(timeouts)
       .concat(consoles)
-      .concat(jestMockSmells);
+      .concat(jestMockSmells)
+      .concat(emptyDescribe);
     return result;
   }
 
@@ -215,4 +219,36 @@ export class TypescriptSmells implements SmellsFinder {
     });
     return functionCalls;
   }
+
+  private findEmptyDescribes(sourceFile: ts.SourceFile): Smell[] {
+    const emptyDescribes: Smell[] = [];
+
+    function traverse(node: ts.Node) {
+      if (ts.isCallExpression(node)) {
+        const expression = node.expression;
+        const isDescribeCall = ts.isIdentifier(expression) && expression.text === 'describe';
+        if (isDescribeCall && node.arguments.length === 2) {
+          const secondArg = node.arguments[1];
+          if (ts.isArrowFunction(secondArg) || ts.isFunctionExpression(secondArg)) {
+            const body = secondArg.body;
+            if (ts.isBlock(body) && body.statements.length === 0) {
+              const { line, character: startAt } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+              const { line: lineEnd, character: endsAt } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+              emptyDescribes.push(SmellsBuilder.emptyDescribe(
+                line + 1,
+                lineEnd + 1,
+                startAt,
+                endsAt,
+              ));
+            }
+          }
+        }
+      }
+
+      ts.forEachChild(node, traverse);
+    }
+
+    traverse(sourceFile);
+    return emptyDescribes;
+  }
 }

detector/src/smells-builder.ts

@@ -118,6 +118,23 @@ export class SmellsBuilder {
       description: `Smelly: Avoid mocking too many dependencies in the test file. Split the test cases to distribute the mocking load.`,
       diagnostic: `Smelly: Avoid mocking too many dependencies in the test file. Split the test cases to distribute the mocking load.`,
     };
+  }
+
+  public static emptyDescribe(
+    lineStart: number,
+    lineEnd: number,
+    startAt: number,
+    endsAt: number
+  ): Smell {
+    return {
+      type: SmellType.emptyDescribe,
+      lineStart,
+      lineEnd,
+      startAt,
+      endsAt,
+      description: 'Smelly: avoid empty test cases.',
+      diagnostic: 'Smelly: avoid empty test cases.',
+    };
 
   }
 }

detector/src/smells-detector.ts

@@ -26,11 +26,15 @@ export class SmellDetector {
     testCases.push(...foundItEachCalls);
     testCases.push(...this.findItSkipCalls(ast));
 
+    const smells = new TypescriptSmells(ast).searchSmells();
+
     const smellsList = {
       fileName: this.fileName,
       fileContent: this.code,
-      smells: new TypescriptSmells(ast).searchSmells(), language 
+      smells,
+      language 
     };
+
     return { smellsList, testCases };
   }
 

detector/src/smells/findDuplicatedTestCases.ts

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import { Smell, TestCase } from '../types';
+
+export class FindDuplicatedTestCases {
+  findTestCases(sourceFile: ts.SourceFile): TestCase[] {
+    const testCases: TestCase[] = [];
+
+    function traverse(node: ts.Node) {
+      if (ts.isCallExpression(node)) {
+        const expression = node.expression;
+        const isTestCall = ts.isIdentifier(expression) && (expression.text === 'it' || expression.text === 'test');
+        if (isTestCall && node.arguments.length > 1) {
+          const firstArg = node.arguments[0];
+          const secondArg = node.arguments[1];
+          if (ts.isStringLiteral(firstArg) && ts.isFunctionLike(secondArg)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            const { line: lineEnd, character: endsAt } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+            // const bodyText = secondArg.getText(sourceFile);
+            testCases.push({
+              lineStart: line + 1,
+              lineEnd: lineEnd + 1,
+              startAt: character,
+              endsAt: endsAt,
+            });
+          }
+        }
+      }
+
+      ts.forEachChild(node, traverse);
+    }
+
+    traverse(sourceFile);
+    return testCases;
+  }
+
+  detectDuplicateTestCases(testCases: TestCase[]): Smell[] {
+    const seen = new Map<string, TestCase[]>();
+    const duplicates: Smell[] = [];
+
+    for (const testCase of testCases) {
+      const key = `${testCase.lineStart}:${testCase.lineEnd}`;
+      if (!seen.has(key)) {
+        seen.set(key, []);
+      }
+      seen.get(key)!.push(testCase);
+    }
+
+    for (const [key, cases] of seen.entries()) {
+      if (cases.length > 1) {
+        duplicates.push({
+          type: 'duplicated-test-case',
+          description: `Duplicated test case: ${key}`,
+          diagnostic: `Duplicated test case: ${key}`,
+          lineStart: cases[0].lineStart,
+          lineEnd: cases[0].lineEnd,
+          startAt: cases[0].startAt,
+          endsAt: cases[0].endsAt,
+        });
+      }
+    }
+
+    return duplicates;
+  }
+}

detector/src/types.ts

@@ -48,4 +48,5 @@ export enum SmellType {
   timeOut = 'timeout',
   consoleStatement = "console-statement",
   jestMock = "excessive-jest-mock",
+  emptyDescribe = "empty-describe",
 }

detector/test/smells-detector-builder.ts

@@ -8,6 +8,7 @@ export const FOR = 'for-statement';
 export const TIMEOUT = 'timeout';
 export const CONSOLE = 'console-statement';
 export const MOCKERY = 'excessive-jest-mock';
+export const EMPTY_DESCRIBE = 'empty-describe';
 
 export const JAVASCRIPT_FILE = 'javascript.js';
 export const TYPESCRIPT_FILE = 'javascript.ts';

detector/test/smells-detector-with-smells.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { CONSOLE, FOR, FOR_IN, FOR_OF, IF_STATEMENT, MOCKERY, smellDetectorInstance, TIMEOUT, totalTestCaseDetectorInstance, JAVASCRIPT_FILE, TYPESCRIPT_FILE } from './smells-detector-builder';
+import { CONSOLE, FOR, FOR_IN, FOR_OF, IF_STATEMENT, MOCKERY, smellDetectorInstance, TIMEOUT, totalTestCaseDetectorInstance, JAVASCRIPT_FILE, TYPESCRIPT_FILE, EMPTY_DESCRIBE } from './smells-detector-builder';
 
 describe('Smelly Test Smell Detection Suite', () => {
   describe.each([[{
@@ -358,9 +358,21 @@ jest.mock("../");`,
     total: 1,
     description: `Smelly: Avoid mocking too many dependencies in the test file. Split the test cases to distribute the mocking load.`,
     diagnostic: `Smelly: Avoid mocking too many dependencies in the test file. Split the test cases to distribute the mocking load.`,
+  }],
+  [{
+    code: `describe('test', () => {})`,
+    fileName: JAVASCRIPT_FILE,
+    index: 0,
+    type: EMPTY_DESCRIBE,
+    lineStart: 1,
+    lineEnd: 1,
+    startAt: 0,
+    endsAt: 26,
+    total: 1,
+    description: `Smelly: avoid empty test cases.`,
+    diagnostic: `Smelly: avoid empty test cases.`,
   }]
   ])(`detect test smell for %s %s: type %s %s at index %s`, ({ code, fileName, index, type, lineStart, lineEnd, startAt, endsAt, total, description, diagnostic }) => {
-    
     test(`should find ${total} test smells`, () => {
       const result = smellDetectorInstance(code, fileName);
 

run-report.sh

@@ -2,6 +2,6 @@
 
 clear && \
   npm run build && \
-  rm smelly-report.html && \
-  npm run cli -w cli -- "$1" typescript --report=html --report-output=$(pwd) && \
+  rm -rf smelly-report.html && \
+  npm run cli -w cli -- "$1" --report=html --report-output=$(pwd) && \
   open smelly-report.html

vscode/src/dataset/javascript/no_smells.test.js

@@ -0,0 +1,5 @@
+describe("my test", () => {
+  it("a", () => {
+    expect(1).toBe(1);
+  });
+});

vscode/src/extension.ts

@@ -13,7 +13,7 @@ let currentDecoration: vscode.TextEditorDecorationType = warningDecorationType;
 let ranges: ComposedSmell[] = [];
 let hovers: vscode.Disposable[] = [];
 let collection: vscode.DiagnosticCollection;
-let smellyStatusBar: vscode.StatusBarItem;
+export let smellyStatusBar: vscode.StatusBarItem;
 
 function fetchConfiguration(): SmellyConfiguration {
   return vscode.workspace.getConfiguration().get<SmellyConfiguration>(EXTENSION_IDENTIFIER) || {};