@Override public synchronized PaginatedCollection<V> getPage(Page page) { List<V> result = new LinkedList<>(); int offset = page.getOffset(); int limit = page.getLimit(); List<V> values = new ArrayList<>(items.values()); for (int i = offset; i < values.size() && i < offset + limit; i++) { V value = values.get(i); result.add(value); } PaginatedCollection<V> paginatedCollection = new PaginatedCollection<>(result); paginatedCollection.setPage(page); paginatedCollection.setHasMore(offset + limit < items.size() || this.hasMore); return paginatedCollection; }
public PaginatedCollection<ComicSeries> getAllComicsInCache() { Collection<ComicSeries> all; try { all = repository.getAll(ReadPolicy.CACHE_ONLY); } catch (Exception e) { all = new ArrayList<>(); } if (all == null) { all = new ArrayList<>(); } Page page = Page.withOffsetAndLimit(0, all.size()); PaginatedCollection<ComicSeries> comics = new PaginatedCollection<>(all); comics.setPage(page); comics.setHasMore(true); return comics; }
public static Page withOffsetAndLimit(int offset, int limit) { return new Page(offset, limit); }
@Test public void shouldReturnTheRequestedOffset() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); Collection<AnyRepositoryValue> values = givenSomeItems(ANY_OFFSET + ANY_LIMIT); PaginatedCacheDataSource<AnyRepositoryKey, AnyRepositoryValue> cache = givenAnInMemoryPaginatedCacheDataSource(); cache.addOrUpdatePage(page, values, ANY_HAS_MORE); PaginatedCollection<AnyRepositoryValue> paginatedCollection = cache.getPage(page); assertEquals(ANY_OFFSET, paginatedCollection.getPage().getOffset()); }
@Test public void shouldReturnRequestedLimit() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); Collection<AnyRepositoryValue> values = givenSomeItems(ANY_OFFSET + ANY_LIMIT); PaginatedCacheDataSource<AnyRepositoryKey, AnyRepositoryValue> cache = givenAnInMemoryPaginatedCacheDataSource(); cache.addOrUpdatePage(page, values, ANY_HAS_MORE); PaginatedCollection<AnyRepositoryValue> paginatedCollection = cache.getPage(page); assertEquals(ANY_LIMIT, paginatedCollection.getPage().getLimit()); }
@Override public void update() { super.update(); getView().hideCharacters(); showLoading(); PaginatedCollection<Character> allCharactersInCache = getCharacters.getAllCharactersInCache(); if (allCharactersInCache.getPage().getLimit() == 0) { loadCharacters(); } else { getView().clearCharacters(); showCharacters(allCharactersInCache); offset = allCharactersInCache.getItems().size(); } }
@Override public void update() { super.update(); getView().hideComicSeries(); showLoading(); PaginatedCollection<ComicSeries> allComicsInCache = getComicSeriesPage.getAllComicsInCache(); if (allComicsInCache.getPage().getLimit() == 0) { loadComics(); } else { getView().clearComicSeries(); showComics(allComicsInCache); offset = allComicsInCache.getItems().size(); } }
@Override public PaginatedCollection<Character> getPage(Page page) throws MarvelApiException { int offset = page.getOffset(); int limit = page.getLimit(); Collection<Character> charactersToReturn = new LinkedList<>(); fakeDelay(); if (offset < characters.length) { for (int i = offset; i - offset < limit && i < characters.length; i++) { charactersToReturn.add(characters[i]); } } PaginatedCollection<Character> charactersPage = new PaginatedCollection<>(charactersToReturn); charactersPage.setPage(page); charactersPage.setHasMore(offset + charactersToReturn.size() < characters.length); return charactersPage; }
public PaginatedCollection<Character> getAllCharactersInCache() { Collection<Character> all; try { all = charactersRepository.getAll(ReadPolicy.CACHE_ONLY); } catch (Exception e) { all = new ArrayList<>(); } if (all == null) { all = new ArrayList<>(); } Page page = Page.withOffsetAndLimit(0, all.size()); PaginatedCollection<Character> comics = new PaginatedCollection<>(all); comics.setPage(page); comics.setHasMore(true); return comics; }
@Override public PaginatedCollection<ComicSeries> getPage(Page page) { Collection<ComicSeries> comics = new LinkedList<>(); fakeDelay(); int offset = page.getOffset(); int limit = page.getLimit(); if (offset < allComicSeries.length) { for (int i = offset; i - offset < limit && i < allComicSeries.length; i++) { comics.add(getComicSeries(i)); } } PaginatedCollection<ComicSeries> comicsPage = new PaginatedCollection<>(comics); comicsPage.setPage(page); comicsPage.setHasMore(offset + comics.size() < allComicSeries.length); return comicsPage; }
private void givenEmptyCharacters() throws Exception { when(charactersRepository.getAll(ReadPolicy.CACHE_ONLY)).thenReturn(new ArrayList<Character>()); PaginatedCollection<Character> emptyPage = new PaginatedCollection<>(); emptyPage.setPage(Page.withOffsetAndLimit(0, 0)); emptyPage.setHasMore(false); when(charactersRepository.getPage(any(Page.class))).thenReturn(emptyPage); }
@Override public PaginatedCollection<ComicSeries> getPage(Page page) throws MarvelApiException { int offset = page.getOffset(); int limit = page.getLimit(); MarvelResponse<SeriesCollectionDto> seriesApiResponse = seriesApiClient.getAll(offset, limit); SeriesCollectionDto seriesCollectionDto = seriesApiResponse.getResponse(); Collection<ComicSeries> comicSeries = mapper.reverseMap(seriesCollectionDto.getSeries()); PaginatedCollection<ComicSeries> comicSeriesPage = new PaginatedCollection<>(comicSeries); comicSeriesPage.setPage(page); comicSeriesPage.setHasMore( seriesCollectionDto.getOffset() + seriesCollectionDto.getCount() < seriesCollectionDto.getTotal()); return comicSeriesPage; }
private List<ComicSeries> givenThereAreSomeComicSeries(int numberOfComicSeries) throws Exception { List<ComicSeries> comics = new LinkedList<>(); for (int i = 0; i < numberOfComicSeries; i++) { ComicSeries comic = getComicSeries(i); comics.add(comic); } PaginatedCollection<ComicSeries> paginatedCollection = new PaginatedCollection<>(comics); paginatedCollection.setPage(Page.withOffsetAndLimit(0, numberOfComicSeries)); paginatedCollection.setHasMore(false); when(comicSeriesRepository.getPage(any(Page.class))).thenReturn(paginatedCollection); return comics; }
@Override public PaginatedCollection<Character> getPage(Page page) throws MarvelApiException { int offset = page.getOffset(); int limit = page.getLimit(); MarvelResponse<CharactersDto> charactersApiResponse = characterApiClient.getAll(offset, limit); CharactersDto charactersDto = charactersApiResponse.getResponse(); Collection<Character> characters = mapper.reverseMap(charactersDto.getCharacters()); PaginatedCollection<Character> charactersPage = new PaginatedCollection<>(characters); charactersPage.setPage(page); charactersPage.setHasMore( charactersDto.getOffset() + charactersDto.getCount() < charactersDto.getTotal()); return charactersPage; } }
private void givenEmptyComicSeries() throws Exception { when(comicSeriesRepository.getAll(ReadPolicy.CACHE_ONLY)).thenReturn( new ArrayList<ComicSeries>()); PaginatedCollection<ComicSeries> emptyPage = new PaginatedCollection<>(); emptyPage.setPage(Page.withOffsetAndLimit(0, 0)); emptyPage.setHasMore(false); when(comicSeriesRepository.getPage(any(Page.class))).thenReturn(emptyPage); }
private List<Character> givenThereAreSomeCharacters(int numberOfCharacters) throws Exception { List<Character> characters = new LinkedList<>(); for (int i = 0; i < numberOfCharacters; i++) { Character character = getCharacter(i); characters.add(character); when(charactersRepository.getByKey(String.valueOf(i))).thenReturn(character); } PaginatedCollection<Character> paginatedCollection = new PaginatedCollection<>(characters); paginatedCollection.setPage(Page.withOffsetAndLimit(0, numberOfCharacters)); paginatedCollection.setHasMore(false); when(charactersRepository.getPage(any(Page.class))).thenReturn(paginatedCollection); return characters; }
private void loadCharacters() { createUseCaseCall(getCharacters).args( Page.withOffsetAndLimit(offset, NUMBER_OF_CHARACTERS_PER_PAGE)) .onSuccess(new OnSuccessCallback() { @Success public void onCharactersLoaded(PaginatedCollection<Character> characters) { showCharacters(characters); offset = characters.getPage().getOffset() + NUMBER_OF_CHARACTERS_PER_PAGE; } }).onError(new OnErrorCallback() { @Override public boolean onError(Error error) { getView().hideLoading(); return false; } }) .execute(); }
private void loadComics() { createUseCaseCall(getComicSeriesPage).args( Page.withOffsetAndLimit(offset, NUMBER_OF_COMIC_SERIES_PER_PAGE)) .onSuccess(new OnSuccessCallback() { @Success public void onComicSeriesLoaded(PaginatedCollection<ComicSeries> comicSeries) { showComics(comicSeries); offset = comicSeries.getPage().getOffset() + NUMBER_OF_COMIC_SERIES_PER_PAGE; } }) .onError(new OnErrorCallback() { @Override public boolean onError(Error error) { getView().hideLoading(); return false; } }) .execute(); }
@Test public void shouldNotRemoveDataFromCacheIfCacheDoNotHaveThisPage() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNonValidValues(page); givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); repository.getPage(page); Page nextPage = Page.withOffsetAndLimit(ANY_OFFSET + ANY_LIMIT, ANY_LIMIT); repository.getPage(nextPage); verify(cacheDataSource, times(1)).deleteAll(); }
@Test public void shouldReturnValuesFromReadableDataSourceIfCacheDoNotHaveThisPage() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNonValidValues(page); givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); repository.getPage(page); Page nextPage = Page.withOffsetAndLimit(ANY_OFFSET + ANY_LIMIT, ANY_LIMIT); repository.getPage(nextPage); verify(cacheDataSource).getPage(page); verify(readableDataSource).getPage(page); verify(cacheDataSource).getPage(nextPage); verify(readableDataSource).getPage(nextPage); }