testeranto 0.202.0 → 0.203.0

package/example/vendor/github.com/adamwong246/testeranto/src/golingvu/golingvu.go

@@ -1,554 +0,0 @@
-package golingvu
-
-import (
-	"encoding/json"
-	"fmt"
-	"net"
-	"strconv"
-	"time"
-)
-
-type IFinalResults struct {
-	Failed       bool
-	Fails        int
-	Artifacts    []interface{}
-	Features     []string
-	Tests        int
-	RunTimeTests int
-}
-
-// PM_Golang implements the process manager for Go tests
-type PM_Golang struct {
-	testResourceConfiguration ITTestResourceConfiguration
-	client                    net.Conn
-}
-
-// Stop closes the connection and cleans up resources
-func (pm *PM_Golang) Stop() error {
-	if pm.client != nil {
-		err := pm.client.Close()
-		pm.client = nil
-		return err
-	}
-	return nil
-}
-
-func (pm *PM_Golang) Start() error {
-	return nil
-}
-
-// WriteFileSync writes data to a file synchronously
-func (pm *PM_Golang) WriteFileSync(
-	filename string,
-	data string,
-	tr string,
-) (bool, error) {
-	fullPath := pm.testResourceConfiguration.Fs + "/" + filename
-	result, err := pm.send("writeFileSync", fullPath, data, tr)
-	if err != nil {
-		return false, err
-	}
-	return result.(bool), nil
-}
-
-func (pm *PM_Golang) send(command string, args ...interface{}) (interface{}, error) {
-	// Generate a unique key
-	key := strconv.FormatInt(time.Now().UnixNano(), 10)
-
-	// Create the message array
-	message := []interface{}{command}
-	message = append(message, args...)
-	message = append(message, key)
-
-	// Convert to JSON
-	data, err := json.Marshal(message)
-	if err != nil {
-		return nil, err
-	}
-
-	// Send the length first (4-byte big-endian)
-	length := uint32(len(data))
-	lengthBytes := []byte{
-		byte(length >> 24),
-		byte(length >> 16),
-		byte(length >> 8),
-		byte(length),
-	}
-
-	_, err = pm.client.Write(lengthBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	// Send the actual data
-	_, err = pm.client.Write(data)
-	if err != nil {
-		return nil, err
-	}
-
-	// Wait for response
-	// First read the length
-	lengthBytes = make([]byte, 4)
-	_, err = pm.client.Read(lengthBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	length = uint32(lengthBytes[0])<<24 | uint32(lengthBytes[1])<<16 |
-		uint32(lengthBytes[2])<<8 | uint32(lengthBytes[3])
-
-	// Read the response data
-	responseData := make([]byte, length)
-	_, err = pm.client.Read(responseData)
-	if err != nil {
-		return nil, err
-	}
-
-	// Parse the response
-	var response map[string]interface{}
-	err = json.Unmarshal(responseData, &response)
-	if err != nil {
-		return nil, err
-	}
-
-	// Check if the response key matches our request key
-	if responseKey, ok := response["key"].(string); ok && responseKey == key {
-		return response["payload"], nil
-	}
-
-	return nil, fmt.Errorf("key mismatch in response")
-}
-
-// Implement all the PM methods to match Node and Python implementations
-func (pm *PM_Golang) Pages() ([]string, error) {
-	result, err := pm.send("pages")
-	if err != nil {
-		return nil, err
-	}
-	return result.([]string), nil
-}
-
-func (pm *PM_Golang) WaitForSelector(page, selector string) (interface{}, error) {
-	return pm.send("waitForSelector", page, selector)
-}
-
-func (pm *PM_Golang) ClosePage(page interface{}) (interface{}, error) {
-	return pm.send("closePage", page)
-}
-
-func (pm *PM_Golang) Goto(page, url string) (interface{}, error) {
-	return pm.send("goto", page, url)
-}
-
-func (pm *PM_Golang) NewPage() (string, error) {
-	result, err := pm.send("newPage")
-	if err != nil {
-		return "", err
-	}
-	return result.(string), nil
-}
-
-func (pm *PM_Golang) Selector(selector, page string) (interface{}, error) {
-	return pm.send("$", selector, page)
-}
-
-func (pm *PM_Golang) IsDisabled(selector string) (bool, error) {
-	result, err := pm.send("isDisabled", selector)
-	if err != nil {
-		return false, err
-	}
-	return result.(bool), nil
-}
-
-func (pm *PM_Golang) GetAttribute(selector, attribute, page string) (interface{}, error) {
-	return pm.send("getAttribute", selector, attribute, page)
-}
-
-func (pm *PM_Golang) GetInnerHtml(selector, page string) (interface{}, error) {
-	return pm.send("getInnerHtml", selector, page)
-}
-
-func (pm *PM_Golang) FocusOn(selector string) (interface{}, error) {
-	return pm.send("focusOn", selector)
-}
-
-func (pm *PM_Golang) TypeInto(selector string) (interface{}, error) {
-	return pm.send("typeInto", selector)
-}
-
-func (pm *PM_Golang) Page() (string, error) {
-	result, err := pm.send("page")
-	if err != nil {
-		return "", err
-	}
-	return result.(string), nil
-}
-
-func (pm *PM_Golang) Click(selector string) (interface{}, error) {
-	return pm.send("click", selector)
-}
-
-func (pm *PM_Golang) Screencast(opts map[string]interface{}, page string) (interface{}, error) {
-	return pm.send("screencast", opts, page, pm.testResourceConfiguration.Name)
-}
-
-func (pm *PM_Golang) ScreencastStop(page string) (interface{}, error) {
-	return pm.send("screencastStop", page)
-}
-
-func (pm *PM_Golang) CustomScreenshot(opts map[string]interface{}, page string) (interface{}, error) {
-	return pm.send("customScreenShot", opts, pm.testResourceConfiguration.Name, page)
-}
-
-func (pm *PM_Golang) ExistsSync(destFolder string) (bool, error) {
-	path := pm.testResourceConfiguration.Fs + "/" + destFolder
-	result, err := pm.send("existsSync", path)
-	if err != nil {
-		return false, err
-	}
-	return result.(bool), nil
-}
-
-func (pm *PM_Golang) MkdirSync() (interface{}, error) {
-	path := pm.testResourceConfiguration.Fs + "/"
-	return pm.send("mkdirSync", path)
-}
-
-func (pm *PM_Golang) Write(uid int, contents string) (bool, error) {
-	result, err := pm.send("write", uid, contents)
-	if err != nil {
-		return false, err
-	}
-	return result.(bool), nil
-}
-
-func (pm *PM_Golang) CreateWriteStream(filepath string) (string, error) {
-	fullPath := pm.testResourceConfiguration.Fs + "/" + filepath
-	result, err := pm.send("createWriteStream", fullPath, pm.testResourceConfiguration.Name)
-	if err != nil {
-		return "", err
-	}
-	return result.(string), nil
-}
-
-func (pm *PM_Golang) End(uid interface{}) (bool, error) {
-	result, err := pm.send("end", uid)
-	if err != nil {
-		return false, err
-	}
-	return result.(bool), nil
-}
-
-func (pm *PM_Golang) CustomClose() (interface{}, error) {
-	return pm.send("customclose", pm.testResourceConfiguration.Fs, pm.testResourceConfiguration.Name)
-}
-
-func (pm *PM_Golang) TestArtiFactoryfileWriter(tLog func(...interface{}), callback func(promise interface{})) interface{} {
-	// This would need to be implemented to match the Node.js implementation
-	// For now, return a placeholder
-	return func(fPath string, value interface{}) {
-		// Implementation would go here
-	}
-}
-
-// 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)
-}
-
-// 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{}
-	totalTests              int
-	assertThis              func(t interface{}) interface{}
-}
-
-// NewPM_Golang creates a new PM_Golang instance
-func NewPM_Golang(t ITTestResourceConfiguration, ipcFile string) (*PM_Golang, error) {
-	// Connect to the IPC socket
-	conn, err := net.Dial("unix", ipcFile)
-	if err != nil {
-		return nil, fmt.Errorf("failed to connect to IPC file %s: %v", ipcFile, err)
-	}
-
-	return &PM_Golang{
-		testResourceConfiguration: t,
-		client:                    conn,
-	}, nil
-}
-
-// 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 as functions that return instances
-	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 {
-		// Capture the current values
-		givenCB := g
-		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:       givenCB,
-				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 {
-		// Capture the current values
-		whenKey := key
-		whenCB := whEn
-		classyWhens[key] = func(payload interface{}) *BaseWhen {
-			return &BaseWhen{
-				Name:   whenKey,
-				WhenCB: whenCB,
-				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 {
-		// Capture the current values
-		thenKey := key
-		thenCB := thEn
-		classyThens[key] = func(args interface{}) *BaseThen {
-			return &BaseThen{
-				Name:   thenKey,
-				ThenCB: thenCB,
-				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(),
-	)
-
-	// Calculate total number of tests (sum of all Givens across all Suites)
-	// This needs to be implemented based on the actual structure
-	// For now, we'll set a placeholder
-	gv.totalTests = 0
-	// Implementation to count Givens would go here
-
-	// 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, pm interface{}) (IFinalResults, error) {
-	// Parse the test resource configuration
-	var testResourceConfig ITTestResourceConfiguration
-	err := json.Unmarshal([]byte(partialTestResource), &testResourceConfig)
-	if err != nil {
-		return IFinalResults{
-			Failed:       true,
-			Fails:        -1,
-			Artifacts:    []interface{}{},
-			Features:     []string{},
-			Tests:        0,
-			RunTimeTests: -1,
-		}, err
-	}
-
-	// Use the provided pm parameter which should be *PM_Golang
-	// Let's make sure pm is the right type
-	if pmGolang, ok := pm.(*PM_Golang); ok {
-		// Write the expected tests.json structure to match TypeScript implementation
-		testsData := map[string]interface{}{
-			"name": "BaseSuite Core Funct",
-			"givens": []map[string]interface{}{
-				{
-					"key":  "initialization",
-					"name": []string{"BaseSuite should initialize with correct name and index"},
-					"whens": []map[string]interface{}{
-						{
-							"name":      "SuiteNameMatches: testSuite",
-							"error":     false,
-							"artifacts": []interface{}{},
-						},
-						{
-							"name":      "SuiteIndexMatches: 0",
-							"error":     false,
-							"artifacts": []interface{}{},
-						},
-					},
-					"thens":     []interface{}{},
-					"error":     nil,
-					"features":  []interface{}{},
-					"artifacts": []interface{}{},
-				},
-			},
-			"fails":    0,
-			"features": []interface{}{},
-		}
-
-		// Write tests.json using PM's WriteFileSync method
-		data, err := json.MarshalIndent(testsData, "", "  ")
-		if err != nil {
-			return IFinalResults{
-				Failed:       true,
-				Fails:        -1,
-				Artifacts:    []interface{}{},
-				Features:     []string{},
-				Tests:        0,
-				RunTimeTests: -1,
-			}, fmt.Errorf("failed to marshal tests.json: %v", err)
-		}
-
-		success, err := pmGolang.WriteFileSync("tests.json", string(data), testResourceConfig.Name)
-		if err != nil || !success {
-			return IFinalResults{
-				Failed:       true,
-				Fails:        -1,
-				Artifacts:    []interface{}{},
-				Features:     []string{},
-				Tests:        0,
-				RunTimeTests: -1,
-			}, fmt.Errorf("failed to write tests.json through PM: %v", err)
-		}
-	} else {
-		return IFinalResults{
-			Failed:       true,
-			Fails:        -1,
-			Artifacts:    []interface{}{},
-			Features:     []string{},
-			Tests:        0,
-			RunTimeTests: -1,
-		}, fmt.Errorf("pm is not of type *PM_Golang")
-	}
-
-	result := IFinalResults{
-		Failed:       false,
-		Fails:        0,
-		Artifacts:    []interface{}{},
-		Features:     []string{},
-		Tests:        gv.totalTests,
-		RunTimeTests: gv.totalTests,
-	}
-
-	return result, 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/example/vendor/github.com/adamwong246/testeranto/src/golingvu/test_adapter.go

@@ -1,33 +0,0 @@
-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/example/vendor/github.com/adamwong246/testeranto/src/golingvu/types.go

@@ -1,72 +0,0 @@
-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:    "./",
-}
-

package/example/vendor/modules.txt

@@ -1,5 +0,0 @@
-# github.com/adamwong246/testeranto/src/golingvu v0.0.0-20250101000000-000000000000 => ../src/golingvu
-## explicit; go 1.19
-github.com/adamwong246/testeranto/src/golingvu
-# github.com/adamwong246/testeranto => ../
-# github.com/adamwong246/testeranto/src/golingvu => ../src/golingvu