testeranto 0.202.0 → 0.203.0

package/pitono/__init__.py

@@ -1,54 +0,0 @@
-from typing import Any, List, Dict, Callable
-from .types import ITestSpecification, ITestImplementation, ITestAdapter, ITTestResourceRequest
-from .simple_adapter import SimpleTestAdapter
-
-class Pitono:
-    def __init__(
-        self,
-        input_val: Any,
-        test_specification: ITestSpecification,
-        test_implementation: ITestImplementation,
-        test_resource_requirement: ITTestResourceRequest,
-        test_adapter: ITestAdapter,
-        uber_catcher: Callable[[Callable], None]
-    ):
-        self.test_resource_requirement = test_resource_requirement
-        self.artifacts: List[Any] = []
-        self.test_jobs: List[Any] = []
-        self.test_specification = test_specification
-        self.suites_overrides: Dict[str, Any] = {}
-        self.given_overrides: Dict[str, Any] = {}
-        self.when_overrides: Dict[str, Any] = {}
-        self.then_overrides: Dict[str, Any] = {}
-        self.puppet_master: Any = None
-        self.specs: Any = None
-        self.assert_this_func = test_adapter.assert_this
-        
-        # Generate specs
-        self.specs = test_specification(
-            self.suites(),
-            self.given(),
-            self.when(),
-            self.then()
-        )
-    
-    def suites(self) -> Dict[str, Any]:
-        return self.suites_overrides
-    
-    def given(self) -> Dict[str, Any]:
-        return self.given_overrides
-    
-    def when(self) -> Dict[str, Any]:
-        return self.when_overrides
-    
-    def then(self) -> Dict[str, Any]:
-        return self.then_overrides
-    
-    def get_test_jobs(self) -> List[Any]:
-        return self.test_jobs
-    
-    def get_specs(self) -> Any:
-        return self.specs
-    
-    def assert_this(self, t: Any) -> Any:
-        return self.assert_this_func(t)

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/PM/metafileOutputs.ts

@@ -1,90 +0,0 @@
-// import { IRunTime } from "../Types";
-// import { IOutputs, filesHash } from "./utils";
-
-// import ansiC from "ansi-colors";
-// import fs from "fs";
-
-// export const metafileOutputs = async (platform: IRunTime) => {
-//   let metafilePath: string;
-//   if (platform === "python") {
-//     metafilePath = `./testeranto/metafiles/python/core.json`;
-//   } else {
-//     metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
-//   }
-
-//   // Check if the file exists
-//   if (!fs.existsSync(metafilePath)) {
-//     if (platform === "python") {
-//       console.log(
-//         ansiC.yellow(
-//           ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`)
-//         )
-//       );
-//     }
-//     return;
-//   }
-
-//   let metafile;
-//   try {
-//     const fileContent = fs.readFileSync(metafilePath).toString();
-//     const parsedData = JSON.parse(fileContent);
-//     // Handle different metafile structures
-//     if (platform === "python") {
-//       // Pitono metafile might be the entire content or have a different structure
-//       metafile = parsedData.metafile || parsedData;
-//     } else {
-//       metafile = parsedData.metafile;
-//     }
-//     if (!metafile) {
-//       console.log(
-//         ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
-//       );
-//       return;
-//     }
-//   } catch (error) {
-//     console.error(`Error reading metafile at ${metafilePath}:`, error);
-//     return;
-//   }
-
-//   const outputs: IOutputs = metafile.outputs;
-
-//   Object.keys(outputs).forEach(async (k) => {
-//     const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
-//     if (!k.startsWith(pattern)) {
-//       return false;
-//     }
-
-//     const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-//       if (!fs.existsSync(i)) return false;
-//       if (i.startsWith("node_modules")) return false;
-//       if (i.startsWith("./node_modules")) return false;
-
-//       return true;
-//     });
-
-//     const f = `${k.split(".").slice(0, -1).join(".")}/`;
-
-//     if (!fs.existsSync(f)) {
-//       fs.mkdirSync(f);
-//     }
-
-//     const entrypoint = outputs[k].entryPoint;
-
-//     if (entrypoint) {
-//       const changeDigest = await filesHash(addableFiles);
-
-//       if (changeDigest === changes[entrypoint]) {
-//         // skip
-//       } else {
-//         changes[entrypoint] = changeDigest;
-//         this.tscCheck({
-//           platform,
-//           addableFiles,
-//           entrypoint: entrypoint,
-//         });
-//         this.eslintCheck(entrypoint, platform, addableFiles);
-//         this.makePrompt(entrypoint, addableFiles, platform);
-//       }
-//     }
-//   });
-// };

package/src/golingvu/base_suite_test.go

@@ -1,197 +0,0 @@
-package golingvu
-
-import (
-	"testing"
-)
-
-// Test types to match the TypeScript implementation
-type TestStore struct {
-	Name          string
-	Index         int
-	TestStore     bool
-	TestSelection bool
-	Error         error
-}
-
-type TestSelection struct {
-	TestSelection bool
-	Error         bool
-}
-
-// TestBaseSuiteInitialization tests that BaseSuite initializes correctly
-func TestBaseSuiteInitialization(t *testing.T) {
-	suite := &BaseSuite{
-		Name: "testSuite",
-		Givens: map[string]*BaseGiven{
-			"testGiven": {
-				Name:     "testGiven",
-				Features: []string{"testFeature"},
-				Whens:    []*BaseWhen{},
-				Thens:    []*BaseThen{},
-			},
-		},
-	}
-
-	if suite.Name != "testSuite" {
-		t.Errorf("Expected suite name 'testSuite', got '%s'", suite.Name)
-	}
-
-	if len(suite.Givens) != 1 {
-		t.Errorf("Expected 1 given, got %d", len(suite.Givens))
-	}
-
-	given := suite.Givens["testGiven"]
-	if given.Name != "testGiven" {
-		t.Errorf("Expected given name 'testGiven', got '%s'", given.Name)
-	}
-
-	if len(given.Features) != 1 || given.Features[0] != "testFeature" {
-		t.Errorf("Expected feature 'testFeature', got %v", given.Features)
-	}
-}
-
-// TestBaseSuiteToObj tests the ToObj method
-func TestBaseSuiteToObj(t *testing.T) {
-	suite := &BaseSuite{
-		Name: "testSuite",
-		Givens: map[string]*BaseGiven{
-			"testGiven": {
-				Name:     "testGiven",
-				Features: []string{"testFeature"},
-				Whens:    []*BaseWhen{},
-				Thens:    []*BaseThen{},
-			},
-		},
-	}
-
-	obj := suite.ToObj()
-	if obj["name"] != "testSuite" {
-		t.Errorf("Expected obj name 'testSuite', got '%v'", obj["name"])
-	}
-}
-
-// TestBaseSuiteFeatures tests the Features method
-func TestBaseSuiteFeatures(t *testing.T) {
-	suite := &BaseSuite{
-		Name: "testSuite",
-		Givens: map[string]*BaseGiven{
-			"testGiven": {
-				Name:     "testGiven",
-				Features: []string{"testFeature"},
-				Whens:    []*BaseWhen{},
-				Thens:    []*BaseThen{},
-			},
-		},
-	}
-
-	features := suite.Features()
-	if len(features) != 1 || features[0] != "testFeature" {
-		t.Errorf("Expected ['testFeature'], got %v", features)
-	}
-}
-
-// TestBaseSuiteRun tests the Run method
-func TestBaseSuiteRun(t *testing.T) {
-	suite := &BaseSuite{
-		Name: "testSuite",
-		Givens: map[string]*BaseGiven{
-			"testGiven": {
-				Name:     "testGiven",
-				Features: []string{"testFeature"},
-				Whens:    []*BaseWhen{},
-				Thens:    []*BaseThen{},
-			},
-		},
-	}
-
-	// Mock test resource configuration
-	testConfig := ITTestResourceConfiguration{
-		Name:        "test",
-		Fs:          "/tmp",
-		Ports:       []int{3000},
-		Environment: map[string]string{},
-		Timeout:     5000,
-		Retries:     3,
-	}
-
-	// Mock artifactory function
-	artifactory := func(path string, value interface{}) {}
-
-	// Mock tLog function
-	tLog := func(args ...string) {}
-
-	// Mock PM
-	pm := struct{}{}
-
-	result, err := suite.Run(nil, testConfig, artifactory, tLog, pm)
-	if err != nil {
-		t.Errorf("Run failed: %v", err)
-	}
-
-	if result == nil {
-		t.Error("Expected non-nil result from Run")
-	}
-}
-
-// TestBaseGivenAddArtifact tests adding artifacts
-func TestBaseGivenAddArtifact(t *testing.T) {
-	given := &BaseGiven{
-		Name:     "testGiven",
-		Artifacts: []string{},
-	}
-
-	given.AddArtifact("test/path")
-	given.AddArtifact("another/path")
-
-	if len(given.Artifacts) != 2 {
-		t.Errorf("Expected 2 artifacts, got %d", len(given.Artifacts))
-	}
-
-	if given.Artifacts[0] != "test/path" || given.Artifacts[1] != "another/path" {
-		t.Errorf("Unexpected artifacts: %v", given.Artifacts)
-	}
-}
-
-// TestBaseGivenToObj tests the ToObj method
-func TestBaseGivenToObj(t *testing.T) {
-	given := &BaseGiven{
-		Name:     "testGiven",
-		Features: []string{"testFeature"},
-		Whens:    []*BaseWhen{},
-		Thens:    []*BaseThen{},
-		Key:      "testKey",
-		Artifacts: []string{"test/artifact"},
-	}
-
-	obj := given.ToObj()
-	if obj["name"] != "testGiven" {
-		t.Errorf("Expected name 'testGiven', got '%v'", obj["name"])
-	}
-	if obj["key"] != "testKey" {
-		t.Errorf("Expected key 'testKey', got '%v'", obj["key"])
-	}
-}
-
-// TestBaseWhenToObj tests the ToObj method for BaseWhen
-func TestBaseWhenToObj(t *testing.T) {
-	when := &BaseWhen{
-		Name: "testWhen",
-	}
-
-	obj := when.ToObj()
-	if obj["name"] != "testWhen" {
-		t.Errorf("Expected name 'testWhen', got '%v'", obj["name"])
-	}
-}
-
-// TestBaseThenToObj tests the ToObj method for BaseThen
-func TestBaseThenToObj(t *testing.T) {
-	then := &BaseThen{
-		Name: "testThen",
-	}
-
-	obj := then.ToObj()
-	if obj["name"] != "testThen" {
-		t.Errorf("Expected name 'testThen', got '%v'", obj["name"])
-	}
-}