Created PendingOOOStatusWorker

FabApprovalWorkerServiceTests/UserServiceTests.cs

@@ -1,4 +1,3 @@
-using Dapper;
 using Dapper.Contrib.Extensions;
 
 using FabApprovalWorkerService.Models;
@@ -7,16 +6,13 @@ using FabApprovalWorkerService.Services;
 using Microsoft.Extensions.Logging;
 
 using Moq;
-using Moq.Dapper;
-
-using System.Data;
 
 namespace FabApprovalWorkerServiceTests;
 
 public class UserServiceTests {
     private static readonly ILogger<UserService> MOCK_LOGGER = Mock.Of<ILogger<UserService>>();
 
-    private static readonly IEnumerable<User> MOCK_USERS = new List<User>() { 
+    private static readonly IEnumerable<User> MOCK_USERS = new List<User>() {
         new User() {
             UserID = 1,
             LoginID = "fred",
@@ -24,7 +20,7 @@ public class UserServiceTests {
             LastName = "flintstone",
             Email = "fred.flintstone@email.com",
             IsAdmin = true,
-            OOO = false,
+            OOO = true,
             CanViewITAR = true,
             IsManager = false
         },
@@ -35,12 +31,27 @@ public class UserServiceTests {
             LastName = "rubble",
             Email = "barney.rubble@email.com",
             IsAdmin = false,
-            OOO = false,
+            OOO = true,
             CanViewITAR = true,
             IsManager = false
         }
     };
 
+    private static readonly IEnumerable<OOOTemp> MOCK_OOO_TEMPS = new List<OOOTemp>() {
+        new OOOTemp() {
+            ID = 1,
+            OOOUserID = 1,
+            OOOExpirationDate = DateTime.Now,
+            OOOStartDate = DateTime.Now,
+        },
+        new OOOTemp() {
+            ID = 2,
+            OOOUserID = 2,
+            OOOExpirationDate = DateTime.Now,
+            OOOStartDate = DateTime.Now,
+        }
+    };
+
     Mock<IDalService> _mockDalService;
 
     public UserService _userService;
@@ -48,27 +59,273 @@ public class UserServiceTests {
     [SetUp]
     public void Setup() {
         _mockDalService = new Mock<IDalService>();
-
-        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));
-        _mockDalService.Setup(d => d.UpdateAsync<User>(It.IsAny<ICollection<User>>())).Returns(Task.FromResult(true));
-
-        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
     }
 
     [Test]
-    public async Task GetAllUsersShouldReturnMockUsers() {
-        Dictionary<string, User> users = await _userService.GetAllUsers();
+    public void UserServiceWithNullLoggerShouldThrowException() {
+        _mockDalService = new Mock<IDalService>();
+
+        Assert.Throws<ArgumentNullException>(() => new UserService(null, _mockDalService.Object));
+    }
+
+    [Test]
+    public void UserServiceWithNullDalServiceShouldThrowException() {
+        Assert.Throws<ArgumentNullException>(() => new UserService(MOCK_LOGGER, null));
+    }
+
+    [Test]
+    public async Task GetAllActiveOOOUsersShouldReturnMockUsers() {
+        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        List<User> users = await _userService.GetAllActiveOOOUsersAsync();
+
         Assert.True(users.Count() == 2);
     }
 
     [Test]
-    public void UpdateUserCertificateDataWithNullListShouldThrowException() {
-        Assert.ThrowsAsync<ArgumentNullException>(async () => await _userService.UpdateUserCertificationData(null));
+    public async Task GetAllPendingOOOUsersShouldReturnMockOOOTemps() {
+        _mockDalService.Setup(d => d.QueryAsync<OOOTemp>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_OOO_TEMPS));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        List<OOOTemp> oooTemps = await _userService.GetAllPendingOOOUsersAsync();
+
+        Assert.True(oooTemps.Count() == 2);
     }
 
     [Test]
-    public async Task UpdateUserCertificationDataShouldReturnTrue() {
-        bool result = await _userService.UpdateUserCertificationData(MOCK_USERS.ToList());
-        Assert.True(result);
+    public async Task IsUserAlreadyOOOWithInvalidUserIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.IsUserAlreadyOOO(0));
+    }
+
+    [Test]
+    public async Task IsUserAlreadyOOOWithNoUsersShouldReturnFalse() {
+        IEnumerable<User> emptyUsers = new List<User>();
+
+        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(emptyUsers));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.IsUserAlreadyOOO(2);
+
+        Assert.False(actual);
+    }
+
+    [Test]
+    public async Task IsUserAlreadyOOOWithSomeUsersShouldReturnTrue() {
+        IEnumerable<User> emptyUsers = new List<User>();
+
+        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.IsUserAlreadyOOO(2);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task IsDelegatorAlreadyDelegatedToWithInvalidUserIdShouldReturnFalse() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.False(await _userService.IsDelegatorAlreadyDelegatedTo(0));
+    }
+
+    [Test]
+    public async Task IsDelegatorAlreadyDelegatedToWithNoUsersShouldReturnFalse() {
+        IEnumerable<User> emptyUsers = new List<User>();
+
+        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(emptyUsers));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.IsDelegatorAlreadyDelegatedTo(2);
+
+        Assert.False(actual);
+    }
+
+    [Test]
+    public async Task IsDelegatorAlreadyDelegatedToWithSomeUsersShouldReturnTrue() {
+        IEnumerable<User> emptyUsers = new List<User>();
+
+        _mockDalService.Setup(d => d.QueryAsync<User>(It.IsAny<string>())).Returns(Task.FromResult(MOCK_USERS));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.IsDelegatorAlreadyDelegatedTo(2);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task InsertDelegatedRolesWithInvalidUserIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.InsertDelegatedRoles(0));
+    }
+
+    [Test]
+    public async Task InsertDelegatedRolesWithValidUserIdShouldReturnTrue() {
+        IEnumerable<UserSubRole> userSubRoles = new List<UserSubRole>() { 
+            new UserSubRole() {
+                UserSubRoleID = 1,
+                UserID = 1,
+                SubRoleID = 1
+            },
+            new UserSubRole() {
+                UserSubRoleID = 2,
+                UserID = 2,
+                SubRoleID = 2
+            }
+        };
+
+        _mockDalService.Setup(d => d.QueryAsync<UserSubRole>(It.IsAny<string>())).Returns(Task.FromResult(userSubRoles));
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.InsertDelegatedRoles(2);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task UpdateUserSubRolesWithInvalidUserIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.UpdateUserSubRoles(0, 2));
+    }
+
+    [Test]
+    public async Task UpdateUserSubRolesWithInvalidDelegateIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.UpdateUserSubRoles(2, 0));
+    }
+
+    [Test]
+    public async Task UpdateUserSubRolesWithValidUserIdShouldReturnTrue() {
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.UpdateUserSubRoles(2, 2);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task DelegateApprovalsForUserWithInvalidUserIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateApprovalsForUser(0, 2));
+    }
+
+    [Test]
+    public async Task DelegateApprovalsForUserWithInvalidDelegateIdShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentException>(async Task () => await _userService.DelegateApprovalsForUser(2, 0));
+    }
+
+    [Test]
+    public async Task DelegateApprovalsForUserWithValidUserIdShouldReturnTrue() {
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.DelegateApprovalsForUser(2, 2);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task FlagUserAsOOOWithNullOOOTempShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentNullException>(async Task () => await _userService.FlagUserAsOOO(null));
+    }
+
+    [Test]
+    public async Task FlagUserAsOOOWithValidOOOTempShouldReturnTrue() {
+        OOOTemp oooTemp = new OOOTemp() { 
+            ID = 1,
+            OOOUserID = 1,
+            OOOStartDate = DateTime.Now,
+            OOOExpirationDate = DateTime.Now
+        };
+
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.FlagUserAsOOO(oooTemp);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task FlagUserAsOOOWithInvalidUserIdShouldReturnFalse() {
+        OOOTemp oooTemp = new OOOTemp() {
+            ID = 1,
+            OOOUserID = 1,
+            OOOStartDate = DateTime.Now,
+            OOOExpirationDate = DateTime.Now
+        };
+
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(0));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.FlagUserAsOOO(oooTemp);
+
+        Assert.False(actual);
+    }
+
+    [Test]
+    public async Task SetOOOTempProcessedWithNullOOOTempShouldThrowException() {
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        Assert.ThrowsAsync<ArgumentNullException>(async Task () => await _userService.SetOOOTempProcessed(null));
+    }
+
+    [Test]
+    public async Task SetOOOTempProcessedWithValidOOOTempShouldReturnTrue() {
+        OOOTemp oooTemp = new OOOTemp() {
+            ID = 1,
+            OOOUserID = 1,
+            OOOStartDate = DateTime.Now,
+            OOOExpirationDate = DateTime.Now
+        };
+
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(1));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.SetOOOTempProcessed(oooTemp);
+
+        Assert.True(actual);
+    }
+
+    [Test]
+    public async Task SetOOOTempProcessedWithInvalidIdShouldReturnFalse() {
+        OOOTemp oooTemp = new OOOTemp() {
+            ID = 1,
+            OOOUserID = 1,
+            OOOStartDate = DateTime.Now,
+            OOOExpirationDate = DateTime.Now
+        };
+
+        _mockDalService.Setup(d => d.ExecuteAsync(It.IsAny<string>())).Returns(Task.FromResult(0));
+
+        _userService = new UserService(MOCK_LOGGER, _mockDalService.Object);
+
+        bool actual = await _userService.SetOOOTempProcessed(oooTemp);
+
+        Assert.False(actual);
     }
 }