public async Task ClearCache_ShouldClearAllLevels()
        {
            // Arrange
            _firstLevelCachingService.Setup(x => x.ClearCache());
            _secondLevelCachingService.Setup(x => x.ClearCache());

            // Act
            await _sut.ClearCache();

            // Assert
            _firstLevelCachingService.Verify(x => x.ClearCache(), Times.Once);
            _secondLevelCachingService.Verify(x => x.ClearCache(), Times.Once);
        }
示例#2
0
        public async Task ClearCache_ShouldClearCache()
        {
            // Arrange
            await _cachingService.GetLanguages().ConfigureAwait(false);

            await _consumerHttpClient.Received().GetLanguagesAsync().ConfigureAwait(false);

            // Act
            _cachingService.ClearCache();

            // Assert
            await _consumerHttpClient.Received().GetLanguagesAsync().ConfigureAwait(false);
        }
        public async Task ClearCache_ShouldClearAllItems()
        {
            // Arrange
            await _sut.StoreTranslationsAsync(TestData.Language_DE, TestData.Translations_De);

            await _sut.StoreTranslationsAsync(TestData.Language_EN, TestData.Translations_En);

            // Act
            await _sut.ClearCache();

            // Assert
            (await _sut.GetTranslations(TestData.Language_DE, false)).Result.Should().BeEquivalentTo(TestData.EmptyTranslations);
            (await _sut.GetTranslations(TestData.Language_EN, false)).Result.Should().BeEquivalentTo(TestData.EmptyTranslations);
        }
示例#4
0
        public Task ClearCache()
        {
            _languages = null;

            return(_cachingService.ClearCache());
        }
示例#5
0
        public async Task RefreshFilms(string cinemaId)
        {
            var externalFilms = await _apiClient.GetFilmsForCinema(cinemaId);

            var localFilms = await GetLocalFilms();

            var allFilms = await _apiClient.GetAllFilms();

            await CheckForUnlimitedScreenings();

            var isFirstRun = !localFilms.Any();

            var existingLocalFilms = localFilms
                                     .Where(x => externalFilms.Any(y => y.FilmId == x.Code))
                                     .ToList();

            var localFilmsChanged = CorrectWeightingOfExistingFilms(existingLocalFilms, allFilms);

            var existingExternalFilms = externalFilms
                                        .Where(x => localFilms.Any(y => y.Code == x.FilmId))
                                        .ToList();

            var filmsToRemove = localFilms
                                .Where(x => existingLocalFilms.All(y => y.Code != x.Code))
                                .ToList();

            if (filmsToRemove.Any())
            {
                RemoveFilms(localFilms, filmsToRemove);
                localFilmsChanged = true;
            }

            var addedExternalFilms = externalFilms
                                     .Except(existingExternalFilms)
                                     .ToList();

            var addedLocalFilms = allFilms
                                  .Where(x => addedExternalFilms.Any(y => y.FilmId == x.Code))
                                  .ToList();

            if (addedExternalFilms.Any())
            {
                if (!isFirstRun)
                {
                    await _toastService.DisplayToasts(addedLocalFilms);
                }

                localFilms.AddRange(addedLocalFilms);
                localFilmsChanged = true;
            }

            if (localFilmsChanged)
            {
                localFilms = localFilms.OrderBy(x => x.Weight).ToList();
                await WriteFilmsToFile(FilmCacheFile, localFilms);

                _filmCache.ClearCache(FilmCacheFile);
            }

            await WriteFilmsToFile(AllFilmCacheFile, allFilms);
        }
示例#6
0
 public void ClearCache()
 {
     _cachingService.ClearCache();
 }