773 lines
27 KiB
C#
773 lines
27 KiB
C#
/*
|
|
* 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 System.Linq;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using Moq;
|
|
using SafeExamBrowser.Communication.Contracts.Data;
|
|
using SafeExamBrowser.Communication.Contracts.Events;
|
|
using SafeExamBrowser.Communication.Contracts.Hosts;
|
|
using SafeExamBrowser.Communication.Contracts.Proxies;
|
|
using SafeExamBrowser.Configuration.Contracts;
|
|
using SafeExamBrowser.Core.Contracts.OperationModel;
|
|
using SafeExamBrowser.Core.Contracts.OperationModel.Events;
|
|
using SafeExamBrowser.I18n.Contracts;
|
|
using SafeExamBrowser.Logging.Contracts;
|
|
using SafeExamBrowser.Runtime.Operations.Events;
|
|
using SafeExamBrowser.Server.Contracts.Data;
|
|
using SafeExamBrowser.Settings;
|
|
using SafeExamBrowser.Settings.Security;
|
|
using SafeExamBrowser.Settings.Service;
|
|
using SafeExamBrowser.UserInterface.Contracts;
|
|
using SafeExamBrowser.UserInterface.Contracts.MessageBox;
|
|
using SafeExamBrowser.UserInterface.Contracts.Windows;
|
|
using SafeExamBrowser.UserInterface.Contracts.Windows.Data;
|
|
using SafeExamBrowser.WindowsApi.Contracts;
|
|
|
|
namespace SafeExamBrowser.Runtime.UnitTests
|
|
{
|
|
[TestClass]
|
|
public class RuntimeControllerTests
|
|
{
|
|
private AppConfig appConfig;
|
|
private Mock<IOperationSequence> bootstrapSequence;
|
|
private Mock<IProcess> clientProcess;
|
|
private Mock<IClientProxy> clientProxy;
|
|
private SessionConfiguration currentSession;
|
|
private AppSettings currentSettings;
|
|
private Mock<ILogger> logger;
|
|
private Mock<IMessageBox> messageBox;
|
|
private SessionConfiguration nextSession;
|
|
private AppSettings nextSettings;
|
|
private Mock<IRuntimeHost> runtimeHost;
|
|
private Mock<IRuntimeWindow> runtimeWindow;
|
|
private Mock<IServiceProxy> service;
|
|
private SessionContext sessionContext;
|
|
private Mock<IRepeatableOperationSequence> sessionSequence;
|
|
private Mock<Action> shutdown;
|
|
private Mock<ISplashScreen> splashScreen;
|
|
private Mock<IText> text;
|
|
private Mock<IUserInterfaceFactory> uiFactory;
|
|
|
|
private RuntimeController sut;
|
|
|
|
[TestInitialize]
|
|
public void Initialize()
|
|
{
|
|
appConfig = new AppConfig();
|
|
bootstrapSequence = new Mock<IOperationSequence>();
|
|
clientProcess = new Mock<IProcess>();
|
|
clientProxy = new Mock<IClientProxy>();
|
|
currentSession = new SessionConfiguration();
|
|
currentSettings = new AppSettings();
|
|
logger = new Mock<ILogger>();
|
|
messageBox = new Mock<IMessageBox>();
|
|
nextSession = new SessionConfiguration();
|
|
nextSettings = new AppSettings();
|
|
runtimeHost = new Mock<IRuntimeHost>();
|
|
runtimeWindow = new Mock<IRuntimeWindow>();
|
|
service = new Mock<IServiceProxy>();
|
|
sessionContext = new SessionContext();
|
|
sessionSequence = new Mock<IRepeatableOperationSequence>();
|
|
shutdown = new Mock<Action>();
|
|
splashScreen = new Mock<ISplashScreen>();
|
|
text = new Mock<IText>();
|
|
uiFactory = new Mock<IUserInterfaceFactory>();
|
|
|
|
currentSession.Settings = currentSettings;
|
|
nextSession.Settings = nextSettings;
|
|
|
|
sessionContext.ClientProcess = clientProcess.Object;
|
|
sessionContext.ClientProxy = clientProxy.Object;
|
|
sessionContext.Current = currentSession;
|
|
sessionContext.Next = nextSession;
|
|
|
|
uiFactory.Setup(u => u.CreateRuntimeWindow(It.IsAny<AppConfig>())).Returns(new Mock<IRuntimeWindow>().Object);
|
|
uiFactory.Setup(u => u.CreateSplashScreen(It.IsAny<AppConfig>())).Returns(new Mock<ISplashScreen>().Object);
|
|
|
|
sut = new RuntimeController(
|
|
appConfig,
|
|
logger.Object,
|
|
messageBox.Object,
|
|
bootstrapSequence.Object,
|
|
sessionSequence.Object,
|
|
runtimeHost.Object,
|
|
runtimeWindow.Object,
|
|
service.Object,
|
|
sessionContext,
|
|
shutdown.Object,
|
|
splashScreen.Object,
|
|
text.Object,
|
|
uiFactory.Object);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClientProcess_MustShutdownWhenClientTerminated()
|
|
{
|
|
StartSession();
|
|
clientProcess.Raise(c => c.Terminated += null, -1);
|
|
|
|
messageBox.Verify(m => m.Show(
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<MessageBoxAction>(),
|
|
It.Is<MessageBoxIcon>(i => i == MessageBoxIcon.Error),
|
|
It.IsAny<IWindow>()), Times.Once);
|
|
sessionSequence.Verify(s => s.TryRevert(), Times.Once);
|
|
shutdown.Verify(s => s(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClientProxy_MustShutdownWhenConnectionLost()
|
|
{
|
|
StartSession();
|
|
clientProxy.Raise(c => c.ConnectionLost += null);
|
|
|
|
messageBox.Verify(m => m.Show(
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<MessageBoxAction>(),
|
|
It.Is<MessageBoxIcon>(i => i == MessageBoxIcon.Error),
|
|
It.IsAny<IWindow>()), Times.Once);
|
|
sessionSequence.Verify(s => s.TryRevert(), Times.Once);
|
|
shutdown.Verify(s => s(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Communication_MustProvideClientConfigurationUponRequest()
|
|
{
|
|
var args = new ClientConfigurationEventArgs();
|
|
var nextAppConfig = new AppConfig();
|
|
var nextSessionId = Guid.NewGuid();
|
|
var nextSettings = new AppSettings();
|
|
|
|
nextSession.AppConfig = nextAppConfig;
|
|
nextSession.SessionId = nextSessionId;
|
|
nextSession.Settings = nextSettings;
|
|
StartSession();
|
|
|
|
runtimeHost.Raise(r => r.ClientConfigurationNeeded += null, args);
|
|
|
|
Assert.AreSame(nextAppConfig, args.ClientConfiguration.AppConfig);
|
|
Assert.AreEqual(nextSessionId, args.ClientConfiguration.SessionId);
|
|
Assert.AreSame(nextSettings, args.ClientConfiguration.Settings);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Communication_MustStartNewSessionUponRequest()
|
|
{
|
|
var args = new ReconfigurationEventArgs { ConfigurationPath = "C:\\Some\\File\\Path.seb" };
|
|
|
|
StartSession();
|
|
bootstrapSequence.Reset();
|
|
sessionSequence.Reset();
|
|
sessionSequence.Setup(s => s.TryRepeat()).Returns(OperationResult.Success);
|
|
|
|
runtimeHost.Raise(r => r.ReconfigurationRequested += null, args);
|
|
|
|
bootstrapSequence.VerifyNoOtherCalls();
|
|
sessionSequence.Verify(s => s.TryPerform(), Times.Never);
|
|
sessionSequence.Verify(s => s.TryRepeat(), Times.Once);
|
|
sessionSequence.Verify(s => s.TryRevert(), Times.Never);
|
|
|
|
Assert.AreEqual(sessionContext.ReconfigurationFilePath, args.ConfigurationPath);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Communication_MustInformClientAboutAbortedReconfiguration()
|
|
{
|
|
StartSession();
|
|
sessionSequence.Reset();
|
|
sessionSequence.Setup(s => s.TryRepeat()).Returns(OperationResult.Aborted);
|
|
|
|
runtimeHost.Raise(r => r.ReconfigurationRequested += null, new ReconfigurationEventArgs());
|
|
|
|
clientProxy.Verify(c => c.InformReconfigurationAborted(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Communication_MustShutdownUponRequest()
|
|
{
|
|
StartSession();
|
|
bootstrapSequence.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
runtimeHost.Raise(r => r.ShutdownRequested += null);
|
|
|
|
bootstrapSequence.VerifyNoOtherCalls();
|
|
sessionSequence.VerifyNoOtherCalls();
|
|
shutdown.Verify(s => s(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustAllowToAbortStartupForClientConfiguration()
|
|
{
|
|
var args = new ConfigurationCompletedEventArgs();
|
|
|
|
messageBox.Setup(m => m.Show(It.IsAny<TextKey>(), It.IsAny<TextKey>(), It.IsAny<MessageBoxAction>(), It.IsAny<MessageBoxIcon>(), It.IsAny<IWindow>())).Returns(MessageBoxResult.Yes);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
Assert.IsTrue(args.AbortStartup);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestServerExamSelectionViaDialogOnDefaultDesktop()
|
|
{
|
|
var args = new ExamSelectionEventArgs(Enumerable.Empty<Exam>());
|
|
var examSelectionDialog = new Mock<IExamSelectionDialog>();
|
|
var result = new ExamSelectionDialogResult { SelectedExam = new Exam(), Success = true };
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.DisableExplorerShell;
|
|
examSelectionDialog.Setup(p => p.Show(It.IsAny<IWindow>())).Returns(result);
|
|
uiFactory.Setup(u => u.CreateExamSelectionDialog(It.IsAny<IEnumerable<Exam>>())).Returns(examSelectionDialog.Object);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.VerifyNoOtherCalls();
|
|
examSelectionDialog.Verify(p => p.Show(It.IsAny<IWindow>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreateExamSelectionDialog(It.IsAny<IEnumerable<Exam>>()), Times.Once);
|
|
|
|
Assert.AreEqual(true, args.Success);
|
|
Assert.AreEqual(result.SelectedExam, args.SelectedExam);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestServerExamSelectionViaClientOnNewDesktop()
|
|
{
|
|
var args = new ExamSelectionEventArgs(new[] { new Exam { Id = "abc1234" } });
|
|
var examSelectionReceived = new Action<IEnumerable<(string, string, string, string)>, Guid>((e, id) =>
|
|
{
|
|
runtimeHost.Raise(r => r.ExamSelectionReceived += null, new ExamSelectionReplyEventArgs
|
|
{
|
|
RequestId = id,
|
|
SelectedExamId = "abc1234",
|
|
Success = true
|
|
});
|
|
});
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
clientProxy
|
|
.Setup(c => c.RequestExamSelection(It.IsAny<IEnumerable<(string, string, string, string)>>(), It.IsAny<Guid>()))
|
|
.Returns(new CommunicationResult(true))
|
|
.Callback(examSelectionReceived);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.Verify(c => c.RequestExamSelection(It.IsAny<IEnumerable<(string, string, string, string)>>(), It.IsAny<Guid>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreateExamSelectionDialog(It.IsAny<IEnumerable<Exam>>()), Times.Never);
|
|
|
|
Assert.AreEqual("abc1234", args.SelectedExam.Id);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestPasswordViaDialogOnDefaultDesktop()
|
|
{
|
|
var args = new PasswordRequiredEventArgs();
|
|
var passwordDialog = new Mock<IPasswordDialog>();
|
|
var result = new PasswordDialogResult { Password = "test1234", Success = true };
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.DisableExplorerShell;
|
|
passwordDialog.Setup(p => p.Show(It.IsAny<IWindow>())).Returns(result);
|
|
uiFactory.Setup(u => u.CreatePasswordDialog(It.IsAny<string>(), It.IsAny<string>())).Returns(passwordDialog.Object);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.VerifyNoOtherCalls();
|
|
passwordDialog.Verify(p => p.Show(It.IsAny<IWindow>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreatePasswordDialog(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
|
|
|
|
Assert.AreEqual(true, args.Success);
|
|
Assert.AreEqual(result.Password, args.Password);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestPasswordViaClientOnNewDesktop()
|
|
{
|
|
var args = new PasswordRequiredEventArgs();
|
|
var passwordReceived = new Action<PasswordRequestPurpose, Guid>((p, id) =>
|
|
{
|
|
runtimeHost.Raise(r => r.PasswordReceived += null, new PasswordReplyEventArgs { Password = "test", RequestId = id, Success = true });
|
|
});
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
clientProxy.Setup(c => c.RequestPassword(It.IsAny<PasswordRequestPurpose>(), It.IsAny<Guid>())).Returns(new CommunicationResult(true)).Callback(passwordReceived);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.Verify(c => c.RequestPassword(It.IsAny<PasswordRequestPurpose>(), It.IsAny<Guid>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreatePasswordDialog(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
|
|
|
|
Assert.AreEqual("test", args.Password);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestServerFailureActionViaDialogOnDefaultDesktop()
|
|
{
|
|
var args = new ServerFailureEventArgs(default(string), default(bool));
|
|
var failureDialog = new Mock<IServerFailureDialog>();
|
|
var result = new ServerFailureDialogResult { Fallback = true, Success = true };
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.DisableExplorerShell;
|
|
failureDialog.Setup(p => p.Show(It.IsAny<IWindow>())).Returns(result);
|
|
uiFactory.Setup(u => u.CreateServerFailureDialog(It.IsAny<string>(), It.IsAny<bool>())).Returns(failureDialog.Object);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.VerifyNoOtherCalls();
|
|
failureDialog.Verify(p => p.Show(It.IsAny<IWindow>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreateServerFailureDialog(It.IsAny<string>(), It.IsAny<bool>()), Times.Once);
|
|
|
|
Assert.AreEqual(result.Abort, args.Abort);
|
|
Assert.AreEqual(result.Fallback, args.Fallback);
|
|
Assert.AreEqual(result.Retry, args.Retry);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustRequestServerFailureActionViaClientOnNewDesktop()
|
|
{
|
|
var args = new ServerFailureEventArgs(default(string), default(bool));
|
|
var failureActionReceived = new Action<string, bool, Guid>((m, f, id) =>
|
|
{
|
|
runtimeHost.Raise(r => r.ServerFailureActionReceived += null, new ServerFailureActionReplyEventArgs
|
|
{
|
|
RequestId = id,
|
|
Fallback = true
|
|
});
|
|
});
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
clientProxy
|
|
.Setup(c => c.RequestServerFailureAction(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<Guid>()))
|
|
.Returns(new CommunicationResult(true))
|
|
.Callback(failureActionReceived);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.Verify(c => c.RequestServerFailureAction(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<Guid>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreateServerFailureDialog(It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
|
|
|
|
Assert.IsFalse(args.Abort);
|
|
Assert.IsTrue(args.Fallback);
|
|
Assert.IsFalse(args.Retry);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustAbortAskingForPasswordViaClientIfDecidedByUser()
|
|
{
|
|
var args = new PasswordRequiredEventArgs();
|
|
var passwordReceived = new Action<PasswordRequestPurpose, Guid>((p, id) =>
|
|
{
|
|
runtimeHost.Raise(r => r.PasswordReceived += null, new PasswordReplyEventArgs { RequestId = id, Success = false });
|
|
});
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
clientProxy.Setup(c => c.RequestPassword(It.IsAny<PasswordRequestPurpose>(), It.IsAny<Guid>())).Returns(new CommunicationResult(true)).Callback(passwordReceived);
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
clientProxy.Verify(c => c.RequestPassword(It.IsAny<PasswordRequestPurpose>(), It.IsAny<Guid>()), Times.Once);
|
|
uiFactory.Verify(u => u.CreatePasswordDialog(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustNotWaitForPasswordViaClientIfCommunicationHasFailed()
|
|
{
|
|
var args = new PasswordRequiredEventArgs();
|
|
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
clientProxy.Setup(c => c.RequestPassword(It.IsAny<PasswordRequestPurpose>(), It.IsAny<Guid>())).Returns(new CommunicationResult(false));
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustShowNormalMessageBoxOnDefaultDesktop()
|
|
{
|
|
var args = new MessageEventArgs
|
|
{
|
|
Icon = MessageBoxIcon.Question,
|
|
Message = TextKey.MessageBox_ClientConfigurationQuestion,
|
|
Title = TextKey.MessageBox_ClientConfigurationQuestionTitle
|
|
};
|
|
|
|
StartSession();
|
|
currentSettings.Security.KioskMode = KioskMode.DisableExplorerShell;
|
|
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
messageBox.Verify(m => m.Show(
|
|
It.IsAny<string>(),
|
|
It.IsAny<string>(),
|
|
It.Is<MessageBoxAction>(a => a == MessageBoxAction.Ok),
|
|
It.Is<MessageBoxIcon>(i => i == args.Icon),
|
|
It.IsAny<IWindow>()), Times.Once);
|
|
clientProxy.VerifyAdd(p => p.ConnectionLost += It.IsAny<CommunicationEventHandler>());
|
|
clientProxy.VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustShowMessageBoxViaClientOnNewDesktop()
|
|
{
|
|
var args = new MessageEventArgs
|
|
{
|
|
Icon = MessageBoxIcon.Question,
|
|
Message = TextKey.MessageBox_ClientConfigurationQuestion,
|
|
Title = TextKey.MessageBox_ClientConfigurationQuestionTitle
|
|
};
|
|
var reply = new MessageBoxReplyEventArgs();
|
|
|
|
StartSession();
|
|
currentSettings.Security.KioskMode = KioskMode.CreateNewDesktop;
|
|
|
|
clientProxy.Setup(c => c.ShowMessage(
|
|
It.IsAny<string>(),
|
|
It.IsAny<string>(),
|
|
It.Is<int>(a => a == (int) MessageBoxAction.Ok),
|
|
It.IsAny<int>(),
|
|
It.IsAny<Guid>()))
|
|
.Callback<string, string, int, int, Guid>((m, t, a, i, id) =>
|
|
{
|
|
runtimeHost.Raise(r => r.MessageBoxReplyReceived += null, new MessageBoxReplyEventArgs { RequestId = id });
|
|
})
|
|
.Returns(new CommunicationResult(true));
|
|
|
|
sessionSequence.Raise(s => s.ActionRequired += null, args);
|
|
|
|
messageBox.Verify(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxAction>(), It.IsAny<MessageBoxIcon>(), It.IsAny<IWindow>()), Times.Never);
|
|
clientProxy.Verify(c => c.ShowMessage(
|
|
It.IsAny<string>(),
|
|
It.IsAny<string>(),
|
|
It.Is<int>(a => a == (int) MessageBoxAction.Ok),
|
|
It.Is<int>(i => i == (int) args.Icon),
|
|
It.IsAny<Guid>()), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustUpdateProgress()
|
|
{
|
|
var args = new ProgressChangedEventArgs
|
|
{
|
|
CurrentValue = 23,
|
|
IsIndeterminate = true,
|
|
MaxValue = 150,
|
|
Progress = true,
|
|
Regress = true
|
|
};
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(o => o.ProgressChanged += null, args);
|
|
|
|
runtimeWindow.Verify(s => s.SetValue(It.Is<int>(i => i == args.CurrentValue)), Times.Once);
|
|
runtimeWindow.Verify(s => s.SetIndeterminate(), Times.Exactly(2));
|
|
runtimeWindow.Verify(s => s.SetMaxValue(It.Is<int>(i => i == args.MaxValue)), Times.Once);
|
|
runtimeWindow.Verify(s => s.Progress(), Times.Once);
|
|
runtimeWindow.Verify(s => s.Regress(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Operations_MustUpdateStatus()
|
|
{
|
|
var key = TextKey.OperationStatus_InitializeClipboard;
|
|
|
|
sut.TryStart();
|
|
sessionSequence.Raise(o => o.StatusChanged += null, key);
|
|
|
|
runtimeWindow.Verify(s => s.UpdateStatus(It.Is<TextKey>(k => k == key), It.IsAny<bool>()), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Session_MustHideRuntimeWindowWhenUsingDisableExplorerShell()
|
|
{
|
|
currentSettings.Security.KioskMode = KioskMode.DisableExplorerShell;
|
|
StartSession();
|
|
runtimeWindow.Verify(w => w.Hide(), Times.AtLeastOnce);
|
|
|
|
runtimeWindow.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
sessionSequence.Setup(b => b.TryRepeat()).Returns(OperationResult.Aborted);
|
|
runtimeHost.Raise(h => h.ReconfigurationRequested += null, new ReconfigurationEventArgs());
|
|
runtimeWindow.Verify(w => w.Hide(), Times.AtLeastOnce);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Session_MustShowMessageBoxOnFailure()
|
|
{
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Failed);
|
|
sessionContext.Current = null;
|
|
sut.TryStart();
|
|
messageBox.Verify(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxAction>(), It.IsAny<MessageBoxIcon>(), It.IsAny<IWindow>()), Times.AtLeastOnce);
|
|
|
|
StartSession();
|
|
messageBox.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
sessionSequence.Setup(b => b.TryRepeat()).Returns(OperationResult.Failed);
|
|
runtimeHost.Raise(h => h.ReconfigurationRequested += null, new ReconfigurationEventArgs());
|
|
messageBox.Verify(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxAction>(), It.IsAny<MessageBoxIcon>(), It.IsAny<IWindow>()), Times.AtLeastOnce);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ServiceProxy_MustShutdownWhenConnectionLostAndMandatory()
|
|
{
|
|
currentSettings.Service.Policy = ServicePolicy.Mandatory;
|
|
|
|
StartSession();
|
|
service.Raise(c => c.ConnectionLost += null);
|
|
|
|
messageBox.Verify(m => m.Show(
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<MessageBoxAction>(),
|
|
It.Is<MessageBoxIcon>(i => i == MessageBoxIcon.Error),
|
|
It.IsAny<IWindow>()), Times.Once);
|
|
sessionSequence.Verify(s => s.TryRevert(), Times.Once);
|
|
shutdown.Verify(s => s(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ServiceProxy_MustNotShutdownWhenConnectionLostAndNotMandatory()
|
|
{
|
|
currentSettings.Service.Policy = ServicePolicy.Optional;
|
|
|
|
StartSession();
|
|
service.Raise(c => c.ConnectionLost += null);
|
|
|
|
messageBox.Verify(m => m.Show(
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<TextKey>(),
|
|
It.IsAny<MessageBoxAction>(),
|
|
It.Is<MessageBoxIcon>(i => i == MessageBoxIcon.Error),
|
|
It.IsAny<IWindow>()), Times.Never);
|
|
sessionSequence.Verify(s => s.TryRevert(), Times.Never);
|
|
shutdown.Verify(s => s(), Times.Never);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Shutdown_MustRevertSessionThenBootstrapSequence()
|
|
{
|
|
var order = 0;
|
|
var bootstrap = 0;
|
|
var session = 0;
|
|
|
|
sut.TryStart();
|
|
|
|
bootstrapSequence.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
bootstrapSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Success).Callback(() => bootstrap = ++order);
|
|
sessionSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Success).Callback(() => session = ++order);
|
|
|
|
sut.Terminate();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Never);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Once);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Once);
|
|
|
|
Assert.AreEqual(1, session);
|
|
Assert.AreEqual(2, bootstrap);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Shutdown_MustOnlyRevertBootstrapSequenceIfNoSessionRunning()
|
|
{
|
|
var order = 0;
|
|
var bootstrap = 0;
|
|
var session = 0;
|
|
|
|
sut.TryStart();
|
|
|
|
bootstrapSequence.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
bootstrapSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Success).Callback(() => bootstrap = ++order);
|
|
sessionSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Success).Callback(() => session = ++order);
|
|
sessionContext.Current = null;
|
|
|
|
sut.Terminate();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Never);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Once);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
|
|
Assert.AreEqual(0, session);
|
|
Assert.AreEqual(1, bootstrap);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Shutdown_MustIndicateFailureToUser()
|
|
{
|
|
var order = 0;
|
|
var bootstrap = 0;
|
|
var session = 0;
|
|
|
|
sut.TryStart();
|
|
|
|
bootstrapSequence.Reset();
|
|
sessionSequence.Reset();
|
|
|
|
bootstrapSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Failed).Callback(() => bootstrap = ++order);
|
|
sessionSequence.Setup(b => b.TryRevert()).Returns(OperationResult.Success).Callback(() => session = ++order);
|
|
|
|
sut.Terminate();
|
|
|
|
messageBox.Verify(m => m.Show(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MessageBoxAction>(), It.IsAny<MessageBoxIcon>(), It.IsAny<IWindow>()), Times.AtLeastOnce);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustPerformBootstrapThenSessionSequence()
|
|
{
|
|
var order = 0;
|
|
var bootstrap = 0;
|
|
var session = 0;
|
|
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success).Callback(() => bootstrap = ++order);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success).Callback(() => { session = ++order; sessionContext.Current = currentSession; });
|
|
sessionContext.Current = null;
|
|
|
|
var success = sut.TryStart();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
|
|
Assert.IsTrue(success);
|
|
Assert.AreEqual(1, bootstrap);
|
|
Assert.AreEqual(2, session);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustNotPerformSessionSequenceIfBootstrapFails()
|
|
{
|
|
var order = 0;
|
|
var bootstrap = 0;
|
|
var session = 0;
|
|
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Failed).Callback(() => bootstrap = ++order);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success).Callback(() => { session = ++order; sessionContext.Current = currentSession; });
|
|
sessionContext.Current = null;
|
|
|
|
var success = sut.TryStart();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
|
|
Assert.IsFalse(success);
|
|
Assert.AreEqual(1, bootstrap);
|
|
Assert.AreEqual(0, session);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustTerminateOnSessionStartFailure()
|
|
{
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Failed).Callback(() => sessionContext.Current = currentSession);
|
|
sessionContext.Current = null;
|
|
|
|
var success = sut.TryStart();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Once);
|
|
|
|
shutdown.Verify(s => s(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustNotTerminateOnSessionStartAbortion()
|
|
{
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Aborted).Callback(() => sessionContext.Current = currentSession);
|
|
sessionContext.Current = null;
|
|
|
|
var success = sut.TryStart();
|
|
|
|
bootstrapSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
bootstrapSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryPerform(), Times.Once);
|
|
sessionSequence.Verify(b => b.TryRepeat(), Times.Never);
|
|
sessionSequence.Verify(b => b.TryRevert(), Times.Never);
|
|
|
|
shutdown.Verify(s => s(), Times.Never);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustUpdateProgressForBootstrapSequence()
|
|
{
|
|
var args = new ProgressChangedEventArgs
|
|
{
|
|
CurrentValue = 12,
|
|
IsIndeterminate = true,
|
|
MaxValue = 100,
|
|
Progress = true,
|
|
Regress = true
|
|
};
|
|
|
|
bootstrapSequence
|
|
.Setup(b => b.TryPerform())
|
|
.Returns(OperationResult.Success)
|
|
.Callback(() => { bootstrapSequence.Raise(s => s.ProgressChanged += null, args); });
|
|
|
|
var success = sut.TryStart();
|
|
|
|
splashScreen.Verify(s => s.SetValue(It.Is<int>(i => i == args.CurrentValue)), Times.Once);
|
|
splashScreen.Verify(s => s.SetIndeterminate(), Times.Once);
|
|
splashScreen.Verify(s => s.SetMaxValue(It.Is<int>(i => i == args.MaxValue)), Times.Once);
|
|
splashScreen.Verify(s => s.Progress(), Times.Once);
|
|
splashScreen.Verify(s => s.Regress(), Times.Once);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Startup_MustUpdateStatusForBootstrapSequence()
|
|
{
|
|
var key = TextKey.OperationStatus_InitializeBrowser;
|
|
|
|
bootstrapSequence
|
|
.Setup(b => b.TryPerform())
|
|
.Returns(OperationResult.Success)
|
|
.Callback(() => { bootstrapSequence.Raise(s => s.StatusChanged += null, key); });
|
|
|
|
var success = sut.TryStart();
|
|
|
|
splashScreen.Verify(s => s.UpdateStatus(It.Is<TextKey>(k => k == key), true), Times.Once);
|
|
}
|
|
|
|
private void StartSession()
|
|
{
|
|
bootstrapSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success);
|
|
sessionSequence.Setup(b => b.TryPerform()).Returns(OperationResult.Success).Callback(() => sessionContext.Current = currentSession);
|
|
sessionContext.Current = null;
|
|
|
|
sut.TryStart();
|
|
}
|
|
}
|
|
}
|