public async void HRBorderControllerOnGetAllWithValidPagingInExpectItemsAndCodeStatus200() { List <String> list = new List <String>(); for (int i = 0; i < 300; i++) { list.Add(i.ToString()); } //CoreBordersServiceStub service = new CoreBordersServiceStub(list); PagingParameterInModel validModel = new PagingParameterInModel() { PageNumber = 1, PageSize = 50 }; HRCommonForkerUtilsStub forkerUtil = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRBordersControllersForker forker = new HRBordersControllersForker(forkerUtil); using (Task <(int, PagingParameterOutModel <HRBorder>)> resultService = forker.GetFromPagingAsync( validModel, null, new CoreBordersServiceStub(list), 50 )) { await resultService; Assert.True(resultService.Result.Item1 == StatusCodes.Status200OK); Assert.True(resultService.Result.Item2 != null); } }
public void PaginateEmptyListsReturnSinglePagePaginationWithEmptyResult() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageNumber = 0; model.PageSize = 20; List <String> paginerItems = new List <String>(); PagingParameterOutModel <String> retour = paginer.GetPaginationFromFullList(model, paginerItems); Assert.NotNull(retour); Assert.True(retour.TotalItemsCount == 0); Assert.True(retour.TotalPages == 1); Assert.True(retour.PageSize == 20); Assert.NotNull(retour.PageItems); int itemsCount = 0; IEnumerator <String> enumerator = retour.PageItems.GetEnumerator(); while (enumerator.MoveNext()) { itemsCount++; } Assert.True(itemsCount == 0); Assert.False(retour.HasPreviousPage); Assert.False(retour.HasNextPage); Assert.True(retour.CurrentPage == 0); }
public async void HRCountriesOnGetFromPagingWithModelPageSizeGreaterThanMaxSizeExpectCodeStatus413PayloadTooLarge() { PagingParameterInModel model = new PagingParameterInModel() { PageNumber = 0, PageSize = 51 }; CoreCountriesServiceStub service = new CoreCountriesServiceStub(null) { ThrowException = true }; service.ExceptionToThrow = new IndexOutOfRangeException(); HRCommonForkerUtilsStub utilStub = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(utilStub); using (Task <(int, PagingParameterOutModel <HRCountry>)> forkerTask = forker.GetFromPagingAsync( model, null, service, 50 )) { await forkerTask; Assert.True(forkerTask.Result.Item1 == StatusCodes.Status413PayloadTooLarge); } }
public async void HRCountriesOnGetFromPagingWithCanOrderReturnoingFalseExpectStatus400BadRequest() { PagingParameterInModel model = new PagingParameterInModel() { PageNumber = 0, PageSize = 50 }; HRSortingParamModel sort = new HRSortingParamModel() { OrderBy = "FIELD1;ASC" }; CoreCountriesServiceStub service = new CoreCountriesServiceStub(null) { ThrowException = true, ExceptionToThrow = new IndexOutOfRangeException() }; HRCommonForkerUtilsStub utilStub = new HRCommonForkerUtilsStub() { CanOrderReturn = false }; HRCountriesControllersForker forker = new HRCountriesControllersForker(utilStub); using (Task <(int, PagingParameterOutModel <HRCountry>)> forkerTask = forker.GetFromPagingAsync( model, sort, service, 50 )) { await forkerTask; Assert.True(forkerTask.Result.Item1 == StatusCodes.Status400BadRequest); } }
public void PaginateMultiplePageOnLastPageExpectOutModelIsConsistent() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageSize = 50; model.PageNumber = 4; PagingParameterOutModel <String> result = paginer.GetPaginationFromFullList(model, CreateItems(210)); Assert.NotNull(result); Assert.False(result.HasNextPage); Assert.True(result.HasPreviousPage); Assert.True(result.TotalItemsCount == 210); Assert.True(result.CurrentPage == 4); IEnumerable <String> items = result.PageItems; Assert.NotNull(items); Assert.NotEmpty(items); IEnumerator <String> enumerator = items.GetEnumerator(); int i = 200; String valueExceptedi = String.Empty; while (enumerator.MoveNext()) { valueExceptedi = "Items number " + i.ToString(); Assert.Equal(valueExceptedi, enumerator.Current); i++; } Assert.True(i == 210); }
public async void HRCountriesController_On_GetAll_With_Invalid_PagingIn_Expect_Status416_RequestedRangeNotSatisfiable() { List <String> list = new List <String>() { "FR", "US" }; PagingParameterInModel invalidModel = new PagingParameterInModel() { PageNumber = 2, PageSize = 50 }; IHRCommonForkerUtils util = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(util); using (Task <(int, PagingParameterOutModel <HRCountry>)> resultService = forker.GetFromPagingAsync( invalidModel, null, new CoreCountriesServiceStub(list) { ThrowException = true, ExceptionToThrow = new IndexOutOfRangeException() }, 50)) { await resultService; Assert.True(resultService.Result.Item1 == StatusCodes.Status416RequestedRangeNotSatisfiable); Assert.True(resultService.Result.Item2 == null); } }
public async void HRCountriesOnGetFromPagingWithServiceThrowingIndexOutOfRangeExceptionExpectStatus500InternalServerError() { PagingParameterInModel model = new PagingParameterInModel(); CoreCountriesServiceStub service = new CoreCountriesServiceStub(null) { ThrowException = true, ExceptionToThrow = new IndexOutOfRangeException() }; HRCommonForkerUtilsStub utilStub = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(utilStub); using (Task <(int, PagingParameterOutModel <HRCountry>)> forkerTask = forker.GetFromPagingAsync( model, null, service, 50 )) { await forkerTask; Assert.True(forkerTask.Result.Item1 == StatusCodes.Status416RequestedRangeNotSatisfiable); } }
public void ValidatePaginationInWithEnumerableNullThrowArgumentNullException() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); Assert.Throws <ArgumentNullException>(() => paginer.IsValid(model, null)); }
public async void HRCountriesController_On_GetAll_With_Valid_PagingIn_Expect_Items_And_Code_Status200() { List <String> list = new List <String>() { "FR", "US" }; PagingParameterInModel invalidModel = new PagingParameterInModel() { PageNumber = 1, PageSize = 50 }; IHRCommonForkerUtils util = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(util); using (Task <(int, PagingParameterOutModel <HRCountry>)> resultService = forker.GetFromPagingAsync( invalidModel, null, new CoreCountriesServiceStub(list), 50 )) { await resultService; Assert.True(resultService.Result.Item1 == StatusCodes.Status200OK); } }
public async void HRCountriesController_On_GetAll_With_Exception_Thrown_By_Service_Expect_Status500_InternalServerError() { List <String> list = new List <String>() { "FR", "US" }; PagingParameterInModel invalidModel = new PagingParameterInModel() { PageNumber = 2, PageSize = 50 }; IHRCommonForkerUtils util = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(util); using (Task <(int, PagingParameterOutModel <HRCountry>)> resultService = forker.GetFromPagingAsync( invalidModel, null, new CoreCountriesServiceStub(list) { ThrowException = true }, 50 )) { await resultService; Assert.True(resultService.Result.Item1 == StatusCodes.Status500InternalServerError); Assert.True(resultService.Result.Item2 == null); } }
public async void HRBorderForkerOnGetFromPagingWithServiceThrowingExceptionExpectStatus500InternalServerError() { PagingParameterInModel model = new PagingParameterInModel(); CoreBordersServiceStub service = new CoreBordersServiceStub(null) { ThrowException = true }; service.ExceptionToThrow = new Exception(); HRCommonForkerUtilsStub utilStub = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRBordersControllersForker forker = new HRBordersControllersForker(utilStub); using (Task <(int, PagingParameterOutModel <HRBorder>)> forkerTask = forker.GetFromPagingAsync( model, null, service, 50 )) { await forkerTask; Assert.True(forkerTask.Result.Item1 == StatusCodes.Status500InternalServerError); } }
public async void HRCountriesControllerOnGetAllWithValidPagingInExpectItemsAndCodeStatus200() { List <MongoDB.Bson.ObjectId> list = new List <MongoDB.Bson.ObjectId>(); for (int i = 0; i < 300; i++) { list.Add(new MongoDB.Bson.ObjectId("507f191e810c19729de860ea")); } CoreCountriesServiceStub service = new CoreCountriesServiceStub(list); HRCountriesController ctrl = new HRCountriesController(service, null); PagingParameterInModel invalidModel = new PagingParameterInModel() { PageNumber = 1, PageSize = 100 }; Task <(int, PagingParameterOutModel <HRCountry>)> resultService = ctrl.GetFromPaging(invalidModel, null); await resultService; Assert.True(resultService.Result.Item1 == StatusCodes.Status200OK); Assert.True(resultService.Result.Item2 != null); Assert.True(resultService.Result.Item2.HasNextPage); Assert.True(resultService.Result.Item2.HasPreviousPage); Assert.True(resultService.Result.Item2.TotalItemsCount == 300); int j = 100; foreach (HRCountry iterator in resultService.Result.Item2.PageItems) { j++; } Assert.True(j == 200); }
/// <summary> /// Get Paginated items. /// </summary> /// <param name="pageModel">the PagingParameterInModel. Must not be null.</param> /// <param name="orderBy">an optionnal orderByClause.</param> /// <returns>The corresponding borders paginated an optionnaly</returns> public async Task <PagingParameterOutModel <HRBorder> > GetBordersAsync(PagingParameterInModel pageModel, HRSortingParamModel orderBy = null) { PagingParameterOutModel <HRBorder> retour = null; if (_workflow == null) { if (_logger != null) { _logger.LogError("_workflow is null in HRCoreBordersServices"); } throw new MemberAccessException(); } if (pageModel == null) { if (_logger != null) { _logger.LogError("pageModel is null in HRCoreBordersServices : GetBordersAsync"); } throw new ArgumentNullException(); } using (Task <PagingParameterOutModel <HRBorder> > retourTask = _workflow.GetQueryResultsAsync(pageModel, orderBy)) { await retourTask; retour = retourTask.Result; } return(retour); }
public async void HRCountriesOnGetFromPagingWithServiceNormalResultExpectCode200() { PagingParameterInModel model = new PagingParameterInModel() { PageNumber = 0, PageSize = 10 }; CoreCountriesServiceStub service = new CoreCountriesServiceStub(new System.Collections.Generic.List <string>() { "XX" }) { ThrowException = false }; HRCommonForkerUtilsStub utilStub = new HRCommonForkerUtilsStub() { CanOrderReturn = true }; HRCountriesControllersForker forker = new HRCountriesControllersForker(utilStub); using (Task <(int, PagingParameterOutModel <HRCountry>)> forkerTask = forker.GetFromPagingAsync( model, null, service, 50 )) { await forkerTask; Assert.True(forkerTask.Result.Item1 == StatusCodes.Status200OK); } }
/// <summary> /// Chunk the queried pageModel pageSize. /// 1- If pagingIn has a too large PageSize, return a new Paging : /// 1.1- With the maxPageSize allowed /// 1.2- Reprocess page number : /// 1.2.1 - if original pagenumber is 0, the new is 0 too /// 1.2.1- else With the pageNumber reprocessed to 0. Unfriendly but OK for a first version. /// 2- Else return the PagingIn as is. /// </summary> /// <param name="pageModel"></param> /// <returns></returns> public static PagingParameterInModel LimitPagingIn(PagingParameterInModel pageModel, ushort maxPageSizeAllowed) { //1- if (pageModel != null && pageModel.PageSize > maxPageSizeAllowed) { //1.1- PagingParameterInModel retour = new PagingParameterInModel() { PageSize = maxPageSizeAllowed }; //1.2.1- if (pageModel.PageNumber == 0) { retour.PageNumber = 0; } //1.2.2 else { double ratio = pageModel.PageSize / retour.PageSize; retour.PageNumber = (ushort)(Math.Floor(ratio)); } return(retour); } //2- else { return(pageModel); } }
public void ValidatePaginationInPAgeSizeNullThrowInvalidOperationException() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageSize = 0; Assert.Throws <InvalidOperationException>(() => paginer.IsValid(model, CreateItems(50))); }
/// <summary> /// /// </summary> /// <param name="query"></param> /// <param name="pageModel"></param> /// <param name="orderBy"></param> /// <returns></returns> private String GetSQLQueryMainRecordsCount(HRBirdMainInput query, PagingParameterInModel pageModel, HRSortingParamModel orderBy) { if (query == null || String.IsNullOrEmpty(query.Lang_Iso_Code)) { throw new ArgumentNullException("Lang_Iso_Code not set."); } return(String.Format(SQLQUERY_COUNT, query.Lang_Iso_Code.ToLower())); }
public void PaginatePaginationInInvalidThrowAInvalidArgumentException() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageNumber = 5; model.PageSize = 100; Assert.Throws <Exception>(() => paginer.GetPaginationFromFullList(model, CreateItems(50))); }
public void PaginatePaginationInWithPageSize0ThrowInvalidOperationException() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageNumber = 0; model.PageSize = 0; Assert.Throws <InvalidOperationException>(() => paginer.GetPaginationFromFullList(model, CreateItems(50))); }
private void ValidatePaginationInWith49ItemsOutOfBoundEnumerableReturnFalse() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageSize = 50; model.PageNumber = 2; Assert.False(paginer.IsValid(model, CreateItems(49))); }
/// <summary> /// /// </summary> /// <returns></returns> private PagingParameterInModel GetDefaultMainPagination() { PagingParameterInModel retour = new PagingParameterInModel() { PageNumber = 0, PageSize = 20 }; return(retour); }
public void ValidatePaginationInFirstPageWithSinglePageEnumerableReturnTrue() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageSize = 50; model.PageNumber = 0; Assert.True(paginer.IsValid(model, CreateItems(200))); }
public void PaginateNullListsThrowArgumentNullException() { HRPaginer <String> paginer = new HRPaginer <String>(); PagingParameterInModel model = new PagingParameterInModel(); model.PageNumber = 0; model.PageSize = 20; Assert.Throws <ArgumentNullException>(() => paginer.GetPaginationFromFullList(model, null)); }
public async Task <PagingParameterOutModel <int> > GetPaginatedsAsync(PagingParameterInModel pageModel) { await Task.Delay(1); return(new PagingParameterOutModel <int>() { CurrentPage = 44 }); }
public async Task <ActionResult <PagingParameterOutModel <HRBirdMainOutput> > > Get( [FromQuery] HRBirdMainInput query, [FromQuery] PagingParameterInModel pageModel, [FromQuery] HRSortingParamModel orderBy) { using var resultTask = _birdService.GetMainRecordsAsync(query, pageModel, orderBy); await resultTask; return(resultTask.Result); }
/// <summary> /// TODO /// </summary> /// <param name="pageModel"></param> /// <param name="orderBy"></param> /// <returns></returns> public async Task <PagingParameterOutModel <HRCountry> > GetCountriesAsync(PagingParameterInModel pageModel, HRSortingParamModel orderBy) { if (_workflow == null) { throw new MemberAccessException(); } Task <PagingParameterOutModel <HRCountry> > retourTask = _workflow.GetQueryResultsAsync(pageModel, orderBy); await retourTask; return(retourTask.Result); }
/// <summary> /// Call GetOrderedAndPaginatedsAsync with orederBy set to null. /// </summary> /// <param name="pageModel">the pageModel.</param> /// <returns>The HRBorders corresponding Page</returns> public async Task <PagingParameterOutModel <HRBorder> > GetPaginatedsAsync(PagingParameterInModel pageModel) { PagingParameterOutModel <HRBorder> retour = null; using (Task <PagingParameterOutModel <HRBorder> > retourTask = GetOrderedAndPaginatedsAsync(pageModel, null)) { await retourTask; retour = retourTask.Result; } return(retour); }
public async Task <PagingParameterOutModel <HRCountry> > GetPaginatedsAsync(PagingParameterInModel pageModel) { await Task.Delay(1); PagingParameterOutModel <HRCountry> retour = new PagingParameterOutModel <HRCountry>(); retour.PageItems = _countries; retour.PageSize = 50; retour.CurrentPage = 0; retour.TotalItemsCount = 50; return(retour); }
/// <summary> /// Compute the validity of the input parameter. Can throw Exceptions. /// </summary> /// <param name="model">The input Pagination Parameter</param> /// <param name="items">The full list of items to paginate</param> /// <returns>Throw ArgumentNullException if any of input parameters is null, Throw InvalidOperationException if pageSize is 0 else true if input args are valid else false.</returns> public bool IsValid(PagingParameterInModel model, IEnumerable <T> items) { if (items == null || model == null) { throw new ArgumentNullException(); } else { IEnumerator <T> enumerator = items.GetEnumerator(); uint itemsCount = GetEnumerableCount(enumerator); return(this.IsValid(model, itemsCount)); } }
/// <summary> /// 1- Process PagingInParameter if not supplied /// 2- Get the HRBorders from service /// 3- Paginate previous result /// !Strange we have to âss from query even for an "internal" method ... to untderstand. /// </summary> /// <param name="pageModel">The Paging Model</param> /// <returns>(http Status Code, PagingParameterOutModel)</returns> public async Task <(int, PagingParameterOutModel <HRBorder>)> GetFromPaging( [FromQuery] PagingParameterInModel pageModel, [FromQuery] HRSortingParamModel orderBy) { if (_borderService != null) { if (orderBy != null && orderBy.IsInitialised()) { if (!_borderService.IsSortable()) { return(StatusCodes.Status400BadRequest, null); } else if (!HRSortingParamModelDeserializer.IsValid(orderBy)) { return(StatusCodes.Status400BadRequest, null); } } //1- if (pageModel == null) { pageModel = GetDefaultPagingInParameter(); } //!Add tu on this if (pageModel.PageSize > _maxPageSize) { return(StatusCodes.Status413PayloadTooLarge, null); } try { //2- Task <PagingParameterOutModel <HRBorder> > bordersAction = _borderService.GetBordersAsync(pageModel, orderBy); await bordersAction; //3- return(StatusCodes.Status200OK, bordersAction.Result); } catch (IndexOutOfRangeException) { //!Add tu on this return(StatusCodes.Status416RequestedRangeNotSatisfiable, null); } catch (Exception) { return(StatusCodes.Status500InternalServerError, null); } } else { return(StatusCodes.Status500InternalServerError, null); } }