Browse Source

App tests.

pull/249/head
Sebastian Stehle 8 years ago
parent
commit
21626eab3d
  1. 21
      src/Squidex.Domain.Apps.Entities/Apps/AppGrain.cs
  2. 2
      src/Squidex.Domain.Apps.Entities/Apps/Services/Implementations/NoopAppPlanBillingManager.cs
  3. 4
      src/Squidex.Domain.Apps.Entities/Apps/Services/PlanChangeAsyncResult.cs
  4. 5
      src/Squidex.Domain.Apps.Entities/Apps/Services/PlanChangedResult.cs
  5. 1
      src/Squidex.Infrastructure/EventSourcing/Grains/IEventConsumerGrain.cs
  6. 291
      tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppCommandMiddlewareTests.cs
  7. 399
      tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppDomainObjectTests.cs
  8. 407
      tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppGrainTests.cs
  9. 2
      tests/Squidex.Domain.Apps.Entities.Tests/Apps/Billing/NoopAppPlanBillingManagerTests.cs
  10. 9
      tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetGrainTests.cs
  11. 10
      tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleGrainTests.cs
  12. 32
      tests/Squidex.Domain.Apps.Entities.Tests/Schemas/SchemaGrainTests.cs
  13. 2
      tests/Squidex.Domain.Apps.Entities.Tests/TestHelpers/AssertHelper.cs

21
src/Squidex.Domain.Apps.Entities/Apps/AppGrain.cs

@ -8,6 +8,8 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Threading.Tasks; using System.Threading.Tasks;
using Orleans.Core;
using Orleans.Runtime;
using Squidex.Domain.Apps.Core.Apps; using Squidex.Domain.Apps.Core.Apps;
using Squidex.Domain.Apps.Entities.Apps.Commands; using Squidex.Domain.Apps.Entities.Apps.Commands;
using Squidex.Domain.Apps.Entities.Apps.Guards; using Squidex.Domain.Apps.Entities.Apps.Guards;
@ -25,7 +27,7 @@ using Squidex.Shared.Users;
namespace Squidex.Domain.Apps.Entities.Apps namespace Squidex.Domain.Apps.Entities.Apps
{ {
public sealed class AppGrain : DomainObjectGrain<AppState>, IAppGrain public class AppGrain : DomainObjectGrain<AppState>, IAppGrain
{ {
private readonly InitialPatterns initialPatterns; private readonly InitialPatterns initialPatterns;
private readonly IAppProvider appProvider; private readonly IAppProvider appProvider;
@ -34,13 +36,26 @@ namespace Squidex.Domain.Apps.Entities.Apps
private readonly IUserResolver userResolver; private readonly IUserResolver userResolver;
public AppGrain( public AppGrain(
InitialPatterns initialPatterns,
IStore<Guid> store,
IAppProvider appProvider,
IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager,
IUserResolver userResolver)
: this(initialPatterns, store, appProvider, appPlansProvider, appPlansBillingManager, userResolver, null, null)
{
}
protected AppGrain(
InitialPatterns initialPatterns,
IStore<Guid> store, IStore<Guid> store,
IAppProvider appProvider, IAppProvider appProvider,
IAppPlansProvider appPlansProvider, IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager, IAppPlanBillingManager appPlansBillingManager,
IUserResolver userResolver, IUserResolver userResolver,
InitialPatterns initialPatterns) IGrainIdentity identity,
: base(store) IGrainRuntime runtime)
: base(store, identity, runtime)
{ {
Guard.NotNull(initialPatterns, nameof(initialPatterns)); Guard.NotNull(initialPatterns, nameof(initialPatterns));
Guard.NotNull(appProvider, nameof(appProvider)); Guard.NotNull(appProvider, nameof(appProvider));

2
src/Squidex.Domain.Apps.Entities/Apps/Services/Implementations/NoopAppPlanBillingManager.cs

@ -19,7 +19,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Services.Implementations
public Task<IChangePlanResult> ChangePlanAsync(string userId, Guid appId, string appName, string planId) public Task<IChangePlanResult> ChangePlanAsync(string userId, Guid appId, string appName, string planId)
{ {
return Task.FromResult<IChangePlanResult>(PlanChangedResult.Instance); return Task.FromResult<IChangePlanResult>(new PlanChangedResult());
} }
public Task<string> GetPortalLinkAsync(string userId) public Task<string> GetPortalLinkAsync(string userId)

4
src/Squidex.Domain.Apps.Entities/Apps/Services/PlanChangeAsyncResult.cs

@ -9,9 +9,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Services
{ {
public sealed class PlanChangeAsyncResult : IChangePlanResult public sealed class PlanChangeAsyncResult : IChangePlanResult
{ {
public static readonly PlanChangeAsyncResult Instance = new PlanChangeAsyncResult(); public PlanChangeAsyncResult()
private PlanChangeAsyncResult()
{ {
} }
} }

5
src/Squidex.Domain.Apps.Entities/Apps/Services/PlanChangedResult.cs

@ -9,10 +9,5 @@ namespace Squidex.Domain.Apps.Entities.Apps.Services
{ {
public sealed class PlanChangedResult : IChangePlanResult public sealed class PlanChangedResult : IChangePlanResult
{ {
public static readonly PlanChangedResult Instance = new PlanChangedResult();
private PlanChangedResult()
{
}
} }
} }

1
src/Squidex.Infrastructure/EventSourcing/Grains/IEventConsumerGrain.cs

@ -7,7 +7,6 @@
using System; using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using Orleans;
using Orleans.Concurrency; using Orleans.Concurrency;
using Squidex.Infrastructure.Orleans; using Squidex.Infrastructure.Orleans;

291
tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppCommandMiddlewareTests.cs

@ -1,291 +0,0 @@
//// ==========================================================================
//// Squidex Headless CMS
//// ==========================================================================
//// Copyright (c) Squidex UG (haftungsbeschränkt)
//// All rights reserved. Licensed under the MIT license.
//// ==========================================================================
//using System;
//using System.Threading.Tasks;
//using FakeItEasy;
//using Squidex.Domain.Apps.Entities.Apps.Commands;
//using Squidex.Domain.Apps.Entities.Apps.Services;
//using Squidex.Domain.Apps.Entities.Apps.Services.Implementations;
//using Squidex.Domain.Apps.Entities.TestHelpers;
//using Squidex.Infrastructure;
//using Squidex.Infrastructure.Commands;
//using Squidex.Infrastructure.States;
//using Squidex.Shared.Users;
//using Xunit;
//namespace Squidex.Domain.Apps.Entities.Apps
//{
// public class AppCommandMiddlewareTests : HandlerTestBase<AppDomainObject>
// {
// private readonly IAppProvider appProvider = A.Fake<IAppProvider>();
// private readonly IAppPlansProvider appPlansProvider = A.Fake<IAppPlansProvider>();
// private readonly IAppPlanBillingManager appPlansBillingManager = A.Fake<IAppPlanBillingManager>();
// private readonly IUserResolver userResolver = A.Fake<IUserResolver>();
// private readonly Language language = Language.DE;
// private readonly string contributorId = Guid.NewGuid().ToString();
// private readonly string clientName = "client";
// private readonly Guid patternId = Guid.NewGuid();
// private readonly AppDomainObject app = new AppDomainObject(new InitialPatterns());
// private readonly AppCommandMiddleware sut;
// protected override Guid Id
// {
// get { return AppId; }
// }
// public AppCommandMiddlewareTests()
// {
// A.CallTo(() => appProvider.GetAppAsync(AppName))
// .Returns((IAppEntity)null);
// A.CallTo(() => userResolver.FindByIdAsync(contributorId))
// .Returns(A.Fake<IUser>());
// sut = new AppCommandMiddleware(Handler, appProvider, appPlansProvider, appPlansBillingManager, userResolver);
// app.ActivateAsync(Id, A.Fake<IStore<Guid>>());
// }
// [Fact]
// public async Task Create_should_create_domain_object()
// {
// var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId });
// await TestCreate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// Assert.Equal(AppId, context.Result<EntityCreatedResult<Guid>>().IdOrValue);
// }
// [Fact]
// public async Task AssignContributor_should_update_domain_object_if_user_found()
// {
// A.CallTo(() => appPlansProvider.GetPlan(null))
// .Returns(new ConfigAppLimitsPlan { MaxContributors = -1 });
// CreateApp();
// var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task RemoveContributor_should_update_domain_object()
// {
// CreateApp()
// .AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId }));
// var context = CreateContextForCommand(new RemoveContributor { ContributorId = contributorId });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task AttachClient_should_update_domain_object()
// {
// CreateApp();
// var context = CreateContextForCommand(new AttachClient { Id = clientName });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task RenameClient_should_update_domain_object()
// {
// CreateApp()
// .AttachClient(CreateCommand(new AttachClient { Id = clientName }));
// var context = CreateContextForCommand(new UpdateClient { Id = clientName, Name = "New Name" });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task RevokeClient_should_update_domain_object()
// {
// CreateApp()
// .AttachClient(CreateCommand(new AttachClient { Id = clientName }));
// var context = CreateContextForCommand(new RevokeClient { Id = clientName });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task ChangePlan_should_update_domain_object()
// {
// A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
// .Returns(true);
// CreateApp();
// var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan"))
// .MustHaveHappened();
// }
// [Fact]
// public async Task ChangePlan_should_not_make_update_for_redirect_result()
// {
// A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
// .Returns(true);
// A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan"))
// .Returns(CreateRedirectResult());
// CreateApp();
// var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// Assert.Null(app.Snapshot.Plan);
// }
// [Fact]
// public async Task ChangePlan_should_not_call_billing_manager_for_callback()
// {
// A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
// .Returns(true);
// CreateApp();
// var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan", FromCallback = true });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan"))
// .MustNotHaveHappened();
// }
// [Fact]
// public async Task AddLanguage_should_update_domain_object()
// {
// CreateApp();
// var context = CreateContextForCommand(new AddLanguage { Language = language });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task RemoveLanguage_should_update_domain_object()
// {
// CreateApp()
// .AddLanguage(CreateCommand(new AddLanguage { Language = language }));
// var context = CreateContextForCommand(new RemoveLanguage { Language = language });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task UpdateLanguage_should_update_domain_object()
// {
// CreateApp()
// .AddLanguage(CreateCommand(new AddLanguage { Language = language }));
// var context = CreateContextForCommand(new UpdateLanguage { Language = language });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task AddPattern_should_update_domain_object()
// {
// CreateApp();
// var context = CreateContextForCommand(new AddPattern { Name = "Any", Pattern = ".*" });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task UpdatePattern_should_update_domain()
// {
// CreateApp()
// .AddPattern(CreateCommand(new AddPattern { PatternId = patternId, Name = "Any", Pattern = "." }));
// var context = CreateContextForCommand(new UpdatePattern { PatternId = patternId, Name = "Number", Pattern = "[0-9]" });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// [Fact]
// public async Task DeletePattern_should_update_domain_object()
// {
// CreateApp()
// .AddPattern(CreateCommand(new AddPattern { PatternId = patternId, Name = "Any", Pattern = "." }));
// var context = CreateContextForCommand(new DeletePattern { PatternId = patternId });
// await TestUpdate(app, async _ =>
// {
// await sut.HandleAsync(context);
// });
// }
// private AppDomainObject CreateApp()
// {
// app.Create(CreateCommand(new CreateApp { AppId = AppId, Name = AppName }));
// return app;
// }
// private static Task<IChangePlanResult> CreateRedirectResult()
// {
// return Task.FromResult<IChangePlanResult>(new RedirectToCheckoutResult(new Uri("http://squidex.io")));
// }
// }
//}

399
tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppDomainObjectTests.cs

@ -1,399 +0,0 @@
//// ==========================================================================
//// Squidex Headless CMS
//// ==========================================================================
//// Copyright (c) Squidex UG (haftungsbeschränkt)
//// All rights reserved. Licensed under the MIT license.
//// ==========================================================================
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using FakeItEasy;
//using Squidex.Domain.Apps.Core.Apps;
//using Squidex.Domain.Apps.Entities.Apps.Commands;
//using Squidex.Domain.Apps.Entities.TestHelpers;
//using Squidex.Domain.Apps.Events.Apps;
//using Squidex.Infrastructure;
//using Squidex.Infrastructure.States;
//using Xunit;
//namespace Squidex.Domain.Apps.Entities.Apps
//{
// public class AppDomainObjectTests : HandlerTestBase<AppDomainObject>
// {
// private readonly string contributorId = Guid.NewGuid().ToString();
// private readonly string clientId = "client";
// private readonly string clientNewName = "My Client";
// private readonly string planId = "premium";
// private readonly Guid patternId = Guid.NewGuid();
// private readonly AppDomainObject sut = new AppDomainObject(new InitialPatterns());
// protected override Guid Id
// {
// get { return AppId; }
// }
// public AppDomainObjectTests()
// {
// sut.ActivateAsync(Id, A.Fake<IStore<Guid>>());
// }
// [Fact]
// public void Create_should_throw_exception_if_created()
// {
// CreateApp();
// Assert.Throws<DomainException>(() =>
// {
// sut.Create(CreateCommand(new CreateApp { Name = AppName }));
// });
// }
// [Fact]
// public void Create_should_specify_name_and_owner()
// {
// var id1 = Guid.NewGuid();
// var id2 = Guid.NewGuid();
// var initialPatterns = new InitialPatterns
// {
// { id1, new AppPattern("Number", "[0-9]") },
// { id2, new AppPattern("Numbers", "[0-9]*") }
// };
// var app = new AppDomainObject(initialPatterns);
// app.Create(CreateCommand(new CreateApp { Name = AppName, Actor = User, AppId = AppId }));
// Assert.Equal(AppName, app.Snapshot.Name);
// app.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppCreated { Name = AppName }),
// CreateEvent(new AppContributorAssigned { ContributorId = User.Identifier, Permission = AppContributorPermission.Owner }),
// CreateEvent(new AppLanguageAdded { Language = Language.EN }),
// CreateEvent(new AppPatternAdded { PatternId = id1, Name = "Number", Pattern = "[0-9]" }),
// CreateEvent(new AppPatternAdded { PatternId = id2, Name = "Numbers", Pattern = "[0-9]*" })
// );
// }
// [Fact]
// public void ChangePlan_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = planId }));
// });
// }
// [Fact]
// public void ChangePlan_should_create_events()
// {
// CreateApp();
// sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = planId }));
// Assert.Equal(planId, sut.Snapshot.Plan.PlanId);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppPlanChanged { PlanId = planId })
// );
// }
// [Fact]
// public void AssignContributor_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId }));
// });
// }
// [Fact]
// public void AssignContributor_should_create_events()
// {
// CreateApp();
// sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor }));
// Assert.Equal(AppContributorPermission.Editor, sut.Snapshot.Contributors[contributorId]);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppContributorAssigned { ContributorId = contributorId, Permission = AppContributorPermission.Editor })
// );
// }
// [Fact]
// public void RemoveContributor_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.RemoveContributor(CreateCommand(new RemoveContributor { ContributorId = contributorId }));
// });
// }
// [Fact]
// public void RemoveContributor_should_create_events_and_remove_contributor()
// {
// CreateApp();
// sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor }));
// sut.RemoveContributor(CreateCommand(new RemoveContributor { ContributorId = contributorId }));
// Assert.False(sut.Snapshot.Contributors.ContainsKey(contributorId));
// sut.GetUncomittedEvents().Skip(1)
// .ShouldHaveSameEvents(
// CreateEvent(new AppContributorRemoved { ContributorId = contributorId })
// );
// }
// [Fact]
// public void AttachClient_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.AttachClient(CreateCommand(new AttachClient { Id = clientId }));
// });
// }
// [Fact]
// public void AttachClient_should_create_events()
// {
// var command = new AttachClient { Id = clientId };
// CreateApp();
// sut.AttachClient(CreateCommand(command));
// Assert.True(sut.Snapshot.Clients.ContainsKey(clientId));
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppClientAttached { Id = clientId, Secret = command.Secret })
// );
// }
// [Fact]
// public void RevokeClient_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.RevokeClient(CreateCommand(new RevokeClient { Id = "not-found" }));
// });
// }
// [Fact]
// public void RevokeClient_should_create_events()
// {
// CreateApp();
// CreateClient();
// sut.RevokeClient(CreateCommand(new RevokeClient { Id = clientId }));
// Assert.False(sut.Snapshot.Clients.ContainsKey(clientId));
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppClientRevoked { Id = clientId })
// );
// }
// [Fact]
// public void UpdateClient_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.UpdateClient(CreateCommand(new UpdateClient { Id = "not-found", Name = clientNewName }));
// });
// }
// [Fact]
// public void UpdateClient_should_create_events()
// {
// CreateApp();
// CreateClient();
// sut.UpdateClient(CreateCommand(new UpdateClient { Id = clientId, Name = clientNewName, Permission = AppClientPermission.Developer }));
// Assert.Equal(clientNewName, sut.Snapshot.Clients[clientId].Name);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppClientRenamed { Id = clientId, Name = clientNewName }),
// CreateEvent(new AppClientUpdated { Id = clientId, Permission = AppClientPermission.Developer })
// );
// }
// [Fact]
// public void AddLanguage_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.AddLanguage(CreateCommand(new AddLanguage { Language = Language.DE }));
// });
// }
// [Fact]
// public void AddLanguage_should_create_events()
// {
// CreateApp();
// sut.AddLanguage(CreateCommand(new AddLanguage { Language = Language.DE }));
// Assert.True(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppLanguageAdded { Language = Language.DE })
// );
// }
// [Fact]
// public void RemoveLanguage_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.RemoveLanguage(CreateCommand(new RemoveLanguage { Language = Language.EN }));
// });
// }
// [Fact]
// public void RemoveLanguage_should_create_events()
// {
// CreateApp();
// CreateLanguage(Language.DE);
// sut.RemoveLanguage(CreateCommand(new RemoveLanguage { Language = Language.DE }));
// Assert.False(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppLanguageRemoved { Language = Language.DE })
// );
// }
// [Fact]
// public void UpdateLanguage_should_throw_exception_if_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.UpdateLanguage(CreateCommand(new UpdateLanguage { Language = Language.EN }));
// });
// }
// [Fact]
// public void UpdateLanguage_should_create_events()
// {
// CreateApp();
// CreateLanguage(Language.DE);
// sut.UpdateLanguage(CreateCommand(new UpdateLanguage { Language = Language.DE, Fallback = new List<Language> { Language.EN } }));
// Assert.True(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppLanguageUpdated { Language = Language.DE, Fallback = new List<Language> { Language.EN } })
// );
// }
// [Fact]
// public void AddPattern_should_throw_exception_if_app_not_created()
// {
// Assert.Throws<DomainException>(() => sut.AddPattern(CreateCommand(new AddPattern { PatternId = patternId, Name = "Any", Pattern = ".*" })));
// }
// [Fact]
// public void AddPattern_should_create_events()
// {
// CreateApp();
// sut.AddPattern(CreateCommand(new AddPattern { PatternId = patternId, Name = "Any", Pattern = ".*", Message = "Msg" }));
// Assert.Single(sut.Snapshot.Patterns);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppPatternAdded { PatternId = patternId, Name = "Any", Pattern = ".*", Message = "Msg" })
// );
// }
// [Fact]
// public void DeletePattern_should_throw_exception_if_app_not_created()
// {
// Assert.Throws<DomainException>(() =>
// {
// sut.DeletePattern(CreateCommand(new DeletePattern
// {
// PatternId = Guid.NewGuid()
// }));
// });
// }
// [Fact]
// public void DeletePattern_should_create_events()
// {
// CreateApp();
// CreatePattern();
// sut.DeletePattern(CreateCommand(new DeletePattern { PatternId = patternId }));
// Assert.Empty(sut.Snapshot.Patterns);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppPatternDeleted { PatternId = patternId })
// );
// }
// [Fact]
// public void UpdatePattern_should_throw_exception_if_app_not_created()
// {
// Assert.Throws<DomainException>(() => sut.UpdatePattern(CreateCommand(new UpdatePattern { PatternId = patternId, Name = "Any", Pattern = ".*" })));
// }
// [Fact]
// public void UpdatePattern_should_create_events()
// {
// CreateApp();
// CreatePattern();
// sut.UpdatePattern(CreateCommand(new UpdatePattern { PatternId = patternId, Name = "Any", Pattern = ".*", Message = "Msg" }));
// Assert.Single(sut.Snapshot.Patterns);
// sut.GetUncomittedEvents()
// .ShouldHaveSameEvents(
// CreateEvent(new AppPatternUpdated { PatternId = patternId, Name = "Any", Pattern = ".*", Message = "Msg" })
// );
// }
// private void CreatePattern()
// {
// sut.AddPattern(CreateCommand(new AddPattern { PatternId = patternId, Name = "Name", Pattern = ".*" }));
// sut.ClearUncommittedEvents();
// }
// private void CreateApp()
// {
// sut.Create(CreateCommand(new CreateApp { Name = AppName }));
// sut.ClearUncommittedEvents();
// }
// private void CreateClient()
// {
// sut.AttachClient(CreateCommand(new AttachClient { Id = clientId }));
// sut.ClearUncommittedEvents();
// }
// private void CreateLanguage(Language language)
// {
// sut.AddLanguage(CreateCommand(new AddLanguage { Language = language }));
// sut.ClearUncommittedEvents();
// }
// }
//}

407
tests/Squidex.Domain.Apps.Entities.Tests/Apps/AppGrainTests.cs

@ -0,0 +1,407 @@
// ==========================================================================
// Squidex Headless CMS
// ==========================================================================
// Copyright (c) Squidex UG (haftungsbeschränkt)
// All rights reserved. Licensed under the MIT license.
// ==========================================================================
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using FakeItEasy;
using Orleans.Core;
using Orleans.Runtime;
using Squidex.Domain.Apps.Core.Apps;
using Squidex.Domain.Apps.Entities.Apps.Commands;
using Squidex.Domain.Apps.Entities.Apps.Services;
using Squidex.Domain.Apps.Entities.Apps.State;
using Squidex.Domain.Apps.Entities.TestHelpers;
using Squidex.Domain.Apps.Events.Apps;
using Squidex.Infrastructure;
using Squidex.Infrastructure.Commands;
using Squidex.Infrastructure.States;
using Squidex.Shared.Users;
using Xunit;
namespace Squidex.Domain.Apps.Entities.Apps
{
public class AppGrainTests : HandlerTestBase<AppGrain, AppState>
{
private readonly IAppProvider appProvider = A.Fake<IAppProvider>();
private readonly IAppPlansProvider appPlansProvider = A.Fake<IAppPlansProvider>();
private readonly IAppPlanBillingManager appPlansBillingManager = A.Fake<IAppPlanBillingManager>();
private readonly IUserResolver userResolver = A.Fake<IUserResolver>();
private readonly string contributorId = Guid.NewGuid().ToString();
private readonly string clientId = "client";
private readonly string clientNewName = "My Client";
private readonly string planId = "premium";
private readonly AppGrain sut;
private readonly Guid patternId1 = Guid.NewGuid();
private readonly Guid patternId2 = Guid.NewGuid();
private readonly Guid patternId3 = Guid.NewGuid();
private readonly InitialPatterns initialPatterns;
public class MyAppGrain : AppGrain
{
public MyAppGrain(
InitialPatterns initialPatterns,
IStore<Guid> store,
IAppProvider appProvider,
IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager,
IUserResolver userResolver,
IGrainIdentity identity,
IGrainRuntime runtime)
: base(initialPatterns, store, appProvider, appPlansProvider, appPlansBillingManager, userResolver, identity, runtime)
{
}
}
protected override Guid Id
{
get { return AppId; }
}
public AppGrainTests()
{
A.CallTo(() => appProvider.GetAppAsync(AppName))
.Returns((IAppEntity)null);
A.CallTo(() => userResolver.FindByIdAsync(contributorId))
.Returns(A.Fake<IUser>());
initialPatterns = new InitialPatterns
{
{ patternId1, new AppPattern("Number", "[0-9]") },
{ patternId2, new AppPattern("Numbers", "[0-9]*") }
};
sut = new MyAppGrain(initialPatterns, Store, appProvider, appPlansProvider, appPlansBillingManager, userResolver, Identity, Runtime);
sut.OnActivateAsync();
}
[Fact]
public async Task Create_should_create_events_and_update_state()
{
var command = new CreateApp { Name = AppName, Actor = User, AppId = AppId };
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 4));
Assert.Equal(AppName, sut.Snapshot.Name);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppCreated { Name = AppName }),
CreateEvent(new AppContributorAssigned { ContributorId = User.Identifier, Permission = AppContributorPermission.Owner }),
CreateEvent(new AppLanguageAdded { Language = Language.EN }),
CreateEvent(new AppPatternAdded { PatternId = patternId1, Name = "Number", Pattern = "[0-9]" }),
CreateEvent(new AppPatternAdded { PatternId = patternId2, Name = "Numbers", Pattern = "[0-9]*" })
);
}
[Fact]
public async Task ChangePlan_should_create_events_and_update_state()
{
var command = new ChangePlan { PlanId = planId };
A.CallTo(() => appPlansProvider.IsConfiguredPlan(planId))
.Returns(true);
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, planId))
.Returns(new PlanChangedResult());
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
Assert.True(result.Value is PlanChangedResult);
Assert.Equal(planId, sut.Snapshot.Plan.PlanId);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppPlanChanged { PlanId = planId })
);
}
[Fact]
public async Task ChangePlan_should_not_make_update_for_redirect_result()
{
var command = new ChangePlan { PlanId = planId };
A.CallTo(() => appPlansProvider.IsConfiguredPlan(planId))
.Returns(true);
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, planId))
.Returns(new RedirectToCheckoutResult(new Uri("http://squidex.io")));
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new RedirectToCheckoutResult(new Uri("http://squidex.io")));
Assert.Null(sut.Snapshot.Plan);
}
[Fact]
public async Task ChangePlan_should_not_call_billing_manager_for_callback()
{
var command = new ChangePlan { PlanId = planId, FromCallback = true };
A.CallTo(() => appPlansProvider.IsConfiguredPlan(planId))
.Returns(true);
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(5));
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, planId))
.MustNotHaveHappened();
}
[Fact]
public async Task AssignContributor_should_create_events_and_update_state()
{
var command = new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor };
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(5));
Assert.Equal(AppContributorPermission.Editor, sut.Snapshot.Contributors[contributorId]);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppContributorAssigned { ContributorId = contributorId, Permission = AppContributorPermission.Editor })
);
}
[Fact]
public async Task RemoveContributor_should_create_events_and_update_state()
{
var command = new RemoveContributor { ContributorId = contributorId };
await ExecuteCreateAsync();
await ExecuteAssignContributorAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
Assert.False(sut.Snapshot.Contributors.ContainsKey(contributorId));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppContributorRemoved { ContributorId = contributorId })
);
}
[Fact]
public async Task AttachClient_should_create_events_and_update_state()
{
var command = new AttachClient { Id = clientId };
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(5));
Assert.True(sut.Snapshot.Clients.ContainsKey(clientId));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppClientAttached { Id = clientId, Secret = command.Secret })
);
}
[Fact]
public async Task RevokeClient_should_create_events_and_update_state()
{
var command = new RevokeClient { Id = clientId };
await ExecuteCreateAsync();
await ExecuteAttachClientAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
Assert.False(sut.Snapshot.Clients.ContainsKey(clientId));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppClientRevoked { Id = clientId })
);
}
[Fact]
public async Task UpdateClient_should_create_events_and_update_state()
{
var command = new UpdateClient { Id = clientId, Name = clientNewName, Permission = AppClientPermission.Developer };
await ExecuteCreateAsync();
await ExecuteAttachClientAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(7));
Assert.Equal(clientNewName, sut.Snapshot.Clients[clientId].Name);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppClientRenamed { Id = clientId, Name = clientNewName }),
CreateEvent(new AppClientUpdated { Id = clientId, Permission = AppClientPermission.Developer })
);
}
[Fact]
public async Task AddLanguage_should_create_events_and_update_state()
{
var command = new AddLanguage { Language = Language.DE };
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(5));
Assert.True(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppLanguageAdded { Language = Language.DE })
);
}
[Fact]
public async Task RemoveLanguage_should_create_events_and_update_state()
{
var command = new RemoveLanguage { Language = Language.DE };
await ExecuteCreateAsync();
await ExecuteAddLanguageAsync(Language.DE);
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
Assert.False(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppLanguageRemoved { Language = Language.DE })
);
}
[Fact]
public async Task UpdateLanguage_should_create_events_and_update_state()
{
var command = new UpdateLanguage { Language = Language.DE, Fallback = new List<Language> { Language.EN } };
await ExecuteCreateAsync();
await ExecuteAddLanguageAsync(Language.DE);
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
Assert.True(sut.Snapshot.LanguagesConfig.Contains(Language.DE));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppLanguageUpdated { Language = Language.DE, Fallback = new List<Language> { Language.EN } })
);
}
[Fact]
public async Task AddPattern_should_create_events_and_update_state()
{
var command = new AddPattern { PatternId = patternId3, Name = "Any", Pattern = ".*", Message = "Msg" };
await ExecuteCreateAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(5));
Assert.Equal(initialPatterns.Count + 1, sut.Snapshot.Patterns.Count);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppPatternAdded { PatternId = patternId3, Name = "Any", Pattern = ".*", Message = "Msg" })
);
}
[Fact]
public async Task DeletePattern_should_create_events_and_update_state()
{
var command = new DeletePattern { PatternId = patternId3 };
await ExecuteCreateAsync();
await ExecuteAddPatternAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
Assert.Equal(initialPatterns.Count, sut.Snapshot.Patterns.Count);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppPatternDeleted { PatternId = patternId3 })
);
}
[Fact]
public async Task UpdatePattern_should_create_events_and_update_state()
{
var command = new UpdatePattern { PatternId = patternId3, Name = "Any", Pattern = ".*", Message = "Msg" };
await ExecuteCreateAsync();
await ExecuteAddPatternAsync();
var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquivalent(new EntitySavedResult(6));
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new AppPatternUpdated { PatternId = patternId3, Name = "Any", Pattern = ".*", Message = "Msg" })
);
}
private Task ExecuteAddPatternAsync()
{
return sut.ExecuteAsync(J(CreateCommand(new AddPattern { PatternId = patternId3, Name = "Name", Pattern = ".*" })));
}
private Task ExecuteCreateAsync()
{
return sut.ExecuteAsync(J(CreateCommand(new CreateApp { Name = AppName })));
}
private Task ExecuteAssignContributorAsync()
{
return sut.ExecuteAsync(J(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor })));
}
private Task ExecuteAttachClientAsync()
{
return sut.ExecuteAsync(J(CreateCommand(new AttachClient { Id = clientId })));
}
private Task ExecuteAddLanguageAsync(Language language)
{
return sut.ExecuteAsync(J(CreateCommand(new AddLanguage { Language = language })));
}
}
}

2
tests/Squidex.Domain.Apps.Entities.Tests/Apps/NoopAppPlanBillingManagerTests.cs → tests/Squidex.Domain.Apps.Entities.Tests/Apps/Billing/NoopAppPlanBillingManagerTests.cs

@ -10,7 +10,7 @@ using System.Threading.Tasks;
using Squidex.Domain.Apps.Entities.Apps.Services.Implementations; using Squidex.Domain.Apps.Entities.Apps.Services.Implementations;
using Xunit; using Xunit;
namespace Squidex.Domain.Apps.Entities.Apps namespace Squidex.Domain.Apps.Entities.Apps.Billing
{ {
public class NoopAppPlanBillingManagerTests public class NoopAppPlanBillingManagerTests
{ {

9
tests/Squidex.Domain.Apps.Entities.Tests/Assets/AssetGrainTests.cs

@ -8,7 +8,6 @@
using System; using System;
using System.IO; using System.IO;
using System.Threading.Tasks; using System.Threading.Tasks;
using FakeItEasy;
using Orleans.Core; using Orleans.Core;
using Orleans.Runtime; using Orleans.Runtime;
using Squidex.Domain.Apps.Entities.Assets.Commands; using Squidex.Domain.Apps.Entities.Assets.Commands;
@ -65,7 +64,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
var result = await sut.ExecuteAsync(J(CreateAssetCommand(command))); var result = await sut.ExecuteAsync(J(CreateAssetCommand(command)));
result.ShouldBeEquaivalent(new AssetSavedResult(0, 0)); result.ShouldBeEquivalent(new AssetSavedResult(0, 0));
Assert.Equal(0, sut.Snapshot.FileVersion); Assert.Equal(0, sut.Snapshot.FileVersion);
@ -93,7 +92,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
var result = await sut.ExecuteAsync(J(CreateAssetCommand(command))); var result = await sut.ExecuteAsync(J(CreateAssetCommand(command)));
result.ShouldBeEquaivalent(new AssetSavedResult(1, 1)); result.ShouldBeEquivalent(new AssetSavedResult(1, 1));
Assert.Equal(1, sut.Snapshot.FileVersion); Assert.Equal(1, sut.Snapshot.FileVersion);
@ -120,7 +119,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
var result = await sut.ExecuteAsync(J(CreateAssetCommand(command))); var result = await sut.ExecuteAsync(J(CreateAssetCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.Equal("my-new-image.png", sut.Snapshot.FileName); Assert.Equal("my-new-image.png", sut.Snapshot.FileName);
@ -140,7 +139,7 @@ namespace Squidex.Domain.Apps.Entities.Assets
var result = await sut.ExecuteAsync(J(CreateAssetCommand(command))); var result = await sut.ExecuteAsync(J(CreateAssetCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.True(sut.Snapshot.IsDeleted); Assert.True(sut.Snapshot.IsDeleted);

10
tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleGrainTests.cs

@ -65,7 +65,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
var result = await sut.ExecuteAsync(J(CreateRuleCommand(command))); var result = await sut.ExecuteAsync(J(CreateRuleCommand(command)));
result.ShouldBeEquaivalent(EntityCreatedResult.Create(Id, 0)); result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 0));
Assert.Equal(AppId, sut.Snapshot.AppId.Id); Assert.Equal(AppId, sut.Snapshot.AppId.Id);
@ -87,7 +87,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
var result = await sut.ExecuteAsync(J(CreateRuleCommand(command))); var result = await sut.ExecuteAsync(J(CreateRuleCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.Same(command.Trigger, sut.Snapshot.RuleDef.Trigger); Assert.Same(command.Trigger, sut.Snapshot.RuleDef.Trigger);
Assert.Same(command.Action, sut.Snapshot.RuleDef.Action); Assert.Same(command.Action, sut.Snapshot.RuleDef.Action);
@ -115,7 +115,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
var result = await sut.ExecuteAsync(J(CreateRuleCommand(command))); var result = await sut.ExecuteAsync(J(CreateRuleCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.True(sut.Snapshot.RuleDef.IsEnabled); Assert.True(sut.Snapshot.RuleDef.IsEnabled);
@ -134,7 +134,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
var result = await sut.ExecuteAsync(J(CreateRuleCommand(command))); var result = await sut.ExecuteAsync(J(CreateRuleCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.False(sut.Snapshot.RuleDef.IsEnabled); Assert.False(sut.Snapshot.RuleDef.IsEnabled);
@ -153,7 +153,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
var result = await sut.ExecuteAsync(J(CreateRuleCommand(command))); var result = await sut.ExecuteAsync(J(CreateRuleCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.True(sut.Snapshot.IsDeleted); Assert.True(sut.Snapshot.IsDeleted);

32
tests/Squidex.Domain.Apps.Entities.Tests/Schemas/SchemaGrainTests.cs

@ -74,7 +74,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(EntityCreatedResult.Create(Id, 0)); result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 0));
Assert.Equal(AppId, sut.Snapshot.AppId.Id); Assert.Equal(AppId, sut.Snapshot.AppId.Id);
@ -102,7 +102,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(EntityCreatedResult.Create(Id, 0)); result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 0));
var @event = (SchemaCreated)LastEvents.Single().Payload; var @event = (SchemaCreated)LastEvents.Single().Payload;
@ -122,7 +122,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.Properties); Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.Properties);
@ -148,7 +148,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
LastEvents LastEvents
.ShouldHaveSameEvents( .ShouldHaveSameEvents(
@ -174,7 +174,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(3)); result.ShouldBeEquivalent(new EntitySavedResult(3));
LastEvents LastEvents
.ShouldHaveSameEvents( .ShouldHaveSameEvents(
@ -191,7 +191,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.True(sut.Snapshot.SchemaDef.IsPublished); Assert.True(sut.Snapshot.SchemaDef.IsPublished);
@ -211,7 +211,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.False(sut.Snapshot.SchemaDef.IsPublished); Assert.False(sut.Snapshot.SchemaDef.IsPublished);
@ -230,7 +230,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(1)); result.ShouldBeEquivalent(new EntitySavedResult(1));
Assert.True(sut.Snapshot.IsDeleted); Assert.True(sut.Snapshot.IsDeleted);
@ -249,7 +249,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(EntityCreatedResult.Create(1, 1)); result.ShouldBeEquivalent(EntityCreatedResult.Create(1, 1));
Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.FieldsById[1].RawProperties); Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.FieldsById[1].RawProperties);
@ -269,7 +269,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.FieldsById[1].RawProperties); Assert.Equal(command.Properties, sut.Snapshot.SchemaDef.FieldsById[1].RawProperties);
@ -289,7 +289,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled); Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled);
@ -309,7 +309,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.True(sut.Snapshot.SchemaDef.FieldsById[1].IsHidden); Assert.True(sut.Snapshot.SchemaDef.FieldsById[1].IsHidden);
@ -330,7 +330,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(3)); result.ShouldBeEquivalent(new EntitySavedResult(3));
Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsHidden); Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsHidden);
@ -350,7 +350,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.True(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled); Assert.True(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled);
@ -371,7 +371,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(3)); result.ShouldBeEquivalent(new EntitySavedResult(3));
Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled); Assert.False(sut.Snapshot.SchemaDef.FieldsById[1].IsDisabled);
@ -391,7 +391,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas
var result = await sut.ExecuteAsync(J(CreateCommand(command))); var result = await sut.ExecuteAsync(J(CreateCommand(command)));
result.ShouldBeEquaivalent(new EntitySavedResult(2)); result.ShouldBeEquivalent(new EntitySavedResult(2));
Assert.False(sut.Snapshot.SchemaDef.FieldsById.ContainsKey(1)); Assert.False(sut.Snapshot.SchemaDef.FieldsById.ContainsKey(1));

2
tests/Squidex.Domain.Apps.Entities.Tests/TestHelpers/AssertHelper.cs

@ -42,7 +42,7 @@ namespace Squidex.Domain.Apps.Entities.TestHelpers
lhs.Should().BeOfType(rhs.GetType()); lhs.Should().BeOfType(rhs.GetType());
} }
public static void ShouldBeEquaivalent(this J<object> result, object value) public static void ShouldBeEquivalent(this J<object> result, object value)
{ {
result.Value.ShouldBeEquivalentTo(value, o => o.IncludingAllDeclaredProperties()); result.Value.ShouldBeEquivalentTo(value, o => o.IncludingAllDeclaredProperties());
} }

Loading…
Cancel
Save