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);
}
