public async Task DefaultSearch()
{
await _target.OnGetAsync(_cancellation);
Assert.Equal(0, _capturedRequest.Skip);
Assert.Equal(20, _capturedRequest.Take);
Assert.True(_capturedRequest.IncludePrerelease);
Assert.True(_capturedRequest.IncludeSemVer2);
Assert.Null(_capturedRequest.PackageType);
Assert.Null(_capturedRequest.Framework);
Assert.Null(_capturedRequest.Query);
}
public async Task OnGetAsync_PopulatesThePageModel_WithAListOfMessages()
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("InMemoryDb");
#region arrange
var mockAppDbContext = new Mock <ApplicationDbContext>(optionsBuilder.Options);
var expectedMessages = ApplicationDbContext.GetSeedingMessages();
mockAppDbContext.Setup(
db => db.GetGamesAsync()).Returns(Task.FromResult(expectedMessages));
var pageModel = new IndexModel(mockAppDbContext.Object, _memoryCache);
#endregion
#region act
// Act
await pageModel.OnGetAsync();
#endregion
#region assert
// Assert
var actualMessages = Assert.IsAssignableFrom <List <Game> >(pageModel.Data);
Assert.Equal(
expectedMessages.OrderBy(m => m.Id).Select(m => m.Title),
actualMessages.OrderBy(m => m.Id).Select(m => m.Title));
#endregion
}
public async Task OnGetAsync_PopulatesHomepageKpisDetailsWithTbServiceCodes_WhenUserIsServiceUser()
{
// Arrange
_mockUserService.Setup(s => s.GetUserPermissionsFilterAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new UserPermissionsFilter
{
Type = UserType.ServiceOrRegionalUser,
IncludedTBServiceCodes = new List <string> {
"TB001"
}
});
var pageModel = new IndexModel(_notificationRepository,
_mockAlertRepository.Object,
_mockAuthorizationService.Object,
_mockUserService.Object,
_mockHomepageKpiService.Object,
new Mock <IUserHelper>().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 async Task OnGetAsync_PopulatesPageModel_WithAlerts()
{
// Arrange
var alerts = new List <AlertWithTbServiceForDisplay> {
new AlertWithTbServiceForDisplay {
AlertId = 101
}
};
_mockAlertRepository.Setup(s => s.GetOpenAlertsByTbServiceCodesAsync(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult(alerts));
_mockUserService.Setup(s => s.GetUserType(It.IsAny <ClaimsPrincipal>())).Returns(UserType.ServiceOrRegionalUser);
_mockUserService.Setup(s => s.GetUserPermissionsFilterAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new UserPermissionsFilter {
Type = UserType.ServiceOrRegionalUser
});
var pageModel = new IndexModel(_notificationRepository,
_mockAlertRepository.Object,
_mockAuthorizationService.Object,
_mockUserService.Object,
_mockHomepageKpiService.Object,
new Mock <IUserHelper>().Object);
pageModel.MockOutSession();
// Act
await pageModel.OnGetAsync();
var resultAlerts = Assert.IsAssignableFrom <List <AlertWithTbServiceForDisplay> >(pageModel.Alerts);
// Assert
Assert.Collection(resultAlerts, alert => alert.AlertId = 101);
}
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 IActionResult About()
{
ViewBag.C = m.OnGetAsync().Result;
ViewData["Message"] = "Your application description page.";
return(View());
}
public void Index_Page_Test()
{
//// Arrange & Act
var result = _pageModel.OnGetAsync();
Assert.IsInstanceOf <IActionResult>(result);
}
public async Task RouteDataLoading()
{
IndexModel page = new IndexModel(new BusRouteProvider());
await page.OnGetAsync();
Assert.IsNotNull(page.Routes);
}
public async Task OnGetAsync_GivenGetSpecificationsReturnsNullResults_ThenErrorReturned()
{
// Arrange
ISpecificationSearchService searchService = CreateSearchService();
SpecificationSearchResultViewModel searchResult = null;
searchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(searchResult);
IndexModel indexModel = CreateIndexModel(searchService);
// Act
IActionResult result = await indexModel.OnGetAsync(null, null);
// Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be("There was an error retrieving Specifications from the Search Index.");
await searchService
.Received(1)
.PerformSearch(Arg.Is <SearchRequestViewModel>(
c => c.PageNumber == 1 &&
c.SearchTerm == null));
}
public async Task OnGetAsync_PopulatesThePageModel_WithAListOfUsers()
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <ClippyContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockContext = new Mock <ClippyContext>(optionsBuilder.Options);
var expectedUsers = new List <User> {
new User {
Id = 1, Username = "******", Name = "Clippy Junior", CreateDate = DateTime.UtcNow
}
};
mockContext.Setup(
db => db.GetUsersAsync()).Returns(Task.FromResult(expectedUsers));
var pageModel = new IndexModel(mockContext.Object);
// Act
await pageModel.OnGetAsync();
// Assert
var actualUsers = Assert.IsAssignableFrom <List <User> >(pageModel.Users);
Assert.Equal(
expectedUsers.OrderBy(u => u.Id).Select(u => u.Username),
actualUsers.OrderBy(u => u.Id).Select(u => u.Username));
}
public async Task OnGetAsync_PopulatesThePageModel_WithAListOfTodoItems()
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <BetterDoDbContext>()
.UseInMemoryDatabase("InMemoryDb");
#region snippet1
var mockAppDbContext = new Mock <BetterDoDbContext>(optionsBuilder.Options);
var expectedMessages = BetterDoDbContext.GetSeedingTodoItems();
mockAppDbContext.Setup(
db => db.GetTodoItemsAsync()).Returns(Task.FromResult(expectedMessages));
var pageModel = new IndexModel(mockAppDbContext.Object);
#endregion
#region snippet2
// Act
await pageModel.OnGetAsync();
#endregion
#region snippet3
// Assert
var actualMessages = Assert.IsAssignableFrom <List <TodoItem> >(pageModel.TodoItems);
Assert.Equal(
expectedMessages.OrderBy(m => m.ID).Select(m => m.Title),
actualMessages.OrderBy(m => m.ID).Select(m => m.Title));
#endregion
}
private static async Task <IActionResult> LoadPage(bool isAuthenticated)
{
var principal = new ClaimsPrincipal();
var userManager = TestHelpers.CreateMockUserManager(principal, new ApplicationUser()).Object;
var mockSigninManager = TestHelpers.CreateMockSigninManager(userManager);
mockSigninManager
.Setup(s => s.IsSignedIn(principal))
.Returns(isAuthenticated);
var model = new IndexModel(
TestHelpers.CreateHttpContextAccessor(0x2414188f),
Mock.Of <ILogger <LoginModel> >(),
mockSigninManager.Object,
userManager)
{
PageContext = { HttpContext = new DefaultHttpContext {
User = principal
} }
};
return(await model.OnGetAsync());
}
// GET
public async Task <IActionResult> Index()
{
var model = new IndexModel(_distributedCache);
await model.OnGetAsync();
return(View(model));
}
public async Task OnGetAsync_PopulatesThePageModel()
{
//Arrange
var mockAppRepository = new Mock <IAppRepository>();
List <Post> posts = new List <Post>()
{
new Post {
Id = 1, Title = "My first post", Description = "Body", OwnerId = "zzz", PublishedDate = DateTime.Now, UpdatedDate = DateTime.Now, IsDraft = false
},
new Post {
Id = 2, Title = "My second post", Description = "Body", OwnerId = "zzz", PublishedDate = DateTime.Now, UpdatedDate = DateTime.Now, IsDraft = false
},
};
string userName = "******";
mockAppRepository.Setup(x => x.getPostsByUserAsync(userName)).Returns(Task.FromResult(posts));
//Act
var pageModel = new IndexModel(mockAppRepository.Object);
await pageModel.OnGetAsync(userName);
//Assert
Assert.NotNull(pageModel.UserName);
Assert.NotNull(pageModel.Posts);
}
public async Task OnGetAsync_LoadsResourceLists()
{
// Arrange
var resourceLists = new List <ResourceList>();
var resourceList = new ResourceList
{
Id = 1,
Name = "RL1",
LearningResources = new List <LearningResource>()
};
resourceLists.Add(resourceList);
var mockService = new Mock <IResourceListService>();
mockService.Setup(s => s.Get()).Returns(Task.FromResult(resourceLists));
var pageModel = new IndexModel(mockService.Object);
// Act
await pageModel.OnGetAsync();
// Assert
var actualResourceList = Assert.IsAssignableFrom <IList <ResourceList> >(pageModel.ResourceLists);
Assert.NotNull(actualResourceList);
Assert.Single(actualResourceList);
Assert.Equal(resourceList.Name, actualResourceList.First().Name);
}
public async Task RouteDataIsCorrect()
{
IndexModel page = new IndexModel(new BusRouteProvider());
await page.OnGetAsync();
foreach (var route in page.Routes)
{
Assert.IsFalse(string.IsNullOrEmpty(route.Description));
Assert.IsFalse(string.IsNullOrEmpty(route.ShortName));
}
}
public async Task ShouldHavePassWhenPopulatesThePageModelWithAListAsync()
{
//arrange
var model = new IndexModel(_itemToDoService);
//actual
await model.OnGetAsync();
//assert
Assert.IsAssignableFrom <List <ItemToDoViewModel> >(model.ItemToDos);
}
public async Task IndexSendsActiveOrUpcomingEventsQuery()
{
var mockMediator = new Mock <IMediator>();
var sut = new IndexModel(mockMediator.Object)
{
TempData = Mock.Of <ITempDataDictionary>()
};
await sut.OnGetAsync();
mockMediator.Verify(x => x.SendAsync(It.IsAny <ActiveOrUpcomingEventsQuery>()), Times.Once());
}
public async Task IndexSendsFeaturedCampaignQuery()
{
var mockMediator = new Mock <IMediator>();
var sut = new IndexModel(mockMediator.Object)
{
TempData = Mock.Of <ITempDataDictionary>()
};
await sut.OnGetAsync();
mockMediator.Verify(x => x.SendAsync(It.IsAny <FeaturedCampaignQuery>()), Times.Once());
}
public async Task DisplayTimeIsCorrect()
{
IndexModel page = new IndexModel(new BusRouteProvider());
await page.OnGetAsync();
DisplayRouteData displayRouteData = page.Routes.ToList()[0];
var displayTime = displayRouteData.DisplayArrivalTime;
var expectedDisplay = BusHelpers.ConvertMillisecondsToUTC(displayRouteData.PredictedArrival).ToShortTimeString();
BusHelpers.CleanRouteName("");
Assert.AreEqual("12:00 AM", displayTime);
}
public void WeatherServiceReturnsWeatherReports()
{
//--Arrange
var mock = new Mock <IWeatherService>();
mock.Setup(o => o.GetWeatherForAllCitiesAsync())
.ReturnsAsync(new List <WeatherReport>()
{
new WeatherReport()
{
Id = 1,
City = "Worksop",
Description = "Windy",
Humidity = 84,
Pressure = 1008,
Temperature = 25
},
new WeatherReport()
{
Id = 2,
City = "Doncaster",
Description = "Fog",
Humidity = 89,
Pressure = 1010,
Temperature = 16
}
});
mock.Setup(p => p.GetCityTemperatures())
.Returns(new Dictionary <string, double>()
{
{ "Worksop", 25 },
{ "Doncaster", 16 }
});
var main = new IndexModel(mock.Object);
//-- Act
var actual = main.OnGetAsync();
//-- Assert
Assert.IsTrue(actual.IsCompletedSuccessfully);
Assert.AreEqual("Worksop", main.Weathers[0].City);
Assert.AreEqual(1, main.Weathers[0].Id);
Assert.AreEqual("Fog", main.Weathers[1].Description);
Assert.IsTrue(main.Weathers.Any());
Assert.IsTrue(main.CityTemperatures.Any());
}
public async Task OnGetAsync_PopulatesPageModel_ForProcessor()
{
//Arrange
var authorizationService = new Mock <IAuthorizationService>();
authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >()))
.ReturnsAsync(AuthorizationResult.Success());
var store = new Mock <IUserStore <IdentityUser> >();
var userManager = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null);
//Create test user
var displayName = "User name";
var identity = new GenericIdentity(displayName);
var principleMock = new Mock <ClaimsPrincipal>(identity);
principleMock.Setup(x => x.IsInRole(Constants.LoanProcessorsRole)).Returns(true);
userManager.Setup(x => x.GetUserId(principleMock.Object)).Returns("test.user");
// use default context with user
var httpContext = new DefaultHttpContext()
{
User = principleMock.Object
};
//need these as well for the page context
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
// need page context for the page model
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new IndexModel(AppDbContext, authorizationService.Object, userManager.Object)
{
PageContext = pageContext
};
//Act
await pageModel.OnGetAsync();
// Assert
Assert.NotNull(pageModel.LoanApplications);
Assert.Equal(2, pageModel.LoanApplications.Count);
}
public async void OnGetAsync_ShouldPopulateListOfTasks()
{
//Arrange
var pageModel = new IndexModel(new NullLogger <IndexModel>(), _fixture.MovingAppContext);
List <MovingTask> expectedMovingTasks = _fixture.MovingAppContext.Task.ToList <MovingTask>();
//Act
await pageModel.OnGetAsync(null, null);
//Assert
var actualMovingTasks = Assert.IsAssignableFrom <List <MovingTask> >(pageModel.Tasks);
Assert.Equal(
expectedMovingTasks.OrderBy(t => t.ID).Select(t => t.Title),
actualMovingTasks.OrderBy(t => t.ID).Select(t => t.Title)
);
}
public async Task GetConsumingServices()
{
var mock = new Mock <IDiscoveryHandler>();
mock.Setup(m => m.GetConsumingServices()).ReturnsAsync(new EventLocation(
new List <MicrowaveServiceNode>(),
new List <EventSchema>(),
new List <ReadModelSubscription>()));
mock.Setup(m => m.GetPublishedEvents()).ReturnsAsync(EventsPublishedByService.Reachable(new
ServiceEndPoint(null), new List <EventSchema>()));
var indexModel = new IndexModel(mock.Object, new MicrowaveWebApiConfiguration());
await indexModel.OnGetAsync();
Assert.IsNotNull(indexModel.ConsumingServices);
}
public async Task OnGet_PopulatesThePageModel()
{
var cabinets = ResourceHelper.GetCabinetSummaries(true);
var mockRepo = new Mock <ICabinetRepository>();
mockRepo.Setup(l => l.GetCabinetListAsync(true))
.ReturnsAsync(cabinets)
.Verifiable();
var pageModel = new IndexModel(mockRepo.Object);
var result = await pageModel.OnGetAsync().ConfigureAwait(false);
result.Should().BeOfType <PageResult>();
pageModel.Cabinets.Should().BeEquivalentTo(cabinets);
}
public async Task OnGetAsync_GivenGetSpecificationsSearchTermRequested_ReturnsPageResult()
{
// Arrange
ISpecificationSearchService searchService = CreateSearchService();
const string searchTerm = "testTerm";
SpecificationSearchResultViewModel searchResult = new SpecificationSearchResultViewModel()
{
CurrentPage = 2,
EndItemNumber = 0,
Facets = new List <SearchFacetViewModel>(),
PagerState = new PagerState(1, 1),
Specifications = new List <SpecificationSearchResultItemViewModel>(),
StartItemNumber = 1,
TotalResults = 0
};
searchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(searchResult);
IndexModel indexModel = CreateIndexModel(searchService);
// Act
IActionResult result = await indexModel.OnGetAsync(searchTerm, null);
// Assert
result
.Should()
.BeOfType <PageResult>()
.Which
.Should()
.NotBeNull();
indexModel
.InitialSearchResults
.Should()
.NotBeNull();
await searchService
.Received(1)
.PerformSearch(Arg.Is <SearchRequestViewModel>(
c => c.PageNumber == 1 &&
c.SearchTerm == searchTerm));
}
public async Task Create_Student_Page()
{
using var db = new SchoolContext(Utilities.Utilities.TestDbContextOptions());
{
// Arrange
var repo = new StudentRepository(db);
var dataEntity = new List <Student>
{
new Student {
FirstMidName = "山田", LastName = "太郎"
},
new Student {
FirstMidName = "鈴木", LastName = "一郎"
}
};
dataEntity.ForEach(student => repo.InsertStudent(student));
await repo.Save();
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext =
new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new IndexModel(repo)
{
PageContext = pageContext,
TempData = tempData,
Url = new UrlHelper(actionContext)
};
pageModel.ModelState.AddModelError("Message.Text", "The Text field is required.");
// Act
await pageModel.OnGetAsync("", "", "", null);
// Assert
Assert.Equal("一郎, 鈴木", pageModel.Student.First().FullName);
Assert.Equal("太郎, 山田", pageModel.Student.Last().FullName);
}
}
public async Task OnGetAsync_InvalidId()
{
// Arrange
var role = new Role {
Id = Guid.NewGuid()
};
_roleManager.Setup(x => x.FindByIdAsync($"{role.Id}")).ReturnsAsync(role);
var index = new IndexModel(_roleManager.Object);
// Act
var get = await index.OnGetAsync(Guid.Empty).ConfigureAwait(false);
// Assert
_roleManager.Verify(x => x.FindByIdAsync($"{role.Id}"), Times.Never);
Assert.Null(index.Role);
Assert.IsType <NotFoundResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var role = new Role {
Id = Guid.NewGuid()
};
_roleManager.Setup(x => x.FindByIdAsync($"{role.Id}")).ReturnsAsync(role);
var index = new IndexModel(_roleManager.Object);
// Act
var get = await index.OnGetAsync(role.Id).ConfigureAwait(false);
// Assert
_roleManager.Verify(x => x.FindByIdAsync($"{role.Id}"), Times.Once);
Assert.Equal(role, index.Role);
Assert.IsType <PageResult>(get);
}
public async Task OnGetAsync()
{
// Arrange
var user = new User {
Id = Guid.NewGuid()
};
_userManager.Setup(x => x.FindByIdAsync($"{user.Id}")).ReturnsAsync(user);
var index = new IndexModel(_userManager.Object);
// Act
var get = await index.OnGetAsync(user.Id).ConfigureAwait(false);
// Assert
_userManager.Verify(x => x.FindByIdAsync($"{user.Id}"), Times.Once);
Assert.Equal(user, index.UserModel);
Assert.IsType <PageResult>(get);
}
