public void TestGetUserCache_UserCacheDoesNotExist()
{
var camId = 1;
var camUser = new User
{
PrincipalId = camId,
};
var user = new SimpleUser
{
Id = Guid.NewGuid()
};
var testService = new UserCacheService(cache.Object, expectedTimeToLive);
Assert.AreEqual(0, testService.GetCount());
Assert.IsNull(testService.GetUserCache(user));
}
public void TestRemove_MultipleUsers()
{
var camId1 = 1;
var camId2 = 2;
var isCamUser1Valid = true;
var isCamUser2Valid = true;
var camUser1 = new User
{
PrincipalId = camId1,
};
var camUser2 = new User
{
PrincipalId = camId2,
};
var user1 = new SimpleUser
{
Id = Guid.NewGuid()
};
var user2 = new SimpleUser
{
Id = Guid.NewGuid()
};
var testService = new UserCacheService(cache.Object, expectedTimeToLive);
Assert.AreEqual(0, testService.GetCount());
Assert.AreEqual(0, cacheDictionary.Count);
var userCache1 = new UserCache(user1, camUser1, isCamUser1Valid, new List <IPermission>());
var userCache2 = new UserCache(user2, camUser2, isCamUser2Valid, new List <IPermission>());
testService.Add(userCache1);
testService.Add(userCache2);
Assert.AreEqual(2, testService.GetCount());
Assert.AreEqual(2, cacheDictionary.Count);
testService.Remove(user1);
Assert.AreEqual(1, testService.GetCount());
Assert.AreEqual(1, cacheDictionary.Count);
Assert.IsTrue(cacheDictionary.ContainsKey(testService.GetKey(user2)));
Assert.AreEqual(1, testService.GetCount());
}
public async Task TestGetUserCache_UserIsNotCached_UserExistsInCam()
{
var camId = 1;
var isUserValid = true;
var camUser = new User
{
PrincipalId = camId,
};
var user = new SimpleUser
{
Id = Guid.NewGuid()
};
var permissions = new List <IPermission>();
Action <UserCache> addCallback = (c) =>
{
Assert.IsNotNull(c);
Assert.AreEqual(camId, c.CamPrincipalId);
Assert.AreEqual(isUserValid, c.IsValidCamUser);
Assert.AreEqual(user.Id, c.UserId);
};
cacheService.Setup(x => x.GetUserCache(It.IsAny <IWebApiUser>())).Returns(default(UserCache));
cacheService.Setup(x => x.Add(It.IsAny <UserCache>())).Callback(addCallback);
permissionService.Setup(x => x.GetAllowedPermissionsByPrincipalIdAsync(It.IsAny <int>())).ReturnsAsync(permissions);
userService.Setup(x => x.GetUserById(It.IsAny <Guid>())).Returns(camUser);
userService.Setup(x => x.GetUserByIdAsync(It.IsAny <Guid>())).ReturnsAsync(camUser);
userService.Setup(x => x.IsUserValid(It.IsAny <Guid>())).Returns(isUserValid);
userService.Setup(x => x.IsUserValidAsync(It.IsAny <Guid>())).ReturnsAsync(isUserValid);
var provider = new BearerTokenUserProvider(userService.Object, cacheService.Object, permissionService.Object);
provider.GetUserCache(user);
await provider.GetUserCacheAsync(user);
//be sure we make it through the IsValidUser check and load the user permissions.
permissionService.Verify(x => x.GetAllowedPermissionsByPrincipalIdAsync(It.IsAny <int>()), Times.Exactly(1));
permissionService.Verify(x => x.GetAllowedPermissionsByPrincipalId(It.IsAny <int>()), Times.Exactly(1));
}
public void TestClear_UserCacheIsNotPresent()
{
var camId = 1;
var camUser = new User
{
PrincipalId = camId,
};
var user = new SimpleUser
{
Id = Guid.NewGuid()
};
var permissions = new List <IPermission>();
cacheService.Setup(x => x.GetUserCache(It.IsAny <IWebApiUser>())).Returns(default(UserCache));
cacheService.Setup(x => x.Remove(It.IsAny <IWebApiUser>()));
permissionService.Setup(x => x.GetAllowedPermissionsByPrincipalIdAsync(It.IsAny <int>())).ReturnsAsync(permissions);
var provider = new BearerTokenUserProvider(userService.Object, cacheService.Object, permissionService.Object);
provider.Clear(user);
cacheService.Verify(x => x.Remove(It.IsAny <IWebApiUser>()), Times.Never());
cacheService.Verify(x => x.Remove(It.IsAny <Guid>()), Times.Once());
}
public async Task TestHasSevisUserAccount_CheckCaseInsensitive()
{
var camId = 1;
var isUserValid = true;
var sevisAccount = new SevisUserAccount
{
OrgId = "org",
Username = "******"
};
var camUser = new User
{
PrincipalId = camId,
};
camUser.SevisUserAccounts = new List <SevisUserAccount>
{
sevisAccount
};
var user = new SimpleUser
{
Id = Guid.NewGuid()
};
var permissions = new List <IPermission>();
var userCache = new UserCache(user, camUser, isUserValid, permissions);
cacheService.Setup(x => x.GetUserCache(It.IsAny <IWebApiUser>())).Returns(userCache);
Action <bool> tester = (result) =>
{
Assert.IsTrue(result);
};
var provider = new BearerTokenUserProvider(userService.Object, cacheService.Object, permissionService.Object);
tester(provider.HasSevisUserAccount(user, sevisAccount.Username.ToUpper(), sevisAccount.OrgId.ToUpper()));
tester(await provider.HasSevisUserAccountAsync(user, sevisAccount.Username.ToUpper(), sevisAccount.OrgId.ToUpper()));
}
public void TestAdd()
{
var camId = 1;
var isUserValid = true;
var camUser = new User
{
PrincipalId = camId,
};
var user = new SimpleUser
{
Id = Guid.NewGuid()
};
var testService = new UserCacheService(cache.Object, expectedTimeToLive);
Assert.AreEqual(0, testService.GetCount());
Assert.AreEqual(0, cacheDictionary.Count);
var userCache = new UserCache(user, camUser, isUserValid, new List <IPermission>());
testService.Add(userCache);
Assert.AreEqual(1, testService.GetCount());
Assert.AreEqual(1, cacheDictionary.Count);
Assert.IsInstanceOfType(cacheDictionary[testService.GetKey(user)], typeof(UserCache));
}
public void TestImpersonate_ImpersonatedUserIsValid()
{
Guid impersonatorId = Guid.NewGuid();
var isImpersonatorCamUserValid = false;
var impersonatorCamUser = new User
{
PrincipalId = 1,
};
var impersonator = new SimpleUser {
Id = impersonatorId,
Username = "******"
};
var impersonatorUserCache = new UserCache(impersonator, impersonatorCamUser, isImpersonatorCamUserValid);
Guid impersonatedId = Guid.NewGuid();
var isImpersonatedCamUserValid = true;
var impersonatedUserPermissions = new List <IPermission>
{
new CAM.Business.Service.SimplePermission
{
IsAllowed = true,
PermissionId = 1,
PrincipalId = 2,
ResourceId = 3
}
};
var impersonatedCamUser = new User
{
PrincipalId = 2,
};
var impersonatedUser = new SimpleUser {
Id = impersonatedId,
Username = "******"
};
permissionService.Setup(x => x.GetAllowedPermissionsByPrincipalId(It.IsAny <int>())).Returns(impersonatedUserPermissions);
Func <Guid, User> getUserById = (id) =>
{
if (id == impersonatorId)
{
return(impersonatorCamUser);
}
else
{
return(impersonatedCamUser);
}
};
Func <Guid, bool> getIsUserValid = (id) =>
{
if (id == impersonatorId)
{
return(isImpersonatorCamUserValid);
}
else
{
return(isImpersonatedCamUserValid);
}
};
userService.Setup(x => x.GetUserById(It.IsAny <Guid>())).Returns(getUserById);
userService.Setup(x => x.IsUserValid(It.IsAny <Guid>())).Returns(getIsUserValid);
cacheDictionary.Add(impersonatorId.ToString(), new UserCache(impersonatedUser, impersonatedCamUser, isImpersonatedCamUserValid, impersonatedUserPermissions));
var provider = new BearerTokenUserProvider(userService.Object, cacheService, permissionService.Object);
provider.Impersonate(impersonator, impersonatedId);
var userCache = provider.GetUserCache(impersonator);
Assert.IsNotNull(userCache);
CollectionAssert.AreEqual(impersonatedUserPermissions.ToList(), userCache.Permissions.ToList());
Assert.AreEqual(impersonatorCamUser.PrincipalId, userCache.CamPrincipalId);
Assert.AreEqual(impersonator.Id, userCache.UserId);
Assert.AreEqual(impersonator.Username, userCache.UserName);
Assert.AreEqual(isImpersonatedCamUserValid, userCache.IsValidCamUser);
}
