public async Task GetDefaultTbService_ReturnsMatchingService_ForNationalUser()
{
// Arrange
const string serviceAdGroup = ServicePrefix + "Ashford";
var tbService = new TBService {
ServiceAdGroup = serviceAdGroup, Code = "TBS0008"
};
var claim = new Claim("User", NationalTeam);
SetupClaimMocking(new List <Claim> {
claim
});
var mockTbServiceQuery = new List <TBService> {
tbService
}.AsQueryable().BuildMock();
_mockReferenceDataRepository.Setup(c => c.GetActiveTbServicesOrderedByNameQueryable())
.Returns(mockTbServiceQuery.Object);
// Act
var result = await _service.GetDefaultTbService(_mockUser.Object);
// Assert
Assert.Equal(tbService, result);
}
private static User CreateDefaultCaseManager(string displayName = null, string givenName = null,
string familyName = null,
List <CaseManagerTbService> caseManagerTbServices = null)
{
var defaultTbService = new TBService {
Name = "Test service", Code = "TTT001"
};
return(new User
{
DisplayName = displayName,
GivenName = givenName,
FamilyName = familyName,
CaseManagerTbServices = caseManagerTbServices ?? new List <CaseManagerTbService>
{
new CaseManagerTbService
{
TbService = defaultTbService,
TbServiceCode = defaultTbService.Code,
CaseManagerId = 1
}
},
IsCaseManager = true,
IsActive = true
});
}
public async Task GetDefaultTbService_ReturnsMatchingService_ForPheUser()
{
// Arrange
const string adGroup = "SoE";
const string serviceAdGroup = ServicePrefix + "Ashford";
var tbService = new TBService()
{
ServiceAdGroup = serviceAdGroup, Code = "TBS0008"
};
var claim = new Claim("User", adGroup);
SetupClaimMocking(claim);
_mockReferenceDataRepository.Setup(c => c.GetDefaultTbServicesForPheUserQueryable(It.Is <IEnumerable <string> >(l => l.Contains(adGroup))))
.Returns((new List <TBService>()
{
tbService
}).AsQueryable);
// Act
var result = await _service.GetDefaultTbService(_mockUser.Object);
// Assert
Assert.Equal(tbService, result);
}
public async Task FilterAlertsForUser_FiltersByTheUsersTbServicesForAllUserTypes(UserType userType)
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var tbService = new TBService()
{
Code = "TBS0008"
};
var alertToExpect = new AlertWithTbServiceForDisplay()
{
AlertId = 1, NotificationId = 2, AlertType = AlertType.Test, TbServiceCode = tbService.Code
};
var testAlerts = new List <AlertWithTbServiceForDisplay>
{
alertToExpect,
new AlertWithTbServiceForDisplay()
{
AlertId = 2, NotificationId = 3, AlertType = AlertType.Test, TbServiceCode = "TBS0DOG"
}
};
_mockUserService.Setup(us => us.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult((new List <TBService> {
tbService
}).AsEnumerable()));
_mockUserService.Setup(us => us.GetUserType(It.IsAny <ClaimsPrincipal>()))
.Returns(userType);
// Act
var result = await _authorizationService.FilterAlertsForUserAsync(testUser, testAlerts);
// Assert
Assert.Single(result);
Assert.Contains(alertToExpect, result);
}
public async Task IsUserAuthorizedToManageAlert_AllowsUserWithCorrectTbServiceToManageTransferAlert()
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var tbService = new TBService()
{
Code = "TBS0008"
};
var testAlert = new TransferAlert()
{
NotificationId = 2, AlertType = AlertType.TransferRequest, TbServiceCode = tbService.Code
};
_mockUserHelper.Setup(uh => uh.UserIsReadOnly(It.IsAny <ClaimsPrincipal>())).Returns(false);
_mockUserService.Setup(us => us.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult((new List <TBService> {
tbService
}).AsEnumerable()));
// Act
var result = await _authorizationService.IsUserAuthorizedToManageAlert(testUser, testAlert);
// Assert
Assert.True(result);
}
public async Task IsUserAuthorizedToManageAlert_DoesNotAllowUserWithoutTbServiceToManageNonTransferAlert()
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var tbService = new TBService()
{
Code = "TBS0008"
};
var testAlert = new TestAlert()
{
NotificationId = 2, AlertType = AlertType.Test
};
var testNotification = new Notification {
HospitalDetails = new HospitalDetails {
TBServiceCode = "TBS1111"
}
};
_mockUserHelper.Setup(uh => uh.UserIsReadOnly(It.IsAny <ClaimsPrincipal>())).Returns(false);
_mockUserService.Setup(us => us.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult((new List <TBService> {
tbService
}).AsEnumerable()));
_mockNotificationRepository.Setup(nr => nr.GetNotificationAsync((int)testAlert.NotificationId))
.Returns(Task.FromResult(testNotification));
// Act
var result = await _authorizationService.IsUserAuthorizedToManageAlert(testUser, testAlert);
// Assert
Assert.False(result);
}
public async Task OnGetAsync_PopulatesHomepageKpisDetailsWithTbServiceCodes_WhenUserIsNhsUser()
{
// Arrange
_mockUserService.Setup(s => s.GetUserType(It.IsAny <ClaimsPrincipal>())).Returns(UserType.NhsUser);
var mockTbService = new TBService()
{
Code = mockHomepageKpiWithTbService.Code
};
_mockUserService.Setup(s => s.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult(new List <TBService> {
mockTbService
} as IEnumerable <TBService>));
var pageModel = new IndexModel(_mockNotificationRepository.Object,
_mockAlertRepository.Object,
_mockAuthorizationService.Object,
_mockUserService.Object,
_mockHomepageKpiService.Object);
pageModel.MockOutSession();
// Act
await pageModel.OnGetAsync();
var phecCodes = Assert.IsAssignableFrom <SelectList>(pageModel.KpiFilter);
var homepageKpiDetails = Assert.IsAssignableFrom <List <HomepageKpi> >(pageModel.HomepageKpiDetails);
Assert.True(phecCodes.Count() == 1);
Assert.True(homepageKpiDetails.Count == 1);
Assert.True(homepageKpiDetails[0] == mockHomepageKpiWithTbService);
}
public UserRepositoryTests(RepositoryFixture <UserRepository> userRepositoryFixture)
{
ContextHelper.DisableAudits();
_context = userRepositoryFixture.Context;
_contextOptions = userRepositoryFixture.ContextOptions;
var optionsMonitor = new Mock <IOptionsMonitor <AdOptions> >();
optionsMonitor.Setup(om => om.CurrentValue).Returns(new AdOptions {
ReadOnlyUserGroup = "ReadOnly"
});
_userRepo = new UserRepository(_context, optionsMonitor.Object);
var phec = new PHEC {
Code = "E45000001", Name = "London"
};
_tbService1 = new TBService {
Code = "TBS0001", IsLegacy = false, PHECCode = "E45000001"
};
_tbService2 = new TBService {
Code = "TBS0002", IsLegacy = false, PHECCode = "E45000001"
};
_context.PHEC.Add(phec);
_context.TbService.AddRange(_tbService1, _tbService2);
_context.SaveChanges();
}
private User CreateUserForTbService(TBService tbService)
{
var user = testUsers.Generate();
user.AdGroups = tbService.ServiceAdGroup;
user.CaseManagerTbServices = new List <CaseManagerTbService>
{
new CaseManagerTbService {
TbServiceCode = tbService.Code
}
};
return(user);
}
public async Task FilterAlertsForUser_DoesNotFilterAnyAlertsForRegionalUser()
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var tbService = new TBService()
{
Code = "TBS0008"
};
var alertsToExpect = new List <AlertWithTbServiceForDisplay>
{
new AlertWithTbServiceForDisplay()
{
AlertId = 1,
NotificationId = 2,
AlertType = AlertType.TransferRequest,
TbServiceCode = tbService.Code
},
new AlertWithTbServiceForDisplay()
{
AlertId = 1,
NotificationId = 2,
AlertType = AlertType.Test,
TbServiceCode = tbService.Code
},
new AlertWithTbServiceForDisplay()
{
AlertId = 2,
NotificationId = 3,
AlertType = AlertType.TransferRejected,
TbServiceCode = tbService.Code
}
};
_mockUserService.Setup(us => us.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult((new List <TBService> {
tbService
}).AsEnumerable()));
_mockUserService.Setup(us => us.GetUserType(It.IsAny <ClaimsPrincipal>()))
.Returns(UserType.ServiceOrRegionalUser);
// Act
var result = await _authorizationService.FilterAlertsForUserAsync(testUser, alertsToExpect);
// Assert
Assert.Equal(alertsToExpect.Count, result.Count);
Assert.Contains(alertsToExpect[0], result);
Assert.Contains(alertsToExpect[1], result);
Assert.Contains(alertsToExpect[2], result);
}
public void GetRecordsFromCSV_GetsTBServicesData()
{
var results = SeedingHelper.GetTBServices("../../../TestData/tbservices.csv");
var firstEntryInTBServicesList = new TBService {
Code = "TBS0001",
Name = "Abingdon Community Hospital",
PHECCode = "E45000019",
ServiceAdGroup = "Global.NIS.NTBS.Service_Abingdon"
};
const int expectedCount = 6;
Assert.Equal(results.Count, expectedCount);
Assert.Equal(firstEntryInTBServicesList.Code, ((TBService)results[0]).Code);
Assert.Equal(firstEntryInTBServicesList.Name, ((TBService)results[0]).Name);
Assert.Equal(firstEntryInTBServicesList.PHECCode, ((TBService)results[0]).PHECCode);
Assert.Equal(firstEntryInTBServicesList.ServiceAdGroup, ((TBService)results[0]).ServiceAdGroup);
}
public async Task CreateNewNotificationForUserAsync_CreatesCaseUsingUserDetails()
{
// Arrange
const string serviceCode = "TBS0008";
var tbService = new TBService
{
Code = serviceCode
};
const string username1 = "User1";
var userId1 = 1234;
var user1 = new User {
Id = userId1, Username = username1
};
const string username2 = "User2";
var userId2 = 5678;
var user2 = new User {
Id = userId2, Username = username2
};
var mockPrincipal1 = new Mock <ClaimsPrincipal>();
mockPrincipal1.Setup(u => u.FindFirst(ClaimTypes.Upn)).Returns(new Claim(ClaimTypes.Upn, username1));
_mockUserService.Setup(c => c.GetDefaultTbService(mockPrincipal1.Object)).Returns(Task.FromResult(tbService));
_mockReferenceDataRepository
.Setup(c => c.GetActiveCaseManagersByTbServiceCodesAsync(new List <string> {
serviceCode
}))
.Returns(Task.FromResult((IList <User>)(new List <User> {
user1, user2
})));
// Act
var newNotification = await _notificationService.CreateNewNotificationForUserAsync(mockPrincipal1.Object);
// Assert
Assert.Equal(tbService, newNotification.HospitalDetails.TBService);
Assert.Equal(userId1, newNotification.HospitalDetails.CaseManagerId);
}
public async Task SearchWithTwoKeywords_DoesNotReturnRegionalUsersWhereBothKeywordsInRegion()
{
// Arrange
var searchStrings = SearchStringHelper.GetSearchKeywords("North West");
var southWest = new PHEC {
Code = "P1", Name = "South West", AdGroup = "SW"
};
var northWest = new PHEC {
Code = "P2", Name = "North West", AdGroup = "NW"
};
var burnley = new TBService {
Code = "TB2", Name = "Burnley", PHEC = northWest, PHECCode = northWest.Code
};
var caseManagers = new List <User>
{
CreateDefaultCaseManager(
displayName: "Bar Foo",
caseManagerTbServices: new List <CaseManagerTbService>
{
new CaseManagerTbService {
TbService = burnley, TbServiceCode = burnley.Code
}
}),
CreateRegionalUser(northWest.AdGroup, "Foo Bar"),
CreateRegionalUser(southWest.AdGroup, "Boo Far")
};
_mockReferenceDataRepository.Setup(r => r.GetAllPhecs())
.ReturnsAsync(new List <PHEC> {
southWest, northWest
});
_mockUserRepository.Setup(u => u.GetOrderedUsers()).ReturnsAsync(caseManagers);
// Act
var results = await _service.OrderQueryableAsync(searchStrings);
// Assert
Assert.Empty(results);
}
public async Task SearchWithTwoKeywords_DoesNotReturnUsersContainingBothInTbService()
{
// Arrange
var searchStrings = SearchStringHelper.GetSearchKeywords("South West");
var southWest = new TBService {
Code = "TB1", Name = "South West service"
};
var northWest = new TBService {
Code = "TB2", Name = "North West service"
};
var caseManagers = new List <User>
{
CreateDefaultCaseManager(
displayName: "Foo Bar",
caseManagerTbServices: new List <CaseManagerTbService>
{
new CaseManagerTbService {
TbService = southWest, TbServiceCode = southWest.Code
}
}),
CreateDefaultCaseManager(
displayName: "Bar Foo",
caseManagerTbServices: new List <CaseManagerTbService>
{
new CaseManagerTbService {
TbService = northWest, TbServiceCode = northWest.Code
}
})
};
_mockReferenceDataRepository.Setup(r => r.GetAllPhecs()).ReturnsAsync(new List <PHEC>());
_mockUserRepository.Setup(u => u.GetOrderedUsers()).ReturnsAsync(caseManagers);
// Act
var results = await _service.OrderQueryableAsync(searchStrings);
// Assert
Assert.Empty(results);
}
private async Task <Notification> GivenNotificationWithCaseManagerAndTbService(User caseManager, TBService tbService)
{
var notification = await _context.Notification.AddAsync(new Notification { NotificationId = 6655,
HospitalDetails = new HospitalDetails
{
CaseManager = caseManager,
TBService = tbService
} });
await _context.SaveChangesAsync();
return(notification.Entity);
}
public ServiceDirectoryItemWrapper(TBService tbService)
{
TBService = tbService;
}
