Restore SEBPatch

SafeExamBrowser.Client.UnitTests/Operations/ApplicationOperationTests.cs

@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Applications.Contracts;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Client.Operations.Events;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Core.Contracts.OperationModel.Events;
+using SafeExamBrowser.I18n.Contracts;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Monitoring.Contracts.Applications;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.Settings.Applications;
+using SafeExamBrowser.Settings.Security;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ApplicationOperationTests
+	{
+		private ClientContext context;
+		private Mock<IApplicationFactory> factory;
+		private Mock<IApplicationMonitor> monitor;
+		private Mock<ILogger> logger;
+		private Mock<IText> text;
+
+		private ApplicationOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			factory = new Mock<IApplicationFactory>();
+			monitor = new Mock<IApplicationMonitor>();
+			logger = new Mock<ILogger>();
+			text = new Mock<IText>();
+
+			context.Settings = new AppSettings();
+
+			sut = new ApplicationOperation(context, factory.Object, monitor.Object, logger.Object, text.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustAbortIfUserDeniesAutoTermination()
+		{
+			var initialization = new InitializationResult();
+			var args = default(ActionRequiredEventArgs);
+
+			initialization.RunningApplications.Add(new RunningApplication(default));
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(initialization);
+			sut.ActionRequired += (a) =>
+			{
+				args = a;
+
+				if (a is ApplicationTerminationEventArgs t)
+				{
+					t.TerminateProcesses = false;
+				}
+			};
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Initialize(It.Is<ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
+			monitor.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Aborted, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationTerminationEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustAbortIfUserCancelsApplicationLocationSelection()
+		{
+			var application = new Mock<IApplication<IApplicationWindow>>().Object;
+			var applicationSettings = new WhitelistApplication { AllowCustomPath = true };
+			var args = default(ActionRequiredEventArgs);
+
+			context.Settings.Applications.Whitelist.Add(applicationSettings);
+			factory.Setup(f => f.TryCreate(It.IsAny<WhitelistApplication>(), out application)).Returns(FactoryResult.NotFound);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+			sut.ActionRequired += (a) =>
+			{
+				args = a;
+
+				if (a is ApplicationNotFoundEventArgs n)
+				{
+					n.Success = false;
+				}
+			};
+
+			var result = sut.Perform();
+
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == applicationSettings), out application), Times.Once);
+
+			Assert.AreEqual(OperationResult.Success, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationInitializationFailedEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustAllowUserToChooseApplicationLocation()
+		{
+			var application = new Mock<IApplication<IApplicationWindow>>().Object;
+			var applicationSettings = new WhitelistApplication { AllowCustomPath = true };
+			var args = default(ActionRequiredEventArgs);
+			var attempt = 0;
+			var correct = new Random().Next(2, 50);
+			var factoryResult = new Func<FactoryResult>(() => ++attempt == correct ? FactoryResult.Success : FactoryResult.NotFound);
+
+			context.Settings.Applications.Whitelist.Add(applicationSettings);
+			factory.Setup(f => f.TryCreate(It.IsAny<WhitelistApplication>(), out application)).Returns(factoryResult);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+			sut.ActionRequired += (a) =>
+			{
+				args = a;
+
+				if (a is ApplicationNotFoundEventArgs n)
+				{
+					n.Success = true;
+				}
+			};
+
+			var result = sut.Perform();
+
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == applicationSettings), out application), Times.Exactly(correct));
+
+			Assert.AreEqual(OperationResult.Success, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationNotFoundEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustDenyApplicationLocationSelection()
+		{
+			var application = new Mock<IApplication<IApplicationWindow>>().Object;
+			var applicationSettings = new WhitelistApplication { AllowCustomPath = false };
+			var args = default(ActionRequiredEventArgs);
+
+			context.Settings.Applications.Whitelist.Add(applicationSettings);
+			factory.Setup(f => f.TryCreate(It.IsAny<WhitelistApplication>(), out application)).Returns(FactoryResult.NotFound);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+			sut.ActionRequired += (a) =>
+			{
+				args = a;
+
+				if (a is ApplicationNotFoundEventArgs)
+				{
+					Assert.Fail();
+				}
+			};
+
+			var result = sut.Perform();
+
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == applicationSettings), out application), Times.Once);
+
+			Assert.AreEqual(OperationResult.Success, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationInitializationFailedEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustFailIfAutoTerminationFails()
+		{
+			var initialization = new InitializationResult();
+			var args = default(ActionRequiredEventArgs);
+
+			initialization.FailedAutoTerminations.Add(new RunningApplication(default));
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(initialization);
+			sut.ActionRequired += (a) => args = a;
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Initialize(It.Is<ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
+			monitor.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Failed, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationTerminationFailedEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustFailIfTerminationFails()
+		{
+			var application = new RunningApplication(default);
+			var initialization = new InitializationResult();
+			var args = new List<ActionRequiredEventArgs>();
+
+			initialization.RunningApplications.Add(application);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(initialization);
+			monitor.Setup(m => m.TryTerminate(It.IsAny<RunningApplication>())).Returns(false);
+			sut.ActionRequired += (a) =>
+			{
+				args.Add(a);
+
+				if (a is ApplicationTerminationEventArgs t)
+				{
+					t.TerminateProcesses = true;
+				}
+			};
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Initialize(It.Is<ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
+			monitor.Verify(m => m.TryTerminate(It.Is<RunningApplication>(a => a == application)), Times.Once);
+
+			Assert.AreEqual(OperationResult.Failed, result);
+			Assert.IsInstanceOfType(args[0], typeof(ApplicationTerminationEventArgs));
+			Assert.IsInstanceOfType(args[1], typeof(ApplicationTerminationFailedEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustIndicateApplicationInitializationFailure()
+		{
+			var application = new Mock<IApplication<IApplicationWindow>>().Object;
+			var applicationSettings = new WhitelistApplication();
+			var args = default(ActionRequiredEventArgs);
+
+			context.Settings.Applications.Whitelist.Add(applicationSettings);
+			factory.Setup(f => f.TryCreate(It.IsAny<WhitelistApplication>(), out application)).Returns(FactoryResult.Error);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+			sut.ActionRequired += (a) => args = a;
+
+			var result = sut.Perform();
+
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == applicationSettings), out application), Times.Once);
+
+			Assert.AreEqual(OperationResult.Success, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationInitializationFailedEventArgs));
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeApplications()
+		{
+			var application1 = new Mock<IApplication<IApplicationWindow>>().Object;
+			var application2 = new Mock<IApplication<IApplicationWindow>>().Object;
+			var application3 = new Mock<IApplication<IApplicationWindow>>().Object;
+			var application1Settings = new WhitelistApplication();
+			var application2Settings = new WhitelistApplication();
+			var application3Settings = new WhitelistApplication();
+
+			context.Settings.Applications.Whitelist.Add(application1Settings);
+			context.Settings.Applications.Whitelist.Add(application2Settings);
+			context.Settings.Applications.Whitelist.Add(application3Settings);
+			factory.Setup(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application1Settings), out application1)).Returns(FactoryResult.Success);
+			factory.Setup(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application2Settings), out application2)).Returns(FactoryResult.Success);
+			factory.Setup(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application3Settings), out application3)).Returns(FactoryResult.Success);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+
+			var result = sut.Perform();
+
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application1Settings), out application1), Times.Once);
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application1Settings), out application2), Times.Once);
+			factory.Verify(f => f.TryCreate(It.Is<WhitelistApplication>(a => a == application1Settings), out application3), Times.Once);
+			monitor.Verify(m => m.Initialize(It.Is<ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
+			monitor.Verify(m => m.TryTerminate(It.IsAny<RunningApplication>()), Times.Never);
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void Perform_MustNotStartMonitorWithoutKioskMode()
+		{
+			context.Settings.Security.KioskMode = KioskMode.None;
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Start(), Times.Never);
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void Perform_MustStartMonitorWithKioskMode()
+		{
+			context.Settings.Security.KioskMode = KioskMode.CreateNewDesktop;
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Start(), Times.Once);
+			Assert.AreEqual(OperationResult.Success, result);
+
+			context.Settings.Security.KioskMode = KioskMode.DisableExplorerShell;
+			monitor.Reset();
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(new InitializationResult());
+
+			result = sut.Perform();
+
+			monitor.Verify(m => m.Start(), Times.Once);
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void Perform_MustTerminateRunningApplications()
+		{
+			var application1 = new RunningApplication(default);
+			var application2 = new RunningApplication(default);
+			var application3 = new RunningApplication(default);
+			var initialization = new InitializationResult();
+			var args = default(ActionRequiredEventArgs);
+
+			initialization.RunningApplications.Add(application1);
+			initialization.RunningApplications.Add(application2);
+			initialization.RunningApplications.Add(application3);
+			monitor.Setup(m => m.Initialize(It.IsAny<ApplicationSettings>())).Returns(initialization);
+			monitor.Setup(m => m.TryTerminate(It.IsAny<RunningApplication>())).Returns(true);
+			sut.ActionRequired += (a) =>
+			{
+				args = a;
+
+				if (a is ApplicationTerminationEventArgs t)
+				{
+					t.TerminateProcesses = true;
+				}
+			};
+
+			var result = sut.Perform();
+
+			monitor.Verify(m => m.Initialize(It.Is<ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
+			monitor.Verify(m => m.TryTerminate(It.Is<RunningApplication>(a => a == application1)), Times.Once);
+			monitor.Verify(m => m.TryTerminate(It.Is<RunningApplication>(a => a == application2)), Times.Once);
+			monitor.Verify(m => m.TryTerminate(It.Is<RunningApplication>(a => a == application3)), Times.Once);
+
+			Assert.AreEqual(OperationResult.Success, result);
+			Assert.IsInstanceOfType(args, typeof(ApplicationTerminationEventArgs));
+		}
+
+		[TestMethod]
+		public void Revert_MustNotStopMonitorWithoutKioskMode()
+		{
+			context.Settings.Security.KioskMode = KioskMode.None;
+
+			var result = sut.Revert();
+
+			monitor.Verify(m => m.Stop(), Times.Never);
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void Revert_MustStopMonitorWithKioskMode()
+		{
+			context.Settings.Security.KioskMode = KioskMode.CreateNewDesktop;
+
+			var result = sut.Revert();
+
+			monitor.Verify(m => m.Stop(), Times.Once);
+			Assert.AreEqual(OperationResult.Success, result);
+
+			context.Settings.Security.KioskMode = KioskMode.DisableExplorerShell;
+			monitor.Reset();
+
+			result = sut.Revert();
+
+			monitor.Verify(m => m.Stop(), Times.Once);
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void Revert_MustTerminateApplications()
+		{
+			var application1 = new Mock<IApplication<IApplicationWindow>>();
+			var application2 = new Mock<IApplication<IApplicationWindow>>();
+			var application3 = new Mock<IApplication<IApplicationWindow>>();
+
+			context.Applications.Add(application1.Object);
+			context.Applications.Add(application2.Object);
+			context.Applications.Add(application3.Object);
+
+			var result = sut.Revert();
+
+			application1.Verify(a => a.Terminate(), Times.Once);
+			application2.Verify(a => a.Terminate(), Times.Once);
+			application3.Verify(a => a.Terminate(), Times.Once);
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/BrowserOperationTests.cs

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Applications.Contracts;
+using SafeExamBrowser.Browser.Contracts;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.UserInterface.Contracts;
+using SafeExamBrowser.UserInterface.Contracts.Shell;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class BrowserOperationTests
+	{
+		private Mock<IActionCenter> actionCenter;
+		private Mock<IBrowserApplication> browser;
+		private ClientContext context;
+		private Mock<ILogger> logger;
+		private AppSettings settings;
+		private Mock<ITaskbar> taskbar;
+		private Mock<ITaskview> taskview;
+		private Mock<IUserInterfaceFactory> uiFactory;
+
+		private BrowserOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			actionCenter = new Mock<IActionCenter>();
+			browser = new Mock<IBrowserApplication>();
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+			settings = new AppSettings();
+			taskbar = new Mock<ITaskbar>();
+			taskview = new Mock<ITaskview>();
+			uiFactory = new Mock<IUserInterfaceFactory>();
+
+			context.Browser = browser.Object;
+			context.Settings = settings;
+
+			sut = new BrowserOperation(actionCenter.Object, context, logger.Object, taskbar.Object, taskview.Object, uiFactory.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeBrowserAndTaskview()
+		{
+			settings.Browser.EnableBrowser = true;
+
+			sut.Perform();
+
+			browser.Verify(c => c.Initialize(), Times.Once);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == context.Browser)), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeBrowserIfNotEnabled()
+		{
+			settings.Browser.EnableBrowser = false;
+			settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			settings.UserInterface.Taskbar.EnableTaskbar = true;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Never);
+			browser.Verify(c => c.Initialize(), Times.Never);
+			taskbar.Verify(t => t.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Never);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == context.Browser)), Times.Never);
+		}
+
+		[TestMethod]
+		public void Perform_MustCorrectlyInitializeControls()
+		{
+			settings.Browser.EnableBrowser = true;
+			settings.UserInterface.ActionCenter.EnableActionCenter = false;
+			settings.UserInterface.Taskbar.EnableTaskbar = false;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Never);
+			taskbar.Verify(t => t.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Never);
+
+			settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			settings.UserInterface.Taskbar.EnableTaskbar = true;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Once);
+			taskbar.Verify(t => t.AddApplicationControl(It.IsAny<IApplicationControl>(), true), Times.Once);
+		}
+
+		[TestMethod]
+		public void Revert_MustTerminateBrowser()
+		{
+			settings.Browser.EnableBrowser = true;
+			sut.Revert();
+			browser.Verify(c => c.Terminate(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Revert_MustNotTerminateBrowserIfNotEnabled()
+		{
+			settings.Browser.EnableBrowser = false;
+			sut.Revert();
+			browser.Verify(c => c.Terminate(), Times.Never);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ClientHostDisconnectionOperationTests.cs

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Communication.Contracts.Events;
+using SafeExamBrowser.Communication.Contracts.Hosts;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Logging.Contracts;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ClientHostDisconnectionOperationTests
+	{
+		private Mock<IClientHost> clientHost;
+		private ClientContext context;
+		private Mock<ILogger> logger;
+
+		private ClientHostDisconnectionOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			clientHost = new Mock<IClientHost>();
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+
+			context.ClientHost = clientHost.Object;
+
+			sut = new ClientHostDisconnectionOperation(context, logger.Object, 0);
+		}
+
+		[TestMethod]
+		public void MustWaitForDisconnectionIfConnectionIsActive()
+		{
+			var after = default(DateTime);
+			var before = default(DateTime);
+			var timeout_ms = 200;
+
+			sut = new ClientHostDisconnectionOperation(context, logger.Object, timeout_ms);
+
+			clientHost.SetupGet(h => h.IsConnected).Returns(true).Callback(() => Task.Delay(10).ContinueWith((_) =>
+			{
+				clientHost.Raise(h => h.RuntimeDisconnected += null);
+			}));
+
+			before = DateTime.Now;
+			sut.Revert();
+			after = DateTime.Now;
+
+			clientHost.VerifyGet(h => h.IsConnected);
+			clientHost.VerifyAdd(h => h.RuntimeDisconnected += It.IsAny<CommunicationEventHandler>());
+			clientHost.VerifyRemove(h => h.RuntimeDisconnected -= It.IsAny<CommunicationEventHandler>());
+			clientHost.VerifyNoOtherCalls();
+
+			Assert.IsTrue(after - before < new TimeSpan(0, 0, 0, 0, timeout_ms));
+		}
+
+		[TestMethod]
+		public void MustRespectTimeoutIfWaitingForDisconnection()
+		{
+			var after = default(DateTime);
+			var before = default(DateTime);
+			var timeout_ms = 200;
+
+			sut = new ClientHostDisconnectionOperation(context, logger.Object, timeout_ms);
+
+			clientHost.SetupGet(h => h.IsConnected).Returns(true);
+
+			before = DateTime.Now;
+			sut.Revert();
+			after = DateTime.Now;
+
+			clientHost.VerifyGet(h => h.IsConnected);
+			clientHost.VerifyAdd(h => h.RuntimeDisconnected += It.IsAny<CommunicationEventHandler>());
+			clientHost.VerifyRemove(h => h.RuntimeDisconnected -= It.IsAny<CommunicationEventHandler>());
+			clientHost.VerifyNoOtherCalls();
+
+			Assert.IsTrue(after - before >= new TimeSpan(0, 0, 0, 0, timeout_ms));
+		}
+
+		[TestMethod]
+		public void MustDoNothingIfNoConnectionIsActive()
+		{
+			clientHost.SetupGet(h => h.IsConnected).Returns(false);
+
+			sut.Revert();
+
+			clientHost.VerifyGet(h => h.IsConnected);
+			clientHost.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void MustDoNothingOnPerform()
+		{
+			var result = sut.Perform();
+
+			clientHost.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ClipboardOperationTests.cs

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Monitoring.Contracts;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.Settings.Security;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ClipboardOperationTests
+	{
+		private Mock<IClipboard> clipboard;
+		private ClientContext context;
+		private Mock<ILogger> loggerMock;
+
+		private ClipboardOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			clipboard = new Mock<IClipboard>();
+			context = new ClientContext();
+			context.Settings = new AppSettings();
+			loggerMock = new Mock<ILogger>();
+
+			sut = new ClipboardOperation(context, clipboard.Object, loggerMock.Object);
+		}
+
+		[TestMethod]
+		public void MustPerformCorrectly()
+		{
+			sut.Perform();
+			clipboard.Verify(n => n.Initialize(It.IsAny<ClipboardPolicy>()), Times.Once);
+		}
+
+		[TestMethod]
+		public void MustRevertCorrectly()
+		{
+			sut.Revert();
+			clipboard.Verify(n => n.Terminate(), Times.Once);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ConfigurationOperationTests.cs

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Communication.Contracts.Data;
+using SafeExamBrowser.Communication.Contracts.Proxies;
+using SafeExamBrowser.Configuration.Contracts;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Settings;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ConfigurationOperationTests
+	{
+		private ClientContext context;
+		private Mock<ILogger> logger;
+		private Mock<IRuntimeProxy> runtime;
+		private ConfigurationOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+			runtime = new Mock<IRuntimeProxy>();
+
+			sut = new ConfigurationOperation(context, logger.Object, runtime.Object);
+		}
+
+		[TestMethod]
+		public void MustCorrectlySetConfiguration()
+		{
+			var response = new ConfigurationResponse
+			{
+				Configuration = new ClientConfiguration
+				{
+					AppConfig = new AppConfig(),
+					SessionId = Guid.NewGuid(),
+					Settings = new AppSettings()
+				}
+			};
+
+			runtime.Setup(r => r.GetConfiguration()).Returns(new CommunicationResult<ConfigurationResponse>(true, response));
+
+			var result = sut.Perform();
+
+			Assert.AreSame(context.AppConfig, response.Configuration.AppConfig);
+			Assert.AreEqual(context.SessionId, response.Configuration.SessionId);
+			Assert.AreSame(context.Settings, response.Configuration.Settings);
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void MustDoNothingOnRevert()
+		{
+			var result = sut.Revert();
+
+			logger.VerifyNoOtherCalls();
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/DisplayMonitorOperationTests.cs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Monitoring.Contracts.Display;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.UserInterface.Contracts.Shell;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class DisplayMonitorOperationTests
+	{
+		private ClientContext context;
+		private Mock<IDisplayMonitor> displayMonitor;
+		private Mock<ILogger> logger;
+		private Mock<ITaskbar> taskbar;
+
+		private DisplayMonitorOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			displayMonitor = new Mock<IDisplayMonitor>();
+			logger = new Mock<ILogger>();
+			taskbar = new Mock<ITaskbar>();
+
+			sut = new DisplayMonitorOperation(context, displayMonitor.Object, logger.Object, taskbar.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustExecuteInCorrectOrder()
+		{
+			var order = 0;
+
+			context.Settings = new AppSettings();
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+
+			displayMonitor.Setup(d => d.InitializePrimaryDisplay(It.IsAny<int>())).Callback(() => Assert.AreEqual(++order, 1));
+			displayMonitor.Setup(d => d.StartMonitoringDisplayChanges()).Callback(() => Assert.AreEqual(++order, 2));
+
+			sut.Perform();
+
+			displayMonitor.Verify(d => d.InitializePrimaryDisplay(It.IsAny<int>()), Times.Once);
+			displayMonitor.Verify(d => d.StartMonitoringDisplayChanges(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustCorrectlyInitializeDisplayWithTaskbar()
+		{
+			var height = 25;
+
+			context.Settings = new AppSettings();
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			taskbar.Setup(t => t.GetAbsoluteHeight()).Returns(height);
+
+			sut.Perform();
+
+			displayMonitor.Verify(d => d.InitializePrimaryDisplay(It.Is<int>(h => h == height)), Times.Once);
+			displayMonitor.Verify(d => d.InitializePrimaryDisplay(It.Is<int>(h => h == 0)), Times.Never);
+		}
+
+		[TestMethod]
+		public void Perform_MustCorrectlyInitializeDisplayWithoutTaskbar()
+		{
+			var height = 25;
+
+			context.Settings = new AppSettings();
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = false;
+			taskbar.Setup(t => t.GetAbsoluteHeight()).Returns(height);
+
+			sut.Perform();
+
+			displayMonitor.Verify(d => d.InitializePrimaryDisplay(It.Is<int>(h => h == height)), Times.Never);
+			displayMonitor.Verify(d => d.InitializePrimaryDisplay(It.Is<int>(h => h == 0)), Times.Once);
+		}
+
+		[TestMethod]
+		public void Revert_MustExecuteInCorrectOrder()
+		{
+			var order = 0;
+
+			displayMonitor.Setup(d => d.StopMonitoringDisplayChanges()).Callback(() => Assert.AreEqual(++order, 1));
+			displayMonitor.Setup(d => d.ResetPrimaryDisplay()).Callback(() => Assert.AreEqual(++order, 2));
+
+			sut.Revert();
+
+			displayMonitor.Verify(d => d.StopMonitoringDisplayChanges(), Times.Once);
+			displayMonitor.Verify(d => d.ResetPrimaryDisplay(), Times.Once);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/KeyboardInterceptorOperationTests.cs

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Monitoring.Contracts.Keyboard;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class KeyboardInterceptorOperationTests
+	{
+		private ClientContext context;
+		private Mock<IKeyboardInterceptor> keyboardInterceptorMock;
+		private Mock<ILogger> loggerMock;
+
+		private KeyboardInterceptorOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			keyboardInterceptorMock = new Mock<IKeyboardInterceptor>();
+			loggerMock = new Mock<ILogger>();
+
+			sut = new KeyboardInterceptorOperation(context, keyboardInterceptorMock.Object, loggerMock.Object);
+		}
+
+		[TestMethod]
+		public void MustPerformCorrectly()
+		{
+			sut.Perform();
+
+			keyboardInterceptorMock.Verify(i => i.Start(), Times.Once);
+			keyboardInterceptorMock.Verify(i => i.Stop(), Times.Never);
+		}
+
+		[TestMethod]
+		public void MustRevertCorrectly()
+		{
+			sut.Revert();
+
+			keyboardInterceptorMock.Verify(i => i.Start(), Times.Never);
+			keyboardInterceptorMock.Verify(i => i.Stop(), Times.Once);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/MouseInterceptorOperationTests.cs

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Monitoring.Contracts.Mouse;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class MouseInterceptorOperationTests
+	{
+		private ClientContext context;
+		private Mock<IMouseInterceptor> mouseInterceptorMock;
+		private Mock<ILogger> loggerMock;
+
+		private MouseInterceptorOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			mouseInterceptorMock = new Mock<IMouseInterceptor>();
+			loggerMock = new Mock<ILogger>();
+
+			sut = new MouseInterceptorOperation(context, loggerMock.Object, mouseInterceptorMock.Object);
+		}
+
+		[TestMethod]
+		public void MustPerformCorrectly()
+		{
+			sut.Perform();
+
+			mouseInterceptorMock.Verify(i => i.Start(), Times.Once);
+			mouseInterceptorMock.Verify(i => i.Stop(), Times.Never);
+		}
+
+		[TestMethod]
+		public void MustRevertCorrectly()
+		{
+			sut.Revert();
+
+			mouseInterceptorMock.Verify(i => i.Start(), Times.Never);
+			mouseInterceptorMock.Verify(i => i.Stop(), Times.Once);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ProctoringOperationTests.cs

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Core.Contracts.Notifications;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Proctoring.Contracts;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.Settings.Proctoring;
+using SafeExamBrowser.UserInterface.Contracts;
+using SafeExamBrowser.UserInterface.Contracts.Shell;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ProctoringOperationTests
+	{
+		private Mock<IActionCenter> actionCenter;
+		private ClientContext context;
+		private Mock<IProctoringController> controller;
+		private Mock<ILogger> logger;
+		private Mock<INotification> notification1;
+		private Mock<INotification> notification2;
+		private AppSettings settings;
+		private Mock<ITaskbar> taskbar;
+		private Mock<IUserInterfaceFactory> uiFactory;
+
+		private ProctoringOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			actionCenter = new Mock<IActionCenter>();
+			context = new ClientContext();
+			controller = new Mock<IProctoringController>();
+			logger = new Mock<ILogger>();
+			notification1 = new Mock<INotification>();
+			notification2 = new Mock<INotification>();
+			settings = new AppSettings();
+			taskbar = new Mock<ITaskbar>();
+			uiFactory = new Mock<IUserInterfaceFactory>();
+
+			context.Settings = settings;
+			controller.SetupGet(c => c.Notifications).Returns(new[] { notification1.Object, notification2.Object });
+			sut = new ProctoringOperation(actionCenter.Object, context, controller.Object, logger.Object, taskbar.Object, uiFactory.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeProctoringCorrectly()
+		{
+			settings.Proctoring.Enabled = true;
+			settings.Proctoring.ShowTaskbarNotification = true;
+
+			Assert.AreEqual(OperationResult.Success, sut.Perform());
+
+			actionCenter.Verify(a => a.AddNotificationControl(It.IsAny<INotificationControl>()), Times.Exactly(2));
+			controller.Verify(c => c.Initialize(It.Is<ProctoringSettings>(s => s == settings.Proctoring)));
+			notification1.VerifyNoOtherCalls();
+			notification2.VerifyNoOtherCalls();
+			taskbar.Verify(t => t.AddNotificationControl(It.IsAny<INotificationControl>()), Times.Exactly(2));
+			uiFactory.Verify(u => u.CreateNotificationControl(It.IsAny<INotification>(), Location.ActionCenter), Times.Exactly(2));
+			uiFactory.Verify(u => u.CreateNotificationControl(It.IsAny<INotification>(), Location.Taskbar), Times.Exactly(2));
+		}
+
+		[TestMethod]
+		public void Perform_MustDoNothingIfNotEnabled()
+		{
+			settings.Proctoring.Enabled = false;
+
+			Assert.AreEqual(OperationResult.Success, sut.Perform());
+
+			actionCenter.VerifyNoOtherCalls();
+			controller.VerifyNoOtherCalls();
+			notification1.VerifyNoOtherCalls();
+			notification2.VerifyNoOtherCalls();
+			taskbar.VerifyNoOtherCalls();
+			uiFactory.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Revert_MustFinalizeProctoringCorrectly()
+		{
+			settings.Proctoring.Enabled = true;
+
+			Assert.AreEqual(OperationResult.Success, sut.Revert());
+
+			actionCenter.VerifyNoOtherCalls();
+			controller.Verify(c => c.Terminate(), Times.Once);
+			notification1.Verify(n => n.Terminate(), Times.Once);
+			notification2.Verify(n => n.Terminate(), Times.Once);
+			taskbar.VerifyNoOtherCalls();
+			uiFactory.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Revert_MustDoNothingIfNotEnabled()
+		{
+			settings.Proctoring.Enabled = false;
+
+			Assert.AreEqual(OperationResult.Success, sut.Revert());
+
+			actionCenter.VerifyNoOtherCalls();
+			controller.VerifyNoOtherCalls();
+			notification1.VerifyNoOtherCalls();
+			notification2.VerifyNoOtherCalls();
+			taskbar.VerifyNoOtherCalls();
+			uiFactory.VerifyNoOtherCalls();
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/RuntimeConnectionOperationTests.cs

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Communication.Contracts.Proxies;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Logging.Contracts;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class RuntimeConnectionOperationTests
+	{
+		private ClientContext context;
+		private Mock<ILogger> logger;
+		private Mock<IRuntimeProxy> runtime;
+		private Guid token;
+		private RuntimeConnectionOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+			runtime = new Mock<IRuntimeProxy>();
+			token = Guid.NewGuid();
+
+			sut = new RuntimeConnectionOperation(context, logger.Object, runtime.Object, token);
+		}
+
+		[TestMethod]
+		public void MustConnectOnPerform()
+		{
+			runtime.Setup(r => r.Connect(It.Is<Guid>(t => t == token), true)).Returns(true);
+
+			var result = sut.Perform();
+
+			runtime.Verify(r => r.Connect(It.Is<Guid>(t => t == token), true), Times.Once);
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void MustCorrectlyFailOnPerform()
+		{
+			runtime.Setup(r => r.Connect(It.Is<Guid>(t => t == token), true)).Returns(false);
+
+			var result = sut.Perform();
+
+			runtime.Verify(r => r.Connect(It.Is<Guid>(t => t == token), true), Times.Once);
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Failed, result);
+		}
+
+		[TestMethod]
+		public void MustDisconnectOnRevert()
+		{
+			runtime.Setup(r => r.Connect(It.IsAny<Guid>(), It.IsAny<bool>())).Returns(true);
+			runtime.Setup(r => r.Disconnect()).Returns(true);
+			runtime.SetupGet(r => r.IsConnected).Returns(true);
+			sut.Perform();
+
+			var result = sut.Revert();
+
+			runtime.Verify(r => r.Connect(It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
+			runtime.Verify(r => r.Disconnect(), Times.Once);
+			runtime.VerifyGet(r => r.IsConnected, Times.Once);
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+
+		[TestMethod]
+		public void MustCorrectlyFailOnRevert()
+		{
+			runtime.Setup(r => r.Connect(It.IsAny<Guid>(), It.IsAny<bool>())).Returns(true);
+			runtime.Setup(r => r.Disconnect()).Returns(false);
+			runtime.SetupGet(r => r.IsConnected).Returns(true);
+			sut.Perform();
+
+			var result = sut.Revert();
+
+			runtime.Verify(r => r.Connect(It.IsAny<Guid>(), It.IsAny<bool>()), Times.Once);
+			runtime.Verify(r => r.Disconnect(), Times.Once);
+			runtime.VerifyGet(r => r.IsConnected, Times.Once);
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Failed, result);
+		}
+
+		[TestMethod]
+		public void MustDoNothingOnRevertIfNotConnected()
+		{
+			var result = sut.Revert();
+
+			runtime.VerifyGet(r => r.IsConnected, Times.Once);
+			runtime.VerifyNoOtherCalls();
+
+			Assert.AreEqual(OperationResult.Success, result);
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ServerOperationTests.cs

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Configuration.Contracts;
+using SafeExamBrowser.Core.Contracts.OperationModel;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Server.Contracts;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.Settings.Server;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ServerOperationTests
+	{
+		private AppConfig appConfig;
+		private ClientContext context;
+		private Mock<ILogger> logger;
+		private Mock<IServerProxy> server;
+		private AppSettings settings;
+
+		private ServerOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			appConfig = new AppConfig();
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+			server = new Mock<IServerProxy>();
+			settings = new AppSettings();
+
+			context.AppConfig = appConfig;
+			context.Settings = settings;
+
+			sut = new ServerOperation(context, logger.Object, server.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeCorrectly()
+		{
+			settings.SessionMode = SessionMode.Server;
+
+			Assert.AreEqual(OperationResult.Success, sut.Perform());
+
+			server.Verify(s => s.Initialize(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<ServerSettings>()), Times.Once);
+			server.Verify(s => s.StartConnectivity(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustDoNothingIfNotActive()
+		{
+			settings.SessionMode = SessionMode.Normal;
+
+			Assert.AreEqual(OperationResult.Success, sut.Perform());
+
+			server.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Revert_MustFinalizeCorrectly()
+		{
+			settings.SessionMode = SessionMode.Server;
+
+			Assert.AreEqual(OperationResult.Success, sut.Revert());
+
+			server.Verify(s => s.StopConnectivity(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Revert_MustDoNothingIfNotActive()
+		{
+			settings.SessionMode = SessionMode.Normal;
+
+			Assert.AreEqual(OperationResult.Success, sut.Revert());
+
+			server.VerifyNoOtherCalls();
+		}
+	}
+}

SafeExamBrowser.Client.UnitTests/Operations/ShellOperationTests.cs

@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) 2024 ETH Zürich, IT Services
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using SafeExamBrowser.Applications.Contracts;
+using SafeExamBrowser.Client.Operations;
+using SafeExamBrowser.Core.Contracts.Notifications;
+using SafeExamBrowser.I18n.Contracts;
+using SafeExamBrowser.Logging.Contracts;
+using SafeExamBrowser.Settings;
+using SafeExamBrowser.Settings.Applications;
+using SafeExamBrowser.SystemComponents.Contracts;
+using SafeExamBrowser.SystemComponents.Contracts.Audio;
+using SafeExamBrowser.SystemComponents.Contracts.Keyboard;
+using SafeExamBrowser.SystemComponents.Contracts.Network;
+using SafeExamBrowser.SystemComponents.Contracts.PowerSupply;
+using SafeExamBrowser.UserInterface.Contracts;
+using SafeExamBrowser.UserInterface.Contracts.Shell;
+using SafeExamBrowser.WindowsApi.Contracts;
+
+namespace SafeExamBrowser.Client.UnitTests.Operations
+{
+	[TestClass]
+	public class ShellOperationTests
+	{
+		private Mock<IActionCenter> actionCenter;
+		private Mock<IAudio> audio;
+		private ClientContext context;
+		private Mock<ILogger> logger;
+		private Mock<INotification> aboutNotification;
+		private Mock<IKeyboard> keyboard;
+		private Mock<INotification> logNotification;
+		private Mock<INativeMethods> nativeMethods;
+		private Mock<IPowerSupply> powerSupply;
+		private Mock<ISystemInfo> systemInfo;
+		private Mock<ITaskbar> taskbar;
+		private Mock<ITaskview> taskview;
+		private Mock<IText> text;
+		private Mock<IUserInterfaceFactory> uiFactory;
+		private Mock<INetworkAdapter> networkAdapter;
+
+		private ShellOperation sut;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			actionCenter = new Mock<IActionCenter>();
+			audio = new Mock<IAudio>();
+			context = new ClientContext();
+			logger = new Mock<ILogger>();
+			aboutNotification = new Mock<INotification>();
+			keyboard = new Mock<IKeyboard>();
+			logNotification = new Mock<INotification>();
+			nativeMethods = new Mock<INativeMethods>();
+			networkAdapter = new Mock<INetworkAdapter>();
+			powerSupply = new Mock<IPowerSupply>();
+			systemInfo = new Mock<ISystemInfo>();
+			taskbar = new Mock<ITaskbar>();
+			taskview = new Mock<ITaskview>();
+			text = new Mock<IText>();
+			uiFactory = new Mock<IUserInterfaceFactory>();
+
+			context.Settings = new AppSettings();
+
+			uiFactory
+				.Setup(u => u.CreateNotificationControl(It.IsAny<INotification>(), It.IsAny<Location>()))
+				.Returns(new Mock<INotificationControl>().Object);
+
+			sut = new ShellOperation(
+				actionCenter.Object,
+				audio.Object,
+				aboutNotification.Object,
+				context,
+				keyboard.Object,
+				logger.Object,
+				logNotification.Object,
+				nativeMethods.Object,
+				networkAdapter.Object,
+				powerSupply.Object,
+				systemInfo.Object,
+				taskbar.Object,
+				taskview.Object,
+				text.Object,
+				uiFactory.Object);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeActivators()
+		{
+			var actionCenterActivator = new Mock<IActionCenterActivator>();
+			var taskviewActivator = new Mock<ITaskviewActivator>();
+			var terminationActivator = new Mock<ITerminationActivator>();
+
+			context.Activators.Add(actionCenterActivator.Object);
+			context.Activators.Add(taskviewActivator.Object);
+			context.Activators.Add(terminationActivator.Object);
+			context.Settings.Keyboard.AllowAltTab = true;
+			context.Settings.Security.AllowTermination = true;
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.Register(It.Is<IActionCenterActivator>(a2 => a2 == actionCenterActivator.Object)), Times.Once);
+			actionCenterActivator.Verify(a => a.Start(), Times.Once);
+			taskview.Verify(t => t.Register(It.Is<ITaskviewActivator>(a => a == taskviewActivator.Object)), Times.Once);
+			taskviewActivator.Verify(a => a.Start(), Times.Once);
+			terminationActivator.Verify(a => a.Start(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeApplications()
+		{
+			var application1 = new Mock<IApplication<IApplicationWindow>>();
+			var application1Settings = new WhitelistApplication { ShowInShell = true };
+			var application2 = new Mock<IApplication<IApplicationWindow>>();
+			var application2Settings = new WhitelistApplication { ShowInShell = false };
+			var application3 = new Mock<IApplication<IApplicationWindow>>();
+			var application3Settings = new WhitelistApplication { ShowInShell = true };
+
+			application1.SetupGet(a => a.Id).Returns(application1Settings.Id);
+			application2.SetupGet(a => a.Id).Returns(application2Settings.Id);
+			application3.SetupGet(a => a.Id).Returns(application3Settings.Id);
+
+			context.Applications.Add(application1.Object);
+			context.Applications.Add(application2.Object);
+			context.Applications.Add(application3.Object);
+			context.Settings.Applications.Whitelist.Add(application1Settings);
+			context.Settings.Applications.Whitelist.Add(application2Settings);
+			context.Settings.Applications.Whitelist.Add(application3Settings);
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddApplicationControl(It.IsAny<IApplicationControl>(), false), Times.Exactly(2));
+			taskbar.Verify(t => t.AddApplicationControl(It.IsAny<IApplicationControl>(), false), Times.Exactly(2));
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object)), Times.Once);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object)), Times.Once);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object)), Times.Once);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object), Location.ActionCenter), Times.Once);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object), Location.Taskbar), Times.Once);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object), Location.ActionCenter), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object), Location.Taskbar), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object), Location.ActionCenter), Times.Once);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object), Location.Taskbar), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustNotAddApplicationsToShellIfNotEnabled()
+		{
+			var application1 = new Mock<IApplication<IApplicationWindow>>();
+			var application1Settings = new WhitelistApplication { ShowInShell = true };
+			var application2 = new Mock<IApplication<IApplicationWindow>>();
+			var application2Settings = new WhitelistApplication { ShowInShell = true };
+			var application3 = new Mock<IApplication<IApplicationWindow>>();
+			var application3Settings = new WhitelistApplication { ShowInShell = true };
+
+			application1.SetupGet(a => a.Id).Returns(application1Settings.Id);
+			application2.SetupGet(a => a.Id).Returns(application2Settings.Id);
+			application3.SetupGet(a => a.Id).Returns(application3Settings.Id);
+
+			context.Applications.Add(application1.Object);
+			context.Applications.Add(application2.Object);
+			context.Applications.Add(application3.Object);
+			context.Settings.Applications.Whitelist.Add(application1Settings);
+			context.Settings.Applications.Whitelist.Add(application2Settings);
+			context.Settings.Applications.Whitelist.Add(application3Settings);
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = false;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = false;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddApplicationControl(It.IsAny<IApplicationControl>(), false), Times.Never);
+			taskbar.Verify(t => t.AddApplicationControl(It.IsAny<IApplicationControl>(), false), Times.Never);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object)), Times.Once);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object)), Times.Once);
+			taskview.Verify(t => t.Add(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object)), Times.Once);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object), Location.ActionCenter), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application1.Object), Location.Taskbar), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object), Location.ActionCenter), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application2.Object), Location.Taskbar), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object), Location.ActionCenter), Times.Never);
+			uiFactory.Verify(f => f.CreateApplicationControl(It.Is<IApplication<IApplicationWindow>>(a => a == application3.Object), Location.Taskbar), Times.Never);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeAlwaysOnState()
+		{
+			context.Settings.Display.AlwaysOn = true;
+			context.Settings.System.AlwaysOn = false;
+
+			sut.Perform();
+
+			nativeMethods.Verify(n => n.SetAlwaysOnState(true, false), Times.Once);
+			nativeMethods.Reset();
+
+			context.Settings.Display.AlwaysOn = false;
+			context.Settings.System.AlwaysOn = true;
+
+			sut.Perform();
+
+			nativeMethods.Verify(n => n.SetAlwaysOnState(false, true), Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeClock()
+		{
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowClock = true;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowClock = true;
+
+			sut.Perform();
+
+			actionCenter.VerifySet(a => a.ShowClock = true, Times.Once);
+			taskbar.VerifySet(t => t.ShowClock = true, Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeClock()
+		{
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowClock = false;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowClock = false;
+
+			sut.Perform();
+
+			actionCenter.VerifySet(a => a.ShowClock = false, Times.Once);
+			taskbar.VerifySet(t => t.ShowClock = false, Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeQuitButton()
+		{
+			context.Settings.Security.AllowTermination = false;
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+
+			sut.Perform();
+
+			actionCenter.VerifySet(a => a.ShowQuitButton = false, Times.Once);
+			taskbar.VerifySet(t => t.ShowQuitButton = false, Times.Once);
+			actionCenter.VerifySet(a => a.ShowQuitButton = true, Times.Never);
+			taskbar.VerifySet(t => t.ShowQuitButton = true, Times.Never);
+
+			actionCenter.Reset();
+			taskbar.Reset();
+			context.Settings.Security.AllowTermination = true;
+
+			sut.Perform();
+
+			actionCenter.VerifySet(a => a.ShowQuitButton = false, Times.Never);
+			taskbar.VerifySet(t => t.ShowQuitButton = false, Times.Never);
+			actionCenter.VerifySet(a => a.ShowQuitButton = true, Times.Once);
+			taskbar.VerifySet(t => t.ShowQuitButton = true, Times.Once);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeNotifications()
+		{
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowApplicationInfo = true;
+			context.Settings.UserInterface.ActionCenter.ShowApplicationLog = true;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowApplicationInfo = true;
+			context.Settings.UserInterface.Taskbar.ShowApplicationLog = true;
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddNotificationControl(It.IsAny<INotificationControl>()), Times.AtLeast(2));
+			taskbar.Verify(t => t.AddNotificationControl(It.IsAny<INotificationControl>()), Times.AtLeast(2));
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeNotifications()
+		{
+			var logControl = new Mock<INotificationControl>();
+
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowApplicationLog = false;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowApplicationLog = false;
+
+			uiFactory
+				.Setup(f => f.CreateNotificationControl(It.IsAny<INotification>(), It.IsAny<Location>()))
+				.Returns(logControl.Object);
+
+			sut.Perform();
+
+			actionCenter.Verify(a => a.AddNotificationControl(It.Is<INotificationControl>(i => i == logControl.Object)), Times.Never);
+			taskbar.Verify(t => t.AddNotificationControl(It.Is<INotificationControl>(i => i == logControl.Object)), Times.Never);
+		}
+
+		[TestMethod]
+		public void Perform_MustInitializeSystemComponents()
+		{
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowAudio = true;
+			context.Settings.UserInterface.ActionCenter.ShowKeyboardLayout = true;
+			context.Settings.UserInterface.ActionCenter.ShowNetwork = true;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowAudio = true;
+			context.Settings.UserInterface.Taskbar.ShowKeyboardLayout = true;
+			context.Settings.UserInterface.Taskbar.ShowNetwork = true;
+
+			systemInfo.SetupGet(s => s.HasBattery).Returns(true);
+			uiFactory.Setup(f => f.CreateAudioControl(It.IsAny<IAudio>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreateKeyboardLayoutControl(It.IsAny<IKeyboard>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreatePowerSupplyControl(It.IsAny<IPowerSupply>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreateNetworkControl(It.IsAny<INetworkAdapter>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+
+			sut.Perform();
+
+			audio.Verify(a => a.Initialize(), Times.Once);
+			powerSupply.Verify(p => p.Initialize(), Times.Once);
+			networkAdapter.Verify(w => w.Initialize(), Times.Once);
+			keyboard.Verify(k => k.Initialize(), Times.Once);
+			actionCenter.Verify(a => a.AddSystemControl(It.IsAny<ISystemControl>()), Times.Exactly(4));
+			taskbar.Verify(t => t.AddSystemControl(It.IsAny<ISystemControl>()), Times.Exactly(4));
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeSystemComponents()
+		{
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = true;
+			context.Settings.UserInterface.ActionCenter.ShowAudio = false;
+			context.Settings.UserInterface.ActionCenter.ShowKeyboardLayout = false;
+			context.Settings.UserInterface.ActionCenter.ShowNetwork = false;
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = true;
+			context.Settings.UserInterface.Taskbar.ShowAudio = false;
+			context.Settings.UserInterface.Taskbar.ShowKeyboardLayout = false;
+			context.Settings.UserInterface.Taskbar.ShowNetwork = false;
+
+			systemInfo.SetupGet(s => s.HasBattery).Returns(false);
+			uiFactory.Setup(f => f.CreateAudioControl(It.IsAny<IAudio>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreateKeyboardLayoutControl(It.IsAny<IKeyboard>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreatePowerSupplyControl(It.IsAny<IPowerSupply>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+			uiFactory.Setup(f => f.CreateNetworkControl(It.IsAny<INetworkAdapter>(), It.IsAny<Location>())).Returns(new Mock<ISystemControl>().Object);
+
+			sut.Perform();
+
+			audio.Verify(a => a.Initialize(), Times.Once);
+			powerSupply.Verify(p => p.Initialize(), Times.Once);
+			networkAdapter.Verify(w => w.Initialize(), Times.Once);
+			keyboard.Verify(k => k.Initialize(), Times.Once);
+			actionCenter.Verify(a => a.AddSystemControl(It.IsAny<ISystemControl>()), Times.Never);
+			taskbar.Verify(t => t.AddSystemControl(It.IsAny<ISystemControl>()), Times.Never);
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeActionCenterIfNotEnabled()
+		{
+			var actionCenterActivator = new Mock<IActionCenterActivator>();
+
+			context.Activators.Add(actionCenterActivator.Object);
+			context.Settings.UserInterface.ActionCenter.EnableActionCenter = false;
+
+			sut.Perform();
+
+			actionCenter.VerifyNoOtherCalls();
+			actionCenterActivator.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeTaskviewActivatorIfNotEnabled()
+		{
+			var taskviewActivator = new Mock<ITaskviewActivator>();
+
+			context.Activators.Add(taskviewActivator.Object);
+			context.Settings.Keyboard.AllowAltTab = false;
+
+			sut.Perform();
+
+			taskview.Verify(t => t.Register(It.IsAny<ITaskviewActivator>()), Times.Never);
+			taskviewActivator.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeTaskbarIfNotEnabled()
+		{
+			context.Settings.UserInterface.Taskbar.EnableTaskbar = false;
+			sut.Perform();
+			taskbar.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public void Perform_MustNotInitializeTerminationActivatorIfNotEnabled()
+		{
+			var terminationActivator = new Mock<ITerminationActivator>();
+
+			context.Activators.Add(terminationActivator.Object);
+			context.Settings.Security.AllowTermination = false;
+
+			sut.Perform();
+
+			terminationActivator.Verify(a => a.Start(), Times.Never);
+		}
+
+		[TestMethod]
+		public void Revert_MustTerminateActivators()
+		{
+			var actionCenterActivator = new Mock<IActionCenterActivator>();
+			var taskviewActivator = new Mock<ITaskviewActivator>();
+			var terminationActivator = new Mock<ITerminationActivator>();
+
+			context.Activators.Add(actionCenterActivator.Object);
+			context.Activators.Add(taskviewActivator.Object);
+			context.Activators.Add(terminationActivator.Object);
+
+			sut.Revert();
+
+			actionCenterActivator.Verify(a => a.Stop(), Times.Once);
+			taskviewActivator.Verify(a => a.Stop(), Times.Once);
+			terminationActivator.Verify(a => a.Stop(), Times.Once);
+		}
+
+		[TestMethod]
+		public void Revert_MustTerminateControllers()
+		{
+			sut.Revert();
+
+			aboutNotification.Verify(c => c.Terminate(), Times.Once);
+			audio.Verify(a => a.Terminate(), Times.Once);
+			logNotification.Verify(c => c.Terminate(), Times.Once);
+			powerSupply.Verify(p => p.Terminate(), Times.Once);
+			keyboard.Verify(k => k.Terminate(), Times.Once);
+			networkAdapter.Verify(w => w.Terminate(), Times.Once);
+		}
+	}
+}