Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

update: setup for dependency injection #34

Merged
merged 1 commit into from
Aug 16, 2024
Merged

update: setup for dependency injection #34

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
341 changes: 170 additions & 171 deletions BuddySave.IntegrationTests/Core/LockManagerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,205 +6,204 @@
using BuddySave.TestTools;
using Xunit;

namespace BuddySave.IntegrationTests.Core
namespace BuddySave.IntegrationTests.Core;

public class LockManagerTests
{
public class LockManagerTests
[Theory, AutoMoqData]
public void LockExists_ReturnsFalse_WhenNoLockFile(
GameSave gameSave,
LockManager sut)
{
[Theory, AutoMoqData]
public void LockExists_ReturnsFalse_WhenNoLockFile(
GameSave gameSave,
LockManager sut)
{
// Act
var result = sut.LockExists(gameSave);
// Act
var result = sut.LockExists(gameSave);

// Assert
Assert.False(result);
}
// Assert
Assert.False(result);
}

[Theory, AutoMoqData]
public async Task LockExists_ReturnsTrue_WhenLockFileExists(
GameSave gameSave,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create();
gameSave.CloudPath = lockFile.CloudPath;
[Theory, AutoMoqData]
public async Task LockExists_ReturnsTrue_WhenLockFileExists(
GameSave gameSave,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create();
gameSave.CloudPath = lockFile.CloudPath;

// Act
var result = sut.LockExists(gameSave);
// Act
var result = sut.LockExists(gameSave);

// Assert
Assert.True(result);
}

[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsFalse_WhenNoLockFile(
GameSave gameSave,
Session session,
LockManager sut)
{
// Act
var result = await sut.LockExists(gameSave, session);
// Assert
Assert.True(result);
}

// Assert
Assert.False(result);
}
[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsFalse_WhenNoLockFile(
GameSave gameSave,
Session session,
LockManager sut)
{
// Act
var result = await sut.LockExists(gameSave, session);

[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsFalse_WhenSaveIsLockedByAnotherUserName(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create("buddy");
gameSave.CloudPath = lockFile.CloudPath;

// Act
var result = await sut.LockExists(gameSave, session);

// Assert
Assert.False(result);
}
// Assert
Assert.False(result);
}

[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsTrue_WhenSaveIsLockedByCurrentUser(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create(session.UserName);
gameSave.CloudPath = lockFile.CloudPath;

// Act
var result = await sut.LockExists(gameSave, session);

// Assert
Assert.True(result);
}
[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsFalse_WhenSaveIsLockedByAnotherUserName(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create("buddy");
gameSave.CloudPath = lockFile.CloudPath;

[Theory, AutoMoqData]
public async Task CreateLock_ThrowsException_WhenLockExists(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create();
gameSave.CloudPath = lockFile.CloudPath;
// Act
var result = await sut.LockExists(gameSave, session);

// Act
var act = new Func<Task>(async () => await sut.CreateLock(gameSave, session));
// Assert
Assert.False(result);
}

// Assert
await Assert.ThrowsAnyAsync<Exception>(act);
}
[Theory, AutoMoqData]
public async Task LockExistsForUserName_ReturnsTrue_WhenSaveIsLockedByCurrentUser(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create(session.UserName);
gameSave.CloudPath = lockFile.CloudPath;

[Theory, AutoMoqData]
public async Task CreateLock_CreatesLock_WhenLockDoesNotExist(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
gameSave.CloudPath = lockFile.CloudPath;
// Act
var result = await sut.LockExists(gameSave, session);

// Act
await sut.CreateLock(gameSave, session);
// Assert
Assert.True(result);
}

// Assert
Assert.True(File.Exists(lockFile.LockPath));
var expectedFileContent = (await File.ReadAllTextAsync(lockFile.LockPath)).Trim();
Assert.Equal(expectedFileContent, session.UserName);
}
[Theory, AutoMoqData]
public async Task CreateLock_ThrowsException_WhenLockExists(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create();
gameSave.CloudPath = lockFile.CloudPath;

[Theory, AutoMoqData]
public async Task DeleteLock_DeletesLock_WhenLockExists(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create(session.UserName);
gameSave.CloudPath = lockFile.CloudPath;
// Act
var act = new Func<Task>(async () => await sut.CreateLock(gameSave, session));

// Act
await sut.DeleteLock(gameSave, session);
// Assert
await Assert.ThrowsAnyAsync<Exception>(act);
}

// Assert
Assert.False(File.Exists(lockFile.LockPath));
}
[Theory, AutoMoqData]
public async Task CreateLock_CreatesLock_WhenLockDoesNotExist(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
gameSave.CloudPath = lockFile.CloudPath;

[Theory, AutoMoqData]
public async Task DeleteLock_DoesNothing_WhenLockDoesNotExist(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
gameSave.CloudPath = lockFile.CloudPath;
// Act
await sut.CreateLock(gameSave, session);

// Act
await sut.DeleteLock(gameSave, session);
// Assert
Assert.True(File.Exists(lockFile.LockPath));
var expectedFileContent = (await File.ReadAllTextAsync(lockFile.LockPath)).Trim();
Assert.Equal(expectedFileContent, session.UserName);
}

// Assert
Assert.False(File.Exists(lockFile.LockPath));
}
[Theory, AutoMoqData]
public async Task DeleteLock_DeletesLock_WhenLockExists(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create(session.UserName);
gameSave.CloudPath = lockFile.CloudPath;

// Act
await sut.DeleteLock(gameSave, session);

// Assert
Assert.False(File.Exists(lockFile.LockPath));
}

[Theory, AutoMoqData]
public async Task DeleteLock_DoesNothing_WhenLockDoesNotExist(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
gameSave.CloudPath = lockFile.CloudPath;

// Act
await sut.DeleteLock(gameSave, session);

// Assert
Assert.False(File.Exists(lockFile.LockPath));
}

[Theory, AutoMoqData]
public async Task DeleteLock_ThrowsException_WhenLockIsCreatedByAnotherUser(
GameSave gameSave,
Session session,
LockManager sut)
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create("buddyUser");
gameSave.CloudPath = lockFile.CloudPath;

// Act
var act = new Func<Task>(async () => await sut.DeleteLock(gameSave, session));

[Theory, AutoMoqData]
public async Task DeleteLock_ThrowsException_WhenLockIsCreatedByAnotherUser(
GameSave gameSave,
Session session,
LockManager sut)
// Assert
var exception = await Assert.ThrowsAsync<Exception>(act);
Assert.Equal("Cannot delete lock. Lock is owned by buddyUser.", exception.Message);
}

private class TempLockFile : IDisposable
{
public TempLockFile()
{
// Arrange
using var lockFile = new TempLockFile();
await lockFile.Create("buddyUser");
gameSave.CloudPath = lockFile.CloudPath;
CloudPath = Path.GetTempFileName();
LockPath = CloudPath + ".lock";
}

public string LockPath { get; }

public string CloudPath { get; }

// Act
var act = new Func<Task>(async () => await sut.DeleteLock(gameSave, session));
public void Dispose()
{
File.Delete(LockPath);
}

// Assert
var exception = await Assert.ThrowsAsync<Exception>(act);
Assert.Equal("Cannot delete lock. Lock is owned by buddyUser.", exception.Message);
public async Task Create()
{
await File.WriteAllTextAsync(LockPath, "This is a test lock");
}

private class TempLockFile : IDisposable
public async Task Create(string contents)
{
public TempLockFile()
{
CloudPath = Path.GetTempFileName();
LockPath = CloudPath + ".lock";
}

public string LockPath { get; }

public string CloudPath { get; }

public void Dispose()
{
File.Delete(LockPath);
}

public async Task Create()
{
await File.WriteAllTextAsync(LockPath, "This is a test lock");
}

public async Task Create(string contents)
{
await File.WriteAllTextAsync(LockPath, contents);
}
await File.WriteAllTextAsync(LockPath, contents);
}
}
}
Loading
Loading