mirror of https://github.com/Squidex/squidex.git
Sebastian Stehle
8 years ago
76 changed files with 1399 additions and 3933 deletions
@ -0,0 +1,27 @@ |
|||
// ==========================================================================
|
|||
// PartitioningExtensions.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
|
|||
namespace Squidex.Domain.Apps.Core |
|||
{ |
|||
public static class PartitioningExtensions |
|||
{ |
|||
private static readonly HashSet<string> AllowedPartitions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) |
|||
{ |
|||
Partitioning.Language.Key, |
|||
Partitioning.Invariant.Key |
|||
}; |
|||
|
|||
public static bool IsValidPartitioning(this string value) |
|||
{ |
|||
return value == null || AllowedPartitions.Contains(value); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,72 @@ |
|||
// ==========================================================================
|
|||
// MongoAppRepository_EventHandling.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
|
|||
namespace Squidex.Domain.Apps.Events.Apps.Utils |
|||
{ |
|||
public static class AppEventDispatcher |
|||
{ |
|||
public static void Apply(this AppContributors contributors, AppContributorRemoved @event) |
|||
{ |
|||
contributors.Remove(@event.ContributorId); |
|||
} |
|||
|
|||
public static void Apply(this AppContributors contributors, AppContributorAssigned @event) |
|||
{ |
|||
contributors.Assign(@event.ContributorId, @event.Permission); |
|||
} |
|||
|
|||
public static void Apply(this LanguagesConfig languagesConfig, AppLanguageAdded @event) |
|||
{ |
|||
languagesConfig.Set(new LanguageConfig(@event.Language)); |
|||
} |
|||
|
|||
public static void Apply(this LanguagesConfig languagesConfig, AppLanguageRemoved @event) |
|||
{ |
|||
languagesConfig.Remove(@event.Language); |
|||
} |
|||
|
|||
public static void Apply(this AppClients clients, AppClientAttached @event) |
|||
{ |
|||
clients.Add(@event.Id, @event.Secret); |
|||
} |
|||
|
|||
public static void Apply(this AppClients clients, AppClientRevoked @event) |
|||
{ |
|||
clients.Revoke(@event.Id); |
|||
} |
|||
|
|||
public static void Apply(this AppClients clients, AppClientRenamed @event) |
|||
{ |
|||
if (clients.Clients.TryGetValue(@event.Id, out var client)) |
|||
{ |
|||
client.Rename(@event.Name); |
|||
} |
|||
} |
|||
|
|||
public static void Apply(this AppClients clients, AppClientUpdated @event) |
|||
{ |
|||
if (clients.Clients.TryGetValue(@event.Id, out var client)) |
|||
{ |
|||
client.Update(@event.Permission); |
|||
} |
|||
} |
|||
|
|||
public static void Apply(this LanguagesConfig languagesConfig, AppLanguageUpdated @event) |
|||
{ |
|||
languagesConfig.Set(new LanguageConfig(@event.Language, @event.IsOptional, @event.Fallback)); |
|||
|
|||
if (@event.IsMaster) |
|||
{ |
|||
languagesConfig.MakeMaster(@event.Language); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,43 +0,0 @@ |
|||
// ==========================================================================
|
|||
// MongoAppEntityClient.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using MongoDB.Bson.Serialization.Attributes; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Read.Apps; |
|||
|
|||
namespace Squidex.Domain.Apps.Read.MongoDb.Apps |
|||
{ |
|||
public sealed class MongoAppEntityClient : IAppClientEntity |
|||
{ |
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public string Id { get; set; } |
|||
|
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public string Secret { get; set; } |
|||
|
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public string Name { get; set; } |
|||
|
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public AppClientPermission Permission { get; set; } |
|||
|
|||
string IAppClientEntity.Name |
|||
{ |
|||
get { return !string.IsNullOrWhiteSpace(Name) ? Name : Id; } |
|||
} |
|||
|
|||
public MongoAppEntityClient() |
|||
{ |
|||
Permission = AppClientPermission.Editor; |
|||
} |
|||
} |
|||
} |
|||
@ -1,21 +0,0 @@ |
|||
// ==========================================================================
|
|||
// MongoAppEntityContributor.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using MongoDB.Bson.Serialization.Attributes; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Read.Apps; |
|||
|
|||
namespace Squidex.Domain.Apps.Read.MongoDb.Apps |
|||
{ |
|||
public sealed class MongoAppEntityContributor : IAppContributorEntity |
|||
{ |
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public AppContributorPermission Permission { get; set; } |
|||
} |
|||
} |
|||
@ -1,28 +0,0 @@ |
|||
// ==========================================================================
|
|||
// MongoAppEntityLanguage.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Collections.Generic; |
|||
using MongoDB.Bson.Serialization.Attributes; |
|||
|
|||
namespace Squidex.Domain.Apps.Read.MongoDb.Apps |
|||
{ |
|||
public sealed class MongoAppEntityLanguage |
|||
{ |
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public string Iso2Code { get; set; } |
|||
|
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public bool IsOptional { get; set; } |
|||
|
|||
[BsonRequired] |
|||
[BsonElement] |
|||
public List<string> Fallback { get; set; } |
|||
} |
|||
} |
|||
@ -1,56 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppClient.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public sealed class AppClient |
|||
{ |
|||
private readonly string name; |
|||
private readonly string secret; |
|||
private readonly AppClientPermission permission; |
|||
|
|||
public AppClient(string secret, string name, AppClientPermission permission) |
|||
{ |
|||
Guard.NotNullOrEmpty(name, nameof(name)); |
|||
Guard.NotNullOrEmpty(secret, nameof(secret)); |
|||
Guard.Enum(permission, nameof(permission)); |
|||
|
|||
this.name = name; |
|||
this.secret = secret; |
|||
this.permission = permission; |
|||
} |
|||
|
|||
public AppClient Update(AppClientPermission newPermission, Func<string> message) |
|||
{ |
|||
if (permission == newPermission) |
|||
{ |
|||
var error = new ValidationError("Client has already the permission.", "IsReader"); |
|||
|
|||
throw new ValidationException(message(), error); |
|||
} |
|||
|
|||
return new AppClient(secret, name, newPermission); |
|||
} |
|||
|
|||
public AppClient Rename(string newName, Func<string> message) |
|||
{ |
|||
if (string.Equals(name, newName)) |
|||
{ |
|||
var error = new ValidationError("Client already has the name.", "Id"); |
|||
|
|||
throw new ValidationException(message(), error); |
|||
} |
|||
|
|||
return new AppClient(secret, newName, permission); |
|||
} |
|||
} |
|||
} |
|||
@ -1,66 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppClients.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public class AppClients |
|||
{ |
|||
private readonly Dictionary<string, AppClient> clients = new Dictionary<string, AppClient>(); |
|||
|
|||
public void Add(string id, string secret) |
|||
{ |
|||
ThrowIfFound(id, () => "Cannot add client"); |
|||
|
|||
clients[id] = new AppClient(secret, id, AppClientPermission.Editor); |
|||
} |
|||
|
|||
public void Rename(string clientId, string name) |
|||
{ |
|||
ThrowIfNotFound(clientId); |
|||
|
|||
clients[clientId] = clients[clientId].Rename(name, () => "Cannot rename client"); |
|||
} |
|||
|
|||
public void Update(string clientId, AppClientPermission permission) |
|||
{ |
|||
ThrowIfNotFound(clientId); |
|||
|
|||
clients[clientId] = clients[clientId].Update(permission, () => "Cannot update client"); |
|||
} |
|||
|
|||
public void Revoke(string clientId) |
|||
{ |
|||
ThrowIfNotFound(clientId); |
|||
|
|||
clients.Remove(clientId); |
|||
} |
|||
|
|||
private void ThrowIfNotFound(string clientId) |
|||
{ |
|||
if (!clients.ContainsKey(clientId)) |
|||
{ |
|||
throw new DomainObjectNotFoundException(clientId, "Contributors", typeof(AppDomainObject)); |
|||
} |
|||
} |
|||
|
|||
private void ThrowIfFound(string clientId, Func<string> message) |
|||
{ |
|||
if (clients.ContainsKey(clientId)) |
|||
{ |
|||
var error = new ValidationError("Client id is alreay part of the app.", "Id"); |
|||
|
|||
throw new ValidationException(message(), error); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,78 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppContributors.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public class AppContributors |
|||
{ |
|||
private readonly Dictionary<string, AppContributorPermission> contributors = new Dictionary<string, AppContributorPermission>(); |
|||
|
|||
public int Count |
|||
{ |
|||
get { return contributors.Count; } |
|||
} |
|||
|
|||
public void Assign(string contributorId, AppContributorPermission permission) |
|||
{ |
|||
string Message() => "Cannot assign contributor"; |
|||
|
|||
ThrowIfFound(contributorId, permission, Message); |
|||
ThrowIfNoOwner(c => c[contributorId] = permission, Message); |
|||
|
|||
contributors[contributorId] = permission; |
|||
} |
|||
|
|||
public void Remove(string contributorId) |
|||
{ |
|||
string Message() => "Cannot remove contributor"; |
|||
|
|||
ThrowIfNotFound(contributorId); |
|||
ThrowIfNoOwner(c => c.Remove(contributorId), Message); |
|||
|
|||
contributors.Remove(contributorId); |
|||
} |
|||
|
|||
private void ThrowIfNotFound(string contributorId) |
|||
{ |
|||
if (!contributors.ContainsKey(contributorId)) |
|||
{ |
|||
throw new DomainObjectNotFoundException(contributorId, "Contributors", typeof(AppDomainObject)); |
|||
} |
|||
} |
|||
|
|||
private void ThrowIfFound(string contributorId, AppContributorPermission permission, Func<string> message) |
|||
{ |
|||
if (contributors.TryGetValue(contributorId, out var currentPermission) && currentPermission == permission) |
|||
{ |
|||
var error = new ValidationError("Contributor is already part of the app with same permissions.", "ContributorId"); |
|||
|
|||
throw new ValidationException(message(), error); |
|||
} |
|||
} |
|||
|
|||
private void ThrowIfNoOwner(Action<Dictionary<string, AppContributorPermission>> change, Func<string> message) |
|||
{ |
|||
var contributorsCopy = new Dictionary<string, AppContributorPermission>(contributors); |
|||
|
|||
change(contributorsCopy); |
|||
|
|||
if (contributorsCopy.All(x => x.Value != AppContributorPermission.Owner)) |
|||
{ |
|||
var error = new ValidationError("Contributor is the last owner.", "ContributorId"); |
|||
|
|||
throw new ValidationException(message(), error); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,69 @@ |
|||
// ==========================================================================
|
|||
// GuardContent.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Write.Contents.Commands; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Contents.Guards |
|||
{ |
|||
public static class GuardContent |
|||
{ |
|||
public static void CanCreate(CreateContent command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot created content.", error => |
|||
{ |
|||
if (command.Data == null) |
|||
{ |
|||
error(new ValidationError("Data cannot be null.", nameof(command.Data))); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanCreate(UpdateContent command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot update content.", error => |
|||
{ |
|||
if (command.Data == null) |
|||
{ |
|||
error(new ValidationError("Data cannot be null.", nameof(command.Data))); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanCreate(PatchContent command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot patch content.", error => |
|||
{ |
|||
if (command.Data == null) |
|||
{ |
|||
error(new ValidationError("Data cannot be null.", nameof(command.Data))); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanChangeStatus(Status status, ChangeContentStatus command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot change status.", error => |
|||
{ |
|||
if (!StatusFlow.Exists(command.Status) || !StatusFlow.CanChange(status, command.Status)) |
|||
{ |
|||
error(new ValidationError($"Content cannot be changed from status {status} to {command.Status}.", nameof(command.Status))); |
|||
} |
|||
}); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,130 @@ |
|||
// ==========================================================================
|
|||
// GuardSchema.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Linq; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Read.Schemas.Services; |
|||
using Squidex.Domain.Apps.Write.Schemas.Commands; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public static class GuardSchema |
|||
{ |
|||
public static Task CanCreate(CreateSchema command, ISchemaProvider schemas) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
return Validate.It(() => "Cannot create schema.", async error => |
|||
{ |
|||
if (!command.Name.IsSlug()) |
|||
{ |
|||
error(new ValidationError("Name must be a valid slug.", nameof(command.Name))); |
|||
} |
|||
|
|||
if (await schemas.FindSchemaByNameAsync(command.AppId.Id, command.Name) != null) |
|||
{ |
|||
error(new ValidationError($"A schema with name '{command.Name}' already exists", nameof(command.Name))); |
|||
} |
|||
|
|||
if (command.Fields != null && command.Fields.Any()) |
|||
{ |
|||
var index = 0; |
|||
|
|||
foreach (var field in command.Fields) |
|||
{ |
|||
var prefix = $"Fields.{index}"; |
|||
|
|||
if (!field.Partitioning.IsValidPartitioning()) |
|||
{ |
|||
error(new ValidationError("Partitioning is not valid.", $"{prefix}.{nameof(field.Partitioning)}")); |
|||
} |
|||
|
|||
if (!field.Name.IsPropertyName()) |
|||
{ |
|||
error(new ValidationError("Name must be a valid property name.", $"{prefix}.{nameof(field.Name)}")); |
|||
} |
|||
|
|||
if (field.Properties == null) |
|||
{ |
|||
error(new ValidationError("Properties must be defined.", $"{prefix}.{nameof(field.Properties)}")); |
|||
} |
|||
|
|||
var propertyErrors = FieldPropertiesValidator.Validate(field.Properties); |
|||
|
|||
foreach (var propertyError in propertyErrors) |
|||
{ |
|||
error(propertyError); |
|||
} |
|||
} |
|||
|
|||
if (command.Fields.Select(x => x.Name).Distinct().Count() != command.Fields.Count) |
|||
{ |
|||
error(new ValidationError("Fields cannot have duplicate names.", nameof(command.Fields))); |
|||
} |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanReorder(Schema schema, ReorderFields command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot reorder schema fields.", error => |
|||
{ |
|||
if (command.FieldIds == null) |
|||
{ |
|||
error(new ValidationError("Field ids must be specified.", nameof(command.FieldIds))); |
|||
} |
|||
|
|||
if (command.FieldIds.Count != schema.Fields.Count || command.FieldIds.Any(x => !schema.FieldsById.ContainsKey(x))) |
|||
{ |
|||
error(new ValidationError("Ids must cover all fields.", nameof(command.FieldIds))); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanPublish(Schema schema, PublishSchema command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
if (schema.IsPublished) |
|||
{ |
|||
throw new DomainException("Schema is already published."); |
|||
} |
|||
} |
|||
|
|||
public static void CanUnpublish(Schema schema, UnpublishSchema command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
if (!schema.IsPublished) |
|||
{ |
|||
throw new DomainException("Schema is not published."); |
|||
} |
|||
} |
|||
|
|||
public static void CanUpdate(Schema schema, UpdateSchema command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
} |
|||
|
|||
public static void CanConfigureScripts(Schema schema, ConfigureScripts command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
} |
|||
|
|||
public static void CanDelete(Schema schema, DeleteSchema command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,160 @@ |
|||
// ==========================================================================
|
|||
// SchemaFieldGuard.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Write.Schemas.Commands; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public static class GuardSchemaField |
|||
{ |
|||
public static void CanAdd(Schema schema, AddField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot add a new field.", error => |
|||
{ |
|||
if (!command.Partitioning.IsValidPartitioning()) |
|||
{ |
|||
error(new ValidationError("Partitioning is not valid.", nameof(command.Partitioning))); |
|||
} |
|||
|
|||
if (!command.Name.IsPropertyName()) |
|||
{ |
|||
error(new ValidationError("Name must be a valid property name.", nameof(command.Name))); |
|||
} |
|||
|
|||
if (command.Properties == null) |
|||
{ |
|||
error(new ValidationError("Properties must be defined.", nameof(command.Properties))); |
|||
} |
|||
|
|||
var propertyErrors = FieldPropertiesValidator.Validate(command.Properties); |
|||
|
|||
foreach (var propertyError in propertyErrors) |
|||
{ |
|||
error(propertyError); |
|||
} |
|||
|
|||
if (schema.FieldsByName.ContainsKey(command.Name)) |
|||
{ |
|||
error(new ValidationError($"There is already a field with name '{command.Name}'", nameof(command.Name))); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public static void CanUpdate(Schema schema, UpdateField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
Validate.It(() => "Cannot update field.", error => |
|||
{ |
|||
if (command.Properties == null) |
|||
{ |
|||
error(new ValidationError("Properties must be defined.", nameof(command.Properties))); |
|||
} |
|||
|
|||
var propertyErrors = FieldPropertiesValidator.Validate(command.Properties); |
|||
|
|||
foreach (var propertyError in propertyErrors) |
|||
{ |
|||
error(propertyError); |
|||
} |
|||
}); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is already locked."); |
|||
} |
|||
} |
|||
|
|||
public static void CanDelete(Schema schema, DeleteField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is locked."); |
|||
} |
|||
} |
|||
|
|||
public static void CanHide(Schema schema, HideField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (field.IsHidden) |
|||
{ |
|||
throw new DomainException("Schema field is already hidden."); |
|||
} |
|||
} |
|||
|
|||
public static void CanShow(Schema schema, ShowField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (!field.IsHidden) |
|||
{ |
|||
throw new DomainException("Schema field is already visible."); |
|||
} |
|||
} |
|||
|
|||
public static void CanDisable(Schema schema, DisableField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (field.IsDisabled) |
|||
{ |
|||
throw new DomainException("Schema field is already disabled."); |
|||
} |
|||
} |
|||
|
|||
public static void CanEnable(Schema schema, EnableField command) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (!field.IsDisabled) |
|||
{ |
|||
throw new DomainException("Schema field is already enabled."); |
|||
} |
|||
} |
|||
|
|||
public static void CanLock(Schema schema, LockField command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
var field = GetFieldOrThrow(schema, command.FieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is already locked."); |
|||
} |
|||
} |
|||
|
|||
private static Field GetFieldOrThrow(Schema schema, long fieldId) |
|||
{ |
|||
if (!schema.FieldsById.TryGetValue(fieldId, out var field)) |
|||
{ |
|||
throw new DomainObjectNotFoundException(fieldId.ToString(), "Fields", typeof(Field)); |
|||
} |
|||
|
|||
return field; |
|||
} |
|||
} |
|||
} |
|||
@ -1,106 +0,0 @@ |
|||
// ==========================================================================
|
|||
// SchemaFieldGuard.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public static class SchemaFieldGuard |
|||
{ |
|||
public static void GuardCanAdd(Schema schema, string name) |
|||
{ |
|||
if (schema.FieldsByName.ContainsKey(name)) |
|||
{ |
|||
var error = new ValidationError($"There is already a field with name '{name}'", "Name"); |
|||
|
|||
throw new ValidationException("Cannot add a new field.", error); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanDelete(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is locked."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanHide(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (field.IsHidden) |
|||
{ |
|||
throw new DomainException("Schema field is already hidden."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanShow(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (!field.IsHidden) |
|||
{ |
|||
throw new DomainException("Schema field is already visible."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanDisable(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (field.IsDisabled) |
|||
{ |
|||
throw new DomainException("Schema field is already disabled."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanEnable(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (!field.IsDisabled) |
|||
{ |
|||
throw new DomainException("Schema field is already enabled."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanLock(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is already locked."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanUpdate(Schema schema, long fieldId) |
|||
{ |
|||
var field = GetFieldOrThrow(schema, fieldId); |
|||
|
|||
if (field.IsLocked) |
|||
{ |
|||
throw new DomainException("Schema field is already locked."); |
|||
} |
|||
} |
|||
|
|||
private static Field GetFieldOrThrow(Schema schema, long fieldId) |
|||
{ |
|||
if (!schema.FieldsById.TryGetValue(fieldId, out var field)) |
|||
{ |
|||
throw new DomainObjectNotFoundException(fieldId.ToString(), "Fields", typeof(Field)); |
|||
} |
|||
|
|||
return field; |
|||
} |
|||
} |
|||
} |
|||
@ -1,44 +0,0 @@ |
|||
// ==========================================================================
|
|||
// SchemaGuard.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public static class SchemaGuard |
|||
{ |
|||
public static void GuardCanReorder(Schema schema, List<long> fieldIds) |
|||
{ |
|||
if (fieldIds.Count != schema.Fields.Count || fieldIds.Any(x => !schema.FieldsById.ContainsKey(x))) |
|||
{ |
|||
var error = new ValidationError("Ids must cover all fields.", "FieldIds"); |
|||
|
|||
throw new ValidationException("Cannot reorder schema fields.", error); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanPublish(Schema schema) |
|||
{ |
|||
if (schema.IsPublished) |
|||
{ |
|||
throw new DomainException("Schema is already published."); |
|||
} |
|||
} |
|||
|
|||
public static void GuardCanUnpublish(Schema schema) |
|||
{ |
|||
if (!schema.IsPublished) |
|||
{ |
|||
throw new DomainException("Schema is not published."); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
// ==========================================================================
|
|||
// GuardWebhook.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Linq; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Read.Schemas.Services; |
|||
using Squidex.Domain.Apps.Write.Webhooks.Commands; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Webhooks.Guards |
|||
{ |
|||
public static class GuardWebhook |
|||
{ |
|||
public static Task CanCreate(CreateWebhook command, ISchemaProvider schemas) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
return Validate.It(() => "Cannot create webhook.", error => ValidateCommandAsync(command, error, schemas)); |
|||
} |
|||
|
|||
public static Task CanUpdate(UpdateWebhook command, ISchemaProvider schemas) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
|
|||
return Validate.It(() => "Cannot update webhook.", error => ValidateCommandAsync(command, error, schemas)); |
|||
} |
|||
|
|||
public static void CanDelete(DeleteWebhook command) |
|||
{ |
|||
Guard.NotNull(command, nameof(command)); |
|||
} |
|||
|
|||
private static async Task ValidateCommandAsync(WebhookEditCommand command, Action<ValidationError> error, ISchemaProvider schemas) |
|||
{ |
|||
if (command.Url == null || !command.Url.IsAbsoluteUri) |
|||
{ |
|||
error(new ValidationError("Url must be specified and absolute.", nameof(command.Url))); |
|||
} |
|||
|
|||
if (command.Schemas == null) |
|||
{ |
|||
error(new ValidationError("Schemas cannot be null.", nameof(command.Schemas))); |
|||
} |
|||
|
|||
var schemaErrors = await Task.WhenAll( |
|||
command.Schemas.Select(async s => |
|||
await schemas.FindSchemaByIdAsync(s.SchemaId) == null |
|||
? new ValidationError($"Schema {s.SchemaId} does not exist.", nameof(command.Schemas)) |
|||
: null)); |
|||
|
|||
foreach (var schemaError in schemaErrors.Where(x => x != null)) |
|||
{ |
|||
error(schemaError); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
// ==========================================================================
|
|||
// RefTokenSerializer.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using MongoDB.Bson; |
|||
using MongoDB.Bson.Serialization; |
|||
using MongoDB.Bson.Serialization.Serializers; |
|||
using Newtonsoft.Json; |
|||
using Newtonsoft.Json.Linq; |
|||
|
|||
namespace Squidex.Infrastructure.MongoDb |
|||
{ |
|||
public class JsonBsonSerializer : ClassSerializerBase<object> |
|||
{ |
|||
private readonly JsonSerializer serializer; |
|||
|
|||
public JsonBsonSerializer(JsonSerializer serializer) |
|||
{ |
|||
Guard.NotNull(serializer, nameof(serializer)); |
|||
|
|||
this.serializer = serializer; |
|||
} |
|||
|
|||
protected override object DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args) |
|||
{ |
|||
return BsonSerializer.Deserialize<BsonDocument>(context.Reader).ToJson().ToObject(args.NominalType, serializer); |
|||
} |
|||
|
|||
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, object value) |
|||
{ |
|||
BsonSerializer.Serialize(context.Writer, JObject.FromObject(value, serializer).ToBson()); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,42 @@ |
|||
// ==========================================================================
|
|||
// TypeNameRegistry.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Squidex.Infrastructure |
|||
{ |
|||
public static class Validate |
|||
{ |
|||
public static void It(Func<string> message, Action<Action<ValidationError>> action) |
|||
{ |
|||
var errors = new List<ValidationError>(); |
|||
|
|||
action(errors.Add); |
|||
|
|||
if (errors.Any()) |
|||
{ |
|||
throw new ValidationException(message(), errors); |
|||
} |
|||
} |
|||
|
|||
public static async Task It(Func<string> message, Func<Action<ValidationError>, Task> action) |
|||
{ |
|||
var errors = new List<ValidationError>(); |
|||
|
|||
await action(errors.Add); |
|||
|
|||
if (errors.Any()) |
|||
{ |
|||
throw new ValidationException(message(), errors); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,330 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppCommandMiddlewareTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Read.Apps; |
|||
using Squidex.Domain.Apps.Read.Apps.Repositories; |
|||
using Squidex.Domain.Apps.Read.Apps.Services; |
|||
using Squidex.Domain.Apps.Read.Apps.Services.Implementations; |
|||
using Squidex.Domain.Apps.Write.Apps.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS.Commands; |
|||
using Squidex.Shared.Users; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public class AppCommandMiddlewareTests : HandlerTestBase<AppDomainObject> |
|||
{ |
|||
private readonly IAppRepository appRepository = A.Fake<IAppRepository>(); |
|||
private readonly IAppPlansProvider appPlansProvider = A.Fake<IAppPlansProvider>(); |
|||
private readonly IAppPlanBillingManager appPlansBillingManager = A.Fake<IAppPlanBillingManager>(); |
|||
private readonly IUserResolver userResolver = A.Fake<IUserResolver>(); |
|||
private readonly AppCommandMiddleware sut; |
|||
private readonly AppDomainObject app; |
|||
private readonly Language language = Language.DE; |
|||
private readonly string contributorId = Guid.NewGuid().ToString(); |
|||
private readonly string clientName = "client"; |
|||
|
|||
public AppCommandMiddlewareTests() |
|||
{ |
|||
app = new AppDomainObject(AppId, -1); |
|||
|
|||
sut = new AppCommandMiddleware(Handler, appRepository, appPlansProvider, appPlansBillingManager, userResolver); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_throw_exception_if_a_name_with_same_name_already_exists() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId }); |
|||
|
|||
A.CallTo(() => appRepository.FindAppAsync(AppName)) |
|||
.Returns(A.Dummy<IAppEntity>()); |
|||
|
|||
await TestCreate(app, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(async () => await sut.HandleAsync(context)); |
|||
}, false); |
|||
|
|||
A.CallTo(() => appRepository.FindAppAsync(AppName)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_create_app_if_name_is_free() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId }); |
|||
|
|||
A.CallTo(() => appRepository.FindAppAsync(AppName)) |
|||
.Returns((IAppEntity)null); |
|||
|
|||
await TestCreate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(AppId, context.Result<EntityCreatedResult<Guid>>().IdOrValue); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AssignContributor_should_throw_exception_if_user_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId }); |
|||
|
|||
A.CallTo(() => userResolver.FindByIdAsync(contributorId)) |
|||
.Returns((IUser)null); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AssignContributor_throw_exception_if_reached_max_contributor_size() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.GetPlan(null)) |
|||
.Returns(new ConfigAppLimitsPlan { MaxContributors = 2 }); |
|||
|
|||
CreateApp() |
|||
.AssignContributor(CreateCommand(new AssignContributor { ContributorId = "1" })) |
|||
.AssignContributor(CreateCommand(new AssignContributor { ContributorId = "2" })); |
|||
|
|||
var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId }); |
|||
|
|||
A.CallTo(() => userResolver.FindByIdAsync(A<string>.Ignored)) |
|||
.Returns(A.Dummy<IUser>()); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AssignContributor_should_throw_exception_if_null_user_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId }); |
|||
|
|||
A.CallTo(() => userResolver.FindByIdAsync(contributorId)) |
|||
.Returns((IUser)null); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AssignContributor_should_assign_if_user_found() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.GetPlan(null)) |
|||
.Returns(new ConfigAppLimitsPlan { MaxContributors = -1 }); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId }); |
|||
|
|||
A.CallTo(() => userResolver.FindByIdAsync(contributorId)) |
|||
.Returns(A.Dummy<IUser>()); |
|||
|
|||
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 ChangePlan_should_throw_if_plan_not_found() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan")) |
|||
.Returns(false); |
|||
|
|||
CreateApp() |
|||
.AttachClient(CreateCommand(new AttachClient { Id = clientName })); |
|||
|
|||
var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[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, app.Id, app.Name, "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, app.Id, app.Name, "my-plan")) |
|||
.Returns(CreateRedirectResult()); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Null(app.PlanId); |
|||
} |
|||
|
|||
[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, app.Id, app.Name, "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); |
|||
}); |
|||
} |
|||
|
|||
private AppDomainObject CreateApp() |
|||
{ |
|||
app.Create(CreateCommand(new CreateApp { Name = AppName })); |
|||
|
|||
return app; |
|||
} |
|||
|
|||
private static Task<IChangePlanResult> CreateRedirectResult() |
|||
{ |
|||
return Task.FromResult<IChangePlanResult>(new RedirectToCheckoutResult(new Uri("http://squidex.io"))); |
|||
} |
|||
} |
|||
} |
|||
@ -1,597 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppDomainObjectTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Events.Apps; |
|||
using Squidex.Domain.Apps.Write.Apps.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public class AppDomainObjectTests : HandlerTestBase<AppDomainObject> |
|||
{ |
|||
private readonly AppDomainObject sut; |
|||
private readonly string contributorId = Guid.NewGuid().ToString(); |
|||
private readonly string clientId = "client"; |
|||
private readonly string clientNewName = "My Client"; |
|||
private readonly string planId = "premium"; |
|||
|
|||
public AppDomainObjectTests() |
|||
{ |
|||
sut = new AppDomainObject(AppId, 0); |
|||
} |
|||
|
|||
[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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Create(CreateCommand(new CreateApp())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_specify_name_and_owner() |
|||
{ |
|||
sut.Create(CreateCommand(new CreateApp { Name = AppName, Actor = User, AppId = AppId })); |
|||
|
|||
Assert.Equal(AppName, sut.Name); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateEvent(new AppCreated { Name = AppName }), |
|||
CreateEvent(new AppContributorAssigned { ContributorId = User.Identifier, Permission = AppContributorPermission.Owner }), |
|||
CreateEvent(new AppLanguageAdded { Language = Language.EN }) |
|||
); |
|||
} |
|||
|
|||
[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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.ChangePlan(CreateCommand(new ChangePlan())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangePlan_should_throw_exception_if_plan_configured_from_other_user() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = "other-plan", Actor = new RefToken("User", "other") })); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = planId })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangePlan_should_throw_exception_if_same_plan() |
|||
{ |
|||
CreateApp(); |
|||
sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = planId })); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = planId })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangePlan_should_create_events() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.ChangePlan(CreateCommand(new ChangePlan { PlanId = 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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AssignContributor(CreateCommand(new AssignContributor { Permission = (AppContributorPermission)123 })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AssignContributor_should_throw_exception_if_single_owner_becomes_non_owner() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = User.Identifier, Permission = AppContributorPermission.Editor })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AssignContributor_should_throw_exception_if_user_already_contributor() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor })); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AssignContributor_should_create_events() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId, Permission = AppContributorPermission.Editor })); |
|||
|
|||
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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.RemoveContributor(CreateCommand(new RemoveContributor())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RemoveContributor_should_throw_exception_if_all_owners_removed() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.RemoveContributor(CreateCommand(new RemoveContributor { ContributorId = User.Identifier })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RemoveContributor_should_throw_exception_if_contributor_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => |
|||
{ |
|||
sut.RemoveContributor(CreateCommand(new RemoveContributor { ContributorId = "not-found" })); |
|||
}); |
|||
} |
|||
|
|||
[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 })); |
|||
|
|||
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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AttachClient(CreateCommand(new AttachClient())); |
|||
}); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AttachClient(CreateCommand(new AttachClient { Id = string.Empty })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AttachClient_should_throw_exception_if_id_already_exists() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.AttachClient(CreateCommand(new AttachClient { Id = clientId })); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
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)); |
|||
|
|||
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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.RevokeClient(CreateCommand(new RevokeClient())); |
|||
}); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.RevokeClient(CreateCommand(new RevokeClient { Id = string.Empty })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RevokeClient_should_throw_exception_if_client_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => |
|||
{ |
|||
sut.RevokeClient(CreateCommand(new RevokeClient { Id = "not-found" })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RevokeClient_should_create_events() |
|||
{ |
|||
CreateApp(); |
|||
CreateClient(); |
|||
|
|||
sut.RevokeClient(CreateCommand(new RevokeClient { Id = 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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient())); |
|||
}); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = string.Empty })); |
|||
}); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Permission = (AppClientPermission)int.MaxValue })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = "not-found", Name = clientNewName })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_has_same_reader_state() |
|||
{ |
|||
CreateApp(); |
|||
CreateClient(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = clientId, Permission = AppClientPermission.Editor })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_same_client_name() |
|||
{ |
|||
CreateApp(); |
|||
CreateClient(); |
|||
|
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = clientId, Name = clientNewName })); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = clientId, Name = clientNewName })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_create_events() |
|||
{ |
|||
CreateApp(); |
|||
CreateClient(); |
|||
|
|||
sut.UpdateClient(CreateCommand(new UpdateClient { Id = clientId, Name = clientNewName, Permission = AppClientPermission.Developer })); |
|||
|
|||
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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AddLanguage(CreateCommand(new AddLanguage())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AddLanguage_should_throw_exception_if_language_already_exists() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.AddLanguage(CreateCommand(new AddLanguage { Language = Language.EN })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void AddLanguage_should_create_events() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
sut.AddLanguage(CreateCommand(new AddLanguage { Language = 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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.RemoveLanguage(CreateCommand(new RemoveLanguage())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RemoveLanguage_should_throw_exception_if_language_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => |
|||
{ |
|||
sut.RemoveLanguage(CreateCommand(new RemoveLanguage { Language = Language.DE })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void RemoveLanguage_should_throw_exception_if_master_language() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
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 })); |
|||
|
|||
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_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateLanguage(CreateCommand(new UpdateLanguage())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateLanguage_should_throw_exception_if_language_not_found() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => |
|||
{ |
|||
sut.UpdateLanguage(CreateCommand(new UpdateLanguage { Language = Language.DE })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateLanguage_should_throw_exception_if_master_language() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.UpdateLanguage(CreateCommand(new UpdateLanguage { Language = Language.EN, IsOptional = true })); |
|||
}); |
|||
} |
|||
|
|||
[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 } })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateEvent(new AppLanguageUpdated { Language = Language.DE, Fallback = new List<Language> { Language.EN } }) |
|||
); |
|||
} |
|||
|
|||
private void CreateApp() |
|||
{ |
|||
sut.Create(CreateCommand(new CreateApp { Name = AppName })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void CreateClient() |
|||
{ |
|||
sut.AttachClient(CreateCommand(new AttachClient { Id = clientId })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void CreateLanguage(Language language) |
|||
{ |
|||
sut.AddLanguage(CreateCommand(new AddLanguage { Language = language })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
} |
|||
} |
|||
@ -1,51 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AppEventTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Events; |
|||
using Squidex.Domain.Apps.Events.Apps; |
|||
using Squidex.Domain.Apps.Events.Apps.Old; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable CS0612 // Type or member is obsolete
|
|||
|
|||
namespace Squidex.Domain.Apps.Write.Apps |
|||
{ |
|||
public class AppEventTests |
|||
{ |
|||
private readonly RefToken actor = new RefToken("User", Guid.NewGuid().ToString()); |
|||
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app"); |
|||
|
|||
[Fact] |
|||
public void Should_migrate_client_changed_as_reader_to_client_updated() |
|||
{ |
|||
var source = CreateEvent(new AppClientChanged { IsReader = true }); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new AppClientUpdated { Permission = AppClientPermission.Reader })); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_migrate_client_changed_as_writer_to_client_updated() |
|||
{ |
|||
var source = CreateEvent(new AppClientChanged { IsReader = false }); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new AppClientUpdated { Permission = AppClientPermission.Editor })); |
|||
} |
|||
|
|||
private T CreateEvent<T>(T contentEvent) where T : AppEvent |
|||
{ |
|||
contentEvent.Actor = actor; |
|||
contentEvent.AppId = appId; |
|||
|
|||
return contentEvent; |
|||
} |
|||
} |
|||
} |
|||
@ -1,139 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AssetCommandMiddlewareTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Write.Assets.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure.Assets; |
|||
using Squidex.Infrastructure.CQRS.Commands; |
|||
using Squidex.Infrastructure.Tasks; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Assets |
|||
{ |
|||
public class AssetCommandMiddlewareTests : HandlerTestBase<AssetDomainObject> |
|||
{ |
|||
private readonly IAssetThumbnailGenerator assetThumbnailGenerator = A.Fake<IAssetThumbnailGenerator>(); |
|||
private readonly IAssetStore assetStore = A.Fake<IAssetStore>(); |
|||
private readonly AssetCommandMiddleware sut; |
|||
private readonly AssetDomainObject asset; |
|||
private readonly Guid assetId = Guid.NewGuid(); |
|||
private readonly Stream stream = new MemoryStream(); |
|||
private readonly ImageInfo image = new ImageInfo(2048, 2048); |
|||
private readonly AssetFile file; |
|||
|
|||
public AssetCommandMiddlewareTests() |
|||
{ |
|||
file = new AssetFile("my-image.png", "image/png", 1024, () => stream); |
|||
|
|||
asset = new AssetDomainObject(assetId, -1); |
|||
|
|||
sut = new AssetCommandMiddleware(Handler, assetStore, assetThumbnailGenerator); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_create_asset() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateAsset { AssetId = assetId, File = file }); |
|||
|
|||
SetupStore(0, context.ContextId); |
|||
SetupImageInfo(); |
|||
|
|||
await TestCreate(asset, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(assetId, context.Result<EntityCreatedResult<Guid>>().IdOrValue); |
|||
|
|||
VerifyStore(0, context.ContextId); |
|||
VerifyImageInfo(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Update_should_update_domain_object() |
|||
{ |
|||
var context = CreateContextForCommand(new UpdateAsset { AssetId = assetId, File = file }); |
|||
|
|||
SetupStore(1, context.ContextId); |
|||
SetupImageInfo(); |
|||
|
|||
CreateAsset(); |
|||
|
|||
await TestUpdate(asset, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
VerifyStore(1, context.ContextId); |
|||
VerifyImageInfo(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Rename_should_update_domain_object() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
var context = CreateContextForCommand(new RenameAsset { AssetId = assetId, FileName = "my-new-image.png" }); |
|||
|
|||
await TestUpdate(asset, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Delete_should_update_domain_object() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
var command = CreateContextForCommand(new DeleteAsset { AssetId = assetId }); |
|||
|
|||
await TestUpdate(asset, async _ => |
|||
{ |
|||
await sut.HandleAsync(command); |
|||
}); |
|||
} |
|||
|
|||
private void CreateAsset() |
|||
{ |
|||
asset.Create(new CreateAsset { File = file }); |
|||
} |
|||
|
|||
private void SetupImageInfo() |
|||
{ |
|||
A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(stream)) |
|||
.Returns(image); |
|||
} |
|||
|
|||
private void SetupStore(long version, Guid commitId) |
|||
{ |
|||
A.CallTo(() => assetStore.UploadTemporaryAsync(commitId.ToString(), stream)) |
|||
.Returns(TaskHelper.Done); |
|||
A.CallTo(() => assetStore.CopyTemporaryAsync(commitId.ToString(), assetId.ToString(), version, null)) |
|||
.Returns(TaskHelper.Done); |
|||
A.CallTo(() => assetStore.DeleteTemporaryAsync(commitId.ToString())) |
|||
.Returns(TaskHelper.Done); |
|||
} |
|||
|
|||
private void VerifyImageInfo() |
|||
{ |
|||
A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(stream)).MustHaveHappened(); |
|||
} |
|||
|
|||
private void VerifyStore(long version, Guid commitId) |
|||
{ |
|||
A.CallTo(() => assetStore.UploadTemporaryAsync(commitId.ToString(), stream)).MustHaveHappened(); |
|||
A.CallTo(() => assetStore.CopyTemporaryAsync(commitId.ToString(), assetId.ToString(), version, null)).MustHaveHappened(); |
|||
A.CallTo(() => assetStore.DeleteTemporaryAsync(commitId.ToString())).MustHaveHappened(); |
|||
} |
|||
} |
|||
} |
|||
@ -1,235 +0,0 @@ |
|||
// ==========================================================================
|
|||
// AssetDomainObjectTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using Squidex.Domain.Apps.Events.Assets; |
|||
using Squidex.Domain.Apps.Write.Assets.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.Assets; |
|||
using Squidex.Infrastructure.CQRS; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Assets |
|||
{ |
|||
public class AssetDomainObjectTests : HandlerTestBase<AssetDomainObject> |
|||
{ |
|||
private readonly AssetDomainObject sut; |
|||
private readonly ImageInfo image = new ImageInfo(2048, 2048); |
|||
private readonly AssetFile file = new AssetFile("my-image.png", "image/png", 1024, () => new MemoryStream()); |
|||
|
|||
public Guid AssetId { get; } = Guid.NewGuid(); |
|||
|
|||
public AssetDomainObjectTests() |
|||
{ |
|||
sut = new AssetDomainObject(AssetId, 0); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_created() |
|||
{ |
|||
sut.Create(new CreateAsset { File = file }); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Create(CreateAssetCommand(new CreateAsset { File = file })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_create_events() |
|||
{ |
|||
sut.Create(CreateAssetCommand(new CreateAsset { File = file, ImageInfo = image })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateAssetEvent(new AssetCreated |
|||
{ |
|||
IsImage = true, |
|||
FileName = file.FileName, |
|||
FileSize = file.FileSize, |
|||
FileVersion = 0, |
|||
MimeType = file.MimeType, |
|||
PixelWidth = image.PixelWidth, |
|||
PixelHeight = image.PixelHeight |
|||
}) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateAssetCommand(new UpdateAsset { File = file })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_asset_is_deleted() |
|||
{ |
|||
CreateAsset(); |
|||
DeleteAsset(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateAssetCommand(new UpdateAsset())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_create_events() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
sut.Update(CreateAssetCommand(new UpdateAsset { File = file, ImageInfo = image })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateAssetEvent(new AssetUpdated |
|||
{ |
|||
IsImage = true, |
|||
FileSize = file.FileSize, |
|||
FileVersion = 1, |
|||
MimeType = file.MimeType, |
|||
PixelWidth = image.PixelWidth, |
|||
PixelHeight = image.PixelHeight |
|||
}) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rename_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Rename(CreateAssetCommand(new RenameAsset { FileName = "new-file.png" })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rename_should_throw_exception_if_asset_is_deleted() |
|||
{ |
|||
CreateAsset(); |
|||
DeleteAsset(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateAssetCommand(new UpdateAsset())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rename_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Rename(CreateAssetCommand(new RenameAsset())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rename_should_throw_exception_if_new_name_is_equal_to_old_name() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Rename(CreateAssetCommand(new RenameAsset { FileName = file.FileName })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rename_should_create_events() |
|||
{ |
|||
CreateAsset(); |
|||
|
|||
sut.Rename(CreateAssetCommand(new RenameAsset { FileName = "my-new-image.png" })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateAssetEvent(new AssetRenamed { FileName = "my-new-image.png" }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateAssetCommand(new DeleteAsset())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_already_deleted() |
|||
{ |
|||
CreateAsset(); |
|||
DeleteAsset(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateAssetCommand(new DeleteAsset())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_create_events_with_total_file_size() |
|||
{ |
|||
CreateAsset(); |
|||
UpdateAsset(); |
|||
|
|||
sut.Delete(CreateAssetCommand(new DeleteAsset())); |
|||
|
|||
Assert.True(sut.IsDeleted); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateAssetEvent(new AssetDeleted { DeletedSize = 2048 }) |
|||
); |
|||
} |
|||
|
|||
private void CreateAsset() |
|||
{ |
|||
sut.Create(CreateAssetCommand(new CreateAsset { File = file })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void UpdateAsset() |
|||
{ |
|||
sut.Update(CreateAssetCommand(new UpdateAsset { File = file })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void DeleteAsset() |
|||
{ |
|||
sut.Delete(CreateAssetCommand(new DeleteAsset())); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
protected T CreateAssetEvent<T>(T @event) where T : AssetEvent |
|||
{ |
|||
@event.AssetId = AssetId; |
|||
|
|||
return CreateEvent(@event); |
|||
} |
|||
|
|||
protected T CreateAssetCommand<T>(T command) where T : AssetAggregateCommand |
|||
{ |
|||
command.AssetId = AssetId; |
|||
|
|||
return CreateCommand(command); |
|||
} |
|||
} |
|||
} |
|||
@ -1,240 +0,0 @@ |
|||
// ==========================================================================
|
|||
// ContentCommandMiddlewareTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Core.Scripting; |
|||
using Squidex.Domain.Apps.Read.Apps; |
|||
using Squidex.Domain.Apps.Read.Apps.Services; |
|||
using Squidex.Domain.Apps.Read.Assets.Repositories; |
|||
using Squidex.Domain.Apps.Read.Contents.Repositories; |
|||
using Squidex.Domain.Apps.Read.Schemas; |
|||
using Squidex.Domain.Apps.Read.Schemas.Services; |
|||
using Squidex.Domain.Apps.Write.Contents.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS.Commands; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Contents |
|||
{ |
|||
public class ContentCommandMiddlewareTests : HandlerTestBase<ContentDomainObject> |
|||
{ |
|||
private readonly ContentCommandMiddleware sut; |
|||
private readonly ContentDomainObject content; |
|||
private readonly ISchemaProvider schemas = A.Fake<ISchemaProvider>(); |
|||
private readonly ISchemaEntity schema = A.Fake<ISchemaEntity>(); |
|||
private readonly IScriptEngine scriptEngine = A.Fake<IScriptEngine>(); |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly IAppEntity app = A.Fake<IAppEntity>(); |
|||
private readonly ClaimsPrincipal user = new ClaimsPrincipal(); |
|||
private readonly LanguagesConfig languagesConfig = LanguagesConfig.Create(Language.DE); |
|||
private readonly Guid contentId = Guid.NewGuid(); |
|||
|
|||
private readonly NamedContentData invalidData = |
|||
new NamedContentData() |
|||
.AddField("my-field", new ContentFieldData() |
|||
.SetValue(null)); |
|||
private readonly NamedContentData data = |
|||
new NamedContentData() |
|||
.AddField("my-field", new ContentFieldData() |
|||
.SetValue(1)); |
|||
|
|||
public ContentCommandMiddlewareTests() |
|||
{ |
|||
var schemaDef = |
|||
Schema.Create("my-schema", new SchemaProperties()) |
|||
.AddField(new NumberField(1, "my-field", Partitioning.Invariant, |
|||
new NumberFieldProperties { IsRequired = true })); |
|||
|
|||
content = new ContentDomainObject(contentId, -1); |
|||
|
|||
sut = new ContentCommandMiddleware(Handler, appProvider, A.Dummy<IAssetRepository>(), schemas, scriptEngine, A.Dummy<IContentRepository>()); |
|||
|
|||
A.CallTo(() => app.LanguagesConfig).Returns(languagesConfig); |
|||
A.CallTo(() => app.PartitionResolver).Returns(languagesConfig.ToResolver()); |
|||
|
|||
A.CallTo(() => appProvider.FindAppByIdAsync(AppId)).Returns(app); |
|||
|
|||
A.CallTo(() => schema.SchemaDef).Returns(schemaDef); |
|||
A.CallTo(() => schema.ScriptCreate).Returns("<create-script>"); |
|||
A.CallTo(() => schema.ScriptChange).Returns("<change-script>"); |
|||
A.CallTo(() => schema.ScriptUpdate).Returns("<update-script>"); |
|||
A.CallTo(() => schema.ScriptDelete).Returns("<delete-script>"); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(SchemaId, false)).Returns(schema); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_throw_exception_if_data_is_not_valid() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(invalidData); |
|||
|
|||
var context = CreateContextForCommand(new CreateContent { ContentId = contentId, Data = invalidData, User = user }); |
|||
|
|||
await TestCreate(content, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_create_content() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(data); |
|||
|
|||
var context = CreateContextForCommand(new CreateContent { ContentId = contentId, Data = data, User = user }); |
|||
|
|||
await TestCreate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(data, context.Result<EntityCreatedResult<NamedContentData>>().IdOrValue); |
|||
|
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, "<create-script>")).MustHaveHappened(); |
|||
A.CallTo(() => scriptEngine.Execute(A<ScriptContext>.Ignored, "<change-script>")).MustNotHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_also_invoke_publish_script_when_publishing() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(data); |
|||
|
|||
var context = CreateContextForCommand(new CreateContent { ContentId = contentId, Data = data, User = user, Publish = true }); |
|||
|
|||
await TestCreate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(data, context.Result<EntityCreatedResult<NamedContentData>>().IdOrValue); |
|||
|
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, "<create-script>")).MustHaveHappened(); |
|||
A.CallTo(() => scriptEngine.Execute(A<ScriptContext>.Ignored, "<change-script>")).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Update_should_throw_exception_if_data_is_not_valid() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)).Returns(invalidData); |
|||
|
|||
CreateContent(); |
|||
|
|||
var context = CreateContextForCommand(new UpdateContent { ContentId = contentId, Data = invalidData, User = user }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Update_should_update_domain_object() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(data); |
|||
|
|||
CreateContent(); |
|||
|
|||
var context = CreateContextForCommand(new UpdateContent { ContentId = contentId, Data = data, User = user }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(data, context.Result<ContentDataChangedResult>().Data); |
|||
|
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, "<update-script>")).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Patch_should_throw_exception_if_data_is_not_valid() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(invalidData); |
|||
|
|||
CreateContent(); |
|||
|
|||
var context = CreateContextForCommand(new PatchContent { ContentId = contentId, Data = invalidData, User = user }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context)); |
|||
}, false); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Patch_should_update_domain_object() |
|||
{ |
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)) |
|||
.Returns(data); |
|||
|
|||
var patch = new NamedContentData().AddField("my-field", new ContentFieldData().SetValue(3)); |
|||
|
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored)).Returns(patch); |
|||
|
|||
CreateContent(); |
|||
|
|||
var context = CreateContextForCommand(new PatchContent { ContentId = contentId, Data = patch, User = user }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.NotNull(context.Result<ContentDataChangedResult>().Data); |
|||
|
|||
A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, "<update-script>")).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ChangeStatus_should_publish_domain_object() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
var context = CreateContextForCommand(new ChangeContentStatus { ContentId = contentId, User = user, Status = Status.Published }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
A.CallTo(() => scriptEngine.Execute(A<ScriptContext>.Ignored, "<change-script>")).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Delete_should_update_domain_object() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
var command = CreateContextForCommand(new DeleteContent { ContentId = contentId, User = user }); |
|||
|
|||
await TestUpdate(content, async _ => |
|||
{ |
|||
await sut.HandleAsync(command); |
|||
}); |
|||
|
|||
A.CallTo(() => scriptEngine.Execute(A<ScriptContext>.Ignored, "<delete-script>")).MustHaveHappened(); |
|||
} |
|||
|
|||
private void CreateContent() |
|||
{ |
|||
content.Create(new CreateContent { Data = data }); |
|||
} |
|||
} |
|||
} |
|||
@ -1,323 +0,0 @@ |
|||
// ==========================================================================
|
|||
// ContentDomainObjectTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using FluentAssertions; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Events.Contents; |
|||
using Squidex.Domain.Apps.Write.Contents.Commands; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Contents |
|||
{ |
|||
public class ContentDomainObjectTests : HandlerTestBase<ContentDomainObject> |
|||
{ |
|||
private readonly ContentDomainObject sut; |
|||
private readonly NamedContentData data = |
|||
new NamedContentData() |
|||
.AddField("field1", |
|||
new ContentFieldData() |
|||
.AddValue("iv", 1)); |
|||
private readonly NamedContentData otherData = |
|||
new NamedContentData() |
|||
.AddField("field2", |
|||
new ContentFieldData() |
|||
.AddValue("iv", 2)); |
|||
|
|||
public Guid ContentId { get; } = Guid.NewGuid(); |
|||
|
|||
public ContentDomainObjectTests() |
|||
{ |
|||
sut = new ContentDomainObject(ContentId, 0); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_created() |
|||
{ |
|||
sut.Create(new CreateContent { Data = data }); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Create(CreateContentCommand(new CreateContent { Data = data })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Create(CreateContentCommand(new CreateContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_create_events() |
|||
{ |
|||
sut.Create(CreateContentCommand(new CreateContent { Data = data })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentCreated { Data = data }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_also_publish_if_set_to_true() |
|||
{ |
|||
sut.Create(CreateContentCommand(new CreateContent { Data = data, Publish = true })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentCreated { Data = data }), |
|||
CreateContentEvent(new ContentStatusChanged { Status = Status.Published }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateContentCommand(new UpdateContent { Data = data })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_content_is_deleted() |
|||
{ |
|||
CreateContent(); |
|||
DeleteContent(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Update(CreateContentCommand(new UpdateContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Update(CreateContentCommand(new UpdateContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_create_events() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
sut.Update(CreateContentCommand(new UpdateContent { Data = otherData })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentUpdated { Data = otherData }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_not_create_event_for_same_data() |
|||
{ |
|||
CreateContent(); |
|||
UpdateContent(); |
|||
|
|||
sut.Update(CreateContentCommand(new UpdateContent { Data = data })); |
|||
|
|||
sut.GetUncomittedEvents().Should().BeEmpty(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Patch_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Patch(CreateContentCommand(new PatchContent { Data = data })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Patch_should_throw_exception_if_content_is_deleted() |
|||
{ |
|||
CreateContent(); |
|||
DeleteContent(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Patch(CreateContentCommand(new PatchContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Patch_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Patch(CreateContentCommand(new PatchContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Patch_should_create_events() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
sut.Patch(CreateContentCommand(new PatchContent { Data = otherData })); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentUpdated { Data = otherData }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Patch_should_not_create_event_for_same_data() |
|||
{ |
|||
CreateContent(); |
|||
UpdateContent(); |
|||
|
|||
sut.Patch(CreateContentCommand(new PatchContent { Data = data })); |
|||
|
|||
sut.GetUncomittedEvents().Should().BeEmpty(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangeStatus_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangeStatus_should_throw_exception_if_content_is_deleted() |
|||
{ |
|||
CreateContent(); |
|||
DeleteContent(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangeStatus_should_throw_exception_if_status_flow_not_valid() |
|||
{ |
|||
CreateContent(); |
|||
ChangeStatus(Status.Archived); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = Status.Published })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ChangeStatus_should_refresh_properties_and_create_events() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = Status.Published })); |
|||
|
|||
Assert.Equal(Status.Published, sut.Status); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentStatusChanged { Status = Status.Published }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateContentCommand(new DeleteContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_already_deleted() |
|||
{ |
|||
CreateContent(); |
|||
DeleteContent(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateContentCommand(new DeleteContent())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_update_properties_create_events() |
|||
{ |
|||
CreateContent(); |
|||
|
|||
sut.Delete(CreateContentCommand(new DeleteContent())); |
|||
|
|||
Assert.True(sut.IsDeleted); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateContentEvent(new ContentDeleted()) |
|||
); |
|||
} |
|||
|
|||
private void CreateContent() |
|||
{ |
|||
sut.Create(CreateContentCommand(new CreateContent { Data = data })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void UpdateContent() |
|||
{ |
|||
sut.Update(CreateContentCommand(new UpdateContent { Data = data })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void ChangeStatus(Status status) |
|||
{ |
|||
sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = status })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void DeleteContent() |
|||
{ |
|||
sut.Delete(CreateContentCommand(new DeleteContent())); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
protected T CreateContentEvent<T>(T @event) where T : ContentEvent |
|||
{ |
|||
@event.ContentId = ContentId; |
|||
|
|||
return CreateEvent(@event); |
|||
} |
|||
|
|||
protected T CreateContentCommand<T>(T command) where T : ContentCommand |
|||
{ |
|||
command.ContentId = ContentId; |
|||
|
|||
return CreateCommand(command); |
|||
} |
|||
} |
|||
} |
|||
@ -1,70 +0,0 @@ |
|||
// ==========================================================================
|
|||
// SchemaEventTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Events.Contents; |
|||
using Squidex.Domain.Apps.Events.Contents.Old; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable CS0612 // Type or member is obsolete
|
|||
|
|||
namespace Squidex.Domain.Apps.Write.Contents |
|||
{ |
|||
public class ContentEventTests |
|||
{ |
|||
private readonly RefToken actor = new RefToken("User", Guid.NewGuid().ToString()); |
|||
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app"); |
|||
private readonly NamedId<Guid> schemaId = new NamedId<Guid>(Guid.NewGuid(), "my-schema"); |
|||
private readonly Guid contentId = Guid.NewGuid(); |
|||
|
|||
[Fact] |
|||
public void Should_migrate_content_published_to_content_status_changed() |
|||
{ |
|||
var source = CreateEvent(new ContentPublished()); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new ContentStatusChanged { Status = Status.Published })); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_migrate_content_unpublished_to_content_status_changed() |
|||
{ |
|||
var source = CreateEvent(new ContentUnpublished()); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new ContentStatusChanged { Status = Status.Draft })); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_migrate_content_restored_to_content_status_changed() |
|||
{ |
|||
var source = CreateEvent(new ContentRestored()); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new ContentStatusChanged { Status = Status.Draft })); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_migrate_content_archived_to_content_status_changed() |
|||
{ |
|||
var source = CreateEvent(new ContentArchived()); |
|||
|
|||
source.Migrate().ShouldBeSameEvent(CreateEvent(new ContentStatusChanged { Status = Status.Archived })); |
|||
} |
|||
|
|||
private T CreateEvent<T>(T contentEvent) where T : ContentEvent |
|||
{ |
|||
contentEvent.Actor = actor; |
|||
contentEvent.AppId = appId; |
|||
contentEvent.SchemaId = schemaId; |
|||
contentEvent.ContentId = contentId; |
|||
|
|||
return contentEvent; |
|||
} |
|||
} |
|||
} |
|||
@ -1,139 +0,0 @@ |
|||
// ==========================================================================
|
|||
// ContentVersionLoaderTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Events.Contents; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS.Events; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Contents |
|||
{ |
|||
public class ContentVersionLoaderTests |
|||
{ |
|||
private readonly IEventStore eventStore = A.Fake<IEventStore>(); |
|||
private readonly IStreamNameResolver nameResolver = A.Fake<IStreamNameResolver>(); |
|||
private readonly EventDataFormatter formatter = A.Fake<EventDataFormatter>(); |
|||
private readonly Guid id = Guid.NewGuid(); |
|||
private readonly Guid appId = Guid.NewGuid(); |
|||
private readonly string streamName = Guid.NewGuid().ToString(); |
|||
private readonly ContentVersionLoader sut; |
|||
|
|||
public ContentVersionLoaderTests() |
|||
{ |
|||
A.CallTo(() => nameResolver.GetStreamName(typeof(ContentDomainObject), id)) |
|||
.Returns(streamName); |
|||
|
|||
sut = new ContentVersionLoader(eventStore, nameResolver, formatter); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_throw_exception_when_event_store_returns_no_events() |
|||
{ |
|||
A.CallTo(() => eventStore.GetEventsAsync(streamName)) |
|||
.Returns(new List<StoredEvent>()); |
|||
|
|||
await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.LoadAsync(appId, id, -1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_throw_exception_when_version_not_found() |
|||
{ |
|||
A.CallTo(() => eventStore.GetEventsAsync(streamName)) |
|||
.Returns(new List<StoredEvent>()); |
|||
|
|||
await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.LoadAsync(appId, id, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_throw_exception_when_content_is_from_another_event() |
|||
{ |
|||
var eventData1 = new EventData(); |
|||
|
|||
var event1 = new ContentCreated { Data = new NamedContentData(), AppId = new NamedId<Guid>(Guid.NewGuid(), "my-app") }; |
|||
|
|||
var events = new List<StoredEvent> |
|||
{ |
|||
new StoredEvent("0", 0, eventData1) |
|||
}; |
|||
|
|||
A.CallTo(() => eventStore.GetEventsAsync(streamName)) |
|||
.Returns(events); |
|||
|
|||
A.CallTo(() => formatter.Parse(eventData1, true)) |
|||
.Returns(new Envelope<IEvent>(event1)); |
|||
|
|||
await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.LoadAsync(appId, id, 0)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_load_content_from_created_event() |
|||
{ |
|||
var eventData1 = new EventData(); |
|||
var eventData2 = new EventData(); |
|||
|
|||
var event1 = new ContentCreated { Data = new NamedContentData(), AppId = new NamedId<Guid>(appId, "my-app") }; |
|||
var event2 = new ContentStatusChanged(); |
|||
|
|||
var events = new List<StoredEvent> |
|||
{ |
|||
new StoredEvent("0", 0, eventData1), |
|||
new StoredEvent("1", 1, eventData2) |
|||
}; |
|||
|
|||
A.CallTo(() => eventStore.GetEventsAsync(streamName)) |
|||
.Returns(events); |
|||
|
|||
A.CallTo(() => formatter.Parse(eventData1, true)) |
|||
.Returns(new Envelope<IEvent>(event1)); |
|||
A.CallTo(() => formatter.Parse(eventData2, true)) |
|||
.Returns(new Envelope<IEvent>(event2)); |
|||
|
|||
var data = await sut.LoadAsync(appId, id, 3); |
|||
|
|||
Assert.Same(event1.Data, data); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_load_content_from_correct_version() |
|||
{ |
|||
var eventData1 = new EventData(); |
|||
var eventData2 = new EventData(); |
|||
var eventData3 = new EventData(); |
|||
|
|||
var event1 = new ContentCreated { Data = new NamedContentData(), AppId = new NamedId<Guid>(appId, "my-app") }; |
|||
var event2 = new ContentUpdated { Data = new NamedContentData() }; |
|||
var event3 = new ContentUpdated { Data = new NamedContentData() }; |
|||
|
|||
var events = new List<StoredEvent> |
|||
{ |
|||
new StoredEvent("0", 0, eventData1), |
|||
new StoredEvent("1", 1, eventData2), |
|||
new StoredEvent("2", 2, eventData3) |
|||
}; |
|||
|
|||
A.CallTo(() => eventStore.GetEventsAsync(streamName)) |
|||
.Returns(events); |
|||
|
|||
A.CallTo(() => formatter.Parse(eventData1, true)) |
|||
.Returns(new Envelope<IEvent>(event1)); |
|||
A.CallTo(() => formatter.Parse(eventData2, true)) |
|||
.Returns(new Envelope<IEvent>(event2)); |
|||
A.CallTo(() => formatter.Parse(eventData3, true)) |
|||
.Returns(new Envelope<IEvent>(event3)); |
|||
|
|||
var data = await sut.LoadAsync(appId, id, 1); |
|||
|
|||
Assert.Equal(event2.Data, data); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,234 @@ |
|||
// ==========================================================================
|
|||
// GuardSchemaFieldTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Write.Schemas.Commands; |
|||
using Squidex.Domain.Apps.Write.Schemas.Guards; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas |
|||
{ |
|||
public class GuardSchemaFieldTests |
|||
{ |
|||
private readonly Schema schema = new Schema("my-schema"); |
|||
|
|||
public GuardSchemaFieldTests() |
|||
{ |
|||
schema.AddField(new StringField(1, "field1", Partitioning.Invariant)); |
|||
schema.AddField(new StringField(2, "field2", Partitioning.Invariant)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanHide_should_throw_exception_if_already_hidden() |
|||
{ |
|||
var command = new HideField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Hide(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanHide(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanHide_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new HideField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanHide(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanHide_hould_not_throw_exception_if_visible() |
|||
{ |
|||
var command = new HideField { FieldId = 1 }; |
|||
|
|||
GuardSchemaField.CanHide(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDisable_should_throw_exception_if_already_disabled() |
|||
{ |
|||
var command = new DisableField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Disable(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanDisable(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDisable_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new DisableField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanDisable(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDisable_Should_not_throw_exception_if_enabled() |
|||
{ |
|||
var command = new DisableField { FieldId = 1 }; |
|||
|
|||
GuardSchemaField.CanDisable(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanShow_should_throw_exception_if_already_shown() |
|||
{ |
|||
var command = new ShowField { FieldId = 1 }; |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanShow(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanShow_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new ShowField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanShow(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanShow_should_not_throw_exception_if_hidden() |
|||
{ |
|||
var command = new ShowField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Hide(); |
|||
|
|||
GuardSchemaField.CanShow(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanEnable_should_throw_exception_if_already_enabled() |
|||
{ |
|||
var command = new EnableField { FieldId = 1 }; |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanEnable(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanEnable_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new EnableField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanEnable(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanEnable_should_not_throw_exception_if_disabled() |
|||
{ |
|||
var command = new EnableField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Disable(); |
|||
|
|||
GuardSchemaField.CanEnable(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanLock_should_throw_exception_if_already_locked() |
|||
{ |
|||
var command = new LockField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Lock(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanLock(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LockField_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new LockField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanLock(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanLock_should_not_throw_exception_if_not_locked() |
|||
{ |
|||
var command = new LockField { FieldId = 1 }; |
|||
|
|||
GuardSchemaField.CanLock(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDelete_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new DeleteField { FieldId = 3 }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardSchemaField.CanDelete(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDelete_should_throw_exception_if_locked() |
|||
{ |
|||
var command = new DeleteField { FieldId = 1 }; |
|||
|
|||
schema.FieldsById[1].Lock(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanDelete(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDelete_should_not_throw_exception_if_not_locked() |
|||
{ |
|||
var command = new DeleteField { FieldId = 1 }; |
|||
|
|||
GuardSchemaField.CanDelete(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdate_should_throw_exception_if_locked() |
|||
{ |
|||
var command = new UpdateField { FieldId = 1, Properties = new StringFieldProperties() }; |
|||
|
|||
schema.FieldsById[1].Lock(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchemaField.CanUpdate(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdate_should_not_throw_exception_if_not_locked() |
|||
{ |
|||
var command = new UpdateField { FieldId = 1, Properties = new StringFieldProperties() }; |
|||
|
|||
GuardSchemaField.CanUpdate(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAdd_should_throw_exception_if_field_already_exists() |
|||
{ |
|||
var command = new AddField { Name = "field1", Properties = new StringFieldProperties() }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardSchemaField.CanAdd(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAdd_should_throw_exception_if_name_not_valid() |
|||
{ |
|||
var command = new AddField { Name = "INVALID_NAME", Properties = new StringFieldProperties() }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardSchemaField.CanAdd(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAdd_should_throw_exception_if_properties_not_valid() |
|||
{ |
|||
var command = new AddField { Name = "field3", Properties = new StringFieldProperties { MinLength = 10, MaxLength = 5 } }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardSchemaField.CanAdd(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAdd_should_not_throw_exception_if_field_not_exists() |
|||
{ |
|||
var command = new AddField { Name = "field3", Properties = new StringFieldProperties() }; |
|||
|
|||
GuardSchemaField.CanAdd(schema, command); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,197 @@ |
|||
// ==========================================================================
|
|||
// GuardSchemaTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Read.Schemas; |
|||
using Squidex.Domain.Apps.Read.Schemas.Services; |
|||
using Squidex.Domain.Apps.Write.Schemas.Commands; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public class GuardSchemaTests |
|||
{ |
|||
private readonly ISchemaProvider schemas = A.Fake<ISchemaProvider>(); |
|||
private readonly Schema schema = new Schema("my-schema"); |
|||
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app"); |
|||
|
|||
public GuardSchemaTests() |
|||
{ |
|||
schema.AddField(new StringField(1, "field1", Partitioning.Invariant)); |
|||
schema.AddField(new StringField(2, "field2", Partitioning.Invariant)); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByNameAsync(A<Guid>.Ignored, "new-schema")) |
|||
.Returns(Task.FromResult<ISchemaEntity>(null)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task CanCreate_should_throw_exception_if_name_not_valid() |
|||
{ |
|||
var command = new CreateSchema { AppId = appId, Name = "INVALID NAME" }; |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(() => GuardSchema.CanCreate(command, schemas)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task CanCreate_should_throw_exception_if_name_already_in_use() |
|||
{ |
|||
A.CallTo(() => schemas.FindSchemaByNameAsync(A<Guid>.Ignored, "new-schema")) |
|||
.Returns(Task.FromResult(A.Fake<ISchemaEntity>())); |
|||
|
|||
var command = new CreateSchema { AppId = appId, Name = "new-schema" }; |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(() => GuardSchema.CanCreate(command, schemas)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task CanCreate_should_throw_exception_if_fields_not_valid() |
|||
{ |
|||
var command = new CreateSchema |
|||
{ |
|||
AppId = appId, |
|||
Fields = new List<CreateSchemaField> |
|||
{ |
|||
new CreateSchemaField |
|||
{ |
|||
Name = null, |
|||
Properties = null, |
|||
Partitioning = "invalid", |
|||
}, |
|||
new CreateSchemaField |
|||
{ |
|||
Name = null, |
|||
Properties = InvalidProperties(), |
|||
Partitioning = "invalid", |
|||
} |
|||
}, |
|||
Name = "new-schema" |
|||
}; |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(() => GuardSchema.CanCreate(command, schemas)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task CanCreate_should_throw_exception_if_fields_contain_duplicate_names() |
|||
{ |
|||
var command = new CreateSchema |
|||
{ |
|||
AppId = appId, |
|||
Fields = new List<CreateSchemaField> |
|||
{ |
|||
new CreateSchemaField |
|||
{ |
|||
Name = "field1", |
|||
Properties = ValidProperties(), |
|||
Partitioning = "invariant" |
|||
}, |
|||
new CreateSchemaField |
|||
{ |
|||
Name = "field1", |
|||
Properties = ValidProperties(), |
|||
Partitioning = "invariant" |
|||
} |
|||
}, |
|||
Name = "new-schema" |
|||
}; |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(() => GuardSchema.CanCreate(command, schemas)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task CanCreate_should_not_throw_exception_if_command_is_valid() |
|||
{ |
|||
var command = new CreateSchema { AppId = appId, Name = "new-schema" }; |
|||
|
|||
await GuardSchema.CanCreate(command, schemas); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanPublish_should_throw_exception_if_already_published() |
|||
{ |
|||
var command = new PublishSchema(); |
|||
|
|||
schema.Publish(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchema.CanPublish(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanPublish_should_not_throw_exception_if_not_published() |
|||
{ |
|||
var command = new PublishSchema(); |
|||
|
|||
GuardSchema.CanPublish(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUnpublish_should_throw_exception_if_already_unpublished() |
|||
{ |
|||
var command = new UnpublishSchema(); |
|||
|
|||
Assert.Throws<DomainException>(() => GuardSchema.CanUnpublish(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUnpublish_should_not_throw_exception_if_already_published() |
|||
{ |
|||
var command = new UnpublishSchema(); |
|||
|
|||
schema.Publish(); |
|||
|
|||
GuardSchema.CanUnpublish(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanReorder_should_throw_exception_if_field_ids_contains_invalid_id() |
|||
{ |
|||
var command = new ReorderFields { FieldIds = new List<long> { 1, 3 } }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardSchema.CanReorder(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanReorder_should_throw_exception_if_field_ids_do_not_covers_all_fields() |
|||
{ |
|||
var command = new ReorderFields { FieldIds = new List<long> { 1 } }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardSchema.CanReorder(schema, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanReorder_should_not_throw_exception_if_field_ids_are_valid() |
|||
{ |
|||
var command = new ReorderFields { FieldIds = new List<long> { 1, 2 } }; |
|||
|
|||
GuardSchema.CanReorder(schema, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanDelete_should_not_throw_exception() |
|||
{ |
|||
var command = new DeleteSchema(); |
|||
|
|||
GuardSchema.CanDelete(schema, command); |
|||
} |
|||
|
|||
private static StringFieldProperties ValidProperties() |
|||
{ |
|||
return new StringFieldProperties { MinLength = 10, MaxLength = 20 }; |
|||
} |
|||
|
|||
private static StringFieldProperties InvalidProperties() |
|||
{ |
|||
return new StringFieldProperties { MinLength = 20, MaxLength = 10 }; |
|||
} |
|||
} |
|||
} |
|||
@ -1,169 +0,0 @@ |
|||
// ==========================================================================
|
|||
// SchemaFieldGuardTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public class SchemaFieldGuardTests |
|||
{ |
|||
private Schema schema = |
|||
Schema.Create("my-schema", new SchemaProperties()) |
|||
.AddField(new StringField(1, "field1", Partitioning.Invariant)) |
|||
.AddField(new StringField(2, "field2", Partitioning.Invariant)); |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_hide_already_hidden() |
|||
{ |
|||
schema = schema.HideField(1); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanHide(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_hide_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanHide(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_hide_shown() |
|||
{ |
|||
SchemaFieldGuard.GuardCanHide(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_disable_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanDisable(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_disable_already_disabled() |
|||
{ |
|||
schema = schema.DisableField(1); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanDisable(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_disable_shown() |
|||
{ |
|||
SchemaFieldGuard.GuardCanDisable(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_show_already_shown() |
|||
{ |
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanShow(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_show_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanShow(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_show_hidden() |
|||
{ |
|||
schema = schema.HideField(1); |
|||
|
|||
SchemaFieldGuard.GuardCanShow(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_enable_already_enabled() |
|||
{ |
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanEnable(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_enable_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanEnable(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_enable_disabled() |
|||
{ |
|||
schema = schema.DisableField(1); |
|||
|
|||
SchemaFieldGuard.GuardCanEnable(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_lock_already_locked() |
|||
{ |
|||
schema = schema.LockField(1); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanLock(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_lock_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanLock(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_lock_not_locked() |
|||
{ |
|||
SchemaFieldGuard.GuardCanLock(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_delete_not_found() |
|||
{ |
|||
Assert.Throws<DomainObjectNotFoundException>(() => SchemaFieldGuard.GuardCanDelete(schema, 3)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_delete_is_locked() |
|||
{ |
|||
schema = schema.LockField(1); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanDelete(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_update_not_locked() |
|||
{ |
|||
SchemaFieldGuard.GuardCanUpdate(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_update_is_locked() |
|||
{ |
|||
schema = schema.LockField(1); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaFieldGuard.GuardCanUpdate(schema, 1)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_delete_not_locked() |
|||
{ |
|||
SchemaFieldGuard.GuardCanDelete(schema, 1); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_field_to_add_already_exists() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => SchemaFieldGuard.GuardCanAdd(schema, "field1")); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_field_to_add_not_exists() |
|||
{ |
|||
SchemaFieldGuard.GuardCanAdd(schema, "field3"); |
|||
} |
|||
} |
|||
} |
|||
@ -1,65 +0,0 @@ |
|||
// ==========================================================================
|
|||
// SchemaGuardTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Collections.Generic; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Schemas.Guards |
|||
{ |
|||
public class SchemaGuardTests |
|||
{ |
|||
private Schema schema = |
|||
Schema.Create("my-schema", new SchemaProperties()) |
|||
.AddField(new StringField(1, "field1", Partitioning.Invariant)) |
|||
.AddField(new StringField(2, "field2", Partitioning.Invariant)); |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_schema_to_publish_already_published() |
|||
{ |
|||
schema = schema.Publish(); |
|||
|
|||
Assert.Throws<DomainException>(() => SchemaGuard.GuardCanPublish(schema)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_schema_to_publish_not_published() |
|||
{ |
|||
SchemaGuard.GuardCanPublish(schema); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_exception_if_schema_to_unpublish_already_unpublished() |
|||
{ |
|||
Assert.Throws<DomainException>(() => SchemaGuard.GuardCanUnpublish(schema)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_exception_if_schema_to_unpublish_published() |
|||
{ |
|||
schema = schema.Publish(); |
|||
|
|||
SchemaGuard.GuardCanUnpublish(schema); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_throw_excepotion_if_schema_fields_to_reorder_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => SchemaGuard.GuardCanReorder(schema, new List<long> { 1 })); |
|||
Assert.Throws<ValidationException>(() => SchemaGuard.GuardCanReorder(schema, new List<long> { 1, 3 })); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_throw_excepotion_if_schema_fields_to_reorder_are_valid() |
|||
{ |
|||
SchemaGuard.GuardCanReorder(schema, new List<long> { 1, 2 }); |
|||
} |
|||
} |
|||
} |
|||
@ -1,130 +0,0 @@ |
|||
// ==========================================================================
|
|||
// WebhookCommandMiddlewareTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core.Webhooks; |
|||
using Squidex.Domain.Apps.Read.Schemas; |
|||
using Squidex.Domain.Apps.Read.Schemas.Services; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Domain.Apps.Write.Webhooks.Commands; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS.Commands; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Webhooks |
|||
{ |
|||
public class WebhookCommandMiddlewareTests : HandlerTestBase<WebhookDomainObject> |
|||
{ |
|||
private readonly ISchemaProvider schemas = A.Fake<ISchemaProvider>(); |
|||
private readonly WebhookCommandMiddleware sut; |
|||
private readonly WebhookDomainObject webhook; |
|||
private readonly Uri url = new Uri("http://squidex.io"); |
|||
private readonly Guid schemaId = Guid.NewGuid(); |
|||
private readonly Guid webhookId = Guid.NewGuid(); |
|||
private readonly List<WebhookSchema> webhookSchemas; |
|||
|
|||
public WebhookCommandMiddlewareTests() |
|||
{ |
|||
webhook = new WebhookDomainObject(webhookId, -1); |
|||
|
|||
webhookSchemas = new List<WebhookSchema> |
|||
{ |
|||
new WebhookSchema { SchemaId = schemaId } |
|||
}; |
|||
|
|||
sut = new WebhookCommandMiddleware(Handler, schemas); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_create_webhook() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId }); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(A.Fake<ISchemaEntity>()); |
|||
|
|||
await TestCreate(webhook, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_throw_exception_when_schema_is_not_found() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId }); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns((ISchemaEntity)null); |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(async () => |
|||
{ |
|||
await TestCreate(webhook, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Update_should_update_domain_object() |
|||
{ |
|||
var context = CreateContextForCommand(new UpdateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId }); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(A.Fake<ISchemaEntity>()); |
|||
|
|||
CreateWebhook(); |
|||
|
|||
await TestUpdate(webhook, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Update_should_throw_exception_when_schema_is_not_found() |
|||
{ |
|||
var context = CreateContextForCommand(new UpdateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId }); |
|||
|
|||
A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns((ISchemaEntity)null); |
|||
|
|||
CreateWebhook(); |
|||
|
|||
await Assert.ThrowsAsync<ValidationException>(async () => |
|||
{ |
|||
await TestCreate(webhook, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Delete_should_update_domain_object() |
|||
{ |
|||
CreateWebhook(); |
|||
|
|||
var command = CreateContextForCommand(new DeleteWebhook { WebhookId = webhookId }); |
|||
|
|||
await TestUpdate(webhook, async _ => |
|||
{ |
|||
await sut.HandleAsync(command); |
|||
}); |
|||
} |
|||
|
|||
private void CreateWebhook() |
|||
{ |
|||
webhook.Create(new CreateWebhook { Url = url }); |
|||
} |
|||
} |
|||
} |
|||
@ -1,179 +0,0 @@ |
|||
// ==========================================================================
|
|||
// WebhookDomainObjectTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Squidex.Domain.Apps.Events.Webhooks; |
|||
using Squidex.Domain.Apps.Write.TestHelpers; |
|||
using Squidex.Domain.Apps.Write.Webhooks.Commands; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.CQRS; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Write.Webhooks |
|||
{ |
|||
public class WebhookDomainObjectTests : HandlerTestBase<WebhookDomainObject> |
|||
{ |
|||
private readonly Uri url = new Uri("http://squidex.io"); |
|||
private readonly WebhookDomainObject sut; |
|||
|
|||
public Guid WebhookId { get; } = Guid.NewGuid(); |
|||
|
|||
public WebhookDomainObjectTests() |
|||
{ |
|||
sut = new WebhookDomainObject(WebhookId, 0); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_created() |
|||
{ |
|||
sut.Create(new CreateWebhook { Url = url }); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Create(CreateWebhookCommand(new CreateWebhook { Url = url })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Create(CreateWebhookCommand(new CreateWebhook { Url = new Uri("/invalid", UriKind.Relative) })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_create_events() |
|||
{ |
|||
var command = new CreateWebhook { Url = url }; |
|||
|
|||
sut.Create(CreateWebhookCommand(command)); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateWebhookEvent(new WebhookCreated |
|||
{ |
|||
Url = url, |
|||
Schemas = command.Schemas, |
|||
SharedSecret = command.SharedSecret, |
|||
WebhookId = command.WebhookId |
|||
}) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateWebhookCommand(new UpdateWebhook { Url = url })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_webhook_is_deleted() |
|||
{ |
|||
CreateWebhook(); |
|||
DeleteWebhook(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Update(CreateWebhookCommand(new UpdateWebhook { Url = url })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_throw_exception_if_command_is_not_valid() |
|||
{ |
|||
CreateWebhook(); |
|||
|
|||
Assert.Throws<ValidationException>(() => |
|||
{ |
|||
sut.Update(CreateWebhookCommand(new UpdateWebhook { Url = new Uri("/invalid", UriKind.Relative) })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Update_should_create_events() |
|||
{ |
|||
CreateWebhook(); |
|||
|
|||
var command = new UpdateWebhook { Url = url }; |
|||
|
|||
sut.Update(CreateWebhookCommand(command)); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateWebhookEvent(new WebhookUpdated { Url = url, Schemas = command.Schemas }) |
|||
); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_not_created() |
|||
{ |
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateWebhookCommand(new DeleteWebhook())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_throw_exception_if_already_deleted() |
|||
{ |
|||
CreateWebhook(); |
|||
DeleteWebhook(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Delete(CreateWebhookCommand(new DeleteWebhook())); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Delete_should_update_properties_create_events() |
|||
{ |
|||
CreateWebhook(); |
|||
|
|||
sut.Delete(CreateWebhookCommand(new DeleteWebhook())); |
|||
|
|||
sut.GetUncomittedEvents() |
|||
.ShouldHaveSameEvents( |
|||
CreateWebhookEvent(new WebhookDeleted()) |
|||
); |
|||
} |
|||
|
|||
private void CreateWebhook() |
|||
{ |
|||
sut.Create(CreateWebhookCommand(new CreateWebhook { Url = url })); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void DeleteWebhook() |
|||
{ |
|||
sut.Delete(CreateWebhookCommand(new DeleteWebhook())); |
|||
|
|||
((IAggregate)sut).ClearUncommittedEvents(); |
|||
} |
|||
|
|||
protected T CreateWebhookEvent<T>(T @event) where T : WebhookEvent |
|||
{ |
|||
@event.WebhookId = WebhookId; |
|||
|
|||
return CreateEvent(@event); |
|||
} |
|||
|
|||
protected T CreateWebhookCommand<T>(T command) where T : WebhookAggregateCommand |
|||
{ |
|||
command.WebhookId = WebhookId; |
|||
|
|||
return CreateCommand(command); |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue