public async Task Should_not_retrieve_from_inner_if_cached()
        {
            var contentIds = HashSet.Of(contentId);

            var state = new TextContentState {
                UniqueContentId = contentId
            };

            await sut.SetAsync(new List <TextContentState> {
                state
            }, ct);

            var found1 = await sut.GetAsync(contentIds, ct);

            var found2 = await sut.GetAsync(contentIds, ct);

            Assert.Same(state, found1[contentId]);
            Assert.Same(state, found2[contentId]);

            A.CallTo(() => inner.SetAsync(A <List <TextContentState> > .That.IsSameSequenceAs(state), ct))
            .MustHaveHappenedOnceExactly();

            A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > ._, A <CancellationToken> ._))
            .MustNotHaveHappened();
        }
Exemple #2
0
        public async Task Should_not_retrieve_from_inner_when_cached()
        {
            var state = new TextContentState {
                ContentId = contentId
            };

            await sut.SetAsync(appId, state);

            var found1 = await sut.GetAsync(appId, contentId);

            var found2 = await sut.GetAsync(appId, contentId);

            Assert.Same(state, found1);
            Assert.Same(state, found2);

            A.CallTo(() => inner.SetAsync(appId, state))
            .MustHaveHappenedOnceExactly();

            A.CallTo(() => inner.GetAsync(appId, contentId))
            .MustNotHaveHappened();
        }