Fixed ConfigOperationMode

src/ControlComponents.Core/ConfigOperationMode.cs

@@ -8,7 +8,7 @@ namespace ControlComponents.Core
     {
         // This component includes the external deployed operation mode
         private readonly IControlComponent _externalCC;
-        Task externalOperationMode;
+        Task externalOperationMode = Task.CompletedTask;
 
         public ConfigOperationMode(string name, IControlComponent externalCC) : base(name)
         {
@@ -44,9 +44,13 @@ namespace ControlComponents.Core
 
         private void ConfigureOutputsAtExternalCC()
         {
+            // TODO only roles, which are available in FrameControlComponent
             foreach (var role in _externalCC.Roles)
             {
-                _externalCC.ChangeOutput(role, this.outputs[role].ComponentName);
+                // TODO this can be used for READ interfaces to access target component directly
+                // _externalCC.ChangeOutput(role, this.outputs[role].ComponentName);
+
+                _externalCC.ChangeOutput(role, this.execution.ComponentName);
             }
         }
 
@@ -83,21 +87,30 @@ namespace ControlComponents.Core
 
         protected override async Task Stopping(CancellationToken token)
         {
-            _externalCC.Stop(base.execution.ComponentName);
-            await MirrorState(token);
+            if(_externalCC.OpModeName != "NONE")
+            {
+                _externalCC.Stop(base.execution.ComponentName);
+                await MirrorState(token);
+            }
             await base.Stopping(token);
         }
 
         protected override async Task Clearing(CancellationToken token)
         {
-            _externalCC.Clear(base.execution.ComponentName);
-            await MirrorState(token);
+            if(_externalCC.OpModeName != "NONE")
+            {
+                _externalCC.Clear(base.execution.ComponentName);
+                await MirrorState(token);
+            }
             await base.Clearing(token);
         }
 
         protected override async Task Aborting(CancellationToken token)
         {
-            await MirrorState(token);
+            if(_externalCC.OpModeName != "NONE")
+            {
+                await MirrorState(token);
+            }
             await base.Aborting(token);
         }
 

src/ControlComponents.Core/OrderOutput.cs

@@ -137,12 +137,6 @@ namespace ControlComponents.Core
             }
         }
 
-        public bool ChangeComponent(string id)
-        {
-            T c = _provider.GetComponent<T>(id);
-            return this.ChangeComponent(c);
-        }
-
         private void SubscribeToEvents()
         {
             controlComponent.Subscribe<ExecutionStateEventHandler>(Role, nameof(ExecutionStateChanged), OnExecutionStateChanged);
@@ -157,6 +151,12 @@ namespace ControlComponents.Core
             controlComponent.Unsubscribe<OccupationEventHandler>(Role, nameof(OccupierChanged), OnOccupierChanged);
             controlComponent.Unsubscribe<OperationModeEventHandler>(Role, nameof(OperationModeChanged), OnOperationModeChanged);
         }
+        
+        public bool ChangeComponent(string id)
+        {
+            T c = _provider.GetComponent<T>(id);
+            return this.ChangeComponent(c);
+        }
 
         public bool ChangeComponent(T cc)
         {

tests/ControlComponents.Core.Tests/FrameControlComponentTests.cs

@@ -23,6 +23,7 @@ namespace ControlComponents.Core.Tests
         ControlComponent externalCC;
         FrameControlComponent sut;
         Task running;
+        Mock<IControlComponentProvider> provider;
 
         [OneTimeSetUp]
         public void OneTimeSetUp()
@@ -39,7 +40,7 @@ namespace ControlComponents.Core.Tests
         [SetUp]
         public void Setup()
         {
-            Mock<IControlComponentProvider> provider = new Mock<IControlComponentProvider>();
+            provider = new Mock<IControlComponentProvider>();
 
             // external controlcomponent has different opmodes to test with
             externalCC = new ControlComponent(CC);
@@ -67,6 +68,40 @@ namespace ControlComponents.Core.Tests
             externalCC.OpModeName.Should().Be("NONE");
         }
 
+        [Test]
+        public async Task Given_MissingOutput_When_SelectOperationMode_Then_Abort()
+        {
+            externalCC.AddOrderOutput(new OrderOutput(ROLE, CC, provider.Object));
+
+            running = sut.SelectOperationMode(NormalOpMode);
+            await sut.WaitForAborted();
+            sut.EXST.Should().Be(ExecutionState.ABORTED);
+        }
+
+        public class TestExternalOutput : OrderOutput
+        {
+            public TestExternalOutput(string role, string id, IControlComponentProvider provider) : base(role, id, provider)
+            {
+            }
+            public IControlComponent GetControlComponent => this.controlComponent;
+        }
+
+        [Test, AutoData]
+        public void Given_Output_When_SelectOperationMode_Then_FrameComponentAtOutputConfigured(ControlComponent ese)
+        {
+            provider.Setup(p => p.GetComponent<IControlComponent>(sut.ComponentName)).Returns(sut);
+            provider.Setup(p => p.GetComponent<IControlComponent>(ese.ComponentName)).Returns(ese);
+            provider.Setup(p => p.GetComponent<IControlComponent>(externalCC.ComponentName)).Returns(externalCC);
+
+            var externalCCOutput = new TestExternalOutput(ROLE, externalCC.ComponentName, provider.Object);
+            externalCC.AddOrderOutput(externalCCOutput);
+            sut.AddOrderOutput(new OrderOutput(ROLE, sut.ComponentName, provider.Object, ese));
+
+            running = sut.SelectOperationMode(NormalOpMode);
+            externalCCOutput.ComponentName.Should().Be(ese.ComponentName);
+            externalCCOutput.GetControlComponent.ComponentName.Should().Be(sut.ComponentName);
+        }
+
         [Test]
         public async Task Given_ExternalCC_When_NormalRun_Then_CorrectStateFlow()
         {