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 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; }
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); }
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<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; }
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); }
@Test public void shouldDeleteCacheDataIfItemsAreNotValid() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNonValidValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); repository.getPage(page); verify(cacheDataSource).deleteAll(); }
@Test public void shouldReturnHasMoreIfThereAreMoreItemsToLoad() 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_HAS_MORE, paginatedCollection.hasMore()); }
@Test public void shouldAddValuesBasedOnTheOffsetAndLimit() 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(values, paginatedCollection.getItems()); }
@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()); }
@Test public void shouldReturnValuesFromCacheDataSourceIfDataIsValid() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); PaginatedCollection<AnyRepositoryValue> cacheValues = givenCacheDataSourceReturnsValidValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); PaginatedCollection<AnyRepositoryValue> values = repository.getPage(page); assertEquals(cacheValues, values); }
@Test public void shouldPopulateCacheDataSourceAfterGetPageFromReadableDataSource() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNull(page); PaginatedCollection<AnyRepositoryValue> readableValues = givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); repository.getPage(page); verify(cacheDataSource).addOrUpdatePage(page, readableValues.getItems(), true); }
@Test public void shouldReturnValuesFromReadableDataSourceIfCacheDataSourceIsNotValid() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNonValidValues(page); PaginatedCollection<AnyRepositoryValue> readableValues = givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); PaginatedCollection<AnyRepositoryValue> values = repository.getPage(page); assertEquals(readableValues, values); }
@Test public void shouldReturnValuesFromReadableDataSourceIfPolicyForcesOnlyReadable() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsValidValues(page); PaginatedCollection<AnyRepositoryValue> readableValues = givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); PaginatedCollection<AnyRepositoryValue> values = repository.getPage(page, ReadPolicy.READABLE_ONLY); assertEquals(readableValues, values); }
@Test public void shouldReturnItemsFromReadableDataSourceIfCacheDataSourceHasNoData() throws Exception { Page page = Page.withOffsetAndLimit(ANY_OFFSET, ANY_LIMIT); givenCacheDataSourceReturnsNull(page); PaginatedCollection<AnyRepositoryValue> readableValues = givenReadableDataSourceReturnsValues(page); PaginatedRosieRepository<AnyRepositoryKey, AnyRepositoryValue> repository = givenAPaginatedRepository(); PaginatedCollection<AnyRepositoryValue> values = repository.getPage(page); assertEquals(readableValues, values); }