feat: implement Python testing signal detection and conventions handling

Author: spivx

app/api/scan-repo/route.ts

@@ -6,8 +6,9 @@ import type {
     RepoScanSummary,
     RepoStructureSummary,
 } from "@/types/repo-scan"
-import { inferStackFromScan } from "@/lib/scan-to-wizard"
+import { collectConventionValues, normalizeConventionValue } from "@/lib/convention-values"
 import { loadStackConventions } from "@/lib/conventions"
+import { inferStackFromScan } from "@/lib/scan-to-wizard"
 
 const GITHUB_API_BASE_URL = "https://api.github.com"
 const GITHUB_HOSTNAMES = new Set(["github.com", "www.github.com"])
@@ -114,7 +115,10 @@ const detectStructure = (paths: string[]): RepoStructureSummary => {
     }
 }
 
-const detectTooling = (paths: string[], pkg: PackageJson | null): { tooling: string[]; testing: string[]; frameworks: string[] } => {
+const detectTooling = async (
+    paths: string[],
+    pkg: PackageJson | null,
+): Promise<{ tooling: string[]; testing: string[]; frameworks: string[] }> => {
     const tooling = new Set<string>()
     const testing = new Set<string>()
     const frameworks = new Set<string>()
@@ -276,13 +280,88 @@ const detectTooling = (paths: string[], pkg: PackageJson | null): { tooling: str
         }
     }
 
+    await detectPythonTestingSignals(paths, pkg, testing)
+
     return {
         tooling: dedupeAndSort(tooling),
         testing: dedupeAndSort(testing),
         frameworks: dedupeAndSort(frameworks),
     }
 }
 
+type TestingConventionValues = {
+    unit: string[]
+    e2e: string[]
+}
+
+const testingConventionCache = new Map<string, TestingConventionValues>()
+
+const getTestingConventionValues = async (stackId: string): Promise<TestingConventionValues> => {
+    const normalized = stackId.trim().toLowerCase()
+    if (testingConventionCache.has(normalized)) {
+        return testingConventionCache.get(normalized)!
+    }
+
+    const { conventions } = await loadStackConventions(normalized)
+    const values: TestingConventionValues = {
+        unit: collectConventionValues(conventions, "testingUT"),
+        e2e: collectConventionValues(conventions, "testingE2E"),
+    }
+    testingConventionCache.set(normalized, values)
+    return values
+}
+
+const findConventionValue = (values: string[], target: string): string | null => {
+    const normalizedTarget = normalizeConventionValue(target)
+    return values.find((value) => normalizeConventionValue(value) === normalizedTarget) ?? null
+}
+
+const BEHAVE_DEPENDENCIES = ["behave", "behave-django", "behave-webdriver"]
+
+export const detectPythonTestingSignals = async (
+    paths: string[],
+    pkg: PackageJson | null,
+    testing: Set<string>,
+): Promise<void> => {
+    const { unit } = await getTestingConventionValues("python")
+    if (unit.length === 0) {
+        return
+    }
+
+    const behaveValue = findConventionValue(unit, "behave")
+    const unittestValue = findConventionValue(unit, "unittest")
+
+    if (!behaveValue && !unittestValue) {
+        return
+    }
+
+    const lowerCasePaths = paths.map((path) => path.toLowerCase())
+
+    if (behaveValue) {
+        const hasFeaturesDir = lowerCasePaths.some((path) => path.startsWith("features/") || path.includes("/features/"))
+        const hasStepsDir = lowerCasePaths.some((path) => path.includes("/steps/"))
+        const hasEnvironment = lowerCasePaths.some((path) => path.endsWith("/environment.py") || path.endsWith("environment.py"))
+        const hasDependency = pkg ? dependencyHas(pkg, BEHAVE_DEPENDENCIES) : false
+
+        if (hasDependency || (hasFeaturesDir && (hasStepsDir || hasEnvironment))) {
+            testing.add(behaveValue)
+        }
+    }
+
+    if (unittestValue) {
+        const hasUnitFiles = lowerCasePaths.some((path) => {
+            if (!/(^|\/)(tests?|testcases|specs)\//.test(path)) {
+                return false
+            }
+            return /(^|\/)(test_[^/]+|[^/]+_test)\.py$/.test(path)
+        })
+
+        if (hasUnitFiles) {
+            testing.add(unittestValue)
+        }
+    }
+}
+
 const readPackageJson = async (
     owner: string,
     repo: string,
@@ -770,7 +849,7 @@ export async function GET(request: NextRequest): Promise<NextResponse<RepoScanRe
 
         const packageJson = hasPackageJson ? await readPackageJson(owner, repo, defaultBranch, headers) : null
 
-        const { tooling, testing, frameworks } = detectTooling(paths, packageJson)
+        const { tooling, testing, frameworks } = await detectTooling(paths, packageJson)
 
         if (lowestRateLimit !== null && lowestRateLimit < 5) {
             warnings.push(`GitHub API rate limit is low (remaining: ${lowestRateLimit}).`)

lib/__tests__/repo-scan-python-detection.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest"
+
+import { detectPythonTestingSignals } from "@/app/api/scan-repo/route"
+
+type PackageJson = {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+}
+
+const createPkg = (deps: Partial<PackageJson>): PackageJson => ({ ...deps })
+
+describe("detectPythonTestingSignals", () => {
+  it("adds behave when features directory structure is present", async () => {
+    const testing = new Set<string>()
+    await detectPythonTestingSignals(
+      ["features/example.feature", "features/steps/login_steps.py", "features/environment.py"],
+      null,
+      testing,
+    )
+
+    expect(Array.from(testing)).toContain("behave")
+  })
+
+  it("adds behave when dependency is detected", async () => {
+    const testing = new Set<string>()
+    await detectPythonTestingSignals(
+      [],
+      createPkg({ devDependencies: { behave: "^1.2.3" } }),
+      testing,
+    )
+
+    expect(Array.from(testing)).toContain("behave")
+  })
+
+  it("adds unittest when Python-style test files exist", async () => {
+    const testing = new Set<string>()
+    await detectPythonTestingSignals(["tests/test_example.py", "src/app.py"], null, testing)
+
+    expect(Array.from(testing)).toContain("unittest")
+  })
+})

lib/convention-values.ts

@@ -0,0 +1,32 @@
+import type { LoadedConvention } from "@/types/conventions"
+import type { WizardResponses } from "@/types/wizard"
+
+export const normalizeConventionValue = (value: string): string => value.trim().toLowerCase()
+
+export const collectConventionValues = (
+  conventions: LoadedConvention,
+  key: keyof WizardResponses,
+): string[] => {
+  const values: string[] = []
+  const seen = new Set<string>()
+
+  const pushValue = (candidate: unknown) => {
+    if (typeof candidate !== "string") {
+      return
+    }
+    const normalized = normalizeConventionValue(candidate)
+    if (!normalized || seen.has(normalized)) {
+      return
+    }
+    seen.add(normalized)
+    values.push(candidate)
+  }
+
+  pushValue(conventions.defaults[key])
+
+  conventions.rules.forEach((rule) => {
+    pushValue(rule.set?.[key])
+  })
+
+  return values
+}

lib/scan-to-wizard.ts

@@ -1,3 +1,4 @@
+import { collectConventionValues, normalizeConventionValue } from "@/lib/convention-values"
 import { applyConventionRules, loadStackConventions } from "@/lib/conventions"
 import { buildStepsForStack } from "@/lib/wizard-summary-data"
 import type { RepoScanSummary } from "@/types/repo-scan"
@@ -9,32 +10,6 @@ const STACK_FALLBACK = "react"
 const toLowerArray = (values: string[] | undefined | null) =>
   Array.isArray(values) ? values.map((value) => value.toLowerCase()) : []
 
-const normalizeString = (value: string) => value.trim().toLowerCase()
-
-const collectConventionValues = (
-  conventions: LoadedConvention,
-  key: keyof WizardResponses,
-): string[] => {
-  const values: string[] = []
-  const pushValue = (candidate: unknown) => {
-    if (typeof candidate !== "string") return
-    const normalizedCandidate = normalizeString(candidate)
-    if (normalizedCandidate.length === 0) return
-    if (values.some((existing) => normalizeString(existing) === normalizedCandidate)) {
-      return
-    }
-    values.push(candidate)
-  }
-
-  pushValue(conventions.defaults[key])
-
-  conventions.rules.forEach((rule) => {
-    pushValue(rule.set?.[key])
-  })
-
-  return values
-}
-
 const detectFromScanList = (
   scanList: string[] | undefined | null,
   conventions: LoadedConvention,
@@ -48,10 +23,10 @@ const detectFromScanList = (
     return null
   }
 
-  const normalizedScan = scanList.map((value) => normalizeString(value))
+  const normalizedScan = scanList.map((value) => normalizeConventionValue(value))
 
   for (const candidate of candidates) {
-    if (normalizedScan.includes(normalizeString(candidate))) {
+    if (normalizedScan.includes(normalizeConventionValue(candidate))) {
       return candidate
     }
   }