testeranto 0.200.1 → 0.202.0

package/src/services/GitHubAuthService.ts

@@ -0,0 +1,240 @@
+interface GitHubUser {
+  login: string;
+  id: number;
+  avatar_url: string;
+  name: string;
+  email: string;
+}
+
+type EventListener = (...args: any[]) => void;
+
+export class GitHubAuthService {
+  private static get CLIENT_ID(): string | undefined {
+    // Read from the global configuration
+    if (
+      typeof window !== "undefined" &&
+      (window as any).testerantoConfig?.githubOAuth?.clientId
+    ) {
+      return (window as any).testerantoConfig.githubOAuth.clientId;
+    }
+    console.log("GitHub OAuth client ID not found in configuration");
+    return undefined;
+  }
+  private static readonly REDIRECT_URI = `${window.location.origin}/auth/github/callback`;
+  private static readonly SCOPE = "repo user";
+
+  private accessToken: string | null = null;
+  private user: GitHubUser | null = null;
+  private listeners: Map<string, EventListener[]> = new Map();
+
+  constructor() {
+    this.loadStoredAuth();
+  }
+
+  on(event: string, listener: EventListener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(listener);
+  }
+
+  off(event: string, listener: EventListener) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      const index = eventListeners.indexOf(listener);
+      if (index > -1) {
+        eventListeners.splice(index, 1);
+      }
+    }
+  }
+
+  emit(event: string, ...args: any[]) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      eventListeners.forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(`Error in event listener for ${event}:`, error);
+        }
+      });
+    }
+  }
+
+  private loadStoredAuth() {
+    const token = localStorage.getItem("github_access_token");
+    const userStr = localStorage.getItem("github_user");
+
+    if (token) {
+      this.accessToken = token;
+    }
+
+    if (userStr) {
+      this.user = JSON.parse(userStr);
+    }
+  }
+
+  get isAuthenticated(): boolean {
+    return !!this.accessToken;
+  }
+
+  get userInfo(): GitHubUser | null {
+    return this.user;
+  }
+
+  get token(): string | null {
+    return this.accessToken;
+  }
+
+  initiateLogin() {
+    const clientId = GitHubAuthService.CLIENT_ID;
+    console.log("Initiating login with CLIENT_ID:", clientId);
+
+    if (!clientId) {
+      console.error(
+        "GitHub OAuth client ID is not configured. Please set GITHUB_CLIENT_ID environment variable."
+      );
+
+      // Provide helpful instructions for setup
+      const setupInstructions = `
+GitHub authentication is not configured.
+
+To set up GitHub OAuth:
+
+1. Go to https://github.com/settings/developers
+2. Create a new OAuth App
+3. Set Authorization callback URL to: ${GitHubAuthService.REDIRECT_URI}
+4. Add GITHUB_CLIENT_ID to your environment variables
+5. Restart the development server
+
+For development, you can create a .env file in the root directory with:
+GITHUB_CLIENT_ID=your_client_id_here
+
+Current environment analysis:
+- process.env.GITHUB_CLIENT_ID: ${
+        typeof process !== "undefined"
+          ? process.env?.GITHUB_CLIENT_ID || "undefined"
+          : "process undefined"
+      }
+- window.env.GITHUB_CLIENT_ID: ${
+        typeof window !== "undefined"
+          ? (window as any).env?.GITHUB_CLIENT_ID || "undefined"
+          : "window undefined"
+      }
+      `;
+
+      alert(setupInstructions);
+      return;
+    }
+    const authUrl = `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(
+      GitHubAuthService.REDIRECT_URI
+    )}&scope=${encodeURIComponent(GitHubAuthService.SCOPE)}`;
+    console.log("Opening auth popup:", authUrl);
+    
+    // Open in a popup window
+    const width = 600;
+    const height = 700;
+    const left = (window.screen.width - width) / 2;
+    const top = (window.screen.height - height) / 2;
+    
+    window.open(
+      authUrl,
+      'github-auth',
+      `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`
+    );
+  }
+
+  async handleCallback(code: string): Promise<boolean> {
+    try {
+      const response = await fetch("/api/auth/github/token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ code }),
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to exchange code for token");
+      }
+
+      const data = await response.json();
+      this.accessToken = data.access_token;
+
+      // Store token
+      localStorage.setItem("github_access_token", this.accessToken);
+
+      // Get user info
+      await this.fetchUserInfo();
+
+      this.emit("authChange", true);
+      return true;
+    } catch (error) {
+      console.error("Authentication failed:", error);
+      this.logout();
+      return false;
+    }
+  }
+
+  private async fetchUserInfo() {
+    if (!this.accessToken) return;
+
+    try {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          Accept: "application/vnd.github.v3+json",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch user info");
+      }
+
+      this.user = await response.json();
+      localStorage.setItem("github_user", JSON.stringify(this.user));
+    } catch (error) {
+      console.error("Failed to fetch user info:", error);
+    }
+  }
+
+  logout() {
+    this.accessToken = null;
+    this.user = null;
+    localStorage.removeItem("github_access_token");
+    localStorage.removeItem("github_user");
+    this.emit("authChange", false);
+  }
+
+  isConfigured(): boolean {
+    const clientId = GitHubAuthService.CLIENT_ID;
+    console.log("Checking if configured - CLIENT_ID:", clientId);
+    return !!clientId;
+  }
+
+  async makeAuthenticatedRequest(url: string, options: RequestInit = {}) {
+    if (!this.accessToken) {
+      throw new Error("Not authenticated");
+    }
+
+    const headers = {
+      Authorization: `Bearer ${this.accessToken}`,
+      Accept: "application/vnd.github.v3+json",
+      ...options.headers,
+    };
+
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    if (response.status === 401) {
+      this.logout();
+      throw new Error("Authentication expired");
+    }
+
+    return response;
+  }
+}
+
+export const githubAuthService = new GitHubAuthService();

package/src/testeranto.ts

@@ -4,19 +4,25 @@ import ansiC from "ansi-colors";
 import fs from "fs";
 import path from "path";
 import readline from "readline";
-import esbuild from "esbuild";
 
 import { ITestconfig, IRunTime, ITestTypes, IBuiltConfig } from "./lib";
 import { IProject } from "./Types";
 import { getRunnables } from "./utils";
 import { AppHtml } from "./utils/buildTemplates";
 
-import esbuildNodeConfiger from "./esbuildConfigs/node";
-import esbuildWebConfiger from "./esbuildConfigs/web";
-import esbuildImportConfiger from "./esbuildConfigs/pure";
 import webHtmlFrame from "./web.html";
 import { PM_Main } from "./PM/main";
 
+if (!process.env.GITHUB_CLIENT_ID) {
+  console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
+  process.exit(-1);
+}
+
+if (!process.env.GITHUB_CLIENT_SECRET) {
+  console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
+  process.exit(-1);
+}
+
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
@@ -42,10 +48,15 @@ import(f).then(async (module) => {
     process.exit(-1);
   }
 
-  fs.writeFileSync(
-    `${process.cwd()}/testeranto/projects.json`,
-    JSON.stringify(Object.keys(bigConfig.projects), null, 2)
-  );
+  try {
+    fs.writeFileSync(
+      `${process.cwd()}/testeranto/projects.json`,
+      JSON.stringify(Object.keys(bigConfig.projects), null, 2)
+    );
+  } catch (e) {
+    console.error("there was a problem");
+    console.error(e);
+  }
 
   const rawConfig: ITestconfig = bigConfig.projects[testName];
 
@@ -77,79 +88,11 @@ import(f).then(async (module) => {
     }
   });
 
-  let nodeDone: boolean = false;
-  let webDone: boolean = false;
-  let importDone: boolean = false;
-  let golangDone: boolean = false;
-  let pitonoDone: boolean = false;
-
-  let status: "build" | "built" = "build";
-
-  const {
-    nodeEntryPoints,
-    nodeEntryPointSidecars,
-    webEntryPoints,
-    webEntryPointSidecars,
-    pureEntryPoints,
-    pureEntryPointSidecars,
-  } = getRunnables(config.tests, testName);
-
-  const onNodeDone = () => {
-    nodeDone = true;
-    onDone();
-  };
-
-  const onWebDone = () => {
-    webDone = true;
-    onDone();
-  };
-
-  const onImportDone = () => {
-    importDone = true;
-    onDone();
-  };
-
-  const onGolangDone = () => {
-    golangDone = true;
-    onDone();
-  };
-
-  const onPitonoDone = () => {
-    pitonoDone = true;
-    onDone();
-  };
-
   let pm: PM_Main | null = null;
-  const onDone = async () => {
-    // Check which test types are present
-    const hasGolangTests = config.tests.some(test => test[1] === 'golang');
-    const hasPitonoTests = config.tests.some(test => test[1] === 'pitono');
-    
-    // Wait for all relevant runtimes to be done
-    const allDone = 
-      nodeDone && webDone && importDone && 
-      (!hasGolangTests || golangDone) && 
-      (!hasPitonoTests || pitonoDone);
-      
-    if (allDone) {
-      status = "built";
-
-      // Start the PM_Main to run the tests after build
-      if (!pm) {
-        const { PM_Main } = await import("./PM/main");
-        pm = new PM_Main(config, testName, mode);
-        await pm.start();
-      }
-    }
-    if (allDone && mode === "once") {
-      console.log(
-        ansiC.inverse(
-          `${testName} was built and the builder exited successfully.`
-        )
-      );
-      // Let PM_Main handle the exit after tests are complete
-    }
-  };
+  // Start PM_Main immediately - it will handle the build processes internally
+  const { PM_Main } = await import("./PM/main");
+  pm = new PM_Main(config, testName, mode);
+  await pm.start();
 
   fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
 
@@ -181,47 +124,60 @@ import(f).then(async (module) => {
   };
 
   // Also handle pitono endpoints for HTML generation if needed
-  [...getSecondaryEndpointsPoints("pitono")].forEach(async (sourceFilePath) => {
+  [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
     // You might want to generate specific files for pitono tests here
     console.log(`Pitono test found: ${sourceFilePath}`);
   });
 
   // Handle golang tests by generating their metafiles
-  const golangTests = config.tests.filter(test => test[1] === 'golang');
+  const golangTests = config.tests.filter((test) => test[1] === "golang");
   const hasGolangTests = golangTests.length > 0;
   if (hasGolangTests) {
     // Import and use the golang metafile utilities
-    const { generateGolangMetafile, writeGolangMetafile } = await import('./utils/golingvuMetafile');
+    const { generateGolangMetafile, writeGolangMetafile } = await import(
+      "./utils/golingvuMetafile"
+    );
     // Get the entry points (first element of each test tuple)
-    const golangEntryPoints = golangTests.map(test => test[0]);
+    const golangEntryPoints = golangTests.map((test) => test[0]);
     const metafile = await generateGolangMetafile(testName, golangEntryPoints);
     writeGolangMetafile(testName, metafile);
     // Mark golang as done after writing the metafile
-    onGolangDone();
+    // onGolangDone();
   }
 
   // Handle pitono (Python) tests by generating their metafiles
-  const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
+  const pitonoTests = config.tests.filter((test) => test[1] === "python");
   const hasPitonoTests = pitonoTests.length > 0;
   if (hasPitonoTests) {
     // Import and use the pitono metafile utilities
-    const { generatePitonoMetafile } = await import('./utils/pitonoMetafile');
+    const { generatePitonoMetafile } = await import("./utils/pitonoMetafile");
     // Get the entry points (first element of each test tuple)
-    const pitonoEntryPoints = pitonoTests.map(test => test[0]);
+    const pitonoEntryPoints = pitonoTests.map((test) => test[0]);
     const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
-    
+
     // Ensure the directory exists
     const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
     await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
-    
+
     // Write the metafile to the specified path
     fs.writeFileSync(
       `${pitonoMetafilePath}/core.json`,
       JSON.stringify(metafile, null, 2)
     );
-    
-    // Mark pitono as done after writing the metafile
-    onPitonoDone();
+
+    console.log(
+      ansiC.green(
+        ansiC.inverse(`Python metafile written to: ${pitonoMetafilePath}/core.json`)
+      )
+    );
+
+    // Add Python tests to the processing queue
+    pitonoEntryPoints.forEach((entryPoint) => {
+      if (pm) {
+        // For Python tests, the source file is the entry point itself
+        pm.addToQueue(entryPoint, "python");
+      }
+    });
   }
 
   Promise.resolve(
@@ -255,10 +211,22 @@ import(f).then(async (module) => {
     )
   );
 
+  const {
+    nodeEntryPoints,
+    nodeEntryPointSidecars,
+    webEntryPoints,
+    webEntryPointSidecars,
+    pureEntryPoints,
+    pureEntryPointSidecars,
+    pythonEntryPoints,
+    pythonEntryPointSidecars,
+  } = getRunnables(config.tests, testName);
+
   const x: [IRunTime, string[]][] = [
     ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
     ["web", Object.keys(webEntryPoints)],
+    ["python", Object.keys(pythonEntryPoints)],
   ];
 
   x.forEach(async ([runtime, keys]) => {
@@ -276,6 +244,7 @@ import(f).then(async (module) => {
     [pureEntryPoints, pureEntryPointSidecars, "pure"],
     [webEntryPoints, webEntryPointSidecars, "web"],
     [nodeEntryPoints, nodeEntryPointSidecars, "node"],
+    [pythonEntryPoints, pythonEntryPointSidecars, "python"],
   ].forEach(
     ([eps, eps2, runtime]: [
       Record<string, string>,
@@ -295,53 +264,6 @@ import(f).then(async (module) => {
     }
   );
 
-  await Promise.all([
-    ...(
-      [
-        [
-          esbuildImportConfiger,
-          pureEntryPoints,
-          pureEntryPointSidecars,
-          onImportDone,
-        ],
-        [
-          esbuildNodeConfiger,
-          nodeEntryPoints,
-          nodeEntryPointSidecars,
-          onNodeDone,
-        ],
-        [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
-      ] as [
-        (a, b, c) => any,
-        Record<string, string>,
-        Record<string, string>,
-        () => void
-      ][]
-    ).map(([configer, entryPoints, sidecars, done]) => {
-      esbuild
-        .context(
-          configer(
-            config,
-            [...Object.keys(entryPoints), ...Object.keys(sidecars)],
-            testName
-          )
-        )
-        .then(async (ctx) => {
-          if (mode === "dev") {
-            await ctx.watch().then((v) => {
-              done();
-            });
-          } else {
-            ctx.rebuild().then((v) => {
-              done();
-            });
-          }
-
-          return ctx;
-        });
-    }),
-  ]);
-
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
       console.log("Testeranto is shutting down gracefully...");

package/src/utils/api.ts

@@ -1,14 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ISummary, IBuiltConfig } from "../Types";
-import { 
-  getLogFilesForRuntime,
-  STANDARD_LOGS 
-} from "./logFiles";
+import { getLogFilesForRuntime, STANDARD_LOGS } from "./logFiles";
 
 export const fetchProjectData = async (projectName: string) => {
   const [summaryRes, configRes] = await Promise.all([
-    fetch(`reports/${projectName}/summary.json`),
-    fetch("reports/config.json"),
+    fetch(summaryDotJson(projectName)),
+    fetch("/reports/config.json"),
   ]);
 
   return {
@@ -39,11 +36,11 @@ export const fetchTestData = async (
       try {
         const response = await fetch(`${basePath}/${file}`);
         if (!response.ok) return null;
-        
-        const content = file.endsWith('.json') 
+
+        const content = file.endsWith(".json")
           ? await response.json()
           : await response.text();
-        
+
         return { file, content };
       } catch (err) {
         console.error(`Failed to fetch ${file}:`, err);
@@ -53,7 +50,7 @@ export const fetchTestData = async (
 
     // Wait for all requests and populate logs
     const logResults = await Promise.all(logRequests);
-    logResults.forEach(result => {
+    logResults.forEach((result) => {
       if (result) {
         logs[result.file] = result.content;
       }
@@ -65,7 +62,7 @@ export const fetchTestData = async (
         try {
           const response = await fetch(`${basePath}/${file}`);
           if (response.ok) {
-            logs[file] = file.endsWith('.json') 
+            logs[file] = file.endsWith(".json")
               ? await response.json()
               : await response.text();
           }
@@ -84,13 +81,14 @@ export const fetchTestData = async (
     if (Object.keys(logs).length === 0) {
       return {
         logs: {},
-        error: "No test logs found. The test may not have run or the report files are missing."
+        error:
+          "No test logs found. The test may not have run or the report files are missing.",
       };
     }
 
     return {
       logs,
-      error: null
+      error: null,
     };
   } catch (err) {
     return {
@@ -104,3 +102,7 @@ export const fetchTestData = async (
     };
   }
 };
+
+export const summaryDotJson = (name: string): string => {
+  return `reports/${name}/summary.json`;
+};

package/src/utils/gitTest.ts

@@ -0,0 +1,29 @@
+import { getFileService } from '../services/FileService';
+
+export const testGitIntegration = async () => {
+  try {
+    const fileService = getFileService('dev');
+    
+    // Test basic file operations
+    const testContent = '// Test file content\nconsole.log("Hello Git!");';
+    await fileService.writeFile('test-file.ts', testContent);
+    
+    const content = await fileService.readFile('test-file.ts');
+    console.log('File content:', content);
+    
+    const exists = await fileService.exists('test-file.ts');
+    console.log('File exists:', exists);
+    
+    // Test Git operations
+    const changes = await fileService.getChanges();
+    console.log('Changes:', changes);
+    
+    const branch = await fileService.getCurrentBranch();
+    console.log('Current branch:', branch);
+    
+    return { success: true, changes, branch };
+  } catch (error) {
+    console.error('Git integration test failed:', error);
+    return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+  }
+};