github.com/kubeshop/testkube@v1.17.23/cmd/tcl/testworkflow-init/data/expressions.go (about)

     1  // Copyright 2024 Testkube.
     2  //
     3  // Licensed as a Testkube Pro file under the Testkube Community
     4  // License (the "License"); you may not use this file except in compliance with
     5  // the License. You may obtain a copy of the License at
     6  //
     7  //	https://github.com/kubeshop/testkube/blob/main/licenses/TCL.txt
     8  
     9  package data
    10  
    11  import (
    12  	"os"
    13  	"strings"
    14  
    15  	"github.com/kubeshop/testkube/pkg/tcl/expressionstcl"
    16  	"github.com/kubeshop/testkube/pkg/tcl/expressionstcl/libs"
    17  )
    18  
    19  var aliases = map[string]string{
    20  	"always": `true`,
    21  	"never":  `false`,
    22  
    23  	"error":   `failed`,
    24  	"success": `passed`,
    25  
    26  	"self.error":   `self.failed`,
    27  	"self.success": `self.passed`,
    28  
    29  	"passed": `!status`,
    30  	"failed": `bool(status) && status != "skipped"`,
    31  
    32  	"self.passed": `!self.status`,
    33  	"self.failed": `bool(self.status) && self.status != "skipped"`,
    34  }
    35  
    36  var LocalMachine = expressionstcl.NewMachine().
    37  	Register("status", expressionstcl.MustCompile("self.status"))
    38  
    39  var RefMachine = expressionstcl.NewMachine().
    40  	RegisterAccessor(func(name string) (interface{}, bool) {
    41  		if name == "_ref" {
    42  			return Step.Ref, true
    43  		}
    44  		return nil, false
    45  	})
    46  
    47  var AliasMachine = expressionstcl.NewMachine().
    48  	RegisterAccessorExt(func(name string) (interface{}, bool, error) {
    49  		alias, ok := aliases[name]
    50  		if !ok {
    51  			return nil, false, nil
    52  		}
    53  		expr, err := expressionstcl.Compile(alias)
    54  		if err != nil {
    55  			return expr, false, err
    56  		}
    57  		expr, err = expr.Resolve(RefMachine)
    58  		return expr, true, err
    59  	})
    60  
    61  var StateMachine = expressionstcl.NewMachine().
    62  	RegisterAccessor(func(name string) (interface{}, bool) {
    63  		if name == "status" {
    64  			return State.GetStatus(), true
    65  		} else if name == "self.status" {
    66  			return State.GetSelfStatus(), true
    67  		}
    68  		return nil, false
    69  	}).
    70  	RegisterAccessorExt(func(name string) (interface{}, bool, error) {
    71  		if strings.HasPrefix(name, "output.") {
    72  			return State.GetOutput(name[7:])
    73  		}
    74  		return nil, false, nil
    75  	})
    76  
    77  var EnvMachine = expressionstcl.NewMachine().
    78  	RegisterAccessor(func(name string) (interface{}, bool) {
    79  		if strings.HasPrefix(name, "env.") {
    80  			return os.Getenv(name[4:]), true
    81  		}
    82  		return nil, false
    83  	})
    84  
    85  var RefSuccessMachine = expressionstcl.NewMachine().
    86  	RegisterAccessor(func(ref string) (interface{}, bool) {
    87  		s := State.GetStep(ref)
    88  		return s.Status == StepStatusPassed || s.Status == StepStatusSkipped, s.HasStatus
    89  	})
    90  
    91  var RefStatusMachine = expressionstcl.NewMachine().
    92  	RegisterAccessor(func(ref string) (interface{}, bool) {
    93  		return string(State.GetStep(ref).Status), true
    94  	})
    95  
    96  var wd, _ = os.Getwd()
    97  var FileMachine = libs.NewFsMachine(os.DirFS("/"), wd)
    98  
    99  func Template(tpl string, m ...expressionstcl.Machine) (string, error) {
   100  	m = append(m, AliasMachine, baseTestWorkflowMachine)
   101  	return expressionstcl.EvalTemplate(tpl, m...)
   102  }
   103  
   104  func Expression(expr string, m ...expressionstcl.Machine) (expressionstcl.StaticValue, error) {
   105  	m = append(m, AliasMachine, baseTestWorkflowMachine)
   106  	return expressionstcl.EvalExpression(expr, m...)
   107  }
   108  
   109  func RefSuccessExpression(expr string) (expressionstcl.StaticValue, error) {
   110  	return expressionstcl.EvalExpression(expr, RefSuccessMachine)
   111  }
   112  
   113  func RefStatusExpression(expr string) (expressionstcl.StaticValue, error) {
   114  	return expressionstcl.EvalExpression(expr, RefStatusMachine)
   115  }