@aiready/testability 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,74 @@
+import { Issue, ToolScoringOutput } from '@aiready/core';
+
+interface TestabilityOptions {
+    /** Root directory to scan */
+    rootDir: string;
+    /** Minimum test-to-source ratio to consider acceptable (default: 0.3) */
+    minCoverageRatio?: number;
+    /** Custom test file patterns in addition to built-ins */
+    testPatterns?: string[];
+    /** Maximum scan depth */
+    maxDepth?: number;
+    /** File glob patterns to include */
+    include?: string[];
+    /** File glob patterns to exclude */
+    exclude?: string[];
+}
+interface TestabilityIssue extends Issue {
+    type: 'low-testability';
+    /** Category of testability barrier */
+    dimension: 'test-coverage' | 'purity' | 'dependency-injection' | 'interface-focus' | 'observability' | 'framework';
+}
+interface TestabilityReport {
+    summary: {
+        sourceFiles: number;
+        testFiles: number;
+        coverageRatio: number;
+        score: number;
+        rating: 'excellent' | 'good' | 'moderate' | 'poor' | 'unverifiable';
+        /** THE MOST IMPORTANT FIELD: is AI-generated code safe to ship? */
+        aiChangeSafetyRating: 'safe' | 'moderate-risk' | 'high-risk' | 'blind-risk';
+        dimensions: {
+            testCoverageRatio: number;
+            purityScore: number;
+            dependencyInjectionScore: number;
+            interfaceFocusScore: number;
+            observabilityScore: number;
+        };
+    };
+    issues: TestabilityIssue[];
+    rawData: {
+        sourceFiles: number;
+        testFiles: number;
+        pureFunctions: number;
+        totalFunctions: number;
+        injectionPatterns: number;
+        totalClasses: number;
+        bloatedInterfaces: number;
+        totalInterfaces: number;
+        externalStateMutations: number;
+        hasTestFramework: boolean;
+    };
+    recommendations: string[];
+}
+
+/**
+ * Testability analyzer.
+ *
+ * Walks the codebase and measures 5 structural dimensions that determine
+ * whether AI-generated changes can be safely verified:
+ * 1. Test file coverage ratio
+ * 2. Pure function prevalence
+ * 3. Dependency injection patterns
+ * 4. Interface focus (bloated interface detection)
+ * 5. Observability (return values vs. external state mutations)
+ */
+
+declare function analyzeTestability(options: TestabilityOptions): Promise<TestabilityReport>;
+
+/**
+ * Convert testability report into a ToolScoringOutput for the unified score.
+ */
+declare function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput;
+
+export { type TestabilityIssue, type TestabilityOptions, type TestabilityReport, analyzeTestability, calculateTestabilityScore };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { Issue, ToolScoringOutput } from '@aiready/core';
+
+interface TestabilityOptions {
+    /** Root directory to scan */
+    rootDir: string;
+    /** Minimum test-to-source ratio to consider acceptable (default: 0.3) */
+    minCoverageRatio?: number;
+    /** Custom test file patterns in addition to built-ins */
+    testPatterns?: string[];
+    /** Maximum scan depth */
+    maxDepth?: number;
+    /** File glob patterns to include */
+    include?: string[];
+    /** File glob patterns to exclude */
+    exclude?: string[];
+}
+interface TestabilityIssue extends Issue {
+    type: 'low-testability';
+    /** Category of testability barrier */
+    dimension: 'test-coverage' | 'purity' | 'dependency-injection' | 'interface-focus' | 'observability' | 'framework';
+}
+interface TestabilityReport {
+    summary: {
+        sourceFiles: number;
+        testFiles: number;
+        coverageRatio: number;
+        score: number;
+        rating: 'excellent' | 'good' | 'moderate' | 'poor' | 'unverifiable';
+        /** THE MOST IMPORTANT FIELD: is AI-generated code safe to ship? */
+        aiChangeSafetyRating: 'safe' | 'moderate-risk' | 'high-risk' | 'blind-risk';
+        dimensions: {
+            testCoverageRatio: number;
+            purityScore: number;
+            dependencyInjectionScore: number;
+            interfaceFocusScore: number;
+            observabilityScore: number;
+        };
+    };
+    issues: TestabilityIssue[];
+    rawData: {
+        sourceFiles: number;
+        testFiles: number;
+        pureFunctions: number;
+        totalFunctions: number;
+        injectionPatterns: number;
+        totalClasses: number;
+        bloatedInterfaces: number;
+        totalInterfaces: number;
+        externalStateMutations: number;
+        hasTestFramework: boolean;
+    };
+    recommendations: string[];
+}
+
+/**
+ * Testability analyzer.
+ *
+ * Walks the codebase and measures 5 structural dimensions that determine
+ * whether AI-generated changes can be safely verified:
+ * 1. Test file coverage ratio
+ * 2. Pure function prevalence
+ * 3. Dependency injection patterns
+ * 4. Interface focus (bloated interface detection)
+ * 5. Observability (return values vs. external state mutations)
+ */
+
+declare function analyzeTestability(options: TestabilityOptions): Promise<TestabilityReport>;
+
+/**
+ * Convert testability report into a ToolScoringOutput for the unified score.
+ */
+declare function calculateTestabilityScore(report: TestabilityReport): ToolScoringOutput;
+
+export { type TestabilityIssue, type TestabilityOptions, type TestabilityReport, analyzeTestability, calculateTestabilityScore };

package/dist/index.js

@@ -0,0 +1,365 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  analyzeTestability: () => analyzeTestability,
+  calculateTestabilityScore: () => calculateTestabilityScore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/analyzer.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_typescript_estree = require("@typescript-eslint/typescript-estree");
+var import_core = require("@aiready/core");
+var SRC_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var DEFAULT_EXCLUDES = ["node_modules", "dist", ".git", "coverage", ".turbo", "build"];
+var TEST_PATTERNS = [
+  /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+  /__tests__\//,
+  /\/tests?\//,
+  /\/e2e\//,
+  /\/fixtures\//
+];
+function isTestFile(filePath, extra) {
+  if (TEST_PATTERNS.some((p) => p.test(filePath))) return true;
+  if (extra) return extra.some((p) => filePath.includes(p));
+  return false;
+}
+function isSourceFile(filePath) {
+  return SRC_EXTENSIONS.has((0, import_path.extname)(filePath));
+}
+function collectFiles(dir, options, depth = 0) {
+  if (depth > (options.maxDepth ?? 20)) return [];
+  const excludes = [...DEFAULT_EXCLUDES, ...options.exclude ?? []];
+  const files = [];
+  let entries;
+  try {
+    entries = (0, import_fs.readdirSync)(dir);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    if (excludes.some((ex) => entry === ex || entry.includes(ex))) continue;
+    const full = (0, import_path.join)(dir, entry);
+    let stat;
+    try {
+      stat = (0, import_fs.statSync)(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(full, options, depth + 1));
+    } else if (stat.isFile() && isSourceFile(full)) {
+      if (!options.include || options.include.some((p) => full.includes(p))) {
+        files.push(full);
+      }
+    }
+  }
+  return files;
+}
+function countMethodsInInterface(node) {
+  if (node.type === "TSInterfaceDeclaration") {
+    return node.body.body.filter(
+      (m) => m.type === "TSMethodSignature" || m.type === "TSPropertySignature"
+    ).length;
+  }
+  if (node.type === "TSTypeAliasDeclaration" && node.typeAnnotation.type === "TSTypeLiteral") {
+    return node.typeAnnotation.members.length;
+  }
+  return 0;
+}
+function hasDependencyInjection(node) {
+  for (const member of node.body.body) {
+    if (member.type === "MethodDefinition" && member.key.type === "Identifier" && member.key.name === "constructor") {
+      const fn = member.value;
+      if (fn.params && fn.params.length > 0) {
+        const typedParams = fn.params.filter((p) => {
+          const param = p;
+          return param.typeAnnotation != null || param.parameter?.typeAnnotation != null;
+        });
+        if (typedParams.length > 0) return true;
+      }
+    }
+  }
+  return false;
+}
+function isPureFunction(fn) {
+  let hasReturn = false;
+  let hasSideEffect = false;
+  function walk(node) {
+    if (node.type === "ReturnStatement" && node.argument) hasReturn = true;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression") hasSideEffect = true;
+    if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && ["console", "process", "window", "document", "fs"].includes(node.callee.object.name)) hasSideEffect = true;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          child.forEach((c) => c?.type && walk(c));
+        } else if (child.type) {
+          walk(child);
+        }
+      }
+    }
+  }
+  if (fn.body?.type === "BlockStatement") {
+    fn.body.body.forEach((s) => walk(s));
+  } else if (fn.body) {
+    hasReturn = true;
+  }
+  return hasReturn && !hasSideEffect;
+}
+function hasExternalStateMutation(fn) {
+  let found = false;
+  function walk(node) {
+    if (found) return;
+    if (node.type === "AssignmentExpression" && node.left.type === "MemberExpression") found = true;
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) child.forEach((c) => c?.type && walk(c));
+        else if (child.type) walk(child);
+      }
+    }
+  }
+  if (fn.body?.type === "BlockStatement") fn.body.body.forEach((s) => walk(s));
+  return found;
+}
+function analyzeFileTestability(filePath) {
+  const result = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  let code;
+  try {
+    code = (0, import_fs.readFileSync)(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  let ast;
+  try {
+    ast = (0, import_typescript_estree.parse)(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return result;
+  }
+  function visit(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      result.totalFunctions++;
+      if (isPureFunction(node)) result.pureFunctions++;
+      if (hasExternalStateMutation(node)) result.externalStateMutations++;
+    }
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      result.totalClasses++;
+      if (hasDependencyInjection(node)) result.injectionPatterns++;
+    }
+    if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") {
+      result.totalInterfaces++;
+      const methodCount = countMethodsInInterface(node);
+      if (methodCount > 10) result.bloatedInterfaces++;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) child.forEach((c) => c?.type && visit(c));
+        else if (child.type) visit(child);
+      }
+    }
+  }
+  ast.body.forEach(visit);
+  return result;
+}
+function detectTestFramework(rootDir) {
+  const pkgPath = (0, import_path.join)(rootDir, "package.json");
+  if (!(0, import_fs.existsSync)(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const testFrameworks = ["jest", "vitest", "mocha", "jasmine", "ava", "tap", "pytest", "unittest"];
+    return testFrameworks.some((fw) => allDeps[fw]);
+  } catch {
+    return false;
+  }
+}
+async function analyzeTestability(options) {
+  const allFiles = collectFiles(options.rootDir, options);
+  const sourceFiles = allFiles.filter((f) => !isTestFile(f, options.testPatterns));
+  const testFiles = allFiles.filter((f) => isTestFile(f, options.testPatterns));
+  const aggregated = {
+    pureFunctions: 0,
+    totalFunctions: 0,
+    injectionPatterns: 0,
+    totalClasses: 0,
+    bloatedInterfaces: 0,
+    totalInterfaces: 0,
+    externalStateMutations: 0
+  };
+  for (const f of sourceFiles) {
+    const a = analyzeFileTestability(f);
+    for (const key of Object.keys(aggregated)) {
+      aggregated[key] += a[key];
+    }
+  }
+  const hasTestFramework = detectTestFramework(options.rootDir);
+  const indexResult = (0, import_core.calculateTestabilityIndex)({
+    testFiles: testFiles.length,
+    sourceFiles: sourceFiles.length,
+    pureFunctions: aggregated.pureFunctions,
+    totalFunctions: Math.max(1, aggregated.totalFunctions),
+    injectionPatterns: aggregated.injectionPatterns,
+    totalClasses: Math.max(1, aggregated.totalClasses),
+    bloatedInterfaces: aggregated.bloatedInterfaces,
+    totalInterfaces: Math.max(1, aggregated.totalInterfaces),
+    externalStateMutations: aggregated.externalStateMutations,
+    hasTestFramework
+  });
+  const issues = [];
+  const minCoverage = options.minCoverageRatio ?? 0.3;
+  const actualRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
+  if (!hasTestFramework) {
+    issues.push({
+      type: "low-testability",
+      dimension: "framework",
+      severity: "critical",
+      message: "No testing framework detected in package.json \u2014 AI changes cannot be verified at all.",
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Add Jest, Vitest, or another testing framework as a devDependency."
+    });
+  }
+  if (actualRatio < minCoverage) {
+    const needed = Math.ceil(sourceFiles.length * minCoverage) - testFiles.length;
+    issues.push({
+      type: "low-testability",
+      dimension: "test-coverage",
+      severity: actualRatio === 0 ? "critical" : "major",
+      message: `Test ratio is ${Math.round(actualRatio * 100)}% (${testFiles.length} test files for ${sourceFiles.length} source files). Need at least ${Math.round(minCoverage * 100)}%.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: `Add ~${needed} test file(s) to reach the ${Math.round(minCoverage * 100)}% minimum for safe AI assistance.`
+    });
+  }
+  if (indexResult.dimensions.purityScore < 50) {
+    issues.push({
+      type: "low-testability",
+      dimension: "purity",
+      severity: "major",
+      message: `Only ${indexResult.dimensions.purityScore}% of functions are pure \u2014 side-effectful functions require complex test setup.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Extract pure transformation logic from I/O and mutation code."
+    });
+  }
+  if (indexResult.dimensions.observabilityScore < 50) {
+    issues.push({
+      type: "low-testability",
+      dimension: "observability",
+      severity: "major",
+      message: `Many functions mutate external state directly \u2014 outputs are invisible to unit tests.`,
+      location: { file: options.rootDir, line: 0 },
+      suggestion: "Prefer returning values over mutating shared state."
+    });
+  }
+  return {
+    summary: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      coverageRatio: Math.round(actualRatio * 100) / 100,
+      score: indexResult.score,
+      rating: indexResult.rating,
+      aiChangeSafetyRating: indexResult.aiChangeSafetyRating,
+      dimensions: indexResult.dimensions
+    },
+    issues,
+    rawData: {
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      ...aggregated,
+      hasTestFramework
+    },
+    recommendations: indexResult.recommendations
+  };
+}
+
+// src/scoring.ts
+function calculateTestabilityScore(report) {
+  const { summary, rawData, recommendations } = report;
+  const factors = [
+    {
+      name: "Test Coverage",
+      impact: Math.round(summary.dimensions.testCoverageRatio - 50),
+      description: `${rawData.testFiles} test files / ${rawData.sourceFiles} source files (${Math.round(summary.coverageRatio * 100)}%)`
+    },
+    {
+      name: "Function Purity",
+      impact: Math.round(summary.dimensions.purityScore - 50),
+      description: `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`
+    },
+    {
+      name: "Dependency Injection",
+      impact: Math.round(summary.dimensions.dependencyInjectionScore - 50),
+      description: `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`
+    },
+    {
+      name: "Interface Focus",
+      impact: Math.round(summary.dimensions.interfaceFocusScore - 50),
+      description: `${rawData.bloatedInterfaces} interfaces have >10 methods`
+    },
+    {
+      name: "Observability",
+      impact: Math.round(summary.dimensions.observabilityScore - 50),
+      description: `${rawData.externalStateMutations} functions mutate external state`
+    }
+  ];
+  const recs = recommendations.map((action) => ({
+    action,
+    estimatedImpact: summary.aiChangeSafetyRating === "blind-risk" ? 15 : 8,
+    priority: summary.aiChangeSafetyRating === "blind-risk" || summary.aiChangeSafetyRating === "high-risk" ? "high" : "medium"
+  }));
+  return {
+    toolName: "testability",
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating,
+      aiChangeSafetyRating: summary.aiChangeSafetyRating,
+      coverageRatio: summary.coverageRatio
+    },
+    factors,
+    recommendations: recs
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeTestability,
+  calculateTestabilityScore
+});

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import {
+  analyzeTestability,
+  calculateTestabilityScore
+} from "./chunk-CYZ7DTWN.mjs";
+export {
+  analyzeTestability,
+  calculateTestabilityScore
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@aiready/testability",
+  "version": "0.1.1",
+  "description": "Measures how safely and verifiably AI-generated changes can be made to your codebase",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "aiready-testability": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "keywords": [
+    "aiready",
+    "testability",
+    "ai-safety",
+    "code-quality",
+    "copilot",
+    "claude",
+    "chatgpt",
+    "ai-assisted-development",
+    "testing",
+    "verification"
+  ],
+  "author": "AIReady Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/caopengau/aiready-testability.git"
+  },
+  "homepage": "https://github.com/caopengau/aiready-testability",
+  "dependencies": {
+    "@typescript-eslint/types": "^8.53.0",
+    "@typescript-eslint/typescript-estree": "^8.53.0",
+    "chalk": "^5.3.0",
+    "commander": "^14.0.0",
+    "glob": "^11.0.0",
+    "@aiready/core": "0.9.28"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "lint": "eslint src",
+    "clean": "rm -rf dist",
+    "release": "pnpm build && pnpm publish --no-git-checks"
+  }
+}

package/src/__tests__/analyzer.test.ts

@@ -0,0 +1,84 @@
+import { analyzeTestability } from '../analyzer';
+import { join } from 'path';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+
+describe('Testability Analyzer', () => {
+  const tmpDir = join(tmpdir(), 'aiready-testability-tests');
+
+  beforeAll(() => {
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createTestFile(name: string, content: string): string {
+    const filePath = join(tmpDir, name);
+    const dir = join(filePath, '..');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, content, 'utf8');
+    return filePath;
+  }
+
+  describe('Test Coverage Ratio', () => {
+    it('should calculate ratio of test files to source files', async () => {
+      createTestFile('src/math.ts', 'export const add = (a, b) => a + b;');
+      createTestFile('src/math.test.ts', 'import { add } from "./math"; test("add", () => {});');
+      createTestFile('src/string.ts', 'export const upper = (s) => s.toUpperCase();');
+
+      const report = await analyzeTestability({ rootDir: tmpDir });
+
+      expect(report.rawData.sourceFiles).toBeGreaterThanOrEqual(2);
+      expect(report.rawData.testFiles).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('Pure Functions and State Mutations', () => {
+    it('should detect state mutations inside functions', async () => {
+      createTestFile('src/mutations.ts', `
+        const globalState = { value: 0 };
+        
+        export function impureAdd(a: number) {
+          globalState.value += a; // mutation here
+          return globalState.value;
+        }
+
+        export function pureAdd(a: number, b: number) {
+          return a + b;
+        }
+      `);
+
+      const report = await analyzeTestability({ rootDir: tmpDir });
+
+      expect(report.rawData.externalStateMutations).toBeGreaterThanOrEqual(1);
+      expect(report.rawData.pureFunctions).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('Bloated Interfaces', () => {
+    it('should detect interfaces with too many methods', async () => {
+      createTestFile('src/interfaces.ts', `
+        export interface BloatedService {
+          m1(): void;
+          m2(): void;
+          m3(): void;
+          m4(): void;
+          m5(): void;
+          m6(): void;
+          m7(): void;
+          m8(): void;
+          m9(): void;
+          m10(): void;
+          m11(): void;
+        }
+      `);
+
+      const report = await analyzeTestability({ rootDir: tmpDir });
+
+      expect(report.rawData.bloatedInterfaces).toBeGreaterThanOrEqual(1);
+    });
+  });
+});