testeranto 0.199.0 → 0.200.0

package/src/golingvu/base_suite_test.go

@@ -0,0 +1,197 @@
+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"])
+	}
+}

package/src/golingvu/base_then.go

@@ -0,0 +1,21 @@
+package golingvu
+
+// BaseThen represents a Then condition
+type BaseThen struct {
+	Name        string
+	ThenCB      interface{}
+	ButThenFunc func(store, thenCB, testResource, pm interface{}) (interface{}, error)
+}
+
+// Test executes the Then condition
+func (bt *BaseThen) Test(store interface{}, testResourceConfiguration ITTestResourceConfiguration, tLog func(...string), pm interface{}, path string) (interface{}, error) {
+	// Implementation would go here
+	return nil, nil
+}
+
+// ToObj converts the Then condition to a serializable object
+func (bt *BaseThen) ToObj() map[string]interface{} {
+	return map[string]interface{}{
+		"name": bt.Name,
+	}
+}

package/src/golingvu/base_when.go

@@ -0,0 +1,21 @@
+package golingvu
+
+// BaseWhen represents a When condition
+type BaseWhen struct {
+	Name        string
+	WhenCB      interface{}
+	AndWhenFunc func(store, whenCB, testResource, pm interface{}) (interface{}, error)
+}
+
+// Test executes the When condition
+func (bw *BaseWhen) Test(store interface{}, testResourceConfiguration ITTestResourceConfiguration, tLog func(...string), pm interface{}, path string) (interface{}, error) {
+	// Implementation would go here
+	return nil, nil
+}
+
+// ToObj converts the When condition to a serializable object
+func (bw *BaseWhen) ToObj() map[string]interface{} {
+	return map[string]interface{}{
+		"name": bw.Name,
+	}
+}

package/src/golingvu/golingvu.go

@@ -0,0 +1,179 @@
+package golingvu
+
+
+// Golingvu is the main test runner class (Go implementation of Tiposkripto)
+type Golingvu struct {
+	TestResourceRequirement ITTestResourceRequest
+	Artifacts               []interface{}
+	TestJobs                []ITestJob
+	TestSpecification       ITestSpecification
+	SuitesOverrides         map[string]interface{}
+	GivenOverrides          map[string]interface{}
+	WhenOverrides           map[string]interface{}
+	ThenOverrides           map[string]interface{}
+	PuppetMaster            interface{}
+	Specs                   interface{}
+	assertThis              func(t interface{}) interface{}
+}
+
+// NewGolingvu creates a new Golingvu instance
+func NewGolingvu(
+	input interface{},
+	testSpecification ITestSpecification,
+	testImplementation ITestImplementation,
+	testResourceRequirement ITTestResourceRequest,
+	testAdapter ITestAdapter,
+	uberCatcher func(func()),
+) *Golingvu {
+	gv := &Golingvu{
+		TestResourceRequirement: testResourceRequirement,
+		Artifacts:               make([]interface{}, 0),
+		SuitesOverrides:         make(map[string]interface{}),
+		GivenOverrides:          make(map[string]interface{}),
+		WhenOverrides:           make(map[string]interface{}),
+		ThenOverrides:           make(map[string]interface{}),
+		assertThis: func(t interface{}) interface{} {
+			return testAdapter.AssertThis(t)
+		},
+	}
+
+	// Create classy implementations
+	classySuites := make(map[string]interface{})
+	for key := range testImplementation.Suites {
+		classySuites[key] = func(somestring string, givens map[string]*BaseGiven) *BaseSuite {
+			return &BaseSuite{
+				Name: somestring,
+				Givens: givens,
+				AfterAllFunc: func(store interface{}, artifactory func(string, interface{}), pm interface{}) interface{} {
+					return testAdapter.AfterAll(store, pm)
+				},
+				AssertThatFunc: func(t interface{}) bool {
+					return testAdapter.AssertThis(t)
+				},
+				SetupFunc: func(s interface{}, artifactory func(string, interface{}), tr ITTestResourceConfiguration, pm interface{}) interface{} {
+					result := testAdapter.BeforeAll(s, tr, pm)
+					if result == nil {
+						return s
+					}
+					return result
+				},
+			}
+		}
+	}
+
+	classyGivens := make(map[string]interface{})
+	for key, g := range testImplementation.Givens {
+		classyGivens[key] = func(name string, features []string, whens []*BaseWhen, thens []*BaseThen, gcb interface{}, initialValues interface{}) *BaseGiven {
+			return &BaseGiven{
+				Name:          name,
+				Features:      features,
+				Whens:         whens,
+				Thens:         thens,
+				GivenCB:       g,
+				InitialValues: initialValues,
+				Artifacts:     make([]string, 0),
+				GivenThatFunc: func(subject, testResource, artifactory, initializer, initialValues, pm interface{}) (interface{}, error) {
+					// Type assertion for testResource
+					tr, ok := testResource.(ITTestResourceConfiguration)
+					if !ok {
+						return nil, nil
+					}
+					return testAdapter.BeforeEach(subject, initializer, tr, initialValues, pm), nil
+				},
+				AfterEachFunc: func(store interface{}, key string, artifactory, pm interface{}) (interface{}, error) {
+					return testAdapter.AfterEach(store, key, pm), nil
+				},
+				UberCatcherFunc: uberCatcher,
+			}
+		}
+	}
+
+	classyWhens := make(map[string]interface{})
+	for key, whEn := range testImplementation.Whens {
+		classyWhens[key] = func(payload ...interface{}) *BaseWhen {
+			return &BaseWhen{
+				Name:   key,
+				WhenCB: whEn,
+				AndWhenFunc: func(store, whenCB, testResource, pm interface{}) (interface{}, error) {
+					return testAdapter.AndWhen(store, whenCB, testResource, pm), nil
+				},
+			}
+		}
+	}
+
+	classyThens := make(map[string]interface{})
+	for key, thEn := range testImplementation.Thens {
+		classyThens[key] = func(args ...interface{}) *BaseThen {
+			return &BaseThen{
+				Name:   key,
+				ThenCB: thEn,
+				ButThenFunc: func(store, thenCB, testResource, pm interface{}) (interface{}, error) {
+					return testAdapter.ButThen(store, thenCB, testResource, pm), nil
+				},
+			}
+		}
+	}
+
+	// Set up the overrides
+	gv.SuitesOverrides = classySuites
+	gv.GivenOverrides = classyGivens
+	gv.WhenOverrides = classyWhens
+	gv.ThenOverrides = classyThens
+	gv.TestResourceRequirement = testResourceRequirement
+	gv.TestSpecification = testSpecification
+
+	// Generate specs
+	gv.Specs = testSpecification(
+		gv.Suites(),
+		gv.Given(),
+		gv.When(),
+		gv.Then(),
+	)
+
+	// Create test jobs (simplified)
+	// Note: This part needs to be adapted from TypeScript more carefully
+	gv.TestJobs = []ITestJob{}
+
+	return gv
+}
+
+// ReceiveTestResourceConfig receives test resource configuration
+func (gv *Golingvu) ReceiveTestResourceConfig(partialTestResource string) (IFinalResults, error) {
+	// Implement this method based on the TypeScript version
+	return IFinalResults{}, nil
+}
+
+// Suites returns the suites overrides
+func (gv *Golingvu) Suites() map[string]interface{} {
+	return gv.SuitesOverrides
+}
+
+// Given returns the given overrides
+func (gv *Golingvu) Given() map[string]interface{} {
+	return gv.GivenOverrides
+}
+
+// When returns the when overrides
+func (gv *Golingvu) When() map[string]interface{} {
+	return gv.WhenOverrides
+}
+
+// Then returns the then overrides
+func (gv *Golingvu) Then() map[string]interface{} {
+	return gv.ThenOverrides
+}
+
+// GetTestJobs returns the test jobs
+func (gv *Golingvu) GetTestJobs() []ITestJob {
+	return gv.TestJobs
+}
+
+// GetSpecs returns the generated specs
+func (gv *Golingvu) GetSpecs() interface{} {
+	return gv.Specs
+}
+
+// AssertThis is a helper function for assertions
+func (gv *Golingvu) AssertThis(t interface{}) interface{} {
+	return gv.assertThis(t)
+}

package/src/golingvu/test_adapter.go

@@ -0,0 +1,33 @@
+package golingvu
+
+// SimpleTestAdapter is a basic implementation of ITestAdapter
+type SimpleTestAdapter struct{}
+
+func (a *SimpleTestAdapter) BeforeAll(input interface{}, tr ITTestResourceConfiguration, pm interface{}) interface{} {
+	return input
+}
+
+func (a *SimpleTestAdapter) AfterAll(store interface{}, pm interface{}) interface{} {
+	return store
+}
+
+func (a *SimpleTestAdapter) BeforeEach(subject, initializer interface{}, testResource ITTestResourceConfiguration, initialValues interface{}, pm interface{}) interface{} {
+	return subject
+}
+
+func (a *SimpleTestAdapter) AfterEach(store interface{}, key string, pm interface{}) interface{} {
+	return store
+}
+
+func (a *SimpleTestAdapter) AndWhen(store, whenCB interface{}, testResource interface{}, pm interface{}) interface{} {
+	return store
+}
+
+func (a *SimpleTestAdapter) ButThen(store, thenCB interface{}, testResource interface{}, pm interface{}) interface{} {
+	return store
+}
+
+func (a *SimpleTestAdapter) AssertThis(t interface{}) bool {
+	// Simple implementation - always return true for now
+	return true
+}

package/src/golingvu/types.go

@@ -0,0 +1,86 @@
+package golingvu
+
+// Ibdd_in_any represents the input types for BDD
+type Ibdd_in_any interface {
+	Iinput() interface{}
+	Isubject() interface{}
+	Istore() interface{}
+	Iselection() interface{}
+	Then() interface{}
+	Given() interface{}
+}
+
+// Ibdd_out_any represents the output types for BDD
+type Ibdd_out_any interface{}
+
+// ITestSpecification defines the test specification function
+type ITestSpecification func(suites, givens, whens, thens interface{}) interface{}
+
+// ITestImplementation defines the test implementation structure
+type ITestImplementation struct {
+	Suites map[string]interface{}
+	Givens map[string]interface{}
+	Whens  map[string]interface{}
+	Thens  map[string]interface{}
+}
+
+// ITestAdapter defines the adapter interface
+type ITestAdapter interface {
+	BeforeAll(input interface{}, tr ITTestResourceConfiguration, pm interface{}) interface{}
+	AfterAll(store interface{}, pm interface{}) interface{}
+	BeforeEach(subject, initializer interface{}, testResource ITTestResourceConfiguration, initialValues interface{}, pm interface{}) interface{}
+	AfterEach(store interface{}, key string, pm interface{}) interface{}
+	AndWhen(store, whenCB interface{}, testResource interface{}, pm interface{}) interface{}
+	ButThen(store, thenCB interface{}, testResource interface{}, pm interface{}) interface{}
+	AssertThis(t interface{}) bool
+}
+
+// ITTestResourceConfiguration represents test resource configuration
+type ITTestResourceConfiguration struct {
+	Name              string
+	Fs                string
+	Ports             []int
+	BrowserWSEndpoint string
+	Timeout           int
+	Retries           int
+	Environment       map[string]string
+}
+
+// ITTestResourceRequirement represents test resource requirements
+type ITTestResourceRequirement struct {
+	Name  string
+	Ports int
+	Fs    string
+}
+
+// ITTestResourceRequest represents a test resource request
+type ITTestResourceRequest struct {
+	Ports int
+}
+
+// DefaultTestResourceRequest provides a default request
+var DefaultTestResourceRequest = ITTestResourceRequest{
+	Ports: 0,
+}
+
+// DefaultTestResourceRequirement provides a default requirement
+var DefaultTestResourceRequirement = ITTestResourceRequirement{
+	Name:  "default",
+	Ports: 0,
+	Fs:    "./",
+}
+
+// IFinalResults represents the final results of a test run
+type IFinalResults struct {
+	Failed    bool
+	Fails     int
+	Artifacts []interface{}
+	Features  []string
+}
+
+// ITestJob represents a test job
+type ITestJob interface {
+	ToObj() map[string]interface{}
+	Runner(pm interface{}, tLog func(...string)) (interface{}, error)
+	ReceiveTestResourceConfig(pm interface{}) (IFinalResults, error)
+}

package/src/lib/abstractBase.test/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 import Testeranto from "../../Node";
 import { specification } from "./specification";
 import { implementation } from "./implementation";

package/src/pitono/README.md

@@ -0,0 +1,3 @@
+# Pitono
+
+The python implementation of testeranto.

package/src/run.ts

@@ -1,63 +1,63 @@
-import ansiC from "ansi-colors";
-import readline from "readline";
+// import ansiC from "ansi-colors";
+// import readline from "readline";
 
-import { PM_Main } from "./PM/main";
-import { ITestconfig, IBuiltConfig, IProject } from "./Types";
+// import { PM_Main } from "./PM/main";
+// import { ITestconfig, IBuiltConfig, IProject } from "./Types";
 
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY) process.stdin.setRawMode(true);
+// readline.emitKeypressEvents(process.stdin);
+// if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
-console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+// console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+// console.log(ansiC.inverse("Press 'x' to quit forcefully."));
 
-process.stdin.on("keypress", (str, key) => {
-  if (key.name === "x") {
-    console.log(ansiC.inverse("Shutting down forcefully..."));
-    process.exit(-1);
-  }
-});
+// process.stdin.on("keypress", (str, key) => {
+//   if (key.name === "x") {
+//     console.log(ansiC.inverse("Shutting down forcefully..."));
+//     process.exit(-1);
+//   }
+// });
 
-const projectName = process.argv[2];
+// const projectName = process.argv[2];
 
-const mode = process.argv[3] as "once" | "dev";
-if (mode !== "once" && mode !== "dev") {
-  console.error("the 2nd argument should be 'dev' or 'once' ");
-  process.exit(-1);
-}
+// const mode = process.argv[3] as "once" | "dev";
+// if (mode !== "once" && mode !== "dev") {
+//   console.error("the 2nd argument should be 'dev' or 'once' ");
+//   process.exit(-1);
+// }
 
-const f = process.cwd() + "/" + "testeranto.config.ts";
+// const f = process.cwd() + "/" + "testeranto.config.ts";
 
-console.log("config file:", f);
+// console.log("config file:", f);
 
-import(f).then(async (module) => {
-  const bigConfig: IProject = module.default || module;
+// import(f).then(async (module) => {
+//   const bigConfig: IProject = module.default || module;
 
-  const rawConfig: ITestconfig = bigConfig.projects[projectName];
+//   const rawConfig: ITestconfig = bigConfig.projects[projectName];
 
-  if (!rawConfig) {
-    console.error(`Project "${projectName}" does not exist in the configuration.`);
-    console.error("Available projects:", Object.keys(bigConfig.projects));
-    process.exit(-1);
-  }
+//   if (!rawConfig) {
+//     console.error(`Project "${projectName}" does not exist in the configuration.`);
+//     console.error("Available projects:", Object.keys(bigConfig.projects));
+//     process.exit(-1);
+//   }
 
-  if (!rawConfig.tests) {
-    console.error(projectName, "appears to have no tests: ", f);
-    console.error(`here is the config:`);
-    console.log(JSON.stringify(rawConfig));
-    process.exit(-1);
-  }
+//   if (!rawConfig.tests) {
+//     console.error(projectName, "appears to have no tests: ", f);
+//     console.error(`here is the config:`);
+//     console.log(JSON.stringify(rawConfig));
+//     process.exit(-1);
+//   }
 
-  const config: IBuiltConfig = {
-    ...rawConfig,
-    buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
-  };
+//   const config: IBuiltConfig = {
+//     ...rawConfig,
+//     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
+//   };
 
-  const pm = new PM_Main(config, projectName, mode);
-  pm.start();
+//   const pm = new PM_Main(config, projectName, mode);
+//   pm.start();
 
-  process.stdin.on("keypress", (str, key) => {
-    if (key.name === "q") {
-      pm.stop();
-    }
-  });
-});
+//   process.stdin.on("keypress", (str, key) => {
+//     if (key.name === "q") {
+//       pm.stop();
+//     }
+//   });
+// });