FMesh: add tests

component/activation_result.go

@@ -1,5 +1,7 @@
 package component
 
+import "fmt"
+
 // ActivationResult defines the result (possibly an error) of the activation of given component in given cycle
 type ActivationResult struct {
 	componentName string
@@ -81,7 +83,10 @@ func (c *Component) newActivationCodeWaitingForInput() *ActivationResult {
 
 // newActivationCodeReturnedError builds a specific activation result
 func (c *Component) newActivationCodeReturnedError(err error) *ActivationResult {
-	return NewActivationResult(c.Name()).SetActivated(true).WithActivationCode(ActivationCodeReturnedError).WithError(err)
+	return NewActivationResult(c.Name()).
+		SetActivated(true).
+		WithActivationCode(ActivationCodeReturnedError).
+		WithError(fmt.Errorf("component returned an error: %w", err))
 }
 
 // newActivationCodePanicked builds a specific activation result

component/component.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"github.com/hovsep/fmesh/port"
-	"runtime/debug"
 )
 
 type ActivationFunc func(inputs port.Ports, outputs port.Ports) error
@@ -91,12 +90,9 @@ func (c *Component) hasActivationFunction() bool {
 func (c *Component) MaybeActivate() (activationResult *ActivationResult) {
 	defer func() {
 		if r := recover(); r != nil {
-			errorFormat := "panicked with: %v, stacktrace: %s"
-			if _, ok := r.(error); ok {
-				errorFormat = "panicked with: %w, stacktrace: %s"
-			}
-			//TODO: add custom error
-			activationResult = c.newActivationCodePanicked(fmt.Errorf(errorFormat, r, debug.Stack()))
+			//Clear inputs and exit
+			c.inputs.ClearSignal()
+			activationResult = c.newActivationCodePanicked(fmt.Errorf("panicked with: %v", r))
 		}
 	}()
 

component/component_test.go

@@ -489,7 +489,7 @@ func TestComponent_Activate(t *testing.T) {
 			wantActivationResult: NewActivationResult("c1").
 				SetActivated(true).
 				WithActivationCode(ActivationCodeReturnedError).
-				WithError(errors.New("failed to activate component: test error")),
+				WithError(errors.New("component returned an error: test error")),
 		},
 		{
 			name: "activated without error",
@@ -556,10 +556,10 @@ func TestComponent_Activate(t *testing.T) {
 			assert.Equal(t, got.Activated(), tt.wantActivationResult.Activated())
 			assert.Equal(t, got.ComponentName(), tt.wantActivationResult.ComponentName())
 			assert.Equal(t, got.Code(), tt.wantActivationResult.Code())
-			if !tt.wantActivationResult.HasError() {
-				assert.False(t, got.HasError())
+			if tt.wantActivationResult.HasError() {
+				assert.EqualError(t, got.Error(), tt.wantActivationResult.Error().Error())
 			} else {
-				assert.ErrorContains(t, got.Error(), tt.wantActivationResult.Error().Error())
+				assert.False(t, got.HasError())
 			}
 
 		})

cycle/result.go

@@ -79,7 +79,10 @@ func (cycleResult *Result) HasActivatedComponents() bool {
 	return false
 }
 
-// Add adds a cycle result to existing collection
-func (cycleResults Results) Add(cycleResult *Result) Results {
-	return append(cycleResults, cycleResult)
+// Add adds cycle results to existing collection
+func (cycleResults Results) Add(newCycleResults ...*Result) Results {
+	for _, cycleResult := range newCycleResults {
+		cycleResults = append(cycleResults, cycleResult)
+	}
+	return cycleResults
 }

cycle/result_test.go

@@ -9,7 +9,7 @@ import (
 
 func TestResults_Add(t *testing.T) {
 	type args struct {
-		cycleResult *Result
+		cycleResults []*Result
 	}
 	tests := []struct {
 		name         string
@@ -21,11 +21,24 @@ func TestResults_Add(t *testing.T) {
 			name:         "happy path",
 			cycleResults: NewResults(),
 			args: args{
-				cycleResult: NewResult().SetCycleNumber(1).WithActivationResults(component.NewActivationResult("c1").SetActivated(true)),
+				cycleResults: []*Result{
+					NewResult().
+						SetCycleNumber(1).
+						WithActivationResults(component.NewActivationResult("c1").SetActivated(false)),
+					NewResult().
+						SetCycleNumber(2).
+						WithActivationResults(component.NewActivationResult("c1").SetActivated(true)),
+				},
 			},
 			want: Results{
 				{
 					cycleNumber: 1,
+					activationResults: component.ActivationResults{
+						"c1": component.NewActivationResult("c1").SetActivated(false),
+					},
+				},
+				{
+					cycleNumber: 2,
 					activationResults: component.ActivationResults{
 						"c1": component.NewActivationResult("c1").SetActivated(true),
 					},
@@ -35,7 +48,7 @@ func TestResults_Add(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := tt.cycleResults.Add(tt.args.cycleResult); !reflect.DeepEqual(got, tt.want) {
+			if got := tt.cycleResults.Add(tt.args.cycleResults...); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Add() = %v, want %v", got, tt.want)
 			}
 		})

errors.go

@@ -2,8 +2,6 @@ package fmesh
 
 import (
 	"errors"
-	"fmt"
-	"github.com/hovsep/fmesh/cycle"
 )
 
 type ErrorHandlingStrategy int
@@ -19,7 +17,3 @@ var (
 	ErrHitAPanic                        = errors.New("f-mesh hit a panic and will be stopped")
 	ErrUnsupportedErrorHandlingStrategy = errors.New("unsupported error handling strategy")
 )
-
-func newFMeshStopError(err error, cycleResult *cycle.Result) error {
-	return fmt.Errorf("%w (cycle #%d activation results: %v)", err, cycleResult.CycleNumber(), cycleResult.ActivationResults())
-}

fmesh.go

@@ -72,7 +72,7 @@ func (fm *FMesh) runCycle() *cycle.Result {
 			case aRes := <-activationResultsChan:
 				//@TODO :check for closed channel
 				cycleResult.Lock()
-				cycleResult = cycleResult.WithActivationResult(aRes)
+				cycleResult = cycleResult.WithActivationResults(aRes)
 				cycleResult.Unlock()
 			case <-doneChan:
 				return
@@ -104,15 +104,17 @@ func (fm *FMesh) drainComponents() {
 // Run starts the computation until there is no component which activates (mesh has no unprocessed inputs)
 func (fm *FMesh) Run() (cycle.Results, error) {
 	allCycles := cycle.NewResults()
+	cycleNumber := uint(0)
 	for {
-		cycleResult := fm.runCycle()
+		cycleNumber++
+		cycleResult := fm.runCycle().SetCycleNumber(cycleNumber)
+		allCycles = allCycles.Add(cycleResult)
 
 		mustStop, err := fm.mustStop(cycleResult)
 		if mustStop {
 			return allCycles, err
 		}
 
-		allCycles.Add(cycleResult)
 		fm.drainComponents()
 	}
 }
@@ -126,14 +128,12 @@ func (fm *FMesh) mustStop(cycleResult *cycle.Result) (bool, error) {
 	//Check if mesh must stop because of configured error handling strategy
 	switch fm.errorHandlingStrategy {
 	case StopOnFirstError:
-		return cycleResult.HasErrors(), newFMeshStopError(ErrHitAnError, cycleResult)
+		return cycleResult.HasErrors(), ErrHitAnError
 	case StopOnFirstPanic:
-		return cycleResult.HasPanics(), newFMeshStopError(ErrHitAPanic, cycleResult)
+		return cycleResult.HasPanics(), ErrHitAPanic
 	case IgnoreAll:
 		return false, nil
 	default:
-		//@TODO: maybe better to return error
-
 		return true, ErrUnsupportedErrorHandlingStrategy
 	}
 }