Add stage name to 'stage not found' errors

[azarc-jono-langley]

No description provided.

[waeljammal]

go-cover-view

github.com/azarc-io/vth-faas-sdk-go/pkg/spark/v1/test/stage-tracker.go

    1: package module_test_runner
    2:
    3: import (
    4: 	"errors"
    5: 	"fmt"
    6: 	"github.com/azarc-io/vth-faas-sdk-go/pkg/codec"
    7: 	"reflect"
    8: 	"testing"
    9:
   10: 	sparkv1 "github.com/azarc-io/vth-faas-sdk-go/pkg/spark/v1"
   11: 	"github.com/stretchr/testify/assert"
   12: )
   13:
   14: var (
   15: 	ErrNoStageResult = errors.New("stage result not found")
   16: 	ErrNoOutput      = errors.New("unable to find output")
   17: )
   18:
   19: type stageTracker struct {
   20: 	sparkv1.StageTracker
   21: 	sparkv1.InternalStageTracker
   22: 	results     map[string]*result
   23: 	t           *testing.T
   24: 	resultOrder []string
   25: }
   26:
   27: type result struct {
   28: 	value       sparkv1.Bindable
   29: 	stageStatus sparkv1.StageStatus
   30: }
   31:
X  32: func (st *stageTracker) GetStageResult(name string) (data any, mime codec.MimeType, err sparkv1.StageError) {
X  33: 	res, ok := st.results[name]
X  34: 	if !ok {
X  35: 		return nil, "", sparkv1.NewStageError(fmt.Errorf("%w: %s", ErrNoStageResult, name))
X  36: 	}
   37:
X  38: 	raw, err2 := res.value.GetValue()
X  39: 	if err2 != nil {
X  40: 		return nil, "", sparkv1.NewStageError(err2)
X  41: 	}
   42:
X  43: 	switch v := raw.(type) {
X  44: 	case sparkv1.StageError:
X  45: 		return v, codec.MimeTypeJson.WithType("error"), nil
   46: 	}
X  47: 	return raw, codec.MimeType(res.value.GetMimeType()), nil
   48: }
   49:
O  50: func (st *stageTracker) SetStageStatus(name string, status sparkv1.StageStatus) {
O  51: 	res, ok := st.results[name]
O  52: 	if !ok {
O  53: 		res = &result{}
O  54: 		st.results[name] = res
O  55: 	}
   56:
O  57: 	res.stageStatus = status
   58: }
   59:
O  60: func (st *stageTracker) SetStageResult(name string, val sparkv1.Bindable) {
O  61: 	res, ok := st.results[name]
X  62: 	if !ok {
X  63: 		res = &result{}
X  64: 		st.results[name] = res
X  65: 	}
   66:
O  67: 	res.value = val
O  68: 	st.resultOrder = append(st.resultOrder, name)
   69: }
   70:
X  71: func (st *stageTracker) AssertStageCompleted(stageName string) {
X  72: 	st.assertStageStatus(stageName, sparkv1.StageStatus_STAGE_COMPLETED)
X  73: }
   74:
X  75: func (st *stageTracker) AssertStageStarted(stageName string) {
X  76: 	st.assertStageStatus(stageName, sparkv1.StageStatus_STAGE_STARTED)
X  77: }
   78:
X  79: func (st *stageTracker) AssertStageSkipped(stageName string) {
X  80: 	st.assertStageStatus(stageName, sparkv1.StageStatus_STAGE_SKIPPED)
X  81: }
   82:
X  83: func (st *stageTracker) AssertStageCancelled(stageName string) {
X  84: 	st.assertStageStatus(stageName, sparkv1.StageStatus_STAGE_CANCELED)
X  85: }
   86:
X  87: func (st *stageTracker) AssertStageFailed(stageName string) {
X  88: 	st.assertStageStatus(stageName, sparkv1.StageStatus_STAGE_FAILED)
X  89: }
   90:
X  91: func (st *stageTracker) AssertStageResult(stageName string, expectedStageResult any) {
X  92: 	res, ok := st.results[stageName]
X  93: 	if !ok {
X  94: 		st.t.Error(fmt.Errorf("%w: %s", ErrNoStageResult, stageName))
X  95: 	}
   96:
   97: 	// create new instance of the expected value so
X  98: 	newValPtr := reflect.New(reflect.TypeOf(expectedStageResult))
X  99: 	newVal := newValPtr.Elem().Interface()
X 100: 	err := res.value.Bind(&newVal)
X 101: 	if !assert.NoError(st.t, err) {
X 102: 		return
X 103: 	}
  104:
X 105: 	assert.Equal(st.t, expectedStageResult, newVal)
  106: }
  107:
X 108: func (st *stageTracker) AssertStageOrder(stageNames ...string) {
X 109: 	if len(stageNames) > len(st.resultOrder) {
X 110: 		st.t.Fatalf("more stage names provided than were executed")
X 111: 		return
X 112: 	}
  113:
X 114: 	actual := make([]string, len(stageNames))
X 115: 	for ind := range stageNames {
X 116: 		actual[ind] = st.resultOrder[ind]
X 117: 	}
X 118: 	assert.Equal(st.t, stageNames, actual, fmt.Sprintf("actual stages: %v", st.resultOrder))
  119: }
  120:
X 121: func (st *stageTracker) assertStageStatus(stageName string, expectedStatus sparkv1.StageStatus) {
X 122: 	res, ok := st.results[stageName]
X 123: 	if !ok {
X 124: 		st.t.Error(fmt.Errorf("%w: %s", ErrNoStageResult, stageName))
X 125: 		return
X 126: 	}
  127:
X 128: 	assert.Equal(st.t, expectedStatus, res.stageStatus, "spark status expected: '%s' got: '%s'", expectedStatus, res.stageStatus)
  129: }
  130:
O 131: func newStageTracker(t *testing.T) *stageTracker {
O 132: 	return &stageTracker{
O 133: 		t:       t,
O 134: 		results: make(map[string]*result),
O 135: 	}
O 136: }