CHASM: Fix validation context (#8562)

## What changed?
- Use immutable chasm context to access node when doing validations

## Why?
- Validation doesn't change component state and nothing needs to be
persisted.
- Some parts of the system skips persistence when component access fail
on validation step, if node is marked dirty, a dirty mutable state panic
will be triggered upon releasing the execution lock.

## How did you test it?
- [x] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [x] added new unit test(s)
- [ ] added new functional test(s)

Author: yycptt

chasm/tree.go

@@ -373,7 +373,8 @@ func (n *Node) Component(
 		return nil, errComponentNotFound
 	}
 
-	if err := node.prepareComponentValue(chasmContext); err != nil {
+	validationContext := NewContext(chasmContext.getContext(), node)
+	if err := node.prepareComponentValue(validationContext); err != nil {
 		return nil, err
 	}
 
@@ -388,18 +389,22 @@ func (n *Node) Component(
 	// Access check always begins on the target node's parent, and ignored for nodes
 	// without ancestors.
 	if node.parent != nil {
-		err := node.parent.validateAccess(chasmContext)
+		err := node.parent.validateAccess(validationContext)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	if ref.validationFn != nil {
-		if err := ref.validationFn(node.root().backend, chasmContext, componentValue); err != nil {
+		if err := ref.validationFn(node.root().backend, validationContext, componentValue); err != nil {
 			return nil, err
 		}
 	}
 
+	// prepare component value again using incoming context to mark node as dirty if needed.
+	if err := node.prepareComponentValue(chasmContext); err != nil {
+		return nil, err
+	}
 	return componentValue, nil
 }
 
@@ -2737,14 +2742,12 @@ func (n *Node) ExecutePureTask(
 		return false, fmt.Errorf("ExecutePureTask called on a SideEffect task '%s'", registrableTask.fqType())
 	}
 
-	ctx := NewMutableContext(
-		newContextWithOperationIntent(baseCtx, OperationIntentProgress),
-		n,
-	)
+	progressIntentCtx := newContextWithOperationIntent(baseCtx, OperationIntentProgress)
+	validationContext := NewContext(progressIntentCtx, n)
 
 	// Ensure this node's component value is hydrated before execution. Component
 	// will also check access rules.
-	component, err := n.Component(ctx, ComponentRef{})
+	_, err := n.Component(validationContext, ComponentRef{})
 	if err != nil {
 		// NotFound errors are expected here and we can safely skip the task execution.
 		if errors.As(err, new(*serviceerror.NotFound)) {
@@ -2754,16 +2757,22 @@ func (n *Node) ExecutePureTask(
 	}
 
 	// Run the task's registered value before execution.
-	valid, err := n.validateTask(ctx, taskAttributes, taskInstance)
+	valid, err := n.validateTask(validationContext, taskAttributes, taskInstance)
 	if err != nil {
 		return false, err
 	}
 	if !valid {
 		return false, nil
 	}
 
+	executionContext := NewMutableContext(progressIntentCtx, n)
+	component, err := n.Component(executionContext, ComponentRef{})
+	if err != nil {
+		return false, err
+	}
+
 	result := registrableTask.executeFn.Call([]reflect.Value{
-		reflect.ValueOf(ctx),
+		reflect.ValueOf(executionContext),
 		reflect.ValueOf(component),
 		reflect.ValueOf(taskAttributes),
 		reflect.ValueOf(taskInstance),

chasm/tree_test.go

@@ -1477,10 +1477,8 @@ func (s *nodeSuite) TestValidateAccess() {
 }
 
 func (s *nodeSuite) TestGetComponent() {
-	root, err := s.newTestTree(testComponentSerializedNodes())
-	s.NoError(err)
-
 	errValidation := errors.New("some random validation error")
+
 	expectedTestComponent := &TestComponent{}
 	setTestComponentFields(expectedTestComponent, s.nodeBackend)
 	assertTestComponent := func(component Component) {
@@ -1494,39 +1492,47 @@ func (s *nodeSuite) TestGetComponent() {
 
 	testCases := []struct {
 		name            string
-		chasmContext    Context
+		chasmContextFn  func(root *Node) Context
 		ref             ComponentRef
 		expectedErr     error
-		valueState      valueState
+		nodeDirty       bool
 		assertComponent func(Component)
 	}{
 		{
-			name:         "path not found",
-			chasmContext: NewContext(context.Background(), root),
+			name: "path not found",
+			chasmContextFn: func(root *Node) Context {
+				return NewContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				componentPath: []string{"unknownComponent"},
 			},
 			expectedErr: errComponentNotFound,
 		},
 		{
-			name:         "archetype mismatch",
-			chasmContext: NewContext(context.Background(), root),
+			name: "archetype mismatch",
+			chasmContextFn: func(root *Node) Context {
+				return NewContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				archetype: "TestLibrary.test_sub_component_1",
 			},
 			expectedErr: errComponentNotFound,
 		},
 		{
-			name:         "entityGoType mismatch",
-			chasmContext: NewContext(context.Background(), root),
+			name: "entityGoType mismatch",
+			chasmContextFn: func(root *Node) Context {
+				return NewContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				entityGoType: reflect.TypeFor[*TestSubComponent2](),
 			},
 			expectedErr: errComponentNotFound,
 		},
 		{
-			name:         "initialVT mismatch",
-			chasmContext: NewContext(context.Background(), root),
+			name: "initialVT mismatch",
+			chasmContextFn: func(root *Node) Context {
+				return NewMutableContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				componentPath: []string{"SubComponent1", "SubComponent11"},
 				// should be (1, 1) but we set it to (2, 2)
@@ -1538,8 +1544,10 @@ func (s *nodeSuite) TestGetComponent() {
 			expectedErr: errComponentNotFound,
 		},
 		{
-			name:         "validation failure",
-			chasmContext: NewContext(context.Background(), root),
+			name: "validation failure",
+			chasmContextFn: func(root *Node) Context {
+				return NewMutableContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				componentPath: []string{"SubComponent1"},
 				componentInitialVT: &persistencespb.VersionedTransition{
@@ -1553,8 +1561,10 @@ func (s *nodeSuite) TestGetComponent() {
 			expectedErr: errValidation,
 		},
 		{
-			name:         "success readonly access",
-			chasmContext: NewContext(context.Background(), root),
+			name: "success readonly access",
+			chasmContextFn: func(root *Node) Context {
+				return NewContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				componentPath: []string{}, // root
 				componentInitialVT: &persistencespb.VersionedTransition{
@@ -1566,32 +1576,42 @@ func (s *nodeSuite) TestGetComponent() {
 				},
 			},
 			expectedErr:     nil,
-			valueState:      valueStateSynced,
 			assertComponent: assertTestComponent,
 		},
 		{
-			name:         "success mutable access",
-			chasmContext: NewMutableContext(context.Background(), root),
+			name: "success mutable access",
+			chasmContextFn: func(root *Node) Context {
+				return NewMutableContext(context.Background(), root)
+			},
 			ref: ComponentRef{
 				componentPath: []string{}, // root
 			},
 			expectedErr:     nil,
-			valueState:      valueStateNeedSyncStructure,
+			nodeDirty:       true,
 			assertComponent: assertTestComponent,
 		},
 	}
 
 	for _, tc := range testCases {
 		s.Run(tc.name, func() {
-			component, err := root.Component(tc.chasmContext, tc.ref)
+			root, err := s.newTestTree(testComponentSerializedNodes())
+			s.NoError(err)
+
+			component, err := root.Component(tc.chasmContextFn(root), tc.ref)
 			s.Equal(tc.expectedErr, err)
-			if tc.expectedErr == nil {
-				// s.Equal(tc.expectedComponent, component)
 
-				node, ok := root.findNode(tc.ref.componentPath)
+			node, ok := root.findNode(tc.ref.componentPath)
+			if tc.expectedErr == nil {
 				s.True(ok)
-				s.Equal(component, node.value)
-				s.Equal(tc.valueState, node.valueState)
+				tc.assertComponent(component)
+			}
+
+			if ok {
+				if tc.nodeDirty {
+					s.Greater(node.valueState, valueStateSynced)
+				} else {
+					s.LessOrEqual(node.valueState, valueStateSynced)
+				}
 			}
 		})
 	}
@@ -2739,30 +2759,38 @@ func (s *nodeSuite) TestExecutePureTask() {
 	}
 
 	// Succeed task execution and validation (happy case).
+	root.setValueState(valueStateSynced)
 	expectExecute(nil)
 	expectValidate(true, nil)
 	executed, err := root.ExecutePureTask(ctx, taskAttributes, pureTask)
 	s.NoError(err)
 	s.True(executed)
+	s.Equal(valueStateNeedSyncStructure, root.valueState)
 
 	expectedErr := errors.New("dummy")
 
 	// Succeed validation, fail execution.
+	root.setValueState(valueStateSynced)
 	expectExecute(expectedErr)
 	expectValidate(true, nil)
 	_, err = root.ExecutePureTask(ctx, taskAttributes, pureTask)
 	s.ErrorIs(expectedErr, err)
+	s.Equal(valueStateNeedSyncStructure, root.valueState)
 
 	// Fail task validation (no execution occurs).
+	root.setValueState(valueStateSynced)
 	expectValidate(false, nil)
 	executed, err = root.ExecutePureTask(ctx, taskAttributes, pureTask)
 	s.NoError(err)
 	s.False(executed)
+	s.Equal(valueStateSynced, root.valueState) // task not executed, so node is clean
 
 	// Error during task validation (no execution occurs).
+	root.setValueState(valueStateSynced)
 	expectValidate(false, expectedErr)
 	_, err = root.ExecutePureTask(ctx, taskAttributes, pureTask)
 	s.ErrorIs(expectedErr, err)
+	s.Equal(valueStateSynced, root.valueState) // task not executed, so node is clean
 }
 
 func (s *nodeSuite) TestExecuteSideEffectTask() {