fab-approval-worker-service/FabApprovalWorkerServiceTests/TrainingServiceTests.cs

using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Microsoft.Extensions.Logging;

using Moq;

namespace FabApprovalWorkerServiceTests;
public class TrainingServiceTests {
    private Mock<ILogger<TrainingService>> _mockLogger;
    private Mock<IDalService> _mockDalService;

    private TrainingService _trainingService;

    [SetUp]
    public void Setup() {
        _mockLogger = new Mock<ILogger<TrainingService>>();
        _mockDalService = new Mock<IDalService>();
    }

    [Test]
    public void TrainingServiceWithNullLoggerShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new TrainingService(null, _mockDalService.Object));
    }

    [Test]
    public void TrainingServiceWithNullDalServiceShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new TrainingService(_mockLogger.Object, null));
    }
<<<<<<< Updated upstream
=======

    [Test]
    public void DeleteDocAssignmentWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteDocAssignment(-1));
    }

    [Test]
    public void DeleteDocAssignmentWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteDocAssignment(1));
    }

    [Test]
    public async Task DeleteDocAssignmentShouldExecuteSqlQuery() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(3));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        await _trainingService.DeleteDocAssignment(3);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()));
    }

    [Test]
    public void DeleteTrainingAssignmentWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.DeleteTrainingAssignment(-1));
    }

    [Test]
    public void DeleteTrainingAssignmentWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.DeleteTrainingAssignment(1));
    }

    [Test]
    public async Task DeleteTrainingAssignmentShouldExecuteSqlQuery() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(3));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        await _trainingService.DeleteTrainingAssignment(3);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()));
    }

    [Test]
    public void GetTrainingAssignmentIdsForTrainingWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => {
            IEnumerable<int> ids = await _trainingService.GetTrainingAssignmentIdsForTraining(-1);
        });
    }

    [Test]
    public void GetTrainingAssignmentIdsForTrainingWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingAssignmentIdsForTraining(1));
    }

    [Test]
    public async Task GetTrainingAssignmentIdsForTrainingShouldReturnExpectedIds() {
        IEnumerable<int> expectedIds = new List<int>() { 4, 7, 2 };

        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<int> actualIds = await _trainingService.GetTrainingAssignmentIdsForTraining(1);

        Assert.That(actualIds.Count(), Is.EqualTo(expectedIds.Count()));
    }

    [Test]
    public void GetTrainingIdsForEcnWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => {
            IEnumerable<int> ids = await _trainingService.GetTrainingIdsForECN(-1);
        });
    }

    [Test]
    public void GetTrainingIdsForEcnWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.GetTrainingIdsForECN(1));
    }

    [Test]
    public async Task GetTrainingIdsForEcnsShouldReturnExpectedIds() {
        IEnumerable<int> expectedIds = new List<int>() { 4, 7, 2 };

        _mockDalService.Setup(d => d.QueryAsync<int>(It.IsAny<string>())).Returns(Task.FromResult(expectedIds));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<int> actualIds = await _trainingService.GetTrainingIdsForECN(1);

        Assert.That(actualIds.Count(), Is.EqualTo(expectedIds.Count()));
    }

    [Test]
    public void MarkTrainingAsCompleteWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task() => await _trainingService.MarkTrainingAsComplete(-1));
    }

    [Test]
    public void MarkTrainingCompleteWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.MarkTrainingAsComplete(1));
    }

    [Test]
    public async Task MarkTrainingCompleteShouldExecuteSql() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        await _trainingService.MarkTrainingAsComplete(1);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()));
    }

    [Test]
    public async Task GetActiveTrainingAssignmentsShouldReturnExpectedAssignments() {
        IEnumerable<TrainingAssignment> expectedAssignments = new List<TrainingAssignment>() { 
            new TrainingAssignment() {
                ID = 1,
                TrainingID = 1,
                UserID = 1,
                DateAssigned = DateTime.Now
            },
            new TrainingAssignment() {
                ID = 2,
                TrainingID = 1,
                UserID = 2,
                DateAssigned = DateTime.Now
            },
            new TrainingAssignment() {
                ID = 3,
                TrainingID = 1,
                UserID = 3,
                DateAssigned = DateTime.Now
            }
        };

        _mockDalService.Setup(d => d.QueryAsync<TrainingAssignment>(It.IsAny<string>())).Returns(Task.FromResult(expectedAssignments));

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<TrainingAssignment> actualAssignments = await _trainingService.GetActiveTrainingAssignments();

        Assert.That(actualAssignments.Count() == expectedAssignments.Count());
    }

    [Test]
    public void GetActiveTrainingAssignmentsWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<TrainingAssignment>(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task() => await _trainingService.GetActiveTrainingAssignments());
    }

    [Test]
    public void UpdateTrainingAssignmentLastNotificationWithInvalidIdShouldThrowException() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _trainingService.UpdateTrainingAssignmentLastNotification(-1));
    }

    [Test]
    public void UpdateTrainingAssignmentLastNotificationDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Throws(new Exception());

        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _trainingService.UpdateTrainingAssignmentLastNotification(1));
    }

    [Test]
    public async Task UpdateTrainingAssignmentLastNotificationShouldExecuteSql() {
        _trainingService = new TrainingService(_mockLogger.Object, _mockDalService.Object);

        await _trainingService.UpdateTrainingAssignmentLastNotification(1);

        _mockDalService.Verify(d => d.ExecuteAsync(It.IsAny<string>()), Times.Once());
    }
>>>>>>> Stashed changes
}