public async Task Should_enrich_multiple_contents_and_cache_color()
{
var source1 = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
var source2 = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
var source = new IContentEntity[]
{
source1,
source2
};
A.CallTo(() => contentWorkflow.GetInfoAsync(source1))
.Returns(new StatusInfo(Status.Published, StatusColors.Published));
var result = await sut.EnrichAsync(source, requestContext);
Assert.Equal(StatusColors.Published, result[0].StatusColor);
Assert.Equal(StatusColors.Published, result[1].StatusColor);
A.CallTo(() => contentWorkflow.GetInfoAsync(A <IContentEntity> .Ignored))
.MustHaveHappenedOnceExactly();
}
private async Task TestContentAsyc(ContentEntity content, string expectedName)
{
content.AppId = appId;
var ctx = ContextWithPermissions(schemaId1, schemaId2);
var ids = new List <DomainId> {
content.Id
};
A.CallTo(() => contentIndex.SearchAsync(ctx.App, A <TextQuery> .That.Matches(x => x.Text == "query~" && x.Filter != null), ctx.Scope()))
.Returns(ids);
A.CallTo(() => contentQuery.QueryAsync(ctx, A <Q> .That.HasIds(ids), A <CancellationToken> ._))
.Returns(ResultList.CreateFrom <IEnrichedContentEntity>(1, content));
A.CallTo(() => urlGenerator.ContentUI(appId, schemaId1, content.Id))
.Returns("content-url");
var result = await sut.SearchAsync("query", ctx, default);
result.Should().BeEquivalentTo(
new SearchResults()
.Add(expectedName, SearchResultType.Content, "content-url"));
}
private async Task TestContentAsyc(ContentEntity content, string expectedName)
{
content.AppId = appId;
var ctx = ContextWithPermissions(schemaId1, schemaId2);
var searchFilter = SearchFilter.MustHaveSchemas(schemaId1.Id, schemaId2.Id);
var ids = new List <DomainId> {
content.Id
};
A.CallTo(() => contentIndex.SearchAsync("query~", ctx.App, A <SearchFilter> .That.IsEqualTo(searchFilter), ctx.Scope()))
.Returns(ids);
A.CallTo(() => contentQuery.QueryAsync(ctx, ids))
.Returns(ResultList.CreateFrom <IEnrichedContentEntity>(1, content));
A.CallTo(() => urlGenerator.ContentUI(appId, schemaId1, content.Id))
.Returns("content-url");
var result = await sut.SearchAsync("query", ctx);
result.Should().BeEquivalentTo(
new SearchResults()
.Add(expectedName, SearchResultType.Content, "content-url"));
}
public async Task Should_return_content_with_default_name()
{
var content = new ContentEntity {
Id = DomainId.NewGuid(), SchemaId = schemaId1
};
await TestContentAsyc(content, "Content");
}
public async Task Should_check_is_valid_next()
{
var content = new ContentEntity {
Status = Status.Published
};
var result = await sut.CanMoveToAsync(content, Status.Draft, null !);
Assert.True(result);
}
public async Task Should_not_be_able_to_update_archived()
{
var content = new ContentEntity {
Status = Status.Archived
};
var result = await sut.CanUpdateAsync(content, content.Status, null !);
Assert.False(result);
}
public async Task Should_allow_if_transition_is_valid_for_content()
{
var content = new ContentEntity {
Status = Status.Published
};
var result = await sut.CanMoveToAsync(content, content.Status, Status.Draft, null !);
Assert.True(result);
}
public async Task Should_be_able_to_update_draft()
{
var content = new ContentEntity {
Status = Status.Published
};
var result = await sut.CanUpdateAsync(content, content.Status, null !);
Assert.True(result);
}
public async Task Should_throw_exception_if_state_has_other_version()
{
var content = new ContentEntity {
Version = 5
};
A.CallTo(() => grain.GetStateAsync(10))
.Returns(J.Of <IContentEntity>(content));
await Assert.ThrowsAsync <DomainObjectNotFoundException>(() => sut.LoadAsync(id, 10));
}
public async Task Should_enrich_content_with_default_color_if_not_found()
{
var source = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
A.CallTo(() => workflow.GetInfoAsync(Status.Published))
.Returns(Task.FromResult <StatusInfo>(null));
var result = await sut.EnrichAsync(source);
Assert.Equal(StatusColors.Draft, result.StatusColor);
}
public async Task Should_enrich_content_with_status_color()
{
var source = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
A.CallTo(() => workflow.GetInfoAsync(Status.Published))
.Returns(new StatusInfo(Status.Published, StatusColors.Published));
var result = await sut.EnrichAsync(source);
Assert.Equal(StatusColors.Published, result.StatusColor);
}
public async Task Should_enrich_content_with_can_update()
{
var source = new ContentEntity {
SchemaId = schemaId
};
A.CallTo(() => workflow.CanUpdateAsync(source))
.Returns(true);
var result = await sut.EnrichAsync(source);
Assert.True(result.CanUpdate);
}
private IContentEntity CreateContent(Guid id, Status status)
{
var content = new ContentEntity
{
Id = id,
Data = contentData,
DataDraft = contentData,
SchemaId = schemaId,
Status = status,
};
return(content);
}
public async Task Should_return_content_from_state()
{
var content = new ContentEntity {
Version = 10
};
A.CallTo(() => grain.GetStateAsync(10))
.Returns(J.Of <IContentEntity>(content));
var result = await sut.LoadAsync(id, 10);
Assert.Same(content, result);
}
public async Task Should_not_enrich_content_with_can_update_if_disabled_in_context()
{
context.WithResolveFlow(false);
var source = new ContentEntity {
SchemaId = schemaId
};
var result = await sut.EnrichAsync(source, user);
Assert.False(result.CanUpdate);
A.CallTo(() => contentWorkflow.CanUpdateAsync(source))
.MustNotHaveHappened();
}
public async Task Should_get_next_statuses_for_archived()
{
var content = new ContentEntity {
Status = Status.Archived
};
var expected = new[]
{
new StatusInfo(Status.Draft, StatusColors.Draft)
};
var result = await sut.GetNextAsync(content, content.Status, null !);
result.Should().BeEquivalentTo(expected);
}
public async Task Should_not_invoke_enricher_if_already_enriched()
{
var result = new ContentEntity();
var command = CreateCommand(new MyCommand());
var context = CreateContextForCommand(command);
context.Complete(result);
await sut.HandleAsync(context);
Assert.Same(result, context.Result <IEnrichedContentEntity>());
A.CallTo(() => contentEnricher.EnrichAsync(A <IEnrichedContentEntity> .Ignored, User))
.MustNotHaveHappened();
}
public async Task Should_get_next_statuses_for_draft()
{
var content = new ContentEntity {
Status = Status.Draft
};
var expected = new[]
{
new StatusInfo(Status.Archived, StatusColors.Archived),
new StatusInfo(Status.Published, StatusColors.Published)
};
var result = await sut.GetNextsAsync(content);
result.Should().BeEquivalentTo(expected);
}
public async Task Should_add_app_version_and_schema_as_dependency()
{
var source = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
A.CallTo(() => contentWorkflow.GetInfoAsync(source))
.Returns(new StatusInfo(Status.Published, StatusColors.Published));
var result = await sut.EnrichAsync(source, requestContext);
Assert.Contains(requestContext.App.Version.ToString(), result.CacheDependencies);
Assert.Contains(schema.Id.ToString(), result.CacheDependencies);
Assert.Contains(schema.Version.ToString(), result.CacheDependencies);
}
public async Task Should_enrich_content_result()
{
var result = A.Fake <IContentEntity>();
var command = CreateCommand(new MyCommand());
var context = CreateContextForCommand(command);
context.Complete(result);
var enriched = new ContentEntity();
A.CallTo(() => contentEnricher.EnrichAsync(result, User))
.Returns(enriched);
await sut.HandleAsync(context);
Assert.Same(enriched, context.Result <IEnrichedContentEntity>());
}
public static ContentEntity Create(CreateContent command, EntityCreatedResult <NamedContentData> result)
{
var now = SystemClock.Instance.GetCurrentInstant();
var response = new ContentEntity
{
Id = command.ContentId,
Data = result.IdOrValue,
Version = result.Version,
Created = now,
CreatedBy = command.Actor,
LastModified = now,
LastModifiedBy = command.Actor,
Status = command.Publish ? Status.Published : Status.Draft
};
return(response);
}
public async Task Should_return_content_with_localized_reference_field()
{
var content = new ContentEntity
{
Id = DomainId.NewGuid(),
Data =
new ContentData()
.AddField("field",
new ContentFieldData()
.AddJsonValue("en", JsonValue.Create("hello"))),
ReferenceFields = new[]
{
Fields.String(1, "field", Partitioning.Language)
},
SchemaId = schemaId1
};
await TestContentAsyc(content, "hello");
}
public async Task Should_return_content_with_invariant_reference_field()
{
var content = new ContentEntity
{
Id = DomainId.NewGuid(),
Data =
new ContentData()
.AddField("field",
new ContentFieldData()
.AddInvariant("hello")),
ReferenceFields = new[]
{
Fields.String(1, "field", Partitioning.Invariant)
},
SchemaId = schemaId1
};
await TestContentAsyc(content, "hello");
}
public async Task Should_not_change_status_if_content_has_no_schedule_job()
{
var now = SystemClock.Instance.GetCurrentInstant();
var content1 = new ContentEntity
{
AppId = appId,
Id = DomainId.NewGuid(),
ScheduleJob = null,
};
A.CallTo(() => clock.GetCurrentInstant())
.Returns(now);
A.CallTo(() => contentRepository.QueryScheduledWithoutDataAsync(now, default))
.Returns(new[] { content1 }.ToAsyncEnumerable());
await sut.PublishAsync();
A.CallTo(() => commandBus.PublishAsync(A <ICommand> ._))
.MustNotHaveHappened();
}
private IContentEntity CreateContent(Status status, int value, bool simple = false)
{
var content = new ContentEntity {
AppId = appId, Status = status
};
if (simple)
{
content.SchemaId = simpleSchemaId;
}
else
{
content.SchemaId = schemaId;
}
content.DataDraft =
new NamedContentData()
.AddField("field",
new ContentFieldData()
.AddValue("iv", value));
return(content);
}
public async Task Should_return_content_with_multiple_invariant_reference_fields()
{
var content = new ContentEntity
{
Id = DomainId.NewGuid(),
Data =
new ContentData()
.AddField("field1",
new ContentFieldData()
.AddJsonValue("iv", JsonValue.Create("hello")))
.AddField("field2",
new ContentFieldData()
.AddJsonValue("iv", JsonValue.Create("world"))),
ReferenceFields = new[]
{
Fields.String(1, "field1", Partitioning.Invariant),
Fields.String(2, "field2", Partitioning.Invariant)
},
SchemaId = schemaId1
};
await TestContentAsyc(content, "hello, world");
}
public async Task Should_return_content_with_invariant_field_and_reference_data()
{
var content = new ContentEntity
{
Id = DomainId.NewGuid(),
Data =
new ContentData()
.AddField("field",
new ContentFieldData()
.AddInvariant("raw")),
ReferenceData =
new ContentData()
.AddField("field",
new ContentFieldData()
.AddLocalized("en", "resolved")),
ReferenceFields = new[]
{
Fields.String(1, "field", Partitioning.Language)
},
SchemaId = schemaId1
};
await TestContentAsyc(content, "resolved");
}
public async Task Should_return_content_with_invariant_field_and_reference_data()
{
var content = new ContentEntity
{
Id = Guid.NewGuid(),
Data =
new NamedContentData()
.AddField("field",
new ContentFieldData()
.AddJsonValue("iv", JsonValue.Create("raw"))),
ReferenceData =
new NamedContentData()
.AddField("field",
new ContentFieldData()
.AddJsonValue("en", JsonValue.Create("resolved"))),
ReferenceFields = new[]
{
Fields.String(1, "field", Partitioning.Language)
},
SchemaId = schemaId1
};
await TestContentAsyc(content, "resolved");
}
private async Task ResolveNextsAsync(IContentEntity content, ContentEntity result, Context context)
{
result.Nexts = await contentWorkflow.GetNextsAsync(content, context.User);
}
private async Task ResolveColorAsync(IContentEntity content, ContentEntity result, Dictionary <(Guid, Status), StatusInfo> cache)
