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)