public async Task Should_not_retrieve_from_inner_when_removed() { var contentId = Guid.NewGuid(); var state = new TextContentState { ContentId = contentId }; await sut.SetAsync(state); await sut.RemoveAsync(contentId); var found1 = await sut.GetAsync(contentId); var found2 = await sut.GetAsync(contentId); Assert.Null(found1); Assert.Null(found2); A.CallTo(() => inner.RemoveAsync(contentId)) .MustHaveHappenedOnceExactly(); A.CallTo(() => inner.GetAsync(contentId)) .MustNotHaveHappened(); }
private void Create(ContentEvent @event, ContentData data) { var uniqueId = DomainId.Combine(@event.AppId, @event.ContentId); var state = new TextContentState { UniqueContentId = uniqueId }; state.GenerateDocIdCurrent(); Index(@event, new UpsertIndexEntry { ContentId = @event.ContentId, DocId = state.DocIdCurrent, GeoObjects = data.ToGeo(jsonSerializer), ServeAll = true, ServePublished = false, Texts = data.ToTexts(), IsNew = true }); states[state.UniqueContentId] = state; updates[state.UniqueContentId] = state; }
public async Task Should_retrieve_from_inner_if_not_cached() { var contentIds = HashSet.Of(contentId); var state = new TextContentState { UniqueContentId = contentId }; var states = new Dictionary <DomainId, TextContentState> { [contentId] = state }; A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > .That.Is(contentIds), ct)) .Returns(states); var found1 = await sut.GetAsync(HashSet.Of(contentId), ct); var found2 = await sut.GetAsync(HashSet.Of(contentId), ct); Assert.Same(state, found1[contentId]); Assert.Same(state, found2[contentId]); A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > .That.Is(contentIds), ct)) .MustHaveHappenedOnceExactly(); }
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(); }
public async Task Should_not_retrieve_from_inner_if_removed() { var contentIds = HashSet.Of(contentId); var state = new TextContentState { UniqueContentId = contentId }; await sut.SetAsync(new List <TextContentState> { state }, ct); await sut.SetAsync(new List <TextContentState> { new TextContentState { UniqueContentId = contentId, IsDeleted = true } }, ct); var found1 = await sut.GetAsync(contentIds, ct); var found2 = await sut.GetAsync(contentIds, ct); Assert.Empty(found1); Assert.Empty(found2); A.CallTo(() => inner.SetAsync(A <List <TextContentState> > .That.Matches(x => x.Count == 1 && x[0].IsDeleted), ct)) .MustHaveHappenedOnceExactly(); A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > ._, ct)) .MustNotHaveHappened(); }
public Task SetAsync(DomainId appId, TextContentState state) { var documentId = DomainId.Combine(appId, state.ContentId).ToString(); var document = new MongoTextIndexState(documentId, state); return Collection.ReplaceOneAsync(x => x.DocumentId == documentId, document, UpsertReplace); }
public MongoTextIndexState(DomainId documentId, TextContentState state) { DocumentId = documentId; ContentId = state.ContentId; DocIdNew = state.DocIdNew; DocIdCurrent = state.DocIdCurrent; DocIdForPublished = state.DocIdForPublished; }
public async Task Should_retrieve_from_inner_when_not_cached() { var state = new TextContentState { ContentId = contentId }; A.CallTo(() => inner.GetAsync(appId, contentId)) .Returns(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.GetAsync(appId, contentId)) .MustHaveHappenedOnceExactly(); }
private async Task CreateAsync(ContentCreated @event) { var state = new TextContentState { ContentId = @event.ContentId }; state.GenerateDocIdCurrent(); await IndexAsync(@event, new UpsertIndexEntry { ContentId = @event.ContentId, DocId = state.DocIdCurrent, ServeAll = true, ServePublished = false, Texts = @event.Data.ToTexts(), }); await textIndexerState.SetAsync(state); }
public async Task Should_retrieve_from_inner_when_not_cached_and_not_found() { var contentIds = HashSet.Of(contentId); var state = new TextContentState { UniqueContentId = contentId }; A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > .That.Is(contentIds))) .Returns(new Dictionary <DomainId, TextContentState>()); var found1 = await sut.GetAsync(HashSet.Of(contentId)); var found2 = await sut.GetAsync(HashSet.Of(contentId)); Assert.Empty(found1); Assert.Empty(found2); A.CallTo(() => inner.GetAsync(A <HashSet <DomainId> > .That.Is(contentIds))) .MustHaveHappenedOnceExactly(); }
private async Task CreateAsync(ContentEvent @event, NamedContentData data) { var appId = @event.AppId.Id; var state = new TextContentState { ContentId = @event.ContentId }; state.GenerateDocIdCurrent(); await IndexAsync(@event, new UpsertIndexEntry { ContentId = @event.ContentId, DocId = state.DocIdCurrent, ServeAll = true, ServePublished = false, Texts = data.ToTexts() }); await textIndexerState.SetAsync(appId, state); }