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); }