testeranto 0.202.0 → 0.205.0

package/pitono/base_then.py

@@ -1,50 +0,0 @@
-from typing import Any, Dict, List
-
-class BaseThen:
-    def __init__(self, name: str, then_cb: Any):
-        self.name = name
-        self.then_cb = then_cb
-        self.error = False
-        self.artifacts: List[str] = []
-    
-    def add_artifact(self, path: str) -> None:
-        normalized_path = path.replace('\\', '/')
-        self.artifacts.append(normalized_path)
-    
-    def to_obj(self) -> Dict[str, Any]:
-        return {
-            'name': self.name,
-            'error': self.error,
-            'artifacts': self.artifacts
-        }
-    
-    async def but_then(
-        self,
-        store: Any,
-        then_cb: Any,
-        test_resource_configuration,
-        pm: Any
-    ) -> Any:
-        raise NotImplementedError()
-    
-    async def test(
-        self,
-        store: Any,
-        test_resource_configuration,
-        t_log: Any,
-        pm: Any,
-        filepath: str
-    ) -> Any:
-        try:
-            add_artifact = self.add_artifact
-            # Simple implementation for now
-            result = await self.but_then(
-                store,
-                self.then_cb,
-                test_resource_configuration,
-                pm
-            )
-            return result
-        except Exception as e:
-            self.error = True
-            raise e

package/pitono/base_when.py

@@ -1,52 +0,0 @@
-from typing import Any, Dict, List
-
-class BaseWhen:
-    def __init__(self, name: str, when_cb: Any):
-        self.name = name
-        self.when_cb = when_cb
-        self.artifacts: List[str] = []
-        self.error: Any = None
-    
-    def add_artifact(self, path: str) -> None:
-        normalized_path = path.replace('\\', '/')
-        self.artifacts.append(normalized_path)
-    
-    def to_obj(self) -> Dict[str, Any]:
-        return {
-            'name': self.name,
-            'error': str(self.error) if self.error else None,
-            'artifacts': self.artifacts
-        }
-    
-    async def and_when(
-        self,
-        store: Any,
-        when_cb: Any,
-        test_resource: Any,
-        pm: Any
-    ) -> Any:
-        raise NotImplementedError()
-    
-    async def test(
-        self,
-        store: Any,
-        test_resource_configuration,
-        t_log: Any,
-        pm: Any,
-        filepath: str
-    ) -> Any:
-        try:
-            # Ensure add_artifact is properly bound to 'this'
-            add_artifact = self.add_artifact
-            # In Python, we can just pass self.add_artifact directly
-            # For now, we'll implement a simple version
-            result = await self.and_when(
-                store,
-                self.when_cb,
-                test_resource_configuration,
-                pm
-            )
-            return result
-        except Exception as e:
-            self.error = e
-            raise e

package/pitono/pitono.egg-info/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: pitono
-Version: 0.1.0
-Summary: Python implementation of Testeranto
-Author: Testeranto Team
-Author-email: 
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Dynamic: requires-python

package/pitono/pitono.egg-info/SOURCES.txt

@@ -1,7 +0,0 @@
-pyproject.toml
-setup.py
-pitono.egg-info/PKG-INFO
-pitono.egg-info/SOURCES.txt
-pitono.egg-info/dependency_links.txt
-pitono.egg-info/entry_points.txt
-pitono.egg-info/top_level.txt

package/pitono/types.py

@@ -1,78 +0,0 @@
-from typing import TypeVar, Generic, Callable, Any, Dict, List, Optional
-
-# Type variables for BDD input/output types
-Iinput = TypeVar('Iinput')
-Isubject = TypeVar('Isubject')
-Istore = TypeVar('Istore')
-Iselection = TypeVar('Iselection')
-Then = TypeVar('Then')
-Given = TypeVar('Given')
-
-# Test resource configuration
-class ITTestResourceConfiguration:
-    def __init__(
-        self,
-        name: str,
-        fs: str,
-        ports: List[int],
-        browser_ws_endpoint: Optional[str] = None,
-        timeout: Optional[int] = None,
-        retries: Optional[int] = None,
-        environment: Optional[Dict[str, str]] = None
-    ):
-        self.name = name
-        self.fs = fs
-        self.ports = ports
-        self.browser_ws_endpoint = browser_ws_endpoint
-        self.timeout = timeout
-        self.retries = retries
-        self.environment = environment or {}
-
-# Test adapter interface
-class ITestAdapter:
-    def before_all(self, input_val: Any, tr: ITTestResourceConfiguration, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def after_all(self, store: Any, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def before_each(self, subject: Any, initializer: Any, test_resource: ITTestResourceConfiguration, 
-                   initial_values: Any, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def after_each(self, store: Any, key: str, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def and_when(self, store: Any, when_cb: Any, test_resource: Any, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def but_then(self, store: Any, then_cb: Any, test_resource: Any, pm: Any) -> Any:
-        raise NotImplementedError()
-    
-    def assert_this(self, t: Any) -> bool:
-        raise NotImplementedError()
-
-# Test specification function type
-ITestSpecification = Callable[[Any, Any, Any, Any], Any]
-
-# Test implementation structure
-class ITestImplementation:
-    def __init__(self, suites: Dict[str, Any], givens: Dict[str, Any], 
-                 whens: Dict[str, Any], thens: Dict[str, Any]):
-        self.suites = suites
-        self.givens = givens
-        self.whens = whens
-        self.thens = thens
-
-# Test resource request
-class ITTestResourceRequest:
-    def __init__(self, ports: int):
-        self.ports = ports
-
-# Final results
-class IFinalResults:
-    def __init__(self, failed: bool, fails: int, artifacts: List[Any], features: List[str]):
-        self.failed = failed
-        self.fails = fails
-        self.artifacts = artifacts
-        self.features = features

package/src/App.tsx

@@ -1,228 +0,0 @@
-import React, { useState, useEffect, createContext, useContext } from 'react';
-import ReactDom from "react-dom/client";
-import { HashRouter as Router, Routes, Route } from 'react-router-dom';
-
-import { TestPage } from './components/stateful/TestPage';
-import { ProjectPage } from './components/stateful/ProjectPage';
-import { ProjectsPage } from './components/stateful/ProjectsPage';
-import { AppFrame } from './components/pure/AppFrame';
-import { SignIn } from './components/pure/SignIn';
-import { FeaturesReporter } from './components/stateful/FeaturesReporter';
-import { DesignEditorPage } from './components/DesignEditorPage';
-import { TextEditorPage } from './components/stateful/TextEditorPage';
-import { ProcessManagerPage } from './components/stateful/ProcessManagerPage';
-import { SingleProcessPage } from './components/stateful/SingleProcessPage';
-import { Settings } from './components/pure/Settings';
-import { GitIntegrationPage } from './components/stateful/GitIntegrationPage';
-import { AuthCallbackPage } from './components/stateful/AuthCallbackPage';
-import { githubAuthService } from './services/GitHubAuthService';
-import { SVGEditorPage } from './components/stateful/SVGEditorPage';
-
-interface WebSocketContextType {
-  ws: WebSocket | null;
-  isConnected: boolean;
-}
-
-interface TutorialModeContextType {
-  tutorialMode: boolean;
-  setTutorialMode: (mode: boolean) => void;
-}
-
-interface AuthContextType {
-  isAuthenticated: boolean;
-  user: any;
-  login: () => void;
-  logout: () => void;
-}
-
-// Create a context for the WebSocket
-const WebSocketContext = createContext<WebSocketContextType>({
-  ws: null,
-  isConnected: false,
-});
-
-// Create a context for tutorial mode
-const TutorialModeContext = createContext<TutorialModeContextType>({
-  tutorialMode: false,
-  setTutorialMode: () => {},
-});
-
-// Create a context for authentication
-const AuthContext = createContext<AuthContextType>({
-  isAuthenticated: false,
-  user: null,
-  login: () => {},
-  logout: () => {},
-});
-
-export const useWebSocket = () => {
-  return useContext(WebSocketContext);
-};
-
-export const useTutorialMode = () => {
-  return useContext(TutorialModeContext);
-};
-
-export const useAuth = () => {
-  return useContext(AuthContext);
-};
-
-export const App = () => {
-  const [ws, setWs] = useState<WebSocket | null>(null);
-  const [isConnected, setIsConnected] = useState(false);
-  const [tutorialMode, setTutorialMode] = useState(false);
-  const [isAuthenticated, setIsAuthenticated] = useState(githubAuthService.isAuthenticated);
-  const [user, setUser] = useState(githubAuthService.userInfo);
-
-  useEffect(() => {
-    // Load tutorial mode from localStorage
-    const savedTutorialMode = localStorage.getItem('tutorialMode');
-    if (savedTutorialMode) {
-      setTutorialMode(savedTutorialMode === 'true');
-    }
-
-    // Listen for auth changes
-    const handleAuthChange = (authenticated: boolean) => {
-      setIsAuthenticated(authenticated);
-      setUser(githubAuthService.userInfo);
-    };
-
-    githubAuthService.on('authChange', handleAuthChange);
-    
-    // Handle GitHub OAuth callback from popup
-    const handleMessage = async (event: MessageEvent) => {
-      if (event.data.type === 'github-auth-callback') {
-        const { code } = event.data;
-        try {
-          const success = await githubAuthService.handleCallback(code);
-          if (success) {
-            console.log('GitHub authentication successful');
-          } else {
-            console.error('GitHub authentication failed');
-          }
-        } catch (error) {
-          console.error('Error handling GitHub callback:', error);
-        }
-      } else if (event.data.type === 'github-auth-error') {
-        console.error('GitHub authentication error:', event.data.error);
-      }
-    };
-
-    window.addEventListener('message', handleMessage);
-    
-    const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const wsUrl = `${wsProtocol}//${window.location.host}`;
-    const websocket = new WebSocket(wsUrl);
-    
-    websocket.onopen = () => {
-      console.log('WebSocket connected');
-      setWs(websocket);
-      setIsConnected(true);
-    };
-    
-    websocket.onclose = () => {
-      console.log('WebSocket disconnected');
-      setWs(null);
-      setIsConnected(false);
-    };
-    
-    websocket.onerror = (error) => {
-      console.error('WebSocket error:', error);
-      setIsConnected(false);
-    };
-
-    return () => {
-      githubAuthService.off('authChange', handleAuthChange);
-      window.removeEventListener('message', handleMessage);
-      websocket.close();
-    };
-  }, []);
-
-  const authContextValue = {
-    isAuthenticated,
-    user,
-    login: () => githubAuthService.initiateLogin(),
-    logout: () => githubAuthService.logout(),
-  };
-
-  return (
-    <WebSocketContext.Provider value={{ ws, isConnected }}>
-      <TutorialModeContext.Provider value={{ tutorialMode, setTutorialMode }}>
-        <AuthContext.Provider value={authContextValue}>
-          <Router>
-            <AppFrame>
-              <Routes>
-                {/* Public routes */}
-                <Route path="/" element={<ProjectsPage />} />
-                <Route path="/projects/:projectName" element={<ProjectPage />} />
-                <Route path="/projects/:projectName/tests/*" element={<TestPage />} />
-                <Route path="/projects/:projectName#:tab" element={<ProjectPage />} />
-                <Route path="/signin" element={<SignIn />} />
-                <Route path="/auth/github/callback" element={<AuthCallbackPage />} />
-                
-                {/* Protected routes - handle authentication within components */}
-                <Route path="/features-reporter" element={isAuthenticated ? <FeaturesReporter /> : <SignIn />} />
-                <Route path="/design-editor" element={isAuthenticated ? <DesignEditorPage /> : <SignIn />} />
-                <Route path="/text-editor" element={isAuthenticated ? <TextEditorPage /> : <SignIn />} />
-                {/* Conditionally render process-related routes only if WebSocket is connected */}
-                {isConnected ? (
-                  <>
-                    <Route path="/processes" element={isAuthenticated ? <ProcessManagerPage /> : <SignIn />} />
-                    <Route path="/processes/:processId" element={isAuthenticated ? <SingleProcessPage /> : <SignIn />} />
-                  </>
-                ) : null}
-                <Route path="/settings" element={<Settings />} />
-                <Route path="/git" element={isAuthenticated ? <GitIntegrationPage /> : <SignIn />} />
-                <Route path="/svg-editor" element={isAuthenticated ? <SVGEditorPage /> : <SignIn />} />
-                
-                {/* Catch all - redirect to home for logged out users */}
-                <Route path="*" element={<ProjectsPage />} />
-              </Routes>
-            </AppFrame>
-          </Router>
-        </AuthContext.Provider>
-      </TutorialModeContext.Provider>
-    </WebSocketContext.Provider>
-  );
-};
-
-// Export App to global scope
-function initApp() {
-  const rootElement = document.getElementById('root');
-  if (rootElement) {
-    try {
-      // Try to use React 18's createRoot if available
-      if (ReactDom.createRoot) {
-        const root = ReactDom.createRoot(rootElement);
-        root.render(React.createElement(App));
-      } else {
-        // Fall back to React 17's render
-        ReactDom.render(React.createElement(App), rootElement);
-      }
-    } catch (err) {
-      console.error('Error rendering app:', err);
-      // Retry if React isn't loaded yet
-      setTimeout(initApp, 100);
-    }
-  } else {
-    // Retry if root element isn't available yet
-    setTimeout(initApp, 100);
-  }
-}
-
-// Export App to global scope
-if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-  // @ts-ignore
-  window.App = App;
-  // @ts-ignore
-  window.React = React;
-  // @ts-ignore
-  window.ReactDOM = ReactDom;
-  
-  // Initialize the app when the window is ready
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', initApp);
-  } else {
-    initApp();
-  }
-}

package/src/PM/PM_WithBuild.ts

@@ -1,171 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import esbuild from "esbuild";
-
-import { IBuiltConfig } from "../Types.js";
-import esbuildNodeConfiger from "../esbuildConfigs/node.js";
-import esbuildWebConfiger from "../esbuildConfigs/web.js";
-import esbuildImportConfiger from "../esbuildConfigs/pure.js";
-import { getRunnables } from "../utils.js";
-
-import { PM_WithWebSocket } from "./PM_WithWebSocket.js";
-
-export abstract class PM_WithBuild extends PM_WithWebSocket {
-  configs: IBuiltConfig;
-  name: string;
-  mode: "once" | "dev";
-  currentBuildResolve: (() => void) | null = null;
-  currentBuildReject: ((error: any) => void) | null = null;
-
-  constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
-    super(configs);
-    this.configs = configs;
-    this.name = name;
-    this.mode = mode;
-  }
-
-  async startBuildProcesses(): Promise<void> {
-    const { nodeEntryPoints, webEntryPoints, pureEntryPoints } = getRunnables(
-      this.configs.tests,
-      this.name
-    );
-
-    console.log(`Starting build processes for ${this.name}...`);
-    console.log(`  Node entry points: ${Object.keys(nodeEntryPoints).length}`);
-    console.log(`  Web entry points: ${Object.keys(webEntryPoints).length}`);
-    console.log(`  Pure entry points: ${Object.keys(pureEntryPoints).length}`);
-
-    // Start all build processes (only node, web, pure)
-    await Promise.all([
-      this.startBuildProcess(esbuildNodeConfiger, nodeEntryPoints, "node"),
-      this.startBuildProcess(esbuildWebConfiger, webEntryPoints, "web"),
-      this.startBuildProcess(esbuildImportConfiger, pureEntryPoints, "pure"),
-    ]);
-  }
-
-  private async startBuildProcess(
-    configer: (
-      config: IBuiltConfig,
-      entryPoints: string[],
-      testName: string
-    ) => any,
-    entryPoints: Record<string, string>,
-    runtime: string
-  ): Promise<void> {
-    const entryPointKeys = Object.keys(entryPoints);
-    if (entryPointKeys.length === 0) return;
-
-    // Store reference to 'this' for use in the plugin
-    const self = this;
-
-    // Create a custom plugin to track build processes
-    const buildProcessTrackerPlugin = {
-      name: 'build-process-tracker',
-      setup(build) {
-        build.onStart(() => {
-          const processId = `build-${runtime}-${Date.now()}`;
-          const command = `esbuild ${runtime} for ${self.name}`;
-          
-          // Create a promise that will resolve when the build completes
-          const buildPromise = new Promise<void>((resolve, reject) => {
-            // Store resolve and reject functions to call them in onEnd
-            self.currentBuildResolve = resolve;
-            self.currentBuildReject = reject;
-          });
-
-          // Add to process manager
-          if (self.addPromiseProcess) {
-            self.addPromiseProcess(
-              processId,
-              buildPromise,
-              command,
-              "build-time",
-              self.name,
-              runtime as any
-            );
-          }
-
-          console.log(`Starting ${runtime} build for ${entryPointKeys.length} entry points`);
-          // Broadcast build start event
-          if (self.broadcast) {
-            self.broadcast({
-              type: "buildEvent",
-              event: "start",
-              runtime,
-              timestamp: new Date().toISOString(),
-              entryPoints: entryPointKeys.length,
-              processId
-            });
-          }
-        });
-        
-        build.onEnd((result) => {
-          const event = {
-            type: "buildEvent",
-            event: result.errors.length > 0 ? "error" : "success",
-            runtime,
-            timestamp: new Date().toISOString(),
-            errors: result.errors.length,
-            warnings: result.warnings.length
-          };
-          
-          if (result.errors.length > 0) {
-            console.error(`Build ${runtime} failed with ${result.errors.length} errors`);
-            if (self.currentBuildReject) {
-              self.currentBuildReject(new Error(`Build failed with ${result.errors.length} errors`));
-            }
-          } else {
-            console.log(`Build ${runtime} completed successfully`);
-            if (self.currentBuildResolve) {
-              self.currentBuildResolve();
-            }
-          }
-          
-          // Broadcast build result event
-          if (self.broadcast) {
-            self.broadcast(event);
-          }
-
-          // Clear the current build handlers
-          self.currentBuildResolve = null;
-          self.currentBuildReject = null;
-        });
-      }
-    };
-
-    // Get the base config and add our tracking plugin
-    const baseConfig = configer(this.configs, entryPointKeys, this.name);
-    const configWithPlugin = {
-      ...baseConfig,
-      plugins: [...(baseConfig.plugins || []), buildProcessTrackerPlugin]
-    };
-
-    try {
-      const ctx = await esbuild.context(configWithPlugin);
-
-      if (this.mode === "dev") {
-        // In dev mode, start watching - each rebuild will be tracked as a separate process
-        await ctx.watch();
-      } else {
-        // In once mode, do a single build which will be tracked by the plugin
-        const result = await ctx.rebuild();
-        await ctx.dispose();
-      }
-    } catch (error) {
-      console.error(`Failed to start ${runtime} build context:`, error);
-      // Broadcast error event
-      if (this.broadcast) {
-        this.broadcast({
-          type: "buildEvent",
-          event: "error",
-          runtime,
-          timestamp: new Date().toISOString(),
-          errors: 1,
-          warnings: 0,
-          message: error.message
-        });
-      }
-    }
-  }
-
-  abstract onBuildDone(): void;
-}