phares3757/fab-approval-worker-service
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Created ECNService

Browse Source
This commit is contained in:
Chase Tucker
2024-03-28 14:11:45 -07:00
parent c4baef8025
commit 830c8576e3
10 changed files with 525 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
FabApprovalWorkerServiceTests/ECNServiceTests.cs Normal file
View File

@ -0,0 +1,217 @@
using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;
using Microsoft.Extensions.Logging;
using Moq;
namespace FabApprovalWorkerServiceTests;
internal class ECNServiceTests {
Mock<ILogger<ECNService>> _mockLogger;
Mock<IDalService> _mockDalService;
ECNService _ecnService;
[SetUp]
public void Setup() {
_mockLogger = new Mock<ILogger<ECNService>>();
_mockDalService = new Mock<IDalService>();
}
[Test]
public void EcnServiceWithNullLoggerShouldThrowException() {
Assert.Throws<ArgumentNullException>(() => new ECNService(null, _mockDalService.Object));
}
[Test]
public void EcnServiceWithNullDalServiceShouldThrowException() {
Assert.Throws<ArgumentNullException>(() => new ECNService(_mockLogger.Object, null));
}
[Test]
public async Task GetExpiringTECNsWithDbErrorShouldThrowException() {
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).ThrowsAsync(new Exception());
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetExpiringTECNs());
}
[Test]
public async Task GetExpiredTECNsWithDbErrorShouldThrowException() {
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).ThrowsAsync(new Exception());
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetExpiredTECNs());
}
[Test]
public async Task GetExpiringTECNsWithNoResultsFromDbShouldReturnEmpty() {
IEnumerable<ECN> emptyEcns = new List<ECN>();
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(emptyEcns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();
Assert.That(actual, Is.Empty);
}
[Test]
public async Task GetExpiredTECNsWithNoResultsFromDbShouldReturnEmpty() {
IEnumerable<ECN> emptyEcns = new List<ECN>();
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(emptyEcns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNs();
Assert.That(actual, Is.Empty);
}
[Test]
public async Task GetExpiringTECNsWithNoExtensionFromDbShouldReturnSameResults() {
IEnumerable<ECN> ecns = new List<ECN>() {
new ECN() {
ECNNumber = 1,
OriginatorID = 1,
Title = "title1",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(1)
},
new ECN() {
ECNNumber = 2,
OriginatorID = 1,
Title = "title2",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(2)
},
new ECN() {
ECNNumber = 3,
OriginatorID = 1,
Title = "title3",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(3)
},
};
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();
Assert.That(actual.Count(), Is.EqualTo(3));
}
[Test]
public async Task GetExpiredTECNsWithNoExtensionFromDbShouldReturnSameResults() {
IEnumerable<ECN> ecns = new List<ECN>() {
new ECN() {
ECNNumber = 1,
OriginatorID = 1,
Title = "title1",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-2)
},
new ECN() {
ECNNumber = 2,
OriginatorID = 1,
Title = "title2",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-20)
},
new ECN() {
ECNNumber = 3,
OriginatorID = 1,
Title = "title3",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-12)
},
};
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNs();
Assert.That(actual.Count(), Is.EqualTo(3));
}
// Test when responses include extension dates
[Test]
public async Task GetExpiringTECNsWithExtensionsFromDbShouldReturnSameResults() {
IEnumerable<ECN> ecns = new List<ECN>() {
new ECN() {
ECNNumber = 1,
OriginatorID = 1,
Title = "title1",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(1)
},
new ECN() {
ECNNumber = 2,
OriginatorID = 1,
Title = "title2",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(2)
},
new ECN() {
ECNNumber = 3,
OriginatorID = 1,
Title = "title3",
IsTECN = true,
ExpirationDate = DateTime.Now.AddDays(3),
ExtensionDate = DateTime.Now.AddDays(10)
},
};
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();
Assert.That(actual.Count(), Is.EqualTo(2));
}
[Test]
public async Task GetExpiredTECNsWithExtensionsFromDbShouldReturnSameResults() {
IEnumerable<ECN> ecns = new List<ECN>() {
new ECN() {
ECNNumber = 1,
OriginatorID = 1,
Title = "title1",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-2)
},
new ECN() {
ECNNumber = 2,
OriginatorID = 1,
Title = "title2",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-20)
},
new ECN() {
ECNNumber = 3,
OriginatorID = 1,
Title = "title3",
IsTECN = true,
ExpirationDate = DateTime.Now.AddHours(-12),
ExtensionDate = DateTime.Now.AddDays(10)
},
};
_mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));
_ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);
IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNs();
Assert.That(actual.Count(), Is.EqualTo(2));
}
}

117
FabApprovalWorkerServiceTests/SmtpServiceTests.cs Normal file
View File

@ -0,0 +1,117 @@
using FabApprovalWorkerService.Clients;
using FabApprovalWorkerService.Services;
using Microsoft.Extensions.Logging;
using Moq;
using System.Net.Mail;
namespace FabApprovalWorkerServiceTests;
internal class SmtpServiceTests {
private static readonly List<MailAddress> ADDRESS_LIST = new List<MailAddress>() {
new MailAddress("fake@email.com")
};
private Mock<ILogger<SmtpService>> _mockLogger;
private Mock<ISmtpClientWrapper> _mockSmtpClient;
private SmtpService _smtpService;
[SetUp]
public void Setup() {
_mockLogger = new Mock<ILogger<SmtpService>>();
_mockSmtpClient = new Mock<ISmtpClientWrapper>();
}
[Test]
public void SmtpServiceWithNullLoggerShouldThrowException() {
Assert.Throws<ArgumentNullException>(() => new SmtpService(null, _mockSmtpClient.Object));
}
[Test]
public void SmtpServiceWithNullSmtpClientShouldThrowException() {
Assert.Throws<ArgumentNullException>(() => new SmtpService(_mockLogger.Object, null));
}
[Test]
public void SendMailWithNullRecipientsShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(null, ADDRESS_LIST, "subject", "body");
});
}
[Test]
public void SendMailWithEmptyRecipientsShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(new List<MailAddress> (), ADDRESS_LIST, "subject", "body");
});
}
[Test]
public void SendMailWithNullccRecipientsShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, null, "subject", "body");
});
}
[Test]
public void SendMailWithEmptyccRecipientsShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, new List<MailAddress>(), "subject", "body");
});
}
[Test]
public void SendMailWithNullSubjectShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, ADDRESS_LIST, null, "body");
});
}
[Test]
public void SendMailWithEmptySubjectShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, ADDRESS_LIST, "", "body");
});
}
[Test]
public void SendMailWithNullBodyShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, ADDRESS_LIST, "subject", null);
});
}
[Test]
public void SendMailWithEmptyBodyShouldThrowException() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.ThrowsAsync<ArgumentNullException>(async Task () => {
await _smtpService.SendEmail(ADDRESS_LIST, ADDRESS_LIST, "subject", "");
});
}
[Test]
public async Task SendEmailWithValidArgsShouldSendMailThroughClient() {
_smtpService = new SmtpService(_mockLogger.Object, _mockSmtpClient.Object);
Assert.True(await _smtpService.SendEmail(ADDRESS_LIST, ADDRESS_LIST, "subject", "body"));
_mockSmtpClient.Verify(s => s.Send(It.IsAny<MailMessage>()));
}
}

4
FabApprovalWorkerServiceTests/UserServiceTests.cs
View File

@ -1,5 +1,3 @@
using Dapper.Contrib.Extensions;
using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;
@ -9,7 +7,7 @@ using Moq;
namespace FabApprovalWorkerServiceTests;
public class UserServiceTests {
internal class UserServiceTests {
private static readonly ILogger<UserService> MOCK_LOGGER = Mock.Of<ILogger<UserService>>();
private static readonly IEnumerable<User> MOCK_USERS = new List<User>() {