mirror of https://github.com/Squidex/squidex.git
Sebastian Stehle
9 years ago
50 changed files with 4944 additions and 9 deletions
@ -0,0 +1,30 @@ |
|||
// ==========================================================================
|
|||
// CachingProviderBase.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Microsoft.Extensions.Caching.Memory; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities |
|||
{ |
|||
public abstract class CachingProviderBase |
|||
{ |
|||
private readonly IMemoryCache cache; |
|||
|
|||
protected IMemoryCache Cache |
|||
{ |
|||
get { return cache; } |
|||
} |
|||
|
|||
protected CachingProviderBase(IMemoryCache cache) |
|||
{ |
|||
Guard.NotNull(cache, nameof(cache)); |
|||
|
|||
this.cache = cache; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
// ==========================================================================
|
|||
// ContentHistoryEventsCreator.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Entities.History; |
|||
using Squidex.Domain.Apps.Events.Contents; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.EventSourcing; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public sealed class ContentHistoryEventsCreator : HistoryEventsCreatorBase |
|||
{ |
|||
public ContentHistoryEventsCreator(TypeNameRegistry typeNameRegistry) |
|||
: base(typeNameRegistry) |
|||
{ |
|||
AddEventMessage<ContentCreated>( |
|||
"created content item."); |
|||
|
|||
AddEventMessage<ContentUpdated>( |
|||
"updated content item."); |
|||
|
|||
AddEventMessage<ContentDeleted>( |
|||
"deleted content item."); |
|||
|
|||
AddEventMessage<ContentStatusChanged>( |
|||
"changed status of content item to {[Status]}."); |
|||
} |
|||
|
|||
protected override Task<HistoryEventToStore> CreateEventCoreAsync(Envelope<IEvent> @event) |
|||
{ |
|||
var channel = $"contents.{@event.Headers.AggregateId()}"; |
|||
|
|||
var result = ForEvent(@event.Payload, channel); |
|||
|
|||
if (@event.Payload is ContentStatusChanged contentStatusChanged) |
|||
{ |
|||
result = result.AddParameter("Status", contentStatusChanged.Status); |
|||
} |
|||
|
|||
return Task.FromResult(result); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,216 @@ |
|||
// ==========================================================================
|
|||
// ContentQueryService.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.OData; |
|||
using Microsoft.OData.UriParser; |
|||
using NodaTime; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Core.Scripting; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Contents.Edm; |
|||
using Squidex.Domain.Apps.Entities.Contents.Repositories; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.Reflection; |
|||
using Squidex.Infrastructure.Security; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public sealed class ContentQueryService : IContentQueryService |
|||
{ |
|||
private readonly IContentRepository contentRepository; |
|||
private readonly IAppProvider appProvider; |
|||
private readonly IScriptEngine scriptEngine; |
|||
private readonly EdmModelBuilder modelBuilder; |
|||
|
|||
public ContentQueryService( |
|||
IContentRepository contentRepository, |
|||
IAppProvider appProvider, |
|||
IScriptEngine scriptEngine, |
|||
EdmModelBuilder modelBuilder) |
|||
{ |
|||
Guard.NotNull(contentRepository, nameof(contentRepository)); |
|||
Guard.NotNull(scriptEngine, nameof(scriptEngine)); |
|||
Guard.NotNull(modelBuilder, nameof(modelBuilder)); |
|||
Guard.NotNull(appProvider, nameof(appProvider)); |
|||
|
|||
this.contentRepository = contentRepository; |
|||
this.appProvider = appProvider; |
|||
this.scriptEngine = scriptEngine; |
|||
this.modelBuilder = modelBuilder; |
|||
} |
|||
|
|||
public async Task<(ISchemaEntity Schema, IContentEntity Content)> FindContentAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, Guid id) |
|||
{ |
|||
Guard.NotNull(app, nameof(app)); |
|||
Guard.NotNull(user, nameof(user)); |
|||
Guard.NotNullOrEmpty(schemaIdOrName, nameof(schemaIdOrName)); |
|||
|
|||
var isFrontendClient = user.IsInClient("squidex-frontend"); |
|||
|
|||
var schema = await FindSchemaAsync(app, schemaIdOrName); |
|||
|
|||
var content = await contentRepository.FindContentAsync(app, schema, id); |
|||
|
|||
if (content == null || (content.Status != Status.Published && !isFrontendClient)) |
|||
{ |
|||
throw new DomainObjectNotFoundException(id.ToString(), typeof(ISchemaEntity)); |
|||
} |
|||
|
|||
content = TransformContent(user, schema, new List<IContentEntity> { content })[0]; |
|||
|
|||
return (schema, content); |
|||
} |
|||
|
|||
public async Task<(ISchemaEntity Schema, long Total, IReadOnlyList<IContentEntity> Items)> QueryWithCountAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, string query) |
|||
{ |
|||
Guard.NotNull(app, nameof(app)); |
|||
Guard.NotNull(user, nameof(user)); |
|||
Guard.NotNullOrEmpty(schemaIdOrName, nameof(schemaIdOrName)); |
|||
|
|||
var schema = await FindSchemaAsync(app, schemaIdOrName); |
|||
|
|||
var parsedQuery = ParseQuery(app, query, schema); |
|||
|
|||
var status = ParseStatus(user, archived); |
|||
|
|||
var taskForItems = contentRepository.QueryAsync(app, schema, status.ToArray(), parsedQuery); |
|||
var taskForCount = contentRepository.CountAsync(app, schema, status.ToArray(), parsedQuery); |
|||
|
|||
await Task.WhenAll(taskForItems, taskForCount); |
|||
|
|||
var list = TransformContent(user, schema, taskForItems.Result.ToList()); |
|||
|
|||
return (schema, taskForCount.Result, list); |
|||
} |
|||
|
|||
public async Task<(ISchemaEntity Schema, long Total, IReadOnlyList<IContentEntity> Items)> QueryWithCountAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, HashSet<Guid> ids) |
|||
{ |
|||
Guard.NotNull(ids, nameof(ids)); |
|||
Guard.NotNull(app, nameof(app)); |
|||
Guard.NotNull(user, nameof(user)); |
|||
Guard.NotNullOrEmpty(schemaIdOrName, nameof(schemaIdOrName)); |
|||
|
|||
var schema = await FindSchemaAsync(app, schemaIdOrName); |
|||
|
|||
var status = ParseStatus(user, archived); |
|||
|
|||
var taskForItems = contentRepository.QueryAsync(app, schema, status.ToArray(), ids); |
|||
var taskForCount = contentRepository.CountAsync(app, schema, status.ToArray(), ids); |
|||
|
|||
await Task.WhenAll(taskForItems, taskForCount); |
|||
|
|||
var list = TransformContent(user, schema, taskForItems.Result.ToList()); |
|||
|
|||
return (schema, taskForCount.Result, list); |
|||
} |
|||
|
|||
private List<IContentEntity> TransformContent(ClaimsPrincipal user, ISchemaEntity schema, List<IContentEntity> contents) |
|||
{ |
|||
var scriptText = schema.ScriptQuery; |
|||
|
|||
if (!string.IsNullOrWhiteSpace(scriptText)) |
|||
{ |
|||
for (var i = 0; i < contents.Count; i++) |
|||
{ |
|||
var content = contents[i]; |
|||
var contentData = scriptEngine.Transform(new ScriptContext { User = user, Data = content.Data, ContentId = content.Id }, scriptText); |
|||
|
|||
contents[i] = SimpleMapper.Map(content, new Content { Data = contentData }); |
|||
} |
|||
} |
|||
|
|||
return contents; |
|||
} |
|||
|
|||
private ODataUriParser ParseQuery(IAppEntity app, string query, ISchemaEntity schema) |
|||
{ |
|||
try |
|||
{ |
|||
var model = modelBuilder.BuildEdmModel(schema, app); |
|||
|
|||
return model.ParseQuery(query); |
|||
} |
|||
catch (ODataException ex) |
|||
{ |
|||
throw new ValidationException($"Failed to parse query: {ex.Message}", ex); |
|||
} |
|||
} |
|||
|
|||
public async Task<ISchemaEntity> FindSchemaAsync(IAppEntity app, string schemaIdOrName) |
|||
{ |
|||
Guard.NotNull(app, nameof(app)); |
|||
|
|||
ISchemaEntity schema = null; |
|||
|
|||
if (Guid.TryParse(schemaIdOrName, out var id)) |
|||
{ |
|||
schema = await appProvider.GetSchemaAsync(app.Name, id); |
|||
} |
|||
|
|||
if (schema == null) |
|||
{ |
|||
schema = await appProvider.GetSchemaAsync(app.Name, schemaIdOrName); |
|||
} |
|||
|
|||
if (schema == null) |
|||
{ |
|||
throw new DomainObjectNotFoundException(schemaIdOrName, typeof(ISchemaEntity)); |
|||
} |
|||
|
|||
return schema; |
|||
} |
|||
|
|||
private static List<Status> ParseStatus(ClaimsPrincipal user, bool archived) |
|||
{ |
|||
var status = new List<Status>(); |
|||
|
|||
if (user.IsInClient("squidex-frontend")) |
|||
{ |
|||
if (archived) |
|||
{ |
|||
status.Add(Status.Archived); |
|||
} |
|||
else |
|||
{ |
|||
status.Add(Status.Draft); |
|||
status.Add(Status.Published); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
status.Add(Status.Published); |
|||
} |
|||
|
|||
return status; |
|||
} |
|||
|
|||
private sealed class Content : IContentEntity |
|||
{ |
|||
public Guid Id { get; set; } |
|||
public Guid AppId { get; set; } |
|||
|
|||
public long Version { get; set; } |
|||
|
|||
public Instant Created { get; set; } |
|||
public Instant LastModified { get; set; } |
|||
|
|||
public RefToken CreatedBy { get; set; } |
|||
public RefToken LastModifiedBy { get; set; } |
|||
|
|||
public NamedContentData Data { get; set; } |
|||
|
|||
public Status Status { get; set; } |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,74 @@ |
|||
// ==========================================================================
|
|||
// EdmModelBuilder.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Microsoft.Extensions.Caching.Memory; |
|||
using Microsoft.OData.Edm; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.GenerateEdmSchema; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.Edm |
|||
{ |
|||
public class EdmModelBuilder : CachingProviderBase |
|||
{ |
|||
public EdmModelBuilder(IMemoryCache cache) |
|||
: base(cache) |
|||
{ |
|||
} |
|||
|
|||
public virtual IEdmModel BuildEdmModel(ISchemaEntity schema, IAppEntity app) |
|||
{ |
|||
Guard.NotNull(schema, nameof(schema)); |
|||
|
|||
var cacheKey = $"{schema.Id}_{schema.Version}_{app.Id}_{app.Version}"; |
|||
|
|||
var result = Cache.GetOrCreate<IEdmModel>(cacheKey, entry => |
|||
{ |
|||
entry.AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(60); |
|||
|
|||
return BuildEdmModel(schema.SchemaDef, app.PartitionResolver()); |
|||
}); |
|||
|
|||
return result; |
|||
} |
|||
|
|||
private static EdmModel BuildEdmModel(Schema schema, PartitionResolver partitionResolver) |
|||
{ |
|||
var model = new EdmModel(); |
|||
|
|||
var container = new EdmEntityContainer("Squidex", "Container"); |
|||
|
|||
var schemaType = schema.BuildEdmType(partitionResolver, x => |
|||
{ |
|||
model.AddElement(x); |
|||
|
|||
return x; |
|||
}); |
|||
|
|||
var entityType = new EdmEntityType("Squidex", schema.Name); |
|||
entityType.AddStructuralProperty("data", new EdmComplexTypeReference(schemaType, false)); |
|||
entityType.AddStructuralProperty("version", EdmPrimitiveTypeKind.Int32); |
|||
entityType.AddStructuralProperty("created", EdmPrimitiveTypeKind.DateTimeOffset); |
|||
entityType.AddStructuralProperty("createdBy", EdmPrimitiveTypeKind.String); |
|||
entityType.AddStructuralProperty("lastModified", EdmPrimitiveTypeKind.DateTimeOffset); |
|||
entityType.AddStructuralProperty("lastModifiedBy", EdmPrimitiveTypeKind.String); |
|||
|
|||
model.AddElement(container); |
|||
model.AddElement(schemaType); |
|||
model.AddElement(entityType); |
|||
|
|||
container.AddEntitySet("ContentSet", entityType); |
|||
|
|||
return model; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
// ==========================================================================
|
|||
// EdmModelExtensions.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Linq; |
|||
using Microsoft.OData.Edm; |
|||
using Microsoft.OData.UriParser; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.Edm |
|||
{ |
|||
public static class EdmModelExtensions |
|||
{ |
|||
public static ODataUriParser ParseQuery(this IEdmModel model, string query) |
|||
{ |
|||
if (!model.EntityContainer.EntitySets().Any()) |
|||
{ |
|||
return null; |
|||
} |
|||
|
|||
query = query ?? string.Empty; |
|||
|
|||
var path = model.EntityContainer.EntitySets().First().Path.Path.Split('.').Last(); |
|||
|
|||
if (query.StartsWith("?", StringComparison.Ordinal)) |
|||
{ |
|||
query = query.Substring(1); |
|||
} |
|||
|
|||
var parser = new ODataUriParser(model, new Uri($"{path}?{query}", UriKind.Relative)); |
|||
|
|||
return parser; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,85 @@ |
|||
// ==========================================================================
|
|||
// CachingGraphQLService.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Linq; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.Extensions.Caching.Memory; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets.Repositories; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public sealed class CachingGraphQLService : CachingProviderBase, IGraphQLService |
|||
{ |
|||
private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(10); |
|||
private readonly IContentQueryService contentQuery; |
|||
private readonly IGraphQLUrlGenerator urlGenerator; |
|||
private readonly IAssetRepository assetRepository; |
|||
private readonly IAppProvider appProvider; |
|||
|
|||
public CachingGraphQLService(IMemoryCache cache, |
|||
IAppProvider appProvider, |
|||
IAssetRepository assetRepository, |
|||
IContentQueryService contentQuery, |
|||
IGraphQLUrlGenerator urlGenerator) |
|||
: base(cache) |
|||
{ |
|||
Guard.NotNull(appProvider, nameof(appProvider)); |
|||
Guard.NotNull(assetRepository, nameof(assetRepository)); |
|||
Guard.NotNull(contentQuery, nameof(urlGenerator)); |
|||
Guard.NotNull(contentQuery, nameof(contentQuery)); |
|||
|
|||
this.appProvider = appProvider; |
|||
this.assetRepository = assetRepository; |
|||
this.contentQuery = contentQuery; |
|||
this.urlGenerator = urlGenerator; |
|||
} |
|||
|
|||
public async Task<(object Data, object[] Errors)> QueryAsync(IAppEntity app, ClaimsPrincipal user, GraphQLQuery query) |
|||
{ |
|||
Guard.NotNull(app, nameof(app)); |
|||
Guard.NotNull(query, nameof(query)); |
|||
|
|||
if (string.IsNullOrWhiteSpace(query.Query)) |
|||
{ |
|||
return (new object(), new object[0]); |
|||
} |
|||
|
|||
var modelContext = await GetModelAsync(app); |
|||
var queryContext = new GraphQLQueryContext(app, assetRepository, contentQuery, user, urlGenerator); |
|||
|
|||
return await modelContext.ExecuteAsync(queryContext, query); |
|||
} |
|||
|
|||
private async Task<GraphQLModel> GetModelAsync(IAppEntity app) |
|||
{ |
|||
var cacheKey = CreateCacheKey(app.Id, app.Version.ToString()); |
|||
|
|||
var modelContext = Cache.Get<GraphQLModel>(cacheKey); |
|||
|
|||
if (modelContext == null) |
|||
{ |
|||
var allSchemas = await appProvider.GetSchemasAsync(app.Name); |
|||
|
|||
modelContext = new GraphQLModel(app, allSchemas.Where(x => x.IsPublished), urlGenerator); |
|||
|
|||
Cache.Set(cacheKey, modelContext, CacheDuration); |
|||
} |
|||
|
|||
return modelContext; |
|||
} |
|||
|
|||
private static object CreateCacheKey(Guid appId, string etag) |
|||
{ |
|||
return $"GraphQLModel_{appId}_{etag}"; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,229 @@ |
|||
// ==========================================================================
|
|||
// GraphQLContext.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Threading.Tasks; |
|||
using GraphQL; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Contents.GraphQL.Types; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using GraphQLSchema = GraphQL.Types.Schema; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public sealed class GraphQLModel : IGraphQLContext |
|||
{ |
|||
private readonly Dictionary<Type, Func<Field, (IGraphType ResolveType, IFieldResolver Resolver)>> fieldInfos; |
|||
private readonly Dictionary<Guid, ContentGraphType> schemaTypes = new Dictionary<Guid, ContentGraphType>(); |
|||
private readonly Dictionary<Guid, ISchemaEntity> schemas; |
|||
private readonly PartitionResolver partitionResolver; |
|||
private readonly IAppEntity app; |
|||
private readonly IGraphType assetType; |
|||
private readonly IGraphType assetListType; |
|||
private readonly GraphQLSchema graphQLSchema; |
|||
|
|||
public bool CanGenerateAssetSourceUrl { get; } |
|||
|
|||
public GraphQLModel(IAppEntity app, IEnumerable<ISchemaEntity> schemas, IGraphQLUrlGenerator urlGenerator) |
|||
{ |
|||
this.app = app; |
|||
|
|||
CanGenerateAssetSourceUrl = urlGenerator.CanGenerateAssetSourceUrl; |
|||
|
|||
partitionResolver = app.PartitionResolver(); |
|||
|
|||
assetType = new AssetGraphType(this); |
|||
assetListType = new ListGraphType(new NonNullGraphType(assetType)); |
|||
|
|||
fieldInfos = new Dictionary<Type, Func<Field, (IGraphType ResolveType, IFieldResolver Resolver)>> |
|||
{ |
|||
{ |
|||
typeof(StringField), |
|||
field => ResolveDefault("String") |
|||
}, |
|||
{ |
|||
typeof(BooleanField), |
|||
field => ResolveDefault("Boolean") |
|||
}, |
|||
{ |
|||
typeof(NumberField), |
|||
field => ResolveDefault("Float") |
|||
}, |
|||
{ |
|||
typeof(DateTimeField), |
|||
field => ResolveDefault("Date") |
|||
}, |
|||
{ |
|||
typeof(JsonField), |
|||
field => ResolveDefault("Json") |
|||
}, |
|||
{ |
|||
typeof(TagsField), |
|||
field => ResolveDefault("String") |
|||
}, |
|||
{ |
|||
typeof(GeolocationField), |
|||
field => ResolveDefault("Geolocation") |
|||
}, |
|||
{ |
|||
typeof(AssetsField), |
|||
field => ResolveAssets(assetListType) |
|||
}, |
|||
{ |
|||
typeof(ReferencesField), |
|||
field => ResolveReferences(field) |
|||
} |
|||
}; |
|||
|
|||
this.schemas = schemas.ToDictionary(x => x.Id); |
|||
|
|||
graphQLSchema = new GraphQLSchema { Query = new ContentQueryGraphType(this, this.schemas.Values) }; |
|||
|
|||
foreach (var schemaType in schemaTypes.Values) |
|||
{ |
|||
schemaType.Initialize(); |
|||
} |
|||
} |
|||
|
|||
private static (IGraphType ResolveType, IFieldResolver Resolver) ResolveDefault(string name) |
|||
{ |
|||
return (new NoopGraphType(name), new FuncFieldResolver<ContentFieldData, object>(c => c.Source.GetOrDefault(c.FieldName))); |
|||
} |
|||
|
|||
public IFieldResolver ResolveAssetUrl() |
|||
{ |
|||
var resolver = new FuncFieldResolver<IAssetEntity, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
|
|||
return context.UrlGenerator.GenerateAssetUrl(app, c.Source); |
|||
}); |
|||
|
|||
return resolver; |
|||
} |
|||
|
|||
public IFieldResolver ResolveAssetSourceUrl() |
|||
{ |
|||
var resolver = new FuncFieldResolver<IAssetEntity, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
|
|||
return context.UrlGenerator.GenerateAssetSourceUrl(app, c.Source); |
|||
}); |
|||
|
|||
return resolver; |
|||
} |
|||
|
|||
public IFieldResolver ResolveAssetThumbnailUrl() |
|||
{ |
|||
var resolver = new FuncFieldResolver<IAssetEntity, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
|
|||
return context.UrlGenerator.GenerateAssetThumbnailUrl(app, c.Source); |
|||
}); |
|||
|
|||
return resolver; |
|||
} |
|||
|
|||
public IFieldResolver ResolveContentUrl(ISchemaEntity schema) |
|||
{ |
|||
var resolver = new FuncFieldResolver<IContentEntity, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
|
|||
return context.UrlGenerator.GenerateContentUrl(app, schema, c.Source); |
|||
}); |
|||
|
|||
return resolver; |
|||
} |
|||
|
|||
private static ValueTuple<IGraphType, IFieldResolver> ResolveAssets(IGraphType assetListType) |
|||
{ |
|||
var resolver = new FuncFieldResolver<ContentFieldData, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
var contentIds = c.Source.GetOrDefault(c.FieldName); |
|||
|
|||
return context.GetReferencedAssetsAsync(contentIds); |
|||
}); |
|||
|
|||
return (assetListType, resolver); |
|||
} |
|||
|
|||
private ValueTuple<IGraphType, IFieldResolver> ResolveReferences(Field field) |
|||
{ |
|||
var schemaId = ((ReferencesField)field).Properties.SchemaId; |
|||
var schemaType = GetSchemaType(schemaId); |
|||
|
|||
if (schemaType == null) |
|||
{ |
|||
return (null, null); |
|||
} |
|||
|
|||
var resolver = new FuncFieldResolver<ContentFieldData, object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
var contentIds = c.Source.GetOrDefault(c.FieldName); |
|||
|
|||
return context.GetReferencedContentsAsync(schemaId, contentIds); |
|||
}); |
|||
|
|||
var schemaFieldType = new ListGraphType(new NonNullGraphType(GetSchemaType(schemaId))); |
|||
|
|||
return (schemaFieldType, resolver); |
|||
} |
|||
|
|||
public async Task<(object Data, object[] Errors)> ExecuteAsync(GraphQLQueryContext context, GraphQLQuery query) |
|||
{ |
|||
Guard.NotNull(context, nameof(context)); |
|||
|
|||
var result = await new DocumentExecuter().ExecuteAsync(options => |
|||
{ |
|||
options.Query = query.Query; |
|||
options.Schema = graphQLSchema; |
|||
options.Inputs = query.Variables?.ToInputs() ?? new Inputs(); |
|||
options.UserContext = context; |
|||
options.OperationName = query.OperationName; |
|||
}).ConfigureAwait(false); |
|||
|
|||
return (result.Data, result.Errors?.Select(x => (object)new { x.Message, x.Locations }).ToArray()); |
|||
} |
|||
|
|||
public IFieldPartitioning ResolvePartition(Partitioning key) |
|||
{ |
|||
return partitionResolver(key); |
|||
} |
|||
|
|||
public IGraphType GetAssetType() |
|||
{ |
|||
return assetType; |
|||
} |
|||
|
|||
public (IGraphType ResolveType, IFieldResolver Resolver) GetGraphType(Field field) |
|||
{ |
|||
return fieldInfos[field.GetType()](field); |
|||
} |
|||
|
|||
public IGraphType GetSchemaType(Guid schemaId) |
|||
{ |
|||
var schema = schemas.GetOrDefault(schemaId); |
|||
|
|||
return schema != null ? schemaTypes.GetOrAdd(schemaId, k => new ContentGraphType(schema, this)) : null; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,23 @@ |
|||
// ==========================================================================
|
|||
// GraphQLQuery.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Newtonsoft.Json.Linq; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public class GraphQLQuery |
|||
{ |
|||
public string OperationName { get; set; } |
|||
|
|||
public string NamedQuery { get; set; } |
|||
|
|||
public string Query { get; set; } |
|||
|
|||
public JObject Variables { get; set; } |
|||
} |
|||
} |
|||
@ -0,0 +1,67 @@ |
|||
// ==========================================================================
|
|||
// GraphQLQueryContext.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Newtonsoft.Json.Linq; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Assets.Repositories; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public sealed class GraphQLQueryContext : QueryContext |
|||
{ |
|||
public IGraphQLUrlGenerator UrlGenerator { get; } |
|||
|
|||
public GraphQLQueryContext(IAppEntity app, IAssetRepository assetRepository, IContentQueryService contentQuery, ClaimsPrincipal user, |
|||
IGraphQLUrlGenerator urlGenerator) |
|||
: base(app, assetRepository, contentQuery, user) |
|||
{ |
|||
UrlGenerator = urlGenerator; |
|||
} |
|||
|
|||
public Task<IReadOnlyList<IAssetEntity>> GetReferencedAssetsAsync(JToken value) |
|||
{ |
|||
var ids = ParseIds(value); |
|||
|
|||
return GetReferencedAssetsAsync(ids); |
|||
} |
|||
|
|||
public Task<IReadOnlyList<IContentEntity>> GetReferencedContentsAsync(Guid schemaId, JToken value) |
|||
{ |
|||
var ids = ParseIds(value); |
|||
|
|||
return GetReferencedContentsAsync(schemaId, ids); |
|||
} |
|||
|
|||
private static ICollection<Guid> ParseIds(JToken value) |
|||
{ |
|||
try |
|||
{ |
|||
var result = new List<Guid>(); |
|||
|
|||
if (value is JArray) |
|||
{ |
|||
foreach (var id in value) |
|||
{ |
|||
result.Add(Guid.Parse(id.ToString())); |
|||
} |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
catch |
|||
{ |
|||
return new List<Guid>(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
// ==========================================================================
|
|||
// SchemaGraphType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public interface IGraphQLContext |
|||
{ |
|||
bool CanGenerateAssetSourceUrl { get; } |
|||
|
|||
IFieldPartitioning ResolvePartition(Partitioning key); |
|||
|
|||
IGraphType GetAssetType(); |
|||
|
|||
IGraphType GetSchemaType(Guid schemaId); |
|||
|
|||
IFieldResolver ResolveAssetUrl(); |
|||
|
|||
IFieldResolver ResolveAssetSourceUrl(); |
|||
|
|||
IFieldResolver ResolveAssetThumbnailUrl(); |
|||
|
|||
IFieldResolver ResolveContentUrl(ISchemaEntity schema); |
|||
|
|||
(IGraphType ResolveType, IFieldResolver Resolver) GetGraphType(Field field); |
|||
} |
|||
} |
|||
@ -0,0 +1,19 @@ |
|||
// ==========================================================================
|
|||
// IGraphQLService.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public interface IGraphQLService |
|||
{ |
|||
Task<(object Data, object[] Errors)> QueryAsync(IAppEntity app, ClaimsPrincipal user, GraphQLQuery query); |
|||
} |
|||
} |
|||
@ -0,0 +1,27 @@ |
|||
// ==========================================================================
|
|||
// IGraphQLUrlGenerator.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL |
|||
{ |
|||
public interface IGraphQLUrlGenerator |
|||
{ |
|||
bool CanGenerateAssetSourceUrl { get; } |
|||
|
|||
string GenerateAssetUrl(IAppEntity app, IAssetEntity asset); |
|||
|
|||
string GenerateAssetThumbnailUrl(IAppEntity app, IAssetEntity asset); |
|||
|
|||
string GenerateAssetSourceUrl(IAppEntity app, IAssetEntity asset); |
|||
|
|||
string GenerateContentUrl(IAppEntity app, ISchemaEntity schema, IContentEntity content); |
|||
} |
|||
} |
|||
@ -0,0 +1,170 @@ |
|||
// ==========================================================================
|
|||
// AssetGraphType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types |
|||
{ |
|||
public sealed class AssetGraphType : ObjectGraphType<IAssetEntity> |
|||
{ |
|||
public AssetGraphType(IGraphQLContext context) |
|||
{ |
|||
Name = "AssetDto"; |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "id", |
|||
Resolver = Resolver(x => x.Id.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The id of the asset." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "version", |
|||
Resolver = Resolver(x => x.Version), |
|||
ResolvedType = new NonNullGraphType(new IntGraphType()), |
|||
Description = "The version of the asset." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "created", |
|||
Resolver = Resolver(x => x.Created.ToDateTimeUtc()), |
|||
ResolvedType = new NonNullGraphType(new DateGraphType()), |
|||
Description = "The date and time when the asset has been created." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "createdBy", |
|||
Resolver = Resolver(x => x.CreatedBy.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The user that has created the asset." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "lastModified", |
|||
Resolver = Resolver(x => x.LastModified.ToDateTimeUtc()), |
|||
ResolvedType = new NonNullGraphType(new DateGraphType()), |
|||
Description = "The date and time when the asset has been modified last." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "lastModifiedBy", |
|||
Resolver = Resolver(x => x.LastModifiedBy.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The user that has updated the asset last." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "mimeType", |
|||
Resolver = Resolver(x => x.MimeType), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The mime type." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "url", |
|||
Resolver = context.ResolveAssetUrl(), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The url to the asset." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "thumbnailUrl", |
|||
Resolver = context.ResolveAssetThumbnailUrl(), |
|||
ResolvedType = new StringGraphType(), |
|||
Description = "The thumbnail url to the asset." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "fileName", |
|||
Resolver = Resolver(x => x.FileName), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The file name." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "fileType", |
|||
Resolver = Resolver(x => x.FileName.FileType()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = "The file type." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "fileSize", |
|||
Resolver = Resolver(x => x.FileSize), |
|||
ResolvedType = new NonNullGraphType(new IntGraphType()), |
|||
Description = "The size of the file in bytes." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "fileVersion", |
|||
Resolver = Resolver(x => x.FileVersion), |
|||
ResolvedType = new NonNullGraphType(new IntGraphType()), |
|||
Description = "The version of the file." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "isImage", |
|||
Resolver = Resolver(x => x.IsImage), |
|||
ResolvedType = new NonNullGraphType(new BooleanGraphType()), |
|||
Description = "Determines of the created file is an image." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "pixelWidth", |
|||
Resolver = Resolver(x => x.PixelWidth), |
|||
ResolvedType = new IntGraphType(), |
|||
Description = "The width of the image in pixels if the asset is an image." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "pixelHeight", |
|||
Resolver = Resolver(x => x.PixelHeight), |
|||
ResolvedType = new IntGraphType(), |
|||
Description = "The height of the image in pixels if the asset is an image." |
|||
}); |
|||
|
|||
if (context.CanGenerateAssetSourceUrl) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = "sourceUrl", |
|||
Resolver = context.ResolveAssetSourceUrl(), |
|||
ResolvedType = new StringGraphType(), |
|||
Description = "The source url of the asset." |
|||
}); |
|||
} |
|||
|
|||
Description = "An asset"; |
|||
} |
|||
|
|||
private static IFieldResolver Resolver(Func<IAssetEntity, object> action) |
|||
{ |
|||
return new FuncFieldResolver<IAssetEntity, object>(c => action(c.Source)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,68 @@ |
|||
// ==========================================================================
|
|||
// ContentDataGraphType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Linq; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Infrastructure; |
|||
using Schema = Squidex.Domain.Apps.Core.Schemas.Schema; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types |
|||
{ |
|||
public sealed class ContentDataGraphType : ObjectGraphType<NamedContentData> |
|||
{ |
|||
public ContentDataGraphType(Schema schema, IGraphQLContext context) |
|||
{ |
|||
var schemaName = schema.Properties.Label.WithFallback(schema.Name); |
|||
|
|||
Name = $"{schema.Name.ToPascalCase()}DataDto"; |
|||
|
|||
foreach (var field in schema.Fields.Where(x => !x.IsHidden)) |
|||
{ |
|||
var fieldInfo = context.GetGraphType(field); |
|||
|
|||
if (fieldInfo.ResolveType != null) |
|||
{ |
|||
var fieldName = field.RawProperties.Label.WithFallback(field.Name); |
|||
|
|||
var fieldGraphType = new ObjectGraphType |
|||
{ |
|||
Name = $"{schema.Name.ToPascalCase()}Data{field.Name.ToPascalCase()}Dto" |
|||
}; |
|||
|
|||
var partition = context.ResolvePartition(field.Partitioning); |
|||
|
|||
foreach (var partitionItem in partition) |
|||
{ |
|||
fieldGraphType.AddField(new FieldType |
|||
{ |
|||
Name = partitionItem.Key, |
|||
Resolver = fieldInfo.Resolver, |
|||
ResolvedType = fieldInfo.ResolveType, |
|||
Description = field.RawProperties.Hints |
|||
}); |
|||
} |
|||
|
|||
fieldGraphType.Description = $"The structure of the {fieldName} of a {schemaName} content type."; |
|||
|
|||
var fieldResolver = new FuncFieldResolver<NamedContentData, ContentFieldData>(c => c.Source.GetOrDefault(field.Name)); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = field.Name.ToCamelCase(), |
|||
Resolver = fieldResolver, |
|||
ResolvedType = fieldGraphType |
|||
}); |
|||
} |
|||
} |
|||
|
|||
Description = $"The structure of a {schemaName} content type."; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,112 @@ |
|||
// ==========================================================================
|
|||
// SchemaGraphType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Linq; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types |
|||
{ |
|||
public sealed class ContentGraphType : ObjectGraphType<IContentEntity> |
|||
{ |
|||
private readonly ISchemaEntity schema; |
|||
private readonly IGraphQLContext context; |
|||
|
|||
public ContentGraphType(ISchemaEntity schema, IGraphQLContext context) |
|||
{ |
|||
this.context = context; |
|||
this.schema = schema; |
|||
|
|||
Name = $"{schema.Name.ToPascalCase()}Dto"; |
|||
} |
|||
|
|||
public void Initialize() |
|||
{ |
|||
var schemaName = schema.SchemaDef.Properties.Label.WithFallback(schema.Name); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "id", |
|||
Resolver = Resolver(x => x.Id.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = $"The id of the {schemaName} content." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "version", |
|||
Resolver = Resolver(x => x.Version), |
|||
ResolvedType = new NonNullGraphType(new IntGraphType()), |
|||
Description = $"The version of the {schemaName} content." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "created", |
|||
Resolver = Resolver(x => x.Created.ToDateTimeUtc()), |
|||
ResolvedType = new NonNullGraphType(new DateGraphType()), |
|||
Description = $"The date and time when the {schemaName} content has been created." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "createdBy", |
|||
Resolver = Resolver(x => x.CreatedBy.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = $"The user that has created the {schemaName} content." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "lastModified", |
|||
Resolver = Resolver(x => x.LastModified.ToDateTimeUtc()), |
|||
ResolvedType = new NonNullGraphType(new DateGraphType()), |
|||
Description = $"The date and time when the {schemaName} content has been modified last." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "lastModifiedBy", |
|||
Resolver = Resolver(x => x.LastModifiedBy.ToString()), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = $"The user that has updated the {schemaName} content last." |
|||
}); |
|||
|
|||
AddField(new FieldType |
|||
{ |
|||
Name = "url", |
|||
Resolver = context.ResolveContentUrl(schema), |
|||
ResolvedType = new NonNullGraphType(new StringGraphType()), |
|||
Description = $"The url to the the {schemaName} content." |
|||
}); |
|||
|
|||
var dataType = new ContentDataGraphType(schema.SchemaDef, context); |
|||
|
|||
if (dataType.Fields.Any()) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = "data", |
|||
Resolver = Resolver(x => x.Data), |
|||
ResolvedType = new NonNullGraphType(dataType), |
|||
Description = $"The data of the {schemaName} content." |
|||
}); |
|||
} |
|||
|
|||
Description = $"The structure of a {schemaName} content type."; |
|||
} |
|||
|
|||
private static IFieldResolver Resolver(Func<IContentEntity, object> action) |
|||
{ |
|||
return new FuncFieldResolver<IContentEntity, object>(c => action(c.Source)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,192 @@ |
|||
// ==========================================================================
|
|||
// GraphModelType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using GraphQL.Resolvers; |
|||
using GraphQL.Types; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types |
|||
{ |
|||
public sealed class ContentQueryGraphType : ObjectGraphType |
|||
{ |
|||
public ContentQueryGraphType(IGraphQLContext graphQLContext, IEnumerable<ISchemaEntity> schemas) |
|||
{ |
|||
AddAssetFind(graphQLContext); |
|||
AddAssetsQuery(graphQLContext); |
|||
|
|||
foreach (var schema in schemas) |
|||
{ |
|||
var schemaName = schema.SchemaDef.Properties.Label.WithFallback(schema.SchemaDef.Name); |
|||
var schemaType = graphQLContext.GetSchemaType(schema.Id); |
|||
|
|||
AddContentFind(schema, schemaType, schemaName); |
|||
AddContentQuery(schema, schemaType, schemaName); |
|||
} |
|||
|
|||
Description = "The app queries."; |
|||
} |
|||
|
|||
private void AddAssetFind(IGraphQLContext graphQLContext) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = "findAsset", |
|||
Arguments = new QueryArguments |
|||
{ |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "id", |
|||
Description = "The id of the asset.", |
|||
DefaultValue = string.Empty |
|||
} |
|||
}, |
|||
ResolvedType = graphQLContext.GetAssetType(), |
|||
Resolver = new FuncFieldResolver<object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
var contentId = Guid.Parse(c.GetArgument("id", Guid.Empty.ToString())); |
|||
|
|||
return context.FindAssetAsync(contentId); |
|||
}), |
|||
Description = "Find an asset by id." |
|||
}); |
|||
} |
|||
|
|||
private void AddContentFind(ISchemaEntity schema, IGraphType schemaType, string schemaName) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = $"find{schema.Name.ToPascalCase()}Content", |
|||
Arguments = new QueryArguments |
|||
{ |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "id", |
|||
Description = $"The id of the {schemaName} content.", |
|||
DefaultValue = string.Empty |
|||
} |
|||
}, |
|||
ResolvedType = schemaType, |
|||
Resolver = new FuncFieldResolver<object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
var contentId = Guid.Parse(c.GetArgument("id", Guid.Empty.ToString())); |
|||
|
|||
return context.FindContentAsync(schema.Id, contentId); |
|||
}), |
|||
Description = $"Find an {schemaName} content by id." |
|||
}); |
|||
} |
|||
|
|||
private void AddAssetsQuery(IGraphQLContext graphQLContext) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = "queryAssets", |
|||
Arguments = new QueryArguments |
|||
{ |
|||
new QueryArgument(typeof(IntGraphType)) |
|||
{ |
|||
Name = "top", |
|||
Description = "Optional number of assets to take.", |
|||
DefaultValue = 20 |
|||
}, |
|||
new QueryArgument(typeof(IntGraphType)) |
|||
{ |
|||
Name = "skip", |
|||
Description = "Optional number of assets to skip.", |
|||
DefaultValue = 0 |
|||
}, |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "search", |
|||
Description = "Optional query.", |
|||
DefaultValue = string.Empty |
|||
} |
|||
}, |
|||
ResolvedType = new ListGraphType(new NonNullGraphType(graphQLContext.GetAssetType())), |
|||
Resolver = new FuncFieldResolver<object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
|
|||
var argTop = c.GetArgument("top", 20); |
|||
var argSkip = c.GetArgument("skip", 0); |
|||
var argQuery = c.GetArgument("search", string.Empty); |
|||
|
|||
return context.QueryAssetsAsync(argQuery, argSkip, argTop); |
|||
}), |
|||
Description = "Query assets items." |
|||
}); |
|||
} |
|||
|
|||
private void AddContentQuery(ISchemaEntity schema, IGraphType schemaType, string schemaName) |
|||
{ |
|||
AddField(new FieldType |
|||
{ |
|||
Name = $"query{schema.Name.ToPascalCase()}Contents", |
|||
Arguments = new QueryArguments |
|||
{ |
|||
new QueryArgument(typeof(IntGraphType)) |
|||
{ |
|||
Name = "top", |
|||
Description = "Optional number of contents to take.", |
|||
DefaultValue = 20 |
|||
}, |
|||
new QueryArgument(typeof(IntGraphType)) |
|||
{ |
|||
Name = "skip", |
|||
Description = "Optional number of contents to skip.", |
|||
DefaultValue = 0 |
|||
}, |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "filter", |
|||
Description = "Optional OData filter.", |
|||
DefaultValue = string.Empty |
|||
}, |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "search", |
|||
Description = "Optional OData full text search.", |
|||
DefaultValue = string.Empty |
|||
}, |
|||
new QueryArgument(typeof(StringGraphType)) |
|||
{ |
|||
Name = "orderby", |
|||
Description = "Optional OData order definition.", |
|||
DefaultValue = string.Empty |
|||
} |
|||
}, |
|||
ResolvedType = new ListGraphType(new NonNullGraphType(schemaType)), |
|||
Resolver = new FuncFieldResolver<object>(c => |
|||
{ |
|||
var context = (GraphQLQueryContext)c.UserContext; |
|||
var contentQuery = BuildODataQuery(c); |
|||
|
|||
return context.QueryContentsAsync(schema.Id.ToString(), contentQuery); |
|||
}), |
|||
Description = $"Query {schemaName} content items." |
|||
}); |
|||
} |
|||
|
|||
private static string BuildODataQuery(ResolveFieldContext c) |
|||
{ |
|||
var odataQuery = "?" + |
|||
string.Join("&", |
|||
c.Arguments |
|||
.Select(x => new { x.Key, Value = x.Value.ToString() }).Where(x => !string.IsNullOrWhiteSpace(x.Value)) |
|||
.Select(x => $"${x.Key}={x.Value}")); |
|||
|
|||
return odataQuery; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,37 @@ |
|||
// ==========================================================================
|
|||
// NoopGraphType.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using GraphQL.Language.AST; |
|||
using GraphQL.Types; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.GraphQL.Types |
|||
{ |
|||
public sealed class NoopGraphType : ScalarGraphType |
|||
{ |
|||
public NoopGraphType(string name) |
|||
{ |
|||
Name = name; |
|||
} |
|||
|
|||
public override object Serialize(object value) |
|||
{ |
|||
return value; |
|||
} |
|||
|
|||
public override object ParseValue(object value) |
|||
{ |
|||
return value; |
|||
} |
|||
|
|||
public override object ParseLiteral(IValue value) |
|||
{ |
|||
throw new NotSupportedException(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,25 @@ |
|||
// ==========================================================================
|
|||
// IContentEntity.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public interface IContentEntity : |
|||
IEntity, |
|||
IEntityWithAppRef, |
|||
IEntityWithCreatedBy, |
|||
IEntityWithLastModifiedBy, |
|||
IEntityWithVersion |
|||
{ |
|||
Status Status { get; } |
|||
|
|||
NamedContentData Data { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
// ==========================================================================
|
|||
// IContentQueryService.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public interface IContentQueryService |
|||
{ |
|||
Task<(ISchemaEntity Schema, long Total, IReadOnlyList<IContentEntity> Items)> QueryWithCountAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, HashSet<Guid> ids); |
|||
|
|||
Task<(ISchemaEntity Schema, long Total, IReadOnlyList<IContentEntity> Items)> QueryWithCountAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, bool archived, string query); |
|||
|
|||
Task<(ISchemaEntity Schema, IContentEntity Content)> FindContentAsync(IAppEntity app, string schemaIdOrName, ClaimsPrincipal user, Guid id); |
|||
|
|||
Task<ISchemaEntity> FindSchemaAsync(IAppEntity app, string schemaIdOrName); |
|||
} |
|||
} |
|||
@ -0,0 +1,146 @@ |
|||
// ==========================================================================
|
|||
// QueryContext.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Concurrent; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Assets.Repositories; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public class QueryContext |
|||
{ |
|||
private readonly ConcurrentDictionary<Guid, IContentEntity> cachedContents = new ConcurrentDictionary<Guid, IContentEntity>(); |
|||
private readonly ConcurrentDictionary<Guid, IAssetEntity> cachedAssets = new ConcurrentDictionary<Guid, IAssetEntity>(); |
|||
private readonly IContentQueryService contentQuery; |
|||
private readonly IAssetRepository assetRepository; |
|||
private readonly IAppEntity app; |
|||
private readonly ClaimsPrincipal user; |
|||
|
|||
public QueryContext( |
|||
IAppEntity app, |
|||
IAssetRepository assetRepository, |
|||
IContentQueryService contentQuery, |
|||
ClaimsPrincipal user) |
|||
{ |
|||
Guard.NotNull(assetRepository, nameof(assetRepository)); |
|||
Guard.NotNull(contentQuery, nameof(contentQuery)); |
|||
Guard.NotNull(app, nameof(app)); |
|||
Guard.NotNull(user, nameof(user)); |
|||
|
|||
this.assetRepository = assetRepository; |
|||
this.contentQuery = contentQuery; |
|||
|
|||
this.user = user; |
|||
|
|||
this.app = app; |
|||
} |
|||
|
|||
public async Task<IAssetEntity> FindAssetAsync(Guid id) |
|||
{ |
|||
var asset = cachedAssets.GetOrDefault(id); |
|||
|
|||
if (asset == null) |
|||
{ |
|||
asset = await assetRepository.FindAssetAsync(id); |
|||
|
|||
if (asset != null) |
|||
{ |
|||
cachedAssets[asset.Id] = asset; |
|||
} |
|||
} |
|||
|
|||
return asset; |
|||
} |
|||
|
|||
public async Task<IContentEntity> FindContentAsync(Guid schemaId, Guid id) |
|||
{ |
|||
var content = cachedContents.GetOrDefault(id); |
|||
|
|||
if (content == null) |
|||
{ |
|||
content = (await contentQuery.FindContentAsync(app, schemaId.ToString(), user, id)).Content; |
|||
|
|||
if (content != null) |
|||
{ |
|||
cachedContents[content.Id] = content; |
|||
} |
|||
} |
|||
|
|||
return content; |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IAssetEntity>> QueryAssetsAsync(string query, int skip = 0, int take = 10) |
|||
{ |
|||
var assets = await assetRepository.QueryAsync(app.Id, null, null, query, take, skip); |
|||
|
|||
foreach (var asset in assets) |
|||
{ |
|||
cachedAssets[asset.Id] = asset; |
|||
} |
|||
|
|||
return assets; |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IContentEntity>> QueryContentsAsync(string schemaIdOrName, string query) |
|||
{ |
|||
var contents = await contentQuery.QueryWithCountAsync(app, schemaIdOrName, user, false, query); |
|||
|
|||
foreach (var content in contents.Items) |
|||
{ |
|||
cachedContents[content.Id] = content; |
|||
} |
|||
|
|||
return contents.Items; |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IAssetEntity>> GetReferencedAssetsAsync(ICollection<Guid> ids) |
|||
{ |
|||
Guard.NotNull(ids, nameof(ids)); |
|||
|
|||
var notLoadedAssets = new HashSet<Guid>(ids.Where(id => !cachedAssets.ContainsKey(id))); |
|||
|
|||
if (notLoadedAssets.Count > 0) |
|||
{ |
|||
var assets = await assetRepository.QueryAsync(app.Id, null, notLoadedAssets, null, int.MaxValue); |
|||
|
|||
foreach (var asset in assets) |
|||
{ |
|||
cachedAssets[asset.Id] = asset; |
|||
} |
|||
} |
|||
|
|||
return ids.Select(id => cachedAssets.GetOrDefault(id)).Where(x => x != null).ToList(); |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IContentEntity>> GetReferencedContentsAsync(Guid schemaId, ICollection<Guid> ids) |
|||
{ |
|||
Guard.NotNull(ids, nameof(ids)); |
|||
|
|||
var notLoadedContents = new HashSet<Guid>(ids.Where(id => !cachedContents.ContainsKey(id))); |
|||
|
|||
if (notLoadedContents.Count > 0) |
|||
{ |
|||
var contents = await contentQuery.QueryWithCountAsync(app, schemaId.ToString(), user, false, notLoadedContents); |
|||
|
|||
foreach (var content in contents.Items) |
|||
{ |
|||
cachedContents[content.Id] = content; |
|||
} |
|||
} |
|||
|
|||
return ids.Select(id => cachedContents.GetOrDefault(id)).Where(x => x != null).ToList(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,33 @@ |
|||
// ==========================================================================
|
|||
// IContentRepository.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.OData.UriParser; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.Repositories |
|||
{ |
|||
public interface IContentRepository |
|||
{ |
|||
Task<IReadOnlyList<IContentEntity>> QueryAsync(IAppEntity app, ISchemaEntity schema, Status[] status, HashSet<Guid> ids); |
|||
|
|||
Task<IReadOnlyList<IContentEntity>> QueryAsync(IAppEntity app, ISchemaEntity schema, Status[] status, ODataUriParser odataQuery); |
|||
|
|||
Task<IReadOnlyList<Guid>> QueryNotFoundAsync(Guid appId, Guid schemaId, IList<Guid> contentIds); |
|||
|
|||
Task<long> CountAsync(IAppEntity app, ISchemaEntity schema, Status[] status, HashSet<Guid> ids); |
|||
|
|||
Task<long> CountAsync(IAppEntity app, ISchemaEntity schema, Status[] status, ODataUriParser odataQuery); |
|||
|
|||
Task<IContentEntity> FindContentAsync(IAppEntity app, ISchemaEntity schema, Guid id); |
|||
} |
|||
} |
|||
@ -0,0 +1,244 @@ |
|||
// ==========================================================================
|
|||
// AppCommandMiddlewareTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Entities.Apps.Commands; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services.Implementations; |
|||
using Squidex.Domain.Apps.Entities.TestHelpers; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.Commands; |
|||
using Squidex.Shared.Users; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps |
|||
{ |
|||
public class AppCommandMiddlewareTests : HandlerTestBase<AppDomainObject> |
|||
{ |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly IAppPlansProvider appPlansProvider = A.Fake<IAppPlansProvider>(); |
|||
private readonly IAppPlanBillingManager appPlansBillingManager = A.Fake<IAppPlanBillingManager>(); |
|||
private readonly IUserResolver userResolver = A.Fake<IUserResolver>(); |
|||
private readonly 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(); |
|||
|
|||
A.CallTo(() => appProvider.GetAppAsync(AppName)) |
|||
.Returns((IAppEntity)null); |
|||
|
|||
A.CallTo(() => userResolver.FindByIdAsync(contributorId)) |
|||
.Returns(A.Fake<IUser>()); |
|||
|
|||
sut = new AppCommandMiddleware(Handler, appProvider, appPlansProvider, appPlansBillingManager, userResolver); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Create_should_create_domain_object() |
|||
{ |
|||
var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId }); |
|||
|
|||
await TestCreate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Equal(AppId, context.Result<EntityCreatedResult<Guid>>().IdOrValue); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AssignContributor_should_update_domain_object_if_user_found() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.GetPlan(null)) |
|||
.Returns(new ConfigAppLimitsPlan { MaxContributors = -1 }); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task RemoveContributor_should_update_domain_object() |
|||
{ |
|||
CreateApp() |
|||
.AssignContributor(CreateCommand(new AssignContributor { ContributorId = contributorId })); |
|||
|
|||
var context = CreateContextForCommand(new RemoveContributor { ContributorId = contributorId }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AttachClient_should_update_domain_object() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AttachClient { Id = clientName }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task RenameClient_should_update_domain_object() |
|||
{ |
|||
CreateApp() |
|||
.AttachClient(CreateCommand(new AttachClient { Id = clientName })); |
|||
|
|||
var context = CreateContextForCommand(new UpdateClient { Id = clientName, Name = "New Name" }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task RevokeClient_should_update_domain_object() |
|||
{ |
|||
CreateApp() |
|||
.AttachClient(CreateCommand(new AttachClient { Id = clientName })); |
|||
|
|||
var context = CreateContextForCommand(new RevokeClient { Id = clientName }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ChangePlan_should_update_domain_object() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan")) |
|||
.Returns(true); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan")) |
|||
.MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ChangePlan_should_not_make_update_for_redirect_result() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan")) |
|||
.Returns(true); |
|||
|
|||
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan")) |
|||
.Returns(CreateRedirectResult()); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan" }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
Assert.Null(app.State.Plan); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ChangePlan_should_not_call_billing_manager_for_callback() |
|||
{ |
|||
A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan")) |
|||
.Returns(true); |
|||
|
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new ChangePlan { PlanId = "my-plan", FromCallback = true }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
|
|||
A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, AppId, AppName, "my-plan")) |
|||
.MustNotHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task AddLanguage_should_update_domain_object() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
var context = CreateContextForCommand(new AddLanguage { Language = language }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task RemoveLanguage_should_update_domain_object() |
|||
{ |
|||
CreateApp() |
|||
.AddLanguage(CreateCommand(new AddLanguage { Language = language })); |
|||
|
|||
var context = CreateContextForCommand(new RemoveLanguage { Language = language }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task UpdateLanguage_should_update_domain_object() |
|||
{ |
|||
CreateApp() |
|||
.AddLanguage(CreateCommand(new AddLanguage { Language = language })); |
|||
|
|||
var context = CreateContextForCommand(new UpdateLanguage { Language = language }); |
|||
|
|||
await TestUpdate(app, async _ => |
|||
{ |
|||
await sut.HandleAsync(context); |
|||
}); |
|||
} |
|||
|
|||
private AppDomainObject CreateApp() |
|||
{ |
|||
app.Create(CreateCommand(new CreateApp { AppId = AppId, Name = AppName })); |
|||
|
|||
return app; |
|||
} |
|||
|
|||
private static Task<IChangePlanResult> CreateRedirectResult() |
|||
{ |
|||
return Task.FromResult<IChangePlanResult>(new RedirectToCheckoutResult(new Uri("http://squidex.io"))); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,284 @@ |
|||
// ==========================================================================
|
|||
// 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.Entities.Apps.Commands; |
|||
using Squidex.Domain.Apps.Entities.TestHelpers; |
|||
using Squidex.Domain.Apps.Events.Apps; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.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(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_throw_exception_if_created() |
|||
{ |
|||
CreateApp(); |
|||
|
|||
Assert.Throws<DomainException>(() => |
|||
{ |
|||
sut.Create(CreateCommand(new CreateApp { Name = AppName })); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Create_should_specify_name_and_owner() |
|||
{ |
|||
sut.Create(CreateCommand(new CreateApp { Name = AppName, Actor = User, AppId = AppId })); |
|||
|
|||
Assert.Equal(AppName, sut.State.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_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_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_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_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_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_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_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_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_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 })); |
|||
sut.ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void CreateClient() |
|||
{ |
|||
sut.AttachClient(CreateCommand(new AttachClient { Id = clientId })); |
|||
sut.ClearUncommittedEvents(); |
|||
} |
|||
|
|||
private void CreateLanguage(Language language) |
|||
{ |
|||
sut.AddLanguage(CreateCommand(new AddLanguage { Language = language })); |
|||
sut.ClearUncommittedEvents(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// ==========================================================================
|
|||
// AppEventTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.TestHelpers; |
|||
using Squidex.Domain.Apps.Events; |
|||
using Squidex.Domain.Apps.Events.Apps; |
|||
using Squidex.Domain.Apps.Events.Apps.Old; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable CS0612 // Type or member is obsolete
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.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; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,159 @@ |
|||
// ==========================================================================
|
|||
// ConfigAppLimitsProviderTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Linq; |
|||
using FakeItEasy; |
|||
using FluentAssertions; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services.Implementations; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps |
|||
{ |
|||
public class ConfigAppLimitsProviderTests |
|||
{ |
|||
private static readonly ConfigAppLimitsPlan InfinitePlan = new ConfigAppLimitsPlan |
|||
{ |
|||
Id = "infinite", |
|||
Name = "Infinite", |
|||
MaxApiCalls = -1, |
|||
MaxAssetSize = -1, |
|||
MaxContributors = -1 |
|||
}; |
|||
|
|||
private static readonly ConfigAppLimitsPlan FreePlan = new ConfigAppLimitsPlan |
|||
{ |
|||
Id = "free", |
|||
Name = "Free", |
|||
MaxApiCalls = 50000, |
|||
MaxAssetSize = 1024 * 1024 * 10, |
|||
MaxContributors = 2 |
|||
}; |
|||
|
|||
private static readonly ConfigAppLimitsPlan BasicPlan = new ConfigAppLimitsPlan |
|||
{ |
|||
Id = "basic", |
|||
Name = "Basic", |
|||
MaxApiCalls = 150000, |
|||
MaxAssetSize = 1024 * 1024 * 2, |
|||
MaxContributors = 5 |
|||
}; |
|||
|
|||
private static readonly ConfigAppLimitsPlan[] Plans = { BasicPlan, FreePlan }; |
|||
|
|||
[Fact] |
|||
public void Should_return_plans() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
Plans.OrderBy(x => x.MaxApiCalls).ShouldBeEquivalentTo(sut.GetAvailablePlans()); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(null)] |
|||
[InlineData("my-plan")] |
|||
public void Should_return_infinite_if_nothing_configured(string planId) |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Enumerable.Empty<ConfigAppLimitsPlan>()); |
|||
|
|||
var plan = sut.GetPlanForApp(CreateApp(planId)); |
|||
|
|||
plan.ShouldBeEquivalentTo(InfinitePlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_fitting_app_plan() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var plan = sut.GetPlanForApp(CreateApp("basic")); |
|||
|
|||
plan.ShouldBeEquivalentTo(BasicPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_smallest_plan_if_none_fits() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var plan = sut.GetPlanForApp(CreateApp("enterprise")); |
|||
|
|||
plan.ShouldBeEquivalentTo(FreePlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_second_plan_for_upgrade_if_plan_is_null() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var upgradePlan = sut.GetPlanUpgrade(null); |
|||
|
|||
upgradePlan.ShouldBeEquivalentTo(BasicPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_second_plan_for_upgrade_if_plan_not_found() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var upgradePlan = sut.GetPlanUpgradeForApp(CreateApp("enterprise")); |
|||
|
|||
upgradePlan.ShouldBeEquivalentTo(BasicPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_return_plan_for_upgrade_if_plan_is_highest_plan() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var upgradePlan = sut.GetPlanUpgradeForApp(CreateApp("basic")); |
|||
|
|||
Assert.Null(upgradePlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_next_plan_if_plan_is_upgradeable() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
var upgradePlan = sut.GetPlanUpgradeForApp(CreateApp("free")); |
|||
|
|||
upgradePlan.ShouldBeEquivalentTo(BasicPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_check_plan_exists() |
|||
{ |
|||
var sut = new ConfigAppPlansProvider(Plans); |
|||
|
|||
Assert.True(sut.IsConfiguredPlan("basic")); |
|||
Assert.True(sut.IsConfiguredPlan("free")); |
|||
|
|||
Assert.False(sut.IsConfiguredPlan("infinite")); |
|||
Assert.False(sut.IsConfiguredPlan("invalid")); |
|||
Assert.False(sut.IsConfiguredPlan(null)); |
|||
} |
|||
|
|||
private static IAppEntity CreateApp(string plan) |
|||
{ |
|||
var app = A.Dummy<IAppEntity>(); |
|||
|
|||
if (plan != null) |
|||
{ |
|||
A.CallTo(() => app.Plan).Returns(new AppPlan(new RefToken("user", "me"), plan)); |
|||
} |
|||
else |
|||
{ |
|||
A.CallTo(() => app.Plan).Returns(null); |
|||
} |
|||
|
|||
return app; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,142 @@ |
|||
// ==========================================================================
|
|||
// GuardAppClientsTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.Apps.Commands; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable SA1310 // Field names must not contain underscore
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps.Guards |
|||
{ |
|||
public class GuardAppClientsTests |
|||
{ |
|||
private readonly AppClients clients_0 = AppClients.Empty; |
|||
|
|||
[Fact] |
|||
public void CanAttach_should_throw_execption_if_client_id_is_null() |
|||
{ |
|||
var command = new AttachClient(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanAttach(clients_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAttach_should_throw_exception_if_client_already_exists() |
|||
{ |
|||
var command = new AttachClient { Id = "android" }; |
|||
|
|||
var clients_1 = clients_0.Add("android", "secret"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanAttach(clients_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAttach_should_not_throw_exception_if_client_is_free() |
|||
{ |
|||
var command = new AttachClient { Id = "ios" }; |
|||
|
|||
var clients_1 = clients_0.Add("android", "secret"); |
|||
|
|||
GuardAppClients.CanAttach(clients_1, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRevoke_should_throw_execption_if_client_id_is_null() |
|||
{ |
|||
var command = new RevokeClient(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanRevoke(clients_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRevoke_should_throw_exception_if_client_is_not_found() |
|||
{ |
|||
var command = new RevokeClient { Id = "ios" }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardAppClients.CanRevoke(clients_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRevoke_should_not_throw_exception_if_client_is_found() |
|||
{ |
|||
var command = new RevokeClient { Id = "ios" }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
GuardAppClients.CanRevoke(clients_1, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdate_should_throw_execption_if_client_id_is_null() |
|||
{ |
|||
var command = new UpdateClient(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanUpdate(clients_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_is_not_found() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios", Name = "iOS" }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardAppClients.CanUpdate(clients_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_has_no_name_and_permission() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios" }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanUpdate(clients_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_has_invalid_permission() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios", Permission = (AppClientPermission)10 }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanUpdate(clients_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_has_same_name() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios", Name = "ios" }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanUpdate(clients_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_throw_exception_if_client_has_same_permission() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios", Permission = AppClientPermission.Editor }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppClients.CanUpdate(clients_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void UpdateClient_should_not_throw_exception_if_command_is_valid() |
|||
{ |
|||
var command = new UpdateClient { Id = "ios", Name = "iOS", Permission = AppClientPermission.Reader }; |
|||
|
|||
var clients_1 = clients_0.Add("ios", "secret"); |
|||
|
|||
GuardAppClients.CanUpdate(clients_1, command); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,158 @@ |
|||
// ==========================================================================
|
|||
// GuardAppContributorsTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.Apps.Commands; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Shared.Users; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable SA1310 // Field names must not contain underscore
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps.Guards |
|||
{ |
|||
public class GuardAppContributorsTests |
|||
{ |
|||
private readonly IUserResolver users = A.Fake<IUserResolver>(); |
|||
private readonly IAppLimitsPlan appPlan = A.Fake<IAppLimitsPlan>(); |
|||
private readonly AppContributors contributors_0 = AppContributors.Empty; |
|||
|
|||
public GuardAppContributorsTests() |
|||
{ |
|||
A.CallTo(() => users.FindByIdAsync(A<string>.Ignored)) |
|||
.Returns(A.Fake<IUser>()); |
|||
|
|||
A.CallTo(() => appPlan.MaxContributors) |
|||
.Returns(10); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_throw_exception_if_contributor_id_is_null() |
|||
{ |
|||
var command = new AssignContributor(); |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_throw_exception_if_permission_not_valid() |
|||
{ |
|||
var command = new AssignContributor { ContributorId = "1", Permission = (AppContributorPermission)10 }; |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_throw_exception_if_user_already_exists_with_same_permission() |
|||
{ |
|||
var command = new AssignContributor { ContributorId = "1" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner); |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardAppContributors.CanAssign(contributors_1, command, users, appPlan)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_throw_exception_if_user_not_found() |
|||
{ |
|||
A.CallTo(() => users.FindByIdAsync(A<string>.Ignored)) |
|||
.Returns(Task.FromResult<IUser>(null)); |
|||
|
|||
var command = new AssignContributor { ContributorId = "1", Permission = (AppContributorPermission)10 }; |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_throw_exception_if_contributor_max_reached() |
|||
{ |
|||
A.CallTo(() => appPlan.MaxContributors) |
|||
.Returns(2); |
|||
|
|||
var command = new AssignContributor { ContributorId = "3" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner); |
|||
var contributors_2 = contributors_1.Assign("2", AppContributorPermission.Editor); |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardAppContributors.CanAssign(contributors_2, command, users, appPlan)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_not_throw_exception_if_user_found() |
|||
{ |
|||
var command = new AssignContributor { ContributorId = "1" }; |
|||
|
|||
return GuardAppContributors.CanAssign(contributors_0, command, users, appPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_not_throw_exception_if_contributor_has_another_permission() |
|||
{ |
|||
var command = new AssignContributor { ContributorId = "1" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Editor); |
|||
|
|||
return GuardAppContributors.CanAssign(contributors_1, command, users, appPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanAssign_should_not_throw_exception_if_contributor_max_reached_but_permission_changed() |
|||
{ |
|||
A.CallTo(() => appPlan.MaxContributors) |
|||
.Returns(2); |
|||
|
|||
var command = new AssignContributor { ContributorId = "1" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Editor); |
|||
var contributors_2 = contributors_1.Assign("2", AppContributorPermission.Editor); |
|||
|
|||
return GuardAppContributors.CanAssign(contributors_2, command, users, appPlan); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemove_should_throw_exception_if_contributor_id_is_null() |
|||
{ |
|||
var command = new RemoveContributor(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppContributors.CanRemove(contributors_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemove_should_throw_exception_if_contributor_not_found() |
|||
{ |
|||
var command = new RemoveContributor { ContributorId = "1" }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardAppContributors.CanRemove(contributors_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemove_should_throw_exception_if_contributor_is_only_owner() |
|||
{ |
|||
var command = new RemoveContributor { ContributorId = "1" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner); |
|||
var contributors_2 = contributors_1.Assign("2", AppContributorPermission.Editor); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppContributors.CanRemove(contributors_2, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemove_should_not_throw_exception_if_contributor_not_only_owner() |
|||
{ |
|||
var command = new RemoveContributor { ContributorId = "1" }; |
|||
|
|||
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner); |
|||
var contributors_2 = contributors_1.Assign("2", AppContributorPermission.Owner); |
|||
|
|||
GuardAppContributors.CanRemove(contributors_2, command); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,131 @@ |
|||
// ==========================================================================
|
|||
// GuardAppLanguagesTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Collections.Generic; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.Apps.Commands; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable SA1310 // Field names must not contain underscore
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps.Guards |
|||
{ |
|||
public class GuardAppLanguagesTests |
|||
{ |
|||
private readonly LanguagesConfig languages_0 = LanguagesConfig.Build(Language.DE); |
|||
|
|||
[Fact] |
|||
public void CanAddLanguage_should_throw_exception_if_language_is_null() |
|||
{ |
|||
var command = new AddLanguage(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanAdd(languages_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAddLanguage_should_throw_exception_if_language_already_added() |
|||
{ |
|||
var command = new AddLanguage { Language = Language.DE }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanAdd(languages_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanAddLanguage_should_not_throw_exception_if_language_valid() |
|||
{ |
|||
var command = new AddLanguage { Language = Language.EN }; |
|||
|
|||
GuardAppLanguages.CanAdd(languages_0, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemoveLanguage_should_throw_exception_if_language_is_null() |
|||
{ |
|||
var command = new RemoveLanguage(); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanRemove(languages_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemoveLanguage_should_throw_exception_if_language_not_found() |
|||
{ |
|||
var command = new RemoveLanguage { Language = Language.EN }; |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardAppLanguages.CanRemove(languages_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemoveLanguage_should_throw_exception_if_language_is_master() |
|||
{ |
|||
var command = new RemoveLanguage { Language = Language.DE }; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanRemove(languages_0, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanRemoveLanguage_should_not_throw_exception_if_language_is_valid() |
|||
{ |
|||
var command = new RemoveLanguage { Language = Language.EN }; |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
GuardAppLanguages.CanRemove(languages_1, command); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdateLanguage_should_throw_exception_if_language_is_null() |
|||
{ |
|||
var command = new UpdateLanguage(); |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdateLanguage_should_throw_exception_if_language_is_optional_and_master() |
|||
{ |
|||
var command = new UpdateLanguage { Language = Language.DE, IsOptional = true }; |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdateLanguage_should_throw_exception_if_language_has_invalid_fallback() |
|||
{ |
|||
var command = new UpdateLanguage { Language = Language.DE, Fallback = new List<Language> { Language.IT } }; |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardAppLanguages.CanUpdate(languages_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdateLanguage_should_throw_exception_if_not_found() |
|||
{ |
|||
var command = new UpdateLanguage { Language = Language.IT }; |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
Assert.Throws<DomainObjectNotFoundException>(() => GuardAppLanguages.CanUpdate(languages_1, command)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanUpdateLanguage_should_not_throw_exception_if_language_is_valid() |
|||
{ |
|||
var command = new UpdateLanguage { Language = Language.DE, Fallback = new List<Language> { Language.EN } }; |
|||
|
|||
var languages_1 = languages_0.Set(new LanguageConfig(Language.EN)); |
|||
|
|||
GuardAppLanguages.CanUpdate(languages_1, command); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,118 @@ |
|||
// ==========================================================================
|
|||
// GuardAppTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Entities.Apps.Commands; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Shared.Users; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps.Guards |
|||
{ |
|||
public class GuardAppTests |
|||
{ |
|||
private readonly IAppProvider apps = A.Fake<IAppProvider>(); |
|||
private readonly IUserResolver users = A.Fake<IUserResolver>(); |
|||
private readonly IAppPlansProvider appPlans = A.Fake<IAppPlansProvider>(); |
|||
|
|||
public GuardAppTests() |
|||
{ |
|||
A.CallTo(() => apps.GetAppAsync("new-app")) |
|||
.Returns(Task.FromResult<IAppEntity>(null)); |
|||
|
|||
A.CallTo(() => users.FindByIdAsync(A<string>.Ignored)) |
|||
.Returns(A.Fake<IUser>()); |
|||
|
|||
A.CallTo(() => appPlans.GetPlan("free")) |
|||
.Returns(A.Fake<IAppLimitsPlan>()); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanCreate_should_throw_exception_if_name_already_in_use() |
|||
{ |
|||
A.CallTo(() => apps.GetAppAsync("new-app")) |
|||
.Returns(A.Fake<IAppEntity>()); |
|||
|
|||
var command = new CreateApp { Name = "new-app" }; |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardApp.CanCreate(command, apps)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanCreate_should_throw_exception_if_name_not_valid() |
|||
{ |
|||
var command = new CreateApp { Name = "INVALID NAME" }; |
|||
|
|||
return Assert.ThrowsAsync<ValidationException>(() => GuardApp.CanCreate(command, apps)); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task CanCreate_should_not_throw_exception_if_app_name_is_free() |
|||
{ |
|||
var command = new CreateApp { Name = "new-app" }; |
|||
|
|||
return GuardApp.CanCreate(command, apps); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanChangePlan_should_throw_exception_if_plan_id_null() |
|||
{ |
|||
var command = new ChangePlan { Actor = new RefToken("user", "me") }; |
|||
|
|||
AppPlan plan = null; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardApp.CanChangePlan(command, plan, appPlans)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanChangePlan_should_throw_exception_if_plan_not_found() |
|||
{ |
|||
A.CallTo(() => appPlans.GetPlan("free")) |
|||
.Returns(null); |
|||
|
|||
var command = new ChangePlan { PlanId = "free", Actor = new RefToken("user", "me") }; |
|||
|
|||
AppPlan plan = null; |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardApp.CanChangePlan(command, plan, appPlans)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanChangePlan_should_throw_exception_if_plan_was_configured_from_another_user() |
|||
{ |
|||
var command = new ChangePlan { PlanId = "free", Actor = new RefToken("user", "me") }; |
|||
|
|||
var plan = new AppPlan(new RefToken("user", "other"), "premium"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardApp.CanChangePlan(command, plan, appPlans)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanChangePlan_should_throw_exception_if_plan_is_the_same() |
|||
{ |
|||
var command = new ChangePlan { PlanId = "free", Actor = new RefToken("user", "me") }; |
|||
|
|||
var plan = new AppPlan(new RefToken("user", "me"), "free"); |
|||
|
|||
Assert.Throws<ValidationException>(() => GuardApp.CanChangePlan(command, plan, appPlans)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void CanChangePlan_should_not_throw_exception_if_same_user_but_other_plan() |
|||
{ |
|||
var command = new ChangePlan { PlanId = "free", Actor = new RefToken("user", "me") }; |
|||
|
|||
var plan = new AppPlan(new RefToken("user", "me"), "premium"); |
|||
|
|||
GuardApp.CanChangePlan(command, plan, appPlans); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
// ==========================================================================
|
|||
// NoopAppPlanBillingManagerTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Entities.Apps.Services.Implementations; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Apps |
|||
{ |
|||
public class NoopAppPlanBillingManagerTests |
|||
{ |
|||
private readonly NoopAppPlanBillingManager sut = new NoopAppPlanBillingManager(); |
|||
|
|||
[Fact] |
|||
public void Should_not_have_portal() |
|||
{ |
|||
Assert.False(sut.HasPortal); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_do_nothing_when_changing_plan() |
|||
{ |
|||
await sut.ChangePlanAsync(null, Guid.Empty, null, null); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_not_return_portal_link() |
|||
{ |
|||
Assert.Equal(string.Empty, await sut.GetPortalLinkAsync(null)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,220 @@ |
|||
// ==========================================================================
|
|||
// ContentQueryServiceTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Microsoft.OData.UriParser; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Core.Scripting; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Contents.Edm; |
|||
using Squidex.Domain.Apps.Entities.Contents.Repositories; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.Security; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public class ContentQueryServiceTests |
|||
{ |
|||
private readonly IContentRepository contentRepository = A.Fake<IContentRepository>(); |
|||
private readonly IScriptEngine scriptEngine = A.Fake<IScriptEngine>(); |
|||
private readonly ISchemaEntity schema = A.Fake<ISchemaEntity>(); |
|||
private readonly IContentEntity content = A.Fake<IContentEntity>(); |
|||
private readonly IAppEntity app = A.Fake<IAppEntity>(); |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly Guid appId = Guid.NewGuid(); |
|||
private readonly Guid schemaId = Guid.NewGuid(); |
|||
private readonly Guid contentId = Guid.NewGuid(); |
|||
private readonly string appName = "my-app"; |
|||
private readonly NamedContentData data = new NamedContentData(); |
|||
private readonly NamedContentData transformedData = new NamedContentData(); |
|||
private readonly ClaimsPrincipal user; |
|||
private readonly ClaimsIdentity identity = new ClaimsIdentity(); |
|||
private readonly EdmModelBuilder modelBuilder = A.Fake<EdmModelBuilder>(); |
|||
private readonly ContentQueryService sut; |
|||
|
|||
public ContentQueryServiceTests() |
|||
{ |
|||
user = new ClaimsPrincipal(identity); |
|||
|
|||
A.CallTo(() => app.Id).Returns(appId); |
|||
A.CallTo(() => app.Name).Returns(appName); |
|||
|
|||
A.CallTo(() => content.Id).Returns(contentId); |
|||
A.CallTo(() => content.Data).Returns(data); |
|||
A.CallTo(() => content.Status).Returns(Status.Published); |
|||
|
|||
sut = new ContentQueryService(contentRepository, appProvider, scriptEngine, modelBuilder); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_schema_from_id_if_string_is_guid() |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, schemaId, false)) |
|||
.Returns(schema); |
|||
|
|||
var result = await sut.FindSchemaAsync(app, schemaId.ToString()); |
|||
|
|||
Assert.Equal(schema, result); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_schema_from_name_if_string_not_guid() |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, "my-schema", false)) |
|||
.Returns(schema); |
|||
|
|||
var result = await sut.FindSchemaAsync(app, "my-schema"); |
|||
|
|||
Assert.Equal(schema, result); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_throw_if_schema_not_found() |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, "my-schema", false)) |
|||
.Returns((ISchemaEntity)null); |
|||
|
|||
await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.FindSchemaAsync(app, "my-schema")); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_content_from_repository_and_transform() |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, schemaId, false)) |
|||
.Returns(schema); |
|||
A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId)) |
|||
.Returns(content); |
|||
|
|||
A.CallTo(() => schema.ScriptQuery) |
|||
.Returns("<script-query>"); |
|||
|
|||
A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<query-script>")) |
|||
.Returns(transformedData); |
|||
|
|||
var result = await sut.FindContentAsync(app, schemaId.ToString(), user, contentId); |
|||
|
|||
Assert.Equal(schema, result.Schema); |
|||
Assert.Equal(data, result.Content.Data); |
|||
Assert.Equal(content.Id, result.Content.Id); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_throw_if_content_to_find_does_not_exist() |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, schemaId, false)) |
|||
.Returns(schema); |
|||
A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId)) |
|||
.Returns((IContentEntity)null); |
|||
|
|||
await Assert.ThrowsAsync<DomainObjectNotFoundException>(async () => await sut.FindContentAsync(app, schemaId.ToString(), user, contentId)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_contents_with_ids_from_repository_and_transform() |
|||
{ |
|||
await TestManyIdRequest(true, false, new HashSet<Guid> { Guid.NewGuid() }, Status.Draft, Status.Published); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_non_archived_contents_from_repository_and_transform() |
|||
{ |
|||
await TestManyRequest(true, false, Status.Draft, Status.Published); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_archived_contents_from_repository_and_transform() |
|||
{ |
|||
await TestManyRequest(true, true, Status.Archived); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_draft_contents_from_repository_and_transform() |
|||
{ |
|||
await TestManyRequest(false, false, Status.Published); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_draft_contents_from_repository_and_transform_when_requesting_archive_as_non_frontend() |
|||
{ |
|||
await TestManyRequest(false, true, Status.Published); |
|||
} |
|||
|
|||
private async Task TestManyRequest(bool isFrontend, bool archive, params Status[] status) |
|||
{ |
|||
SetupClaims(isFrontend); |
|||
|
|||
SetupFakeWithOdataQuery(status); |
|||
SetupFakeWithScripting(); |
|||
|
|||
var result = await sut.QueryWithCountAsync(app, schemaId.ToString(), user, archive, string.Empty); |
|||
|
|||
Assert.Equal(123, result.Total); |
|||
Assert.Equal(schema, result.Schema); |
|||
Assert.Equal(data, result.Items[0].Data); |
|||
Assert.Equal(content.Id, result.Items[0].Id); |
|||
} |
|||
|
|||
private async Task TestManyIdRequest(bool isFrontend, bool archive, HashSet<Guid> ids, params Status[] status) |
|||
{ |
|||
SetupClaims(isFrontend); |
|||
|
|||
SetupFakeWithIdQuery(status, ids); |
|||
SetupFakeWithScripting(); |
|||
|
|||
var result = await sut.QueryWithCountAsync(app, schemaId.ToString(), user, archive, ids); |
|||
|
|||
Assert.Equal(123, result.Total); |
|||
Assert.Equal(schema, result.Schema); |
|||
Assert.Equal(data, result.Items[0].Data); |
|||
Assert.Equal(content.Id, result.Items[0].Id); |
|||
} |
|||
|
|||
private void SetupClaims(bool isFrontend) |
|||
{ |
|||
if (isFrontend) |
|||
{ |
|||
identity.AddClaim(new Claim(OpenIdClaims.ClientId, "squidex-frontend")); |
|||
} |
|||
} |
|||
|
|||
private void SetupFakeWithIdQuery(Status[] status, HashSet<Guid> ids) |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, schemaId, false)) |
|||
.Returns(schema); |
|||
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), ids)) |
|||
.Returns(new List<IContentEntity> { content }); |
|||
A.CallTo(() => contentRepository.CountAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), ids)) |
|||
.Returns(123); |
|||
} |
|||
|
|||
private void SetupFakeWithOdataQuery(Status[] status) |
|||
{ |
|||
A.CallTo(() => appProvider.GetSchemaAsync(appName, schemaId, false)) |
|||
.Returns(schema); |
|||
A.CallTo(() => contentRepository.QueryAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<ODataUriParser>.Ignored)) |
|||
.Returns(new List<IContentEntity> { content }); |
|||
A.CallTo(() => contentRepository.CountAsync(app, schema, A<Status[]>.That.IsSameSequenceAs(status), A<ODataUriParser>.Ignored)) |
|||
.Returns(123); |
|||
} |
|||
|
|||
private void SetupFakeWithScripting() |
|||
{ |
|||
A.CallTo(() => schema.ScriptQuery) |
|||
.Returns("<script-query>"); |
|||
|
|||
A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<query-script>")) |
|||
.Returns(transformedData); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,689 @@ |
|||
// ==========================================================================
|
|||
// GraphQLTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Security.Claims; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using Microsoft.Extensions.Caching.Memory; |
|||
using Microsoft.Extensions.Options; |
|||
using Newtonsoft.Json; |
|||
using Newtonsoft.Json.Linq; |
|||
using NodaTime.Extensions; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Assets.Repositories; |
|||
using Squidex.Domain.Apps.Entities.Contents.GraphQL; |
|||
using Squidex.Domain.Apps.Entities.Contents.TestData; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable SA1311 // Static readonly fields must begin with upper-case letter
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public class GraphQLTests |
|||
{ |
|||
private static readonly Guid schemaId = Guid.NewGuid(); |
|||
private static readonly Guid appId = Guid.NewGuid(); |
|||
private static readonly string appName = "my-app"; |
|||
private readonly Schema schemaDef; |
|||
private readonly IContentQueryService contentQuery = A.Fake<IContentQueryService>(); |
|||
private readonly IAssetRepository assetRepository = A.Fake<IAssetRepository>(); |
|||
private readonly ISchemaEntity schema = A.Fake<ISchemaEntity>(); |
|||
private readonly IMemoryCache cache = new MemoryCache(Options.Create(new MemoryCacheOptions())); |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly IAppEntity app = A.Dummy<IAppEntity>(); |
|||
private readonly ClaimsPrincipal user = new ClaimsPrincipal(); |
|||
private readonly IGraphQLService sut; |
|||
|
|||
public GraphQLTests() |
|||
{ |
|||
schemaDef = |
|||
new Schema("my-schema") |
|||
.AddField(new JsonField(1, "my-json", Partitioning.Invariant, |
|||
new JsonFieldProperties())) |
|||
.AddField(new StringField(2, "my-string", Partitioning.Language, |
|||
new StringFieldProperties())) |
|||
.AddField(new NumberField(3, "my-number", Partitioning.Invariant, |
|||
new NumberFieldProperties())) |
|||
.AddField(new AssetsField(4, "my-assets", Partitioning.Invariant, |
|||
new AssetsFieldProperties())) |
|||
.AddField(new BooleanField(5, "my-boolean", Partitioning.Invariant, |
|||
new BooleanFieldProperties())) |
|||
.AddField(new DateTimeField(6, "my-datetime", Partitioning.Invariant, |
|||
new DateTimeFieldProperties())) |
|||
.AddField(new ReferencesField(7, "my-references", Partitioning.Invariant, |
|||
new ReferencesFieldProperties { SchemaId = schemaId })) |
|||
.AddField(new ReferencesField(9, "my-invalid", Partitioning.Invariant, |
|||
new ReferencesFieldProperties { SchemaId = Guid.NewGuid() })) |
|||
.AddField(new GeolocationField(10, "my-geolocation", Partitioning.Invariant, |
|||
new GeolocationFieldProperties())) |
|||
.AddField(new TagsField(11, "my-tags", Partitioning.Invariant, |
|||
new TagsFieldProperties())); |
|||
|
|||
A.CallTo(() => app.Id).Returns(appId); |
|||
A.CallTo(() => app.Name).Returns(appName); |
|||
A.CallTo(() => app.LanguagesConfig).Returns(LanguagesConfig.Build(Language.DE)); |
|||
|
|||
A.CallTo(() => schema.Id).Returns(schemaId); |
|||
A.CallTo(() => schema.Name).Returns(schemaDef.Name); |
|||
A.CallTo(() => schema.SchemaDef).Returns(schemaDef); |
|||
A.CallTo(() => schema.IsPublished).Returns(true); |
|||
A.CallTo(() => schema.ScriptQuery).Returns("<script-query>"); |
|||
|
|||
var allSchemas = new List<ISchemaEntity> { schema }; |
|||
|
|||
A.CallTo(() => appProvider.GetSchemasAsync(appName)).Returns(allSchemas); |
|||
|
|||
sut = new CachingGraphQLService(cache, appProvider, assetRepository, contentQuery, new FakeUrlGenerator()); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(null)] |
|||
[InlineData("")] |
|||
[InlineData(" ")] |
|||
public async Task Should_return_empty_object_for_empty_query(string query) |
|||
{ |
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_multiple_assets_when_querying_assets() |
|||
{ |
|||
const string query = @"
|
|||
query { |
|||
queryAssets(search: ""my-query"", top: 30, skip: 5) { |
|||
id |
|||
version |
|||
created |
|||
createdBy |
|||
lastModified |
|||
lastModifiedBy |
|||
url |
|||
thumbnailUrl |
|||
sourceUrl |
|||
mimeType |
|||
fileName |
|||
fileSize |
|||
fileVersion |
|||
isImage |
|||
pixelWidth |
|||
pixelHeight |
|||
} |
|||
}";
|
|||
|
|||
var asset = CreateAsset(Guid.NewGuid()); |
|||
|
|||
var assets = new List<IAssetEntity> { asset }; |
|||
|
|||
A.CallTo(() => assetRepository.QueryAsync(app.Id, null, null, "my-query", 30, 5)) |
|||
.Returns(assets); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
queryAssets = new dynamic[] |
|||
{ |
|||
new |
|||
{ |
|||
id = asset.Id, |
|||
version = 1, |
|||
created = asset.Created.ToDateTimeUtc(), |
|||
createdBy = "subject:user1", |
|||
lastModified = asset.LastModified.ToDateTimeUtc(), |
|||
lastModifiedBy = "subject:user2", |
|||
url = $"assets/{asset.Id}", |
|||
thumbnailUrl = $"assets/{asset.Id}?width=100", |
|||
sourceUrl = $"assets/source/{asset.Id}", |
|||
mimeType = "image/png", |
|||
fileName = "MyFile.png", |
|||
fileSize = 1024, |
|||
fileVersion = 123, |
|||
isImage = true, |
|||
pixelWidth = 800, |
|||
pixelHeight = 600 |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_single_asset_when_finding_asset() |
|||
{ |
|||
var assetId = Guid.NewGuid(); |
|||
var asset = CreateAsset(Guid.NewGuid()); |
|||
|
|||
var query = $@"
|
|||
query {{ |
|||
findAsset(id: ""{assetId}"") {{ |
|||
id |
|||
version |
|||
created |
|||
createdBy |
|||
lastModified |
|||
lastModifiedBy |
|||
url |
|||
thumbnailUrl |
|||
sourceUrl |
|||
mimeType |
|||
fileName |
|||
fileSize |
|||
fileVersion |
|||
isImage |
|||
pixelWidth |
|||
pixelHeight |
|||
}} |
|||
}}";
|
|||
|
|||
A.CallTo(() => assetRepository.FindAssetAsync(assetId)) |
|||
.Returns(asset); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
findAsset = new |
|||
{ |
|||
id = asset.Id, |
|||
version = 1, |
|||
created = asset.Created.ToDateTimeUtc(), |
|||
createdBy = "subject:user1", |
|||
lastModified = asset.LastModified.ToDateTimeUtc(), |
|||
lastModifiedBy = "subject:user2", |
|||
url = $"assets/{asset.Id}", |
|||
thumbnailUrl = $"assets/{asset.Id}?width=100", |
|||
sourceUrl = $"assets/source/{asset.Id}", |
|||
mimeType = "image/png", |
|||
fileName = "MyFile.png", |
|||
fileSize = 1024, |
|||
fileVersion = 123, |
|||
isImage = true, |
|||
pixelWidth = 800, |
|||
pixelHeight = 600 |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_multiple_contents_when_querying_contents() |
|||
{ |
|||
const string query = @"
|
|||
query { |
|||
queryMySchemaContents(top: 30, skip: 5) { |
|||
id |
|||
version |
|||
created |
|||
createdBy |
|||
lastModified |
|||
lastModifiedBy |
|||
url |
|||
data { |
|||
myString { |
|||
de |
|||
} |
|||
myNumber { |
|||
iv |
|||
} |
|||
myBoolean { |
|||
iv |
|||
} |
|||
myDatetime { |
|||
iv |
|||
} |
|||
myJson { |
|||
iv |
|||
} |
|||
myGeolocation { |
|||
iv |
|||
} |
|||
myTags { |
|||
iv |
|||
} |
|||
} |
|||
} |
|||
}";
|
|||
|
|||
var content = CreateContent(Guid.NewGuid(), Guid.Empty, Guid.Empty); |
|||
|
|||
var contents = new List<IContentEntity> { content }; |
|||
|
|||
A.CallTo(() => contentQuery.QueryWithCountAsync(app, schema.Id.ToString(), user, false, "?$top=30&$skip=5")) |
|||
.Returns((schema, 0L, (IReadOnlyList<IContentEntity>)contents)); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
queryMySchemaContents = new dynamic[] |
|||
{ |
|||
new |
|||
{ |
|||
id = content.Id, |
|||
version = 1, |
|||
created = content.Created.ToDateTimeUtc(), |
|||
createdBy = "subject:user1", |
|||
lastModified = content.LastModified.ToDateTimeUtc(), |
|||
lastModifiedBy = "subject:user2", |
|||
url = $"contents/my-schema/{content.Id}", |
|||
data = new |
|||
{ |
|||
myString = new |
|||
{ |
|||
de = "value" |
|||
}, |
|||
myNumber = new |
|||
{ |
|||
iv = 1 |
|||
}, |
|||
myBoolean = new |
|||
{ |
|||
iv = true |
|||
}, |
|||
myDatetime = new |
|||
{ |
|||
iv = content.LastModified.ToDateTimeUtc() |
|||
}, |
|||
myJson = new |
|||
{ |
|||
iv = new |
|||
{ |
|||
value = 1 |
|||
} |
|||
}, |
|||
myGeolocation = new |
|||
{ |
|||
iv = new |
|||
{ |
|||
latitude = 10, |
|||
longitude = 20 |
|||
} |
|||
}, |
|||
myTags = new |
|||
{ |
|||
iv = new[] |
|||
{ |
|||
"tag1", |
|||
"tag2" |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_return_single_content_when_finding_content() |
|||
{ |
|||
var contentId = Guid.NewGuid(); |
|||
var content = CreateContent(contentId, Guid.Empty, Guid.Empty); |
|||
|
|||
var query = $@"
|
|||
query {{ |
|||
findMySchemaContent(id: ""{contentId}"") {{ |
|||
id |
|||
version |
|||
created |
|||
createdBy |
|||
lastModified |
|||
lastModifiedBy |
|||
url |
|||
data {{ |
|||
myString {{ |
|||
de |
|||
}} |
|||
myNumber {{ |
|||
iv |
|||
}} |
|||
myBoolean {{ |
|||
iv |
|||
}} |
|||
myDatetime {{ |
|||
iv |
|||
}} |
|||
myJson {{ |
|||
iv |
|||
}} |
|||
myGeolocation {{ |
|||
iv |
|||
}} |
|||
myTags {{ |
|||
iv |
|||
}} |
|||
}} |
|||
}} |
|||
}}";
|
|||
|
|||
A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId)) |
|||
.Returns((schema, content)); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
findMySchemaContent = new |
|||
{ |
|||
id = content.Id, |
|||
version = 1, |
|||
created = content.Created.ToDateTimeUtc(), |
|||
createdBy = "subject:user1", |
|||
lastModified = content.LastModified.ToDateTimeUtc(), |
|||
lastModifiedBy = "subject:user2", |
|||
url = $"contents/my-schema/{content.Id}", |
|||
data = new |
|||
{ |
|||
myString = new |
|||
{ |
|||
de = "value" |
|||
}, |
|||
myNumber = new |
|||
{ |
|||
iv = 1 |
|||
}, |
|||
myBoolean = new |
|||
{ |
|||
iv = true |
|||
}, |
|||
myDatetime = new |
|||
{ |
|||
iv = content.LastModified.ToDateTimeUtc() |
|||
}, |
|||
myJson = new |
|||
{ |
|||
iv = new |
|||
{ |
|||
value = 1 |
|||
} |
|||
}, |
|||
myGeolocation = new |
|||
{ |
|||
iv = new |
|||
{ |
|||
latitude = 10, |
|||
longitude = 20 |
|||
} |
|||
}, |
|||
myTags = new |
|||
{ |
|||
iv = new[] |
|||
{ |
|||
"tag1", |
|||
"tag2" |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_also_fetch_referenced_contents_when_field_is_included_in_query() |
|||
{ |
|||
var contentRefId = Guid.NewGuid(); |
|||
var contentRef = CreateContent(contentRefId, Guid.Empty, Guid.Empty); |
|||
|
|||
var contentId = Guid.NewGuid(); |
|||
var content = CreateContent(contentId, contentRefId, Guid.Empty); |
|||
|
|||
var query = $@"
|
|||
query {{ |
|||
findMySchemaContent(id: ""{contentId}"") {{ |
|||
id |
|||
data {{ |
|||
myReferences {{ |
|||
iv {{ |
|||
id |
|||
}} |
|||
}} |
|||
}} |
|||
}} |
|||
}}";
|
|||
|
|||
var refContents = new List<IContentEntity> { contentRef }; |
|||
|
|||
A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId)) |
|||
.Returns((schema, content)); |
|||
|
|||
A.CallTo(() => contentQuery.QueryWithCountAsync(app, schema.Id.ToString(), user, false, A<HashSet<Guid>>.That.Matches(x => x.Contains(contentRefId)))) |
|||
.Returns((schema, 0L, (IReadOnlyList<IContentEntity>)refContents)); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
findMySchemaContent = new |
|||
{ |
|||
id = content.Id, |
|||
data = new |
|||
{ |
|||
myReferences = new |
|||
{ |
|||
iv = new[] |
|||
{ |
|||
new |
|||
{ |
|||
id = contentRefId |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_also_fetch_referenced_assets_when_field_is_included_in_query() |
|||
{ |
|||
var assetRefId = Guid.NewGuid(); |
|||
var assetRef = CreateAsset(assetRefId); |
|||
|
|||
var contentId = Guid.NewGuid(); |
|||
var content = CreateContent(contentId, Guid.Empty, assetRefId); |
|||
|
|||
var query = $@"
|
|||
query {{ |
|||
findMySchemaContent(id: ""{contentId}"") {{ |
|||
id |
|||
data {{ |
|||
myAssets {{ |
|||
iv {{ |
|||
id |
|||
}} |
|||
}} |
|||
}} |
|||
}} |
|||
}}";
|
|||
|
|||
var refAssets = new List<IAssetEntity> { assetRef }; |
|||
|
|||
A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId)) |
|||
.Returns((schema, content)); |
|||
|
|||
A.CallTo(() => assetRepository.QueryAsync(app.Id, null, A<HashSet<Guid>>.That.Matches(x => x.Contains(assetRefId)), null, int.MaxValue, 0)) |
|||
.Returns(refAssets); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = new |
|||
{ |
|||
findMySchemaContent = new |
|||
{ |
|||
id = content.Id, |
|||
data = new |
|||
{ |
|||
myAssets = new |
|||
{ |
|||
iv = new[] |
|||
{ |
|||
new |
|||
{ |
|||
id = assetRefId |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_not_return_data_when_field_not_part_of_content() |
|||
{ |
|||
var contentId = Guid.NewGuid(); |
|||
var content = CreateContent(contentId, Guid.Empty, Guid.Empty, new NamedContentData()); |
|||
|
|||
var query = $@"
|
|||
query {{ |
|||
findMySchemaContent(id: ""{contentId}"") {{ |
|||
id |
|||
version |
|||
created |
|||
createdBy |
|||
lastModified |
|||
lastModifiedBy |
|||
url |
|||
data {{ |
|||
myInvalid {{ |
|||
iv |
|||
}} |
|||
}} |
|||
}} |
|||
}}";
|
|||
|
|||
A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId)) |
|||
.Returns((schema, content)); |
|||
|
|||
var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query }); |
|||
|
|||
var expected = new |
|||
{ |
|||
data = (object)null |
|||
}; |
|||
|
|||
AssertJson(expected, new { data = result.Data }); |
|||
} |
|||
|
|||
private static IContentEntity CreateContent(Guid id, Guid refId, Guid assetId, NamedContentData data = null) |
|||
{ |
|||
var now = DateTime.UtcNow.ToInstant(); |
|||
|
|||
data = data ?? |
|||
new NamedContentData() |
|||
.AddField("my-json", |
|||
new ContentFieldData().AddValue("iv", JToken.FromObject(new { value = 1 }))) |
|||
.AddField("my-string", |
|||
new ContentFieldData().AddValue("de", "value")) |
|||
.AddField("my-assets", |
|||
new ContentFieldData().AddValue("iv", JToken.FromObject(new[] { assetId }))) |
|||
.AddField("my-number", |
|||
new ContentFieldData().AddValue("iv", 1)) |
|||
.AddField("my-boolean", |
|||
new ContentFieldData().AddValue("iv", true)) |
|||
.AddField("my-datetime", |
|||
new ContentFieldData().AddValue("iv", now.ToDateTimeUtc())) |
|||
.AddField("my-tags", |
|||
new ContentFieldData().AddValue("iv", JToken.FromObject(new[] { "tag1", "tag2" }))) |
|||
.AddField("my-references", |
|||
new ContentFieldData().AddValue("iv", JToken.FromObject(new[] { refId }))) |
|||
.AddField("my-geolocation", |
|||
new ContentFieldData().AddValue("iv", JToken.FromObject(new { latitude = 10, longitude = 20 }))); |
|||
|
|||
var content = new FakeContentEntity |
|||
{ |
|||
Id = id, |
|||
Version = 1, |
|||
Created = now, |
|||
CreatedBy = new RefToken("subject", "user1"), |
|||
LastModified = now, |
|||
LastModifiedBy = new RefToken("subject", "user2"), |
|||
Data = data |
|||
}; |
|||
|
|||
return content; |
|||
} |
|||
|
|||
private static IAssetEntity CreateAsset(Guid id) |
|||
{ |
|||
var now = DateTime.UtcNow.ToInstant(); |
|||
|
|||
var asset = new FakeAssetEntity |
|||
{ |
|||
Id = id, |
|||
Version = 1, |
|||
Created = now, |
|||
CreatedBy = new RefToken("subject", "user1"), |
|||
LastModified = now, |
|||
LastModifiedBy = new RefToken("subject", "user2"), |
|||
FileName = "MyFile.png", |
|||
FileSize = 1024, |
|||
FileVersion = 123, |
|||
MimeType = "image/png", |
|||
IsImage = true, |
|||
PixelWidth = 800, |
|||
PixelHeight = 600 |
|||
}; |
|||
|
|||
return asset; |
|||
} |
|||
|
|||
private static void AssertJson(object expected, object result) |
|||
{ |
|||
var resultJson = JsonConvert.SerializeObject(result, Formatting.Indented); |
|||
var expectJson = JsonConvert.SerializeObject(expected, Formatting.Indented); |
|||
|
|||
Assert.Equal(expectJson, resultJson); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,394 @@ |
|||
// ==========================================================================
|
|||
// ODataQueryTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
/* |
|||
using System; |
|||
using System.Collections.Immutable; |
|||
using FakeItEasy; |
|||
using Microsoft.Extensions.Caching.Memory; |
|||
using Microsoft.Extensions.Options; |
|||
using Microsoft.OData.Edm; |
|||
using MongoDB.Bson.Serialization; |
|||
using MongoDB.Driver; |
|||
using Squidex.Domain.Apps.Core; |
|||
using Squidex.Domain.Apps.Core.Apps; |
|||
using Squidex.Domain.Apps.Core.Schemas; |
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Contents.Edm; |
|||
using Squidex.Domain.Apps.Entities.MongoDb.Contents; |
|||
using Squidex.Domain.Apps.Entities.MongoDb.Contents.Visitors; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.MongoDb; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents |
|||
{ |
|||
public class ODataQueryTests |
|||
{ |
|||
private readonly Schema schemaDef; |
|||
private readonly IBsonSerializerRegistry registry = BsonSerializer.SerializerRegistry; |
|||
private readonly IBsonSerializer<MongoContentEntity> serializer = BsonSerializer.SerializerRegistry.GetSerializer<MongoContentEntity>(); |
|||
private readonly IEdmModel edmModel; |
|||
private readonly LanguagesConfig languagesConfig = LanguagesConfig.Build(Language.EN, Language.DE); |
|||
|
|||
static ODataQueryTests() |
|||
{ |
|||
InstantSerializer.Register(); |
|||
} |
|||
|
|||
public ODataQueryTests() |
|||
{ |
|||
schemaDef = |
|||
new Schema("user") |
|||
.AddField(new StringField(1, "firstName", Partitioning.Language, |
|||
new StringFieldProperties { Label = "FirstName", IsRequired = true, AllowedValues = ImmutableList.Create("1", "2") })) |
|||
.AddField(new StringField(2, "lastName", Partitioning.Language, |
|||
new StringFieldProperties { Hints = "Last Name", Editor = StringFieldEditor.Input })) |
|||
.AddField(new BooleanField(3, "isAdmin", Partitioning.Invariant, |
|||
new BooleanFieldProperties())) |
|||
.AddField(new NumberField(4, "age", Partitioning.Invariant, |
|||
new NumberFieldProperties { MinValue = 1, MaxValue = 10 })) |
|||
.AddField(new DateTimeField(5, "birthday", Partitioning.Invariant, |
|||
new DateTimeFieldProperties())) |
|||
.AddField(new AssetsField(6, "pictures", Partitioning.Invariant, |
|||
new AssetsFieldProperties())) |
|||
.AddField(new ReferencesField(7, "friends", Partitioning.Invariant, |
|||
new ReferencesFieldProperties())) |
|||
.AddField(new StringField(8, "dashed-field", Partitioning.Invariant, |
|||
new StringFieldProperties())) |
|||
.Update(new SchemaProperties { Hints = "The User" }); |
|||
|
|||
var builder = new EdmModelBuilder(new MemoryCache(Options.Create(new MemoryCacheOptions()))); |
|||
|
|||
var schema = A.Dummy<ISchemaEntity>(); |
|||
A.CallTo(() => schema.Id).Returns(Guid.NewGuid()); |
|||
A.CallTo(() => schema.Version).Returns(3); |
|||
A.CallTo(() => schema.SchemaDef).Returns(schemaDef); |
|||
|
|||
var app = A.Dummy<IAppEntity>(); |
|||
A.CallTo(() => app.Id).Returns(Guid.NewGuid()); |
|||
A.CallTo(() => app.Version).Returns(3); |
|||
A.CallTo(() => app.LanguagesConfig).Returns(languagesConfig); |
|||
|
|||
edmModel = builder.BuildEdmModel(schema, app); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_parse_query() |
|||
{ |
|||
var parser = edmModel.ParseQuery("$filter=data/firstName/de eq 'Sebastian'"); |
|||
|
|||
Assert.NotNull(parser); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_make_query_with_underscore_field() |
|||
{ |
|||
var i = F("$filter=data/dashed_field/iv eq 'Value'"); |
|||
var o = C("{ 'do.8.iv' : 'Value' }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_not_operator() |
|||
{ |
|||
var i = F("$filter=not endswith(data/firstName/de, 'Sebastian')"); |
|||
var o = C("{ 'do.1.de' : { '$not' : /Sebastian$/i } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_starts_with_query() |
|||
{ |
|||
var i = F("$filter=startswith(data/firstName/de, 'Sebastian')"); |
|||
var o = C("{ 'do.1.de' : /^Sebastian/i }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_ends_with_query() |
|||
{ |
|||
var i = F("$filter=endswith(data/firstName/de, 'Sebastian')"); |
|||
var o = C("{ 'do.1.de' : /Sebastian$/i }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_contains_query() |
|||
{ |
|||
var i = F("$filter=contains(data/firstName/de, 'Sebastian')"); |
|||
var o = C("{ 'do.1.de' : /Sebastian/i }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_contains_query_with_equals() |
|||
{ |
|||
var i = F("$filter=contains(data/firstName/de, 'Sebastian') eq true"); |
|||
var o = C("{ 'do.1.de' : /Sebastian/i }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_negated_contains_query_with_equals() |
|||
{ |
|||
var i = F("$filter=contains(data/firstName/de, 'Sebastian') eq false"); |
|||
var o = C("{ 'do.1.de' : { '$not' : /Sebastian/i } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_negated_contains_query_and_other() |
|||
{ |
|||
var i = F("$filter=contains(data/firstName/de, 'Sebastian') eq false and data/isAdmin/iv eq true"); |
|||
var o = C("{ 'do.1.de' : { '$not' : /Sebastian/i }, 'do.3.iv' : true }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_string_equals_query() |
|||
{ |
|||
var i = F("$filter=data/firstName/de eq 'Sebastian'"); |
|||
var o = C("{ 'do.1.de' : 'Sebastian' }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_datetime_equals_query() |
|||
{ |
|||
var i = F("$filter=data/birthday/iv eq 1988-01-19T12:00:00Z"); |
|||
var o = C("{ 'do.5.iv' : ISODate(\"1988-01-19T12:00:00Z\") }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_boolean_equals_query() |
|||
{ |
|||
var i = F("$filter=data/isAdmin/iv eq true"); |
|||
var o = C("{ 'do.3.iv' : true }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_string_not_equals_query() |
|||
{ |
|||
var i = F("$filter=data/firstName/de ne 'Sebastian'"); |
|||
var o = C("{ '$or' : [{ 'do.1.de' : { '$exists' : false } }, { 'do.1.de' : { '$ne' : 'Sebastian' } }] }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_number_less_than_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv lt 1"); |
|||
var o = C("{ 'do.4.iv' : { '$lt' : 1.0 } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_number_less_equals_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv le 1"); |
|||
var o = C("{ 'do.4.iv' : { '$lte' : 1.0 } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_number_greater_than_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv gt 1"); |
|||
var o = C("{ 'do.4.iv' : { '$gt' : 1.0 } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_number_greater_equals_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv ge 1"); |
|||
var o = C("{ 'do.4.iv' : { '$gte' : 1.0 } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_equals_query_for_assets() |
|||
{ |
|||
var i = F("$filter=data/pictures/iv eq 'guid'"); |
|||
var o = C("{ 'do.6.iv' : 'guid' }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_equals_query_for_references() |
|||
{ |
|||
var i = F("$filter=data/friends/iv eq 'guid'"); |
|||
var o = C("{ 'do.7.iv' : 'guid' }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_and_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv eq 1 and data/age/iv eq 2"); |
|||
var o = C("{ '$and' : [{ 'do.4.iv' : 1.0 }, { 'do.4.iv' : 2.0 }] }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_or_query() |
|||
{ |
|||
var i = F("$filter=data/age/iv eq 1 or data/age/iv eq 2"); |
|||
var o = C("{ '$or' : [{ 'do.4.iv' : 1.0 }, { 'do.4.iv' : 2.0 }] }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_full_text_query() |
|||
{ |
|||
var i = F("$search=Hello my World"); |
|||
var o = C("{ '$text' : { '$search' : 'Hello my World' } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_create_full_text_query_with_and() |
|||
{ |
|||
var i = F("$search=A and B"); |
|||
var o = C("{ '$text' : { '$search' : 'A and B' } }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_convert_orderby_with_single_statements() |
|||
{ |
|||
var i = S("$orderby=data/age/iv desc"); |
|||
var o = C("{ 'do.4.iv' : -1 }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_convert_orderby_with_multiple_statements() |
|||
{ |
|||
var i = S("$orderby=data/age/iv, data/firstName/en desc"); |
|||
var o = C("{ 'do.4.iv' : 1, 'do.1.en' : -1 }"); |
|||
|
|||
Assert.Equal(o, i); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_top() |
|||
{ |
|||
var parser = edmModel.ParseQuery("$top=3"); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
cursor.Take(parser); |
|||
|
|||
A.CallTo(() => cursor.Limit(3)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_max_top_if_larger() |
|||
{ |
|||
var parser = edmModel.ParseQuery("$top=300"); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
cursor.Take(parser); |
|||
|
|||
A.CallTo(() => cursor.Limit(200)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_default_top() |
|||
{ |
|||
var parser = edmModel.ParseQuery(string.Empty); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
cursor.Take(parser); |
|||
|
|||
A.CallTo(() => cursor.Limit(20)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_set_skip() |
|||
{ |
|||
var parser = edmModel.ParseQuery("$skip=3"); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
cursor.Skip(parser); |
|||
|
|||
A.CallTo(() => cursor.Skip(3)).MustHaveHappened(); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_not_set_skip() |
|||
{ |
|||
var parser = edmModel.ParseQuery(string.Empty); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
cursor.Take(parser); |
|||
|
|||
A.CallTo(() => cursor.Skip(A<int>.Ignored)).MustNotHaveHappened(); |
|||
} |
|||
|
|||
private static string C(string value) |
|||
{ |
|||
return value.Replace('\'', '"'); |
|||
} |
|||
|
|||
private string S(string value) |
|||
{ |
|||
var parser = edmModel.ParseQuery(value); |
|||
var cursor = A.Fake<IFindFluent<MongoContentEntity, MongoContentEntity>>(); |
|||
|
|||
var i = string.Empty; |
|||
|
|||
A.CallTo(() => cursor.Sort(A<SortDefinition<MongoContentEntity>>.Ignored)) |
|||
.Invokes((SortDefinition<MongoContentEntity> sortDefinition) => |
|||
{ |
|||
i = sortDefinition.Render(serializer, registry).ToString(); |
|||
}); |
|||
|
|||
cursor.Sort(parser, schemaDef); |
|||
|
|||
return i; |
|||
} |
|||
|
|||
private string F(string value) |
|||
{ |
|||
var parser = edmModel.ParseQuery(value); |
|||
|
|||
var query = FilterBuilder.Build(parser, schemaDef).Render(serializer, registry).ToString(); |
|||
|
|||
return query; |
|||
} |
|||
} |
|||
} |
|||
*/ |
|||
@ -0,0 +1,50 @@ |
|||
// ==========================================================================
|
|||
// MockupAssetEntity.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using NodaTime; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.TestData |
|||
{ |
|||
public sealed class FakeAssetEntity : IAssetEntity |
|||
{ |
|||
public Guid Id { get; set; } |
|||
|
|||
public Guid AppId { get; set; } |
|||
|
|||
public Guid AssetId { get; set; } |
|||
|
|||
public Instant Created { get; set; } |
|||
|
|||
public Instant LastModified { get; set; } |
|||
|
|||
public RefToken CreatedBy { get; set; } |
|||
|
|||
public RefToken LastModifiedBy { get; set; } |
|||
|
|||
public long Version { get; set; } |
|||
|
|||
public string MimeType { get; set; } |
|||
|
|||
public string FileName { get; set; } |
|||
|
|||
public long FileSize { get; set; } |
|||
|
|||
public long FileVersion { get; set; } |
|||
|
|||
public bool IsImage { get; set; } |
|||
|
|||
public bool IsDeleted { get; set; } |
|||
|
|||
public int? PixelWidth { get; set; } |
|||
|
|||
public int? PixelHeight { get; set; } |
|||
} |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
// ==========================================================================
|
|||
// FakeContentEntity.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using NodaTime; |
|||
using Squidex.Domain.Apps.Core.Contents; |
|||
using Squidex.Infrastructure; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.TestData |
|||
{ |
|||
public sealed class FakeContentEntity : IContentEntity |
|||
{ |
|||
public Guid Id { get; set; } |
|||
|
|||
public Guid AppId { get; set; } |
|||
|
|||
public long Version { get; set; } |
|||
|
|||
public Instant Created { get; set; } |
|||
|
|||
public Instant LastModified { get; set; } |
|||
|
|||
public RefToken CreatedBy { get; set; } |
|||
|
|||
public RefToken LastModifiedBy { get; set; } |
|||
|
|||
public NamedContentData Data { get; set; } |
|||
|
|||
public Status Status { get; set; } |
|||
} |
|||
} |
|||
@ -0,0 +1,40 @@ |
|||
// ==========================================================================
|
|||
// FakeUrlGenerator.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using Squidex.Domain.Apps.Entities.Apps; |
|||
using Squidex.Domain.Apps.Entities.Assets; |
|||
using Squidex.Domain.Apps.Entities.Contents.GraphQL; |
|||
using Squidex.Domain.Apps.Entities.Schemas; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Contents.TestData |
|||
{ |
|||
public sealed class FakeUrlGenerator : IGraphQLUrlGenerator |
|||
{ |
|||
public bool CanGenerateAssetSourceUrl { get; } = true; |
|||
|
|||
public string GenerateAssetUrl(IAppEntity app, IAssetEntity asset) |
|||
{ |
|||
return $"assets/{asset.Id}"; |
|||
} |
|||
|
|||
public string GenerateAssetThumbnailUrl(IAppEntity app, IAssetEntity asset) |
|||
{ |
|||
return $"assets/{asset.Id}?width=100"; |
|||
} |
|||
|
|||
public string GenerateAssetSourceUrl(IAppEntity app, IAssetEntity asset) |
|||
{ |
|||
return $"assets/source/{asset.Id}"; |
|||
} |
|||
|
|||
public string GenerateContentUrl(IAppEntity app, ISchemaEntity schema, IContentEntity content) |
|||
{ |
|||
return $"contents/{schema.Name}/{content.Id}"; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,99 @@ |
|||
// ==========================================================================
|
|||
// RuleDequeuerGrainTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using NodaTime; |
|||
using Squidex.Domain.Apps.Core.HandleRules; |
|||
using Squidex.Domain.Apps.Core.Rules; |
|||
using Squidex.Domain.Apps.Entities.Rules.Repositories; |
|||
using Squidex.Infrastructure.Log; |
|||
using Xunit; |
|||
|
|||
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Rules |
|||
{ |
|||
public class RuleDequeuerTests |
|||
{ |
|||
private readonly IClock clock = A.Fake<IClock>(); |
|||
private readonly ISemanticLog log = A.Fake<ISemanticLog>(); |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly IRuleEventRepository ruleEventRepository = A.Fake<IRuleEventRepository>(); |
|||
private readonly RuleService ruleService = A.Fake<RuleService>(); |
|||
private readonly RuleDequeuer sut; |
|||
private readonly Instant now = SystemClock.Instance.GetCurrentInstant(); |
|||
|
|||
public RuleDequeuerTests() |
|||
{ |
|||
A.CallTo(() => clock.GetCurrentInstant()).Returns(now); |
|||
|
|||
sut = new RuleDequeuer( |
|||
ruleService, |
|||
ruleEventRepository, |
|||
log, |
|||
clock); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(0, 0, RuleResult.Success, RuleJobResult.Success)] |
|||
[InlineData(0, 5, RuleResult.Timeout, RuleJobResult.Retry)] |
|||
[InlineData(1, 60, RuleResult.Timeout, RuleJobResult.Retry)] |
|||
[InlineData(2, 360, RuleResult.Failed, RuleJobResult.Retry)] |
|||
[InlineData(3, 720, RuleResult.Failed, RuleJobResult.Retry)] |
|||
[InlineData(4, 0, RuleResult.Failed, RuleJobResult.Failed)] |
|||
public async Task Should_set_next_attempt_based_on_num_calls(int calls, int minutes, RuleResult result, RuleJobResult jobResult) |
|||
{ |
|||
var actionData = new RuleJobData(); |
|||
var actionName = "MyAction"; |
|||
|
|||
var @event = CreateEvent(calls, actionName, actionData); |
|||
|
|||
var requestElapsed = TimeSpan.FromMinutes(1); |
|||
var requestDump = "Dump"; |
|||
|
|||
A.CallTo(() => ruleService.InvokeAsync(@event.Job.ActionName, @event.Job.ActionData)) |
|||
.Returns((requestDump, result, requestElapsed)); |
|||
|
|||
Instant? nextCall = null; |
|||
|
|||
if (minutes > 0) |
|||
{ |
|||
nextCall = now.Plus(Duration.FromMinutes(minutes)); |
|||
} |
|||
|
|||
await sut.HandleAsync(@event); |
|||
|
|||
sut.Dispose(); |
|||
|
|||
A.CallTo(() => ruleEventRepository.MarkSentAsync(@event.Id, requestDump, result, jobResult, requestElapsed, nextCall)) |
|||
.MustHaveHappened(); |
|||
} |
|||
|
|||
private IRuleEventEntity CreateEvent(int numCalls, string actionName, RuleJobData actionData) |
|||
{ |
|||
var @event = A.Fake<IRuleEventEntity>(); |
|||
|
|||
var job = new RuleJob |
|||
{ |
|||
RuleId = Guid.NewGuid(), |
|||
ActionData = actionData, |
|||
ActionName = actionName, |
|||
Created = now |
|||
}; |
|||
|
|||
A.CallTo(() => @event.Id).Returns(Guid.NewGuid()); |
|||
A.CallTo(() => @event.Job).Returns(job); |
|||
A.CallTo(() => @event.Created).Returns(now); |
|||
A.CallTo(() => @event.NumCalls).Returns(numCalls); |
|||
|
|||
return @event; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,102 @@ |
|||
// ==========================================================================
|
|||
// RuleEnqueuerTests.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Threading.Tasks; |
|||
using FakeItEasy; |
|||
using NodaTime; |
|||
using Squidex.Domain.Apps.Core.HandleRules; |
|||
using Squidex.Domain.Apps.Core.Rules; |
|||
using Squidex.Domain.Apps.Core.Rules.Actions; |
|||
using Squidex.Domain.Apps.Core.Rules.Triggers; |
|||
using Squidex.Domain.Apps.Entities.Rules.Repositories; |
|||
using Squidex.Domain.Apps.Events.Contents; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.EventSourcing; |
|||
using Xunit; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.Rules |
|||
{ |
|||
public class RuleEnqueuerTests |
|||
{ |
|||
private readonly IAppProvider appProvider = A.Fake<IAppProvider>(); |
|||
private readonly IRuleEventRepository ruleEventRepository = A.Fake<IRuleEventRepository>(); |
|||
private readonly RuleService ruleService = A.Fake<RuleService>(); |
|||
private readonly Instant now = SystemClock.Instance.GetCurrentInstant(); |
|||
private readonly NamedId<Guid> appId = new NamedId<Guid>(Guid.NewGuid(), "my-app"); |
|||
private readonly RuleEnqueuer sut; |
|||
|
|||
public RuleEnqueuerTests() |
|||
{ |
|||
sut = new RuleEnqueuer( |
|||
ruleEventRepository, |
|||
appProvider, |
|||
ruleService); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_contents_filter_for_events_filter() |
|||
{ |
|||
Assert.Equal(".*", sut.EventsFilter); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Should_return_type_name_for_name() |
|||
{ |
|||
Assert.Equal(typeof(RuleEnqueuer).Name, sut.Name); |
|||
} |
|||
|
|||
[Fact] |
|||
public Task Should_do_nothing_on_clear() |
|||
{ |
|||
return sut.ClearAsync(); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Should_update_repositories_on_with_jobs_from_sender() |
|||
{ |
|||
var @event = Envelope.Create(new ContentCreated { AppId = appId }); |
|||
|
|||
var rule1 = new Rule(new ContentChangedTrigger(), new WebhookAction { Url = new Uri("https://squidex.io") }); |
|||
var rule2 = new Rule(new ContentChangedTrigger(), new WebhookAction { Url = new Uri("https://squidex.io") }); |
|||
var rule3 = new Rule(new ContentChangedTrigger(), new WebhookAction { Url = new Uri("https://squidex.io") }); |
|||
|
|||
var job1 = new RuleJob { Created = now }; |
|||
var job2 = new RuleJob { Created = now }; |
|||
|
|||
var ruleEntity1 = A.Fake<IRuleEntity>(); |
|||
var ruleEntity2 = A.Fake<IRuleEntity>(); |
|||
var ruleEntity3 = A.Fake<IRuleEntity>(); |
|||
|
|||
A.CallTo(() => ruleEntity1.RuleDef).Returns(rule1); |
|||
A.CallTo(() => ruleEntity2.RuleDef).Returns(rule2); |
|||
A.CallTo(() => ruleEntity3.RuleDef).Returns(rule3); |
|||
|
|||
A.CallTo(() => appProvider.GetRulesAsync(appId.Name)) |
|||
.Returns(new List<IRuleEntity> { ruleEntity1, ruleEntity2, ruleEntity3 }); |
|||
|
|||
A.CallTo(() => ruleService.CreateJob(rule1, @event)) |
|||
.Returns(job1); |
|||
|
|||
A.CallTo(() => ruleService.CreateJob(rule2, @event)) |
|||
.Returns(job2); |
|||
|
|||
A.CallTo(() => ruleService.CreateJob(rule3, @event)) |
|||
.Returns(null); |
|||
|
|||
await sut.On(@event); |
|||
|
|||
A.CallTo(() => ruleEventRepository.EnqueueAsync(job1, now)) |
|||
.MustHaveHappened(); |
|||
|
|||
A.CallTo(() => ruleEventRepository.EnqueueAsync(job2, now)) |
|||
.MustHaveHappened(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
<PropertyGroup> |
|||
<OutputType>Exe</OutputType> |
|||
<TargetFramework>netcoreapp2.0</TargetFramework> |
|||
<RootNamespace>Squidex.Domain.Apps.Entities</RootNamespace> |
|||
</PropertyGroup> |
|||
<ItemGroup> |
|||
<Compile Remove="MongoDb\**" /> |
|||
<EmbeddedResource Remove="MongoDb\**" /> |
|||
<None Remove="MongoDb\**" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ProjectReference Include="..\..\src\Squidex.Domain.Apps.Core.Model\Squidex.Domain.Apps.Core.Model.csproj" /> |
|||
<ProjectReference Include="..\..\src\Squidex.Domain.Apps.Core.Operations\Squidex.Domain.Apps.Core.Operations.csproj" /> |
|||
<ProjectReference Include="..\..\src\Squidex.Domain.Apps.Events\Squidex.Domain.Apps.Events.csproj" /> |
|||
<ProjectReference Include="..\..\src\Squidex.Infrastructure\Squidex.Infrastructure.csproj" /> |
|||
<ProjectReference Include="..\..\src\Squidex.Domain.Apps.Entities\Squidex.Domain.Apps.Entities.csproj" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<PackageReference Include="FakeItEasy" Version="4.2.0" /> |
|||
<PackageReference Include="FluentAssertions" Version="4.19.4" /> |
|||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" /> |
|||
<PackageReference Include="MongoDB.Driver" Version="2.4.4" /> |
|||
<PackageReference Include="RefactoringEssentials" Version="5.4.0" /> |
|||
<PackageReference Include="StyleCop.Analyzers" Version="1.0.2" /> |
|||
<PackageReference Include="System.ValueTuple" Version="4.4.0" /> |
|||
<PackageReference Include="xunit" Version="2.3.1" /> |
|||
<PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<DotNetCliToolReference Include="Microsoft.DotNet.Watcher.Tools" Version="2.0.0" /> |
|||
</ItemGroup> |
|||
<PropertyGroup> |
|||
<CodeAnalysisRuleSet>..\..\Squidex.ruleset</CodeAnalysisRuleSet> |
|||
</PropertyGroup> |
|||
</Project> |
|||
@ -0,0 +1,45 @@ |
|||
// ==========================================================================
|
|||
// AssertHelper.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using FluentAssertions; |
|||
using Squidex.Infrastructure.EventSourcing; |
|||
|
|||
namespace Squidex.Domain.Apps.Entities.TestHelpers |
|||
{ |
|||
public static class AssertHelper |
|||
{ |
|||
public static void ShouldHaveSameEvents(this IEnumerable<Envelope<IEvent>> events, params IEvent[] others) |
|||
{ |
|||
var source = events.Select(x => x.Payload).ToArray(); |
|||
|
|||
source.Should().HaveSameCount(others); |
|||
|
|||
for (var i = 0; i < source.Length; i++) |
|||
{ |
|||
var lhs = source[i]; |
|||
var rhs = others[i]; |
|||
|
|||
lhs.ShouldBeSameEvent(rhs); |
|||
} |
|||
} |
|||
|
|||
public static void ShouldBeSameEvent(this IEvent lhs, IEvent rhs) |
|||
{ |
|||
lhs.Should().BeOfType(rhs.GetType()); |
|||
|
|||
((object)lhs).ShouldBeEquivalentTo(rhs, o => o.IncludingAllDeclaredProperties()); |
|||
} |
|||
|
|||
public static void ShouldBeSameEventType(this IEvent lhs, IEvent rhs) |
|||
{ |
|||
lhs.Should().BeOfType(rhs.GetType()); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,162 @@ |
|||
// ==========================================================================
|
|||
// HandlerTestBase.cs
|
|||
// Squidex Headless CMS
|
|||
// ==========================================================================
|
|||
// Copyright (c) Squidex Group
|
|||
// All rights reserved.
|
|||
// ==========================================================================
|
|||
|
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using Squidex.Domain.Apps.Events; |
|||
using Squidex.Infrastructure; |
|||
using Squidex.Infrastructure.Commands; |
|||
|
|||
#pragma warning disable IDE0019 // Use pattern matching
|
|||
|
|||
namespace Squidex.Domain.Apps.Entities.TestHelpers |
|||
{ |
|||
public abstract class HandlerTestBase<T> where T : IDomainObject |
|||
{ |
|||
private sealed class MockupHandler : IAggregateHandler |
|||
{ |
|||
private T domainObject; |
|||
|
|||
public bool IsCreated { get; private set; } |
|||
public bool IsUpdated { get; private set; } |
|||
|
|||
public void Init(T newDomainObject) |
|||
{ |
|||
domainObject = newDomainObject; |
|||
|
|||
IsCreated = false; |
|||
IsUpdated = false; |
|||
} |
|||
|
|||
public async Task<V> CreateAsync<V>(CommandContext context, Func<V, Task> creator) where V : class, IDomainObject |
|||
{ |
|||
IsCreated = true; |
|||
|
|||
var @do = domainObject as V; |
|||
|
|||
await creator(domainObject as V); |
|||
|
|||
return @do; |
|||
} |
|||
|
|||
public async Task<V> UpdateAsync<V>(CommandContext context, Func<V, Task> updater) where V : class, IDomainObject |
|||
{ |
|||
IsUpdated = true; |
|||
|
|||
var @do = domainObject as V; |
|||
|
|||
await updater(domainObject as V); |
|||
|
|||
return @do; |
|||
} |
|||
} |
|||
|
|||
private readonly MockupHandler handler = new MockupHandler(); |
|||
|
|||
protected RefToken User { get; } = new RefToken("subject", Guid.NewGuid().ToString()); |
|||
|
|||
protected Guid AppId { get; } = Guid.NewGuid(); |
|||
|
|||
protected Guid SchemaId { get; } = Guid.NewGuid(); |
|||
|
|||
protected string AppName { get; } = "my-app"; |
|||
|
|||
protected string SchemaName { get; } = "my-schema"; |
|||
|
|||
protected NamedId<Guid> AppNamedId |
|||
{ |
|||
get { return new NamedId<Guid>(AppId, AppName); } |
|||
} |
|||
|
|||
protected NamedId<Guid> SchemaNamedId |
|||
{ |
|||
get { return new NamedId<Guid>(SchemaId, SchemaName); } |
|||
} |
|||
|
|||
protected IAggregateHandler Handler |
|||
{ |
|||
get { return handler; } |
|||
} |
|||
|
|||
protected CommandContext CreateContextForCommand<TCommand>(TCommand command) where TCommand : SquidexCommand |
|||
{ |
|||
return new CommandContext(CreateCommand(command)); |
|||
} |
|||
|
|||
protected async Task TestCreate(T domainObject, Func<T, Task> action, bool shouldCreate = true) |
|||
{ |
|||
handler.Init(domainObject); |
|||
|
|||
await action(domainObject); |
|||
|
|||
if (!handler.IsCreated && shouldCreate) |
|||
{ |
|||
throw new InvalidOperationException("Create not called."); |
|||
} |
|||
} |
|||
|
|||
protected async Task TestUpdate(T domainObject, Func<T, Task> action, bool shouldUpdate = true) |
|||
{ |
|||
handler.Init(domainObject); |
|||
|
|||
await action(domainObject); |
|||
|
|||
if (!handler.IsUpdated && shouldUpdate) |
|||
{ |
|||
throw new InvalidOperationException("Update not called."); |
|||
} |
|||
} |
|||
|
|||
protected TCommand CreateCommand<TCommand>(TCommand command) where TCommand : SquidexCommand |
|||
{ |
|||
if (command.Actor == null) |
|||
{ |
|||
command.Actor = User; |
|||
} |
|||
|
|||
var appCommand = command as AppCommand; |
|||
|
|||
if (appCommand != null && appCommand.AppId == null) |
|||
{ |
|||
appCommand.AppId = AppNamedId; |
|||
} |
|||
|
|||
var schemaCommand = command as SchemaCommand; |
|||
|
|||
if (schemaCommand != null && schemaCommand.SchemaId == null) |
|||
{ |
|||
schemaCommand.SchemaId = SchemaNamedId; |
|||
} |
|||
|
|||
return command; |
|||
} |
|||
|
|||
protected TEvent CreateEvent<TEvent>(TEvent @event) where TEvent : SquidexEvent |
|||
{ |
|||
@event.Actor = User; |
|||
|
|||
var appEvent = @event as AppEvent; |
|||
|
|||
if (appEvent != null) |
|||
{ |
|||
appEvent.AppId = AppNamedId; |
|||
} |
|||
|
|||
var schemaEvent = @event as SchemaEvent; |
|||
|
|||
if (schemaEvent != null) |
|||
{ |
|||
schemaEvent.SchemaId = SchemaNamedId; |
|||
} |
|||
|
|||
return @event; |
|||
} |
|||
} |
|||
} |
|||
|
|||
#pragma warning restore IDE0019 // Use pattern matching
|
|||
Loading…
Reference in new issue