Skip to content

Commit

Permalink
Merge pull request #44 from SparrowBrain/client-launch
Browse files Browse the repository at this point in the history
Added play action
  • Loading branch information
SparrowBrain authored Sep 16, 2024
2 parents 40d1f2f + b193ce9 commit a5b3df8
Show file tree
Hide file tree
Showing 15 changed files with 567 additions and 322 deletions.
79 changes: 79 additions & 0 deletions BuddySave.UnitTests/Core/ClientSessionTests.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
using AutoFixture.Xunit2;
using BuddySave.Core;
using BuddySave.Core.Models;
using BuddySave.System;
using BuddySave.TestTools;
using Moq;
using System;
using System.Diagnostics;
using Xunit;

namespace BuddySave.UnitTests.Core;

public class ClientSessionTests
{
[Theory]
[InlineAutoMoqData("")]
[InlineAutoMoqData((string)null)]
public void StartClient_ThrowsArgumentException_WhenClientPathIsNull(
string path,
Session session,
ClientParameters clientParameters,
ClientSession sut)
{
// Arrange
clientParameters.Path = path;

// Act
var exception = Record.Exception(() => sut.StartClient(session, clientParameters));

// Assert
Assert.NotNull(exception);
Assert.IsType<ArgumentException>(exception);
Assert.Equal("No client path provided. Cannot start a client session.", exception.Message);
}

[Theory]
[InlineAutoMoqData("")]
[InlineAutoMoqData((string)null)]
public void StartClient_ThrowsArgumentException_WhenClientArgumentsIsNull(
string arguments,
Session session,
ClientParameters clientParameters,
ClientSession sut)
{
// Arrange
clientParameters.Arguments = arguments;

// Act
var exception = Record.Exception(() => sut.StartClient(session, clientParameters));

// Assert
Assert.NotNull(exception);
Assert.IsType<ArgumentException>(exception);
Assert.Equal("No launch arguments provided for client. Cannot start a client session.", exception.Message);
}

[Theory]
[AutoMoqData]
public void StartClient_StartsClient(
[Frozen] Mock<IProcessProvider> processProviderMock,
Session session,
ClientParameters clientParameters,
ClientSession sut)
{
// Arrange
clientParameters.Arguments = "+connect {{Ip}}:{{Port}}";
var expectedArguments = $"+connect {session.Ip}:{session.Port}";

// Act
sut.StartClient(session, clientParameters);

// Assert
processProviderMock.Verify(
x => x.Start(It.Is<ProcessStartInfo>(x =>
x.FileName == $"{clientParameters.Path} {expectedArguments}"
&& x.UseShellExecute == true)),
Times.Once());
}
}
232 changes: 53 additions & 179 deletions BuddySave.UnitTests/Core/GamingSessionTests.cs
Original file line number Diff line number Diff line change
@@ -1,190 +1,64 @@
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using AutoFixture.Xunit2;
using AutoFixture.Xunit2;
using BuddySave.Core;
using BuddySave.Core.Models;
using BuddySave.System;
using BuddySave.TestTools;
using Moq;
using System.Threading.Tasks;
using Xunit;

namespace BuddySave.UnitTests.Core;

public class GamingSessionTests
{
[Theory]
[InlineAutoMoqData((string)null)]
[InlineAutoMoqData("")]
public async Task Run_ThrowsException_WhenNoServerPathIsEmpty(
string serverPath,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
serverParameters.Path = serverPath;

// Act
var act = new Func<Task>(() => sut.RunServerWithAutoSave(gameSave, session, serverParameters));

// Assert
await Assert.ThrowsAsync<ArgumentException>(act);
}

[Theory]
[AutoMoqData]
public async Task Run_DoesNotStartTheServer_WhenLoadingSaveFails(
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
[Frozen] Mock<IProcessProvider> processProviderMock,
Exception exception,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>())).Throws(exception);

// Act
var act = new Func<Task>(() => sut.RunServerWithAutoSave(gameSave, session, serverParameters));

// Assert
await Assert.ThrowsAnyAsync<Exception>(act);
processProviderMock.Verify(x => x.Start(It.IsAny<ProcessStartInfo>()), Times.Never());
}

[Theory]
[InlineAutoMoqData(OrchestratorResult.SaveLocked)]
[InlineAutoMoqData(OrchestratorResult.Failed)]
public async Task Run_DoesNotStartTheServer_WhenGameSaveIsNotLoaded(
OrchestratorResult orchestratorResult,
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
[Frozen] Mock<IProcessProvider> processProviderMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>())).ReturnsAsync(orchestratorResult);

// Act
await sut.RunServerWithAutoSave(gameSave, session, serverParameters);

// Assert
processProviderMock.Verify(x => x.Start(It.IsAny<ProcessStartInfo>()), Times.Never());
}

[Theory]
[InlineAutoMoqData(OrchestratorResult.SaveLocked)]
[InlineAutoMoqData(OrchestratorResult.Failed)]
public async Task Run_DoesWaitForServerToStop_WhenGameSaveIsNotLoaded(
OrchestratorResult orchestratorResult,
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
[Frozen] Mock<IProcessProvider> processProviderMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>())).ReturnsAsync(orchestratorResult);

// Act
await sut.RunServerWithAutoSave(gameSave, session, serverParameters);

// Assert
processProviderMock.Verify(x => x.WaitForExitAsync(It.IsAny<Process>()), Times.Never());
}

[Theory]
[InlineAutoMoqData(OrchestratorResult.SaveLocked)]
[InlineAutoMoqData(OrchestratorResult.Failed)]
public async Task Run_DoesNotCallSave_WhenGameSaveIsNotLoaded(
OrchestratorResult orchestratorResult,
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>())).ReturnsAsync(orchestratorResult);

// Act
await sut.RunServerWithAutoSave(gameSave, session, serverParameters);

// Assert
sharedSaveOrchestratorMock.Verify(x => x.Save(It.IsAny<GameSave>(), It.IsAny<Session>()), Times.Never());
}

[Theory]
[AutoMoqData]
public async Task Run_DoesNotSave_WhenStartingServerFails(
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
[Frozen] Mock<IProcessProvider> processProviderMock,
Exception exception,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock
.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>()))
.ReturnsAsync(OrchestratorResult.Loaded);
processProviderMock.Setup(x => x.Start(It.IsAny<ProcessStartInfo>())).Throws(exception);

// Act
var act = new Func<Task>(() => sut.RunServerWithAutoSave(gameSave, session, serverParameters));

// Assert
await Assert.ThrowsAnyAsync<Exception>(act);
sharedSaveOrchestratorMock.Verify(x => x.Save(It.IsAny<GameSave>(), It.IsAny<Session>()), Times.Never());
}

[Theory]
[AutoMoqData]
public async Task Run_WaitsForServerStop_WhenServerStarts(
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
[Frozen] Mock<IProcessProvider> processProviderMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock
.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>()))
.ReturnsAsync(OrchestratorResult.Loaded);

// Act
await sut.RunServerWithAutoSave(gameSave, session, serverParameters);

// Assert
processProviderMock.Verify(x => x.WaitForExitAsync(It.IsAny<Process>()));
}

[Theory]
[AutoMoqData]
public async Task Run_Saves_WhenServerStops(
[Frozen] Mock<ISharedSaveOrchestrator> sharedSaveOrchestratorMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
GamingSession sut)
{
// Arrange
sharedSaveOrchestratorMock
.Setup(x => x.Load(It.IsAny<GameSave>(), It.IsAny<Session>()))
.ReturnsAsync(OrchestratorResult.Loaded);

// Act
await sut.RunServerWithAutoSave(gameSave, session, serverParameters);

// Assert
sharedSaveOrchestratorMock.Verify(x => x.Save(It.IsAny<GameSave>(), It.IsAny<Session>()));
}
[Theory]
[AutoMoqData]
public async Task Play_StartsClient_WhenLockExists(
[Frozen] Mock<ILockManager> lockManagerMock,
[Frozen] Mock<IClientSession> clientSessionMock,
[Frozen] Mock<IServerSession> serverSessionMock,
GameSave gameSave,
Session ourSession,
Session lockSession,
ServerParameters serverParameters,
ClientParameters clientParameters,
GamingSession sut)
{
// Arrange
lockManagerMock.Setup(x => x.LockExists(gameSave)).Returns(true);
lockManagerMock.Setup(x => x.GetLockedSession(gameSave)).ReturnsAsync(lockSession);

// Act
await sut.Play(gameSave, ourSession, serverParameters, clientParameters);

// Assert
clientSessionMock.Verify(x => x.StartClient(lockSession, clientParameters), Times.Once());
serverSessionMock.Verify(
x => x.RunServerWithAutoSave(It.IsAny<GameSave>(), It.IsAny<Session>(), It.IsAny<ServerParameters>()),
Times.Never);
}

[Theory]
[AutoMoqData]
public async Task Play_StartsServerAndClient_WhenLockDoesNotExist(
[Frozen] Mock<ILockManager> lockManagerMock,
[Frozen] Mock<IClientSession> clientSessionMock,
[Frozen] Mock<IServerSession> serverSessionMock,
GameSave gameSave,
Session session,
ServerParameters serverParameters,
ClientParameters clientParameters,
GamingSession sut)
{
// Arrange
lockManagerMock.Setup(x => x.LockExists(gameSave)).Returns(false);

// Act
await sut.Play(gameSave, session, serverParameters, clientParameters);

// Assert
serverSessionMock.Verify(x => x.RunServerWithAutoSave(gameSave, session, serverParameters), Times.Once());
clientSessionMock.Verify(
x => x.StartClient(It.Is<Session>(s => s.Ip == "127.0.0.1" && s.Port == session.Port), clientParameters),
Times.Once());
}
}
Loading

0 comments on commit a5b3df8

Please sign in to comment.