🐛 parallelisation Ensure that execution options are propagated to compound execution group when creating a PriorityExecutionGroup (#745)

<!--
Copyright (C) 2020-2022 Arm Limited or its affiliates and Contributors.
All rights reserved.
SPDX-License-Identifier: Apache-2.0
-->
### Description

<!--
Please add any detail or context that would be useful to a reviewer.
-->

Ensure that execution options are propagated to compound execution group
when creating a PriorityExecutionGroup.

This solves issues where passing `StopOnFirstError` wasn't stopping the
rest of the commands running.

### Test Coverage

<!--
Please put an `x` in the correct box e.g. `[x]` to indicate the testing
coverage of this change.
-->

- [x]  This change is covered by existing or additional automated tests.
- [ ] Manual testing has been performed (and evidence provided) as
automated testing was not feasible.
- [ ] Additional tests are not required for this change (e.g.
documentation update).

Author: joshjennings98

changes/20251112110252.bugfix

@@ -0,0 +1 @@
+:bug: `parallelisation` Ensure that execution options are propagated to compound execution group when creating a PriorityExecutionGroup

utils/parallelisation/priority_group.go

@@ -95,7 +95,9 @@ func (g *PriorityExecutionGroup[T]) executors() (executor *CompoundExecutionGrou
 	g.mu.RLock()
 	defer g.mu.RUnlock()
 
-	executor = NewCompoundExecutionGroup(DefaultOptions().MergeWithOptions(Sequential).Options()...)
+	opts := DefaultOptions().MergeWithOptions(g.options...)
+	opts.MergeWithOptions(Sequential)
+	executor = NewCompoundExecutionGroup(opts.Options()...)
 	for _, key := range slices.Sorted(maps.Keys(g.groups)) {
 		executor.RegisterExecutor(g.groups[key])
 	}

utils/parallelisation/priority_group_test.go

@@ -392,4 +392,32 @@ func TestPriority(t *testing.T) {
 		err := priorityGroup.Execute(ctx)
 		errortest.AssertError(t, err, commonerrors.ErrTimeout)
 	})
+
+	t.Run("stop on first error propagates properly across priorities", func(t *testing.T) {
+		defer goleak.VerifyNone(t)
+
+		var lowerPriorityCalled, samePriorityCalledAfter atomic.Bool
+
+		priorityGroup := NewPriorityExecutionGroup(Sequential, StopOnFirstError)
+
+		priorityGroup.RegisterFunctionWithPriority(0, testExecutorFunc(func(ctx context.Context) (err error) {
+			err = commonerrors.ErrConflict
+			return
+		}))
+
+		priorityGroup.RegisterFunctionWithPriority(0, testExecutorFunc(func(ctx context.Context) (err error) {
+			samePriorityCalledAfter.Store(true)
+			return
+		}))
+
+		priorityGroup.RegisterFunctionWithPriority(1, testExecutorFunc(func(ctx context.Context) (err error) {
+			lowerPriorityCalled.Store(true)
+			return
+		}))
+
+		err := priorityGroup.Execute(context.Background())
+		errortest.AssertError(t, err, commonerrors.ErrConflict)
+		assert.False(t, samePriorityCalledAfter.Load())
+		assert.False(t, lowerPriorityCalled.Load())
+	})
 }