public async Task GivenAContentItemNameAndAnEmptyCache_ItShouldPutTheContentInTheCache()
            {
                // Arrange
                var testStart      = DateTime.UtcNow;
                var file           = TestFileReference.Create(FileContent);
                var contentService = new TestableContentService();

                contentService.SetFile("TestContentItem.md", null, file);

                // Act
                await contentService.GetContentItemAsync("TestContentItem", TimeSpan.FromSeconds(42));

                // Assert
                var cached = contentService.GetCached("TestContentItem");

                Assert.NotNull(cached);
                Assert.Equal(RenderedFileContent, cached.Content.ToString());
                Assert.Equal(file.ContentId, cached.ContentId);
                Assert.True(EqualWithDrift(TimeSpan.FromSeconds(42), (cached.ExpiryUtc - cached.RetrievedUtc), TimeSpan.FromSeconds(2)));
                Assert.True(cached.RetrievedUtc >= testStart);

                var diff = cached.ExpiryUtc - cached.RetrievedUtc;

                Assert.True(diff > TimeSpan.FromSeconds(40) && diff < TimeSpan.FromSeconds(43));
            }
            public async Task GivenAContentItemAndACachedValueThatHasExpiredAndChanged_ItShouldUseTheFileContent()
            {
                // Arrange
                var testStart       = DateTime.UtcNow;
                var file            = TestFileReference.Create(NewContent);
                var contentService  = new TestableContentService();
                var retrieved       = testStart.AddDays(-1d);
                var cachedContentId =
                    contentService.SetCached("TestContentItem", CachedContent, retrieved.AddSeconds(1), retrieved);

                contentService.SetFile("TestContentItem.md", cachedContentId, file);

                // Act
                var actual = await contentService.GetContentItemAsync("TestContentItem", ".md", TimeSpan.FromHours(12));

                // Assert
                Assert.Equal(RenderedNewContent, actual.ToString());
                contentService.MockFileStorage
                .Verify(fs => fs.GetFileReferenceAsync(CoreConstants.ContentFolderName, "TestContentItem.md", cachedContentId));
                Assert.Equal(1, file.OpenCount); // Make sure we never tried to open the file.

                var updatedCache = contentService.GetCached("TestContentItem");

                Assert.NotNull(updatedCache);
                Assert.Equal(RenderedNewContent, updatedCache.Content.ToString());
                Assert.Equal(file.ContentId, updatedCache.ContentId);
                Assert.True(EqualWithDrift(TimeSpan.FromHours(12), (updatedCache.ExpiryUtc - updatedCache.RetrievedUtc), TimeSpan.FromSeconds(2)));
            }
            public async Task GivenAContentItemNameAndAnEmptyCache_ItShouldFetchThatItemFromFileStorage()
            {
                // Arrange
                var file           = TestFileReference.Create(FileContent);
                var contentService = new TestableContentService();

                contentService.SetFile("TestContentItem.md", null, file);

                // Act
                var actual = await contentService.GetContentItemAsync("TestContentItem", TimeSpan.Zero);

                // Assert
                Assert.Equal(RenderedFileContent, actual.ToString());
            }
Exemple #4
0
            public async Task GivenAContentItemNameAndAnEmptyCache_ItShouldFetchThatItemFromFileStorage()
            {
                // Arrange
                var file           = TestFileReference.Create(FileContent);
                var contentService = new TestableContentService();

                contentService.MockFileStorage
                .Setup(fs => fs.GetFileReferenceAsync(Constants.ContentFolderName, "TestContentItem.md", null))
                .Returns(Task.FromResult <IFileReference>(file));

                // Act
                var actual = await contentService.GetContentItemAsync("TestContentItem", TimeSpan.Zero);

                // Assert
                Assert.Equal(RenderedFileContent, actual.ToString());
            }
            public async Task GivenAContentItemNameAndACachedValueThatHasNotExpired_ItShouldFetchThatItemFromCache()
            {
                // Arrange
                var file           = TestFileReference.Create(FileContent);
                var contentService = new TestableContentService();

                contentService.SetCached("TestContentItem", CachedContent, DateTime.UtcNow.AddDays(365d), DateTime.UtcNow);

                // Act
                var actual = await contentService.GetContentItemAsync("TestContentItem", TimeSpan.Zero);

                // Assert
                Assert.Equal(CachedContent, actual.ToString());
                contentService.MockFileStorage
                .Verify(
                    fs => fs.GetFileReferenceAsync(CoreConstants.ContentFolderName, "TestContentItem.md", It.IsAny <string>()),
                    Times.Never());
            }
Exemple #6
0
            public async Task GivenAContentItemNameAndAnEmptyCache_ItShouldPutTheContentInTheCache()
            {
                // Arrange
                var testStart      = DateTime.UtcNow;
                var file           = TestFileReference.Create(FileContent);
                var contentService = new TestableContentService();

                contentService.MockFileStorage
                .Setup(fs => fs.GetFileReferenceAsync(Constants.ContentFolderName, "TestContentItem.md", null))
                .Returns(Task.FromResult <IFileReference>(file));

                // Act
                await contentService.GetContentItemAsync("TestContentItem", TimeSpan.FromSeconds(42));

                // Assert
                var cached = contentService.GetCached("TestContentItem");

                Assert.NotNull(cached);
                Assert.Equal(RenderedFileContent, cached.Content.ToString());
                Assert.Equal(file.ContentId, cached.ContentId);
                Assert.True(EqualWithDrift(TimeSpan.FromSeconds(42), (cached.ExpiryUtc - cached.RetrievedUtc), TimeSpan.FromSeconds(2)));
                Assert.True(cached.RetrievedUtc >= testStart);
            }