371 lines
12 KiB
C#
371 lines
12 KiB
C#
/*
|
|
* Copyright (c) 2022 ETH Zürich, Educational Development and Technology (LET)
|
|
*
|
|
* 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.Linq;
|
|
using System.Threading;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using Moq;
|
|
using SafeExamBrowser.Client.Communication;
|
|
using SafeExamBrowser.Communication.Contracts;
|
|
using SafeExamBrowser.Communication.Contracts.Data;
|
|
using SafeExamBrowser.Communication.Contracts.Hosts;
|
|
using SafeExamBrowser.Configuration.Contracts;
|
|
using SafeExamBrowser.Logging.Contracts;
|
|
using SafeExamBrowser.UserInterface.Contracts.MessageBox;
|
|
|
|
namespace SafeExamBrowser.Client.UnitTests.Communication
|
|
{
|
|
[TestClass]
|
|
public class ClientHostTests
|
|
{
|
|
private const int PROCESS_ID = 1234;
|
|
|
|
private Mock<IConfigurationRepository> configuration;
|
|
private Mock<IHostObject> hostObject;
|
|
private Mock<IHostObjectFactory> hostObjectFactory;
|
|
private Mock<ILogger> logger;
|
|
private ClientHost sut;
|
|
|
|
[TestInitialize]
|
|
public void Initialize()
|
|
{
|
|
configuration = new Mock<IConfigurationRepository>();
|
|
hostObject = new Mock<IHostObject>();
|
|
hostObjectFactory = new Mock<IHostObjectFactory>();
|
|
logger = new Mock<ILogger>();
|
|
|
|
hostObjectFactory.Setup(f => f.CreateObject(It.IsAny<string>(), It.IsAny<ICommunication>())).Returns(hostObject.Object);
|
|
|
|
sut = new ClientHost("net:pipe://some/address", hostObjectFactory.Object, logger.Object, PROCESS_ID, 0);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustOnlyAllowConnectionIfTokenIsValid()
|
|
{
|
|
var token = Guid.NewGuid();
|
|
|
|
sut.AuthenticationToken = token;
|
|
|
|
var response = sut.Connect(token);
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsTrue(response.ConnectionEstablished);
|
|
Assert.IsTrue(sut.IsConnected);
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void MustRejectConnectionIfTokenInvalid()
|
|
{
|
|
var token = Guid.NewGuid();
|
|
|
|
sut.AuthenticationToken = token;
|
|
|
|
var response = sut.Connect(Guid.NewGuid());
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsFalse(response.ConnectionEstablished);
|
|
Assert.IsFalse(sut.IsConnected);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustOnlyAllowOneConcurrentConnection()
|
|
{
|
|
var token = Guid.NewGuid();
|
|
|
|
sut.AuthenticationToken = token;
|
|
|
|
var response1 = sut.Connect(token);
|
|
var response2 = sut.Connect(token);
|
|
var response3 = sut.Connect(token);
|
|
|
|
Assert.IsNotNull(response1);
|
|
Assert.IsNotNull(response2);
|
|
Assert.IsNotNull(response3);
|
|
Assert.IsNotNull(response1.CommunicationToken);
|
|
Assert.IsNull(response2.CommunicationToken);
|
|
Assert.IsNull(response3.CommunicationToken);
|
|
Assert.IsTrue(response1.ConnectionEstablished);
|
|
Assert.IsFalse(response2.ConnectionEstablished);
|
|
Assert.IsFalse(response3.ConnectionEstablished);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustCorrectlyDisconnect()
|
|
{
|
|
var eventFired = false;
|
|
var token = Guid.NewGuid();
|
|
|
|
sut.RuntimeDisconnected += () => eventFired = true;
|
|
sut.AuthenticationToken = token;
|
|
|
|
var connectionResponse = sut.Connect(token);
|
|
var message = new DisconnectionMessage
|
|
{
|
|
CommunicationToken = connectionResponse.CommunicationToken.Value,
|
|
Interlocutor = Interlocutor.Runtime
|
|
};
|
|
var response = sut.Disconnect(message);
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsTrue(response.ConnectionTerminated);
|
|
Assert.IsTrue(eventFired);
|
|
Assert.IsFalse(sut.IsConnected);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustNotAllowReconnectionAfterDisconnection()
|
|
{
|
|
var token = sut.AuthenticationToken = Guid.NewGuid();
|
|
var response = sut.Connect(token);
|
|
var message = new DisconnectionMessage
|
|
{
|
|
CommunicationToken = response.CommunicationToken.Value,
|
|
Interlocutor = Interlocutor.Runtime
|
|
};
|
|
|
|
sut.Disconnect(message);
|
|
sut.AuthenticationToken = token = Guid.NewGuid();
|
|
|
|
response = sut.Connect(token);
|
|
|
|
Assert.IsFalse(response.ConnectionEstablished);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleAuthenticationRequestCorrectly()
|
|
{
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new SimpleMessage(SimpleMessagePurport.Authenticate) { CommunicationToken = token };
|
|
var response = sut.Send(message);
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(AuthenticationResponse));
|
|
Assert.AreEqual(PROCESS_ID, (response as AuthenticationResponse)?.ProcessId);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleExamSelectionRequestCorrectly()
|
|
{
|
|
var examSelectionRequested = false;
|
|
var requestId = Guid.NewGuid();
|
|
var resetEvent = new AutoResetEvent(false);
|
|
|
|
sut.ExamSelectionRequested += (args) =>
|
|
{
|
|
examSelectionRequested = true;
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var request = new ExamSelectionRequestMessage(Enumerable.Empty<(string id, string lms, string name, string url)>(), requestId) { CommunicationToken = token };
|
|
var response = sut.Send(request);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(examSelectionRequested);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleMessageBoxRequestCorrectly()
|
|
{
|
|
var action = (int) MessageBoxAction.YesNo;
|
|
var icon = (int) MessageBoxIcon.Question;
|
|
var message = "Qwert kndorz safie abcd?";
|
|
var messageBoxRequested = false;
|
|
var requestId = Guid.NewGuid();
|
|
var resetEvent = new AutoResetEvent(false);
|
|
var title = "Poiuztrewq!";
|
|
|
|
sut.MessageBoxRequested += (args) =>
|
|
{
|
|
messageBoxRequested = args.Action == action && args.Icon == icon && args.Message == message && args.RequestId == requestId && args.Title == title;
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var request = new MessageBoxRequestMessage(action, icon, message, requestId, title) { CommunicationToken = token };
|
|
var response = sut.Send(request);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(messageBoxRequested);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandlePasswordRequestCorrectly()
|
|
{
|
|
var passwordRequested = false;
|
|
var purpose = PasswordRequestPurpose.LocalAdministrator;
|
|
var requestId = Guid.NewGuid();
|
|
var resetEvent = new AutoResetEvent(false);
|
|
|
|
sut.PasswordRequested += (args) =>
|
|
{
|
|
passwordRequested = args.Purpose == purpose && args.RequestId == requestId;
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new PasswordRequestMessage(purpose, requestId) { CommunicationToken = token };
|
|
var response = sut.Send(message);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(passwordRequested);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleReconfigurationAbortionCorrectly()
|
|
{
|
|
var reconfigurationAborted = false;
|
|
var resetEvent = new AutoResetEvent(false);
|
|
|
|
sut.ReconfigurationAborted += () =>
|
|
{
|
|
reconfigurationAborted = true;
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new SimpleMessage(SimpleMessagePurport.ReconfigurationAborted) { CommunicationToken = token };
|
|
var response = sut.Send(message);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(reconfigurationAborted);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleReconfigurationDenialCorrectly()
|
|
{
|
|
var filePath = @"C:\Some\Random\Path\To\A\File.seb";
|
|
var reconfigurationDenied = false;
|
|
var resetEvent = new AutoResetEvent(false);
|
|
|
|
sut.ReconfigurationDenied += (args) =>
|
|
{
|
|
reconfigurationDenied = new Uri(args.ConfigurationPath).Equals(new Uri(filePath));
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new ReconfigurationDeniedMessage(filePath) { CommunicationToken = token };
|
|
var response = sut.Send(message);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(reconfigurationDenied);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleServerFailureCorrectly()
|
|
{
|
|
var serverFailureActionRequested = false;
|
|
var requestId = Guid.NewGuid();
|
|
var resetEvent = new AutoResetEvent(false);
|
|
|
|
sut.ServerFailureActionRequested += (args) =>
|
|
{
|
|
serverFailureActionRequested = true;
|
|
resetEvent.Set();
|
|
};
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var request = new ServerFailureActionRequestMessage("", true, requestId) { CommunicationToken = token };
|
|
var response = sut.Send(request);
|
|
|
|
resetEvent.WaitOne();
|
|
|
|
Assert.IsTrue(serverFailureActionRequested);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustHandleShutdownRequestCorrectly()
|
|
{
|
|
var shutdownRequested = false;
|
|
|
|
sut.Shutdown += () => shutdownRequested = true;
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new SimpleMessage(SimpleMessagePurport.Shutdown) { CommunicationToken = token };
|
|
var response = sut.Send(message);
|
|
|
|
Assert.IsTrue(shutdownRequested);
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.Acknowledged, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustReturnUnknownMessageAsDefault()
|
|
{
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
var message = new TestMessage { CommunicationToken = token } as Message;
|
|
var response = sut.Send(message);
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.UnknownMessage, (response as SimpleResponse)?.Purport);
|
|
|
|
message = new SimpleMessage(default(SimpleMessagePurport)) { CommunicationToken = token };
|
|
response = sut.Send(message);
|
|
|
|
Assert.IsNotNull(response);
|
|
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
|
|
Assert.AreEqual(SimpleResponsePurport.UnknownMessage, (response as SimpleResponse)?.Purport);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MustNotFailIfNoEventHandlersSubscribed()
|
|
{
|
|
sut.AuthenticationToken = Guid.Empty;
|
|
|
|
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
|
|
|
|
sut.Send(new MessageBoxRequestMessage(default(int), default(int), "", Guid.Empty, "") { CommunicationToken = token });
|
|
sut.Send(new PasswordRequestMessage(default(PasswordRequestPurpose), Guid.Empty) { CommunicationToken = token });
|
|
sut.Send(new SimpleMessage(SimpleMessagePurport.ReconfigurationAborted));
|
|
sut.Send(new ReconfigurationDeniedMessage("") { CommunicationToken = token });
|
|
sut.Send(new SimpleMessage(SimpleMessagePurport.Shutdown) { CommunicationToken = token });
|
|
sut.Disconnect(new DisconnectionMessage { CommunicationToken = token, Interlocutor = Interlocutor.Runtime });
|
|
}
|
|
|
|
private class TestMessage : Message { };
|
|
}
|
|
}
|