tsai
/
squidex
mirror of https://github.com/Squidex/squidex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Test coverage

pull/1/head
Sebastian 10 years ago
parent
d32a54cbcd
commit
906087a8f6
5 changed files with 261 additions and 159 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 31
      src/Squidex.Write/Schemas/SchemaCommandHandler.cs
  2. 145
      tests/Postman-Collection.json
  3. 16
      tests/Squidex.Write.Tests/Apps/AppCommandHandlerTests.cs
  4. 226
      tests/Squidex.Write.Tests/Schemas/SchemaCommandHandlerTests.cs
  5. 2
      tests/Squidex.Write.Tests/Schemas/SchemaDomainObjectTests.cs

31
src/Squidex.Write/Schemas/SchemaCommandHandler.cs
View File

@ -21,15 +21,15 @@ namespace Squidex.Write.Schemas
private readonly ISchemaProvider schemaProvider;
public SchemaCommandHandler(
ISchemaProvider schemaProvider,
IDomainObjectFactory domainObjectFactory,
IDomainObjectRepository domainObjectRepository)
IDomainObjectRepository domainObjectRepository,
ISchemaProvider schemaProvider)
: base(domainObjectFactory, domainObjectRepository)
{
this.schemaProvider = schemaProvider;
}
public async Task On(CreateSchema command, CommandContext context)
protected async Task On(CreateSchema command, CommandContext context)
{
if (await schemaProvider.FindSchemaIdByNameAsync(command.AppId, command.Name) != null)
{
@ -37,10 +37,15 @@ namespace Squidex.Write.Schemas
throw new ValidationException("Cannot create a new schema", error);
}
await CreateAsync(command, s => s.Create(command));
await CreateAsync(command, s =>
{
s.Create(command);
context.Succeed(command.Name);
});
}
public Task On(AddField command, CommandContext context)
protected Task On(AddField command, CommandContext context)
{
return UpdateAsync(command, s =>
{
@ -50,42 +55,42 @@ namespace Squidex.Write.Schemas
});
}
public Task On(DeleteSchema command, CommandContext context)
protected Task On(DeleteSchema command, CommandContext context)
{
return UpdateAsync(command, s => s.Delete(command));
}
public Task On(DeleteField command, CommandContext context)
protected Task On(DeleteField command, CommandContext context)
{
return UpdateAsync(command, s => s.DeleteField(command));
}
public Task On(DisableField command, CommandContext context)
protected Task On(DisableField command, CommandContext context)
{
return UpdateAsync(command, s => s.DisableField(command));
}
public Task On(EnableField command, CommandContext context)
protected Task On(EnableField command, CommandContext context)
{
return UpdateAsync(command, s => s.EnableField(command));
}
public Task On(HideField command, CommandContext context)
protected Task On(HideField command, CommandContext context)
{
return UpdateAsync(command, s => s.HideField(command));
}
public Task On(ShowField command, CommandContext context)
protected Task On(ShowField command, CommandContext context)
{
return UpdateAsync(command, s => s.ShowField(command));
}
public Task On(UpdateSchema command, CommandContext context)
protected Task On(UpdateSchema command, CommandContext context)
{
return UpdateAsync(command, s => s.Update(command));
}
public Task On(UpdateField command)
protected Task On(UpdateField command, CommandContext context)
{
return UpdateAsync(command, s => { s.UpdateField(command); });
}

145
tests/Postman-Collection.json
View File

@ -1,145 +0,0 @@
{
"variables": [],
"info": {
"name": "Squidex",
"_postman_id": "3534653d-3285-a837-6257-a9454368e761",
"description": "",
"schema": "https://schema.getpostman.com/json/collection/v2.0.0/collection.json"
},
"item": [
{
"name": "Apps",
"description": "",
"item": [
{
"name": "{{url}}/api/apps",
"request": {
"url": "{{url}}/api/apps",
"method": "POST",
"header": [
{
"key": "Content-Type",
"value": "application/json",
"description": ""
}
],
"body": {
"mode": "raw",
"raw": "{\n\t\"name\": \"my-app\"\n}"
},
"description": ""
},
"response": []
},
{
"name": "{{url}}/api/apps",
"request": {
"url": "{{url}}/api/apps",
"method": "GET",
"header": [],
"body": {
"mode": "formdata",
"formdata": []
},
"description": ""
},
"response": []
}
]
},
{
"name": "Schemas",
"description": "",
"item": [
{
"name": "{{url}}/api/schemas",
"request": {
"url": "{{url}}/api/schemas",
"method": "GET",
"header": [],
"body": {
"mode": "formdata",
"formdata": []
},
"description": "Get schemas"
},
"response": []
},
{
"name": "{{url}}/api/schemas/users",
"request": {
"url": "{{url}}/api/schemas/users",
"method": "GET",
"header": [],
"body": {
"mode": "formdata",
"formdata": []
},
"description": "Get schema"
},
"response": []
},
{
"name": "{{url}}/api/schemas/users",
"request": {
"url": "{{url}}/api/schemas/users",
"method": "PUT",
"header": [
{
"key": "Content-Type",
"value": "application/json",
"description": ""
}
],
"body": {
"mode": "raw",
"raw": "{\n \"label\": \"Users\",\n \"hints\": \"All users in our system\"\n}"
},
"description": "Update user"
},
"response": []
},
{
"name": "{{url}}/api/schemas",
"request": {
"url": "{{url}}/api/schemas",
"method": "POST",
"header": [
{
"key": "Content-Type",
"value": "application/json",
"description": ""
}
],
"body": {
"mode": "raw",
"raw": "{\n \"name\": \"users\"\n}"
},
"description": "Create schema"
},
"response": []
},
{
"name": "{{url}}/api/schemas/users/fields",
"request": {
"url": "{{url}}/api/schemas/users/fields",
"method": "POST",
"header": [
{
"key": "Content-Type",
"value": "application/json",
"description": ""
}
],
"body": {
"mode": "raw",
"raw": "{\n \"type\": \"number\",\n \"name\": \"age\",\n \"properties\": {\n \"minValue\": 1\n }\n}"
},
"description": "Creates a field"
},
"response": []
}
]
}
]
}

16
tests/Squidex.Write.Tests/Apps/AppCommandHandlerTests.cs
View File

@ -113,6 +113,22 @@ namespace Squidex.Write.Tests.Apps
}, false);
}
[Fact]
public async Task AssignContributor_should_throw_if_null_user_not_found()
{
CreateApp();
var command = new AssignContributor { AggregateId = Id, ContributorId = null };
var context = new CommandContext(command);
userRepository.Setup(x => x.FindUserByIdAsync(command.ContributorId)).Returns(Task.FromResult<IUserEntity>(null));
await TestUpdate(app, async _ =>
{
await Assert.ThrowsAsync<ValidationException>(() => sut.HandleAsync(context));
}, false);
}
[Fact]
public async Task AssignContributor_should_assign_if_user_found()
{

226
tests/Squidex.Write.Tests/Schemas/SchemaCommandHandlerTests.cs
View File

@ -0,0 +1,226 @@
// ==========================================================================
// SchemaCommandHandlerTests.cs
// Squidex Headless CMS
// ==========================================================================
// Copyright (c) Squidex Group
// All rights reserved.
// ==========================================================================
using System;
using System.Reflection;
using System.Threading.Tasks;
using Moq;
using Squidex.Core.Schemas;
using Squidex.Infrastructure;
using Squidex.Infrastructure.CQRS.Commands;
using Squidex.Read.Schemas.Services;
using Squidex.Write.Schemas;
using Squidex.Write.Schemas.Commands;
using Squidex.Write.Tests.Utils;
using Xunit;
// ReSharper disable ConvertToConstant.Local
namespace Squidex.Write.Tests.Schemas
{
public class SchemaCommandHandlerTests : HandlerTestBase<SchemaDomainObject>
{
private readonly Mock<ISchemaProvider> schemaProvider = new Mock<ISchemaProvider>();
private readonly SchemaCommandHandler sut;
private readonly SchemaDomainObject schema;
private readonly FieldRegistry registry = new FieldRegistry();
private readonly Guid appId = Guid.NewGuid();
private readonly string fieldName = "age";
private readonly string schemaName = "users";
static SchemaCommandHandlerTests()
{
TypeNameRegistry.Map(typeof(Schema).GetTypeInfo().Assembly);
}
public SchemaCommandHandlerTests()
{
schema = new SchemaDomainObject(Id, 0, registry);
sut = new SchemaCommandHandler(
DomainObjectFactory.Object,
DomainObjectRepository.Object,
schemaProvider.Object);
}
[Fact]
public async Task Create_should_throw_if_a_name_with_same_name_already_exists()
{
var command = new CreateSchema { Name = schemaName, AppId = appId, AggregateId = Id };
var context = new CommandContext(command);
schemaProvider.Setup(x => x.FindSchemaIdByNameAsync(appId, schemaName)).Returns(Task.FromResult<Guid?>(Guid.NewGuid())).Verifiable();
await TestCreate(schema, async _ =>
{
await Assert.ThrowsAsync<ValidationException>(async () => await sut.HandleAsync(context));
}, false);
schemaProvider.VerifyAll();
}
[Fact]
public async Task Create_should_create_schema_if_name_is_free()
{
var command = new CreateSchema { Name = schemaName, AppId = appId, AggregateId = Id };
var context = new CommandContext(command);
schemaProvider.Setup(x => x.FindSchemaIdByNameAsync(Id, schemaName)).Returns(Task.FromResult<Guid?>(null)).Verifiable();
await TestCreate(schema, async _ =>
{
await sut.HandleAsync(context);
});
Assert.Equal(command.Name, context.Result<string>());
}
[Fact]
public async Task UpdateSchema_should_update_domain_object()
{
CreateSchema();
var command = new UpdateSchema { AggregateId = Id, Properties = new SchemaProperties() };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task DeleteSchema_should_update_domain_object()
{
CreateSchema();
var command = new DeleteSchema { AggregateId = Id };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task AddField_should_update_domain_object()
{
CreateSchema();
var command = new AddField { AggregateId = Id, Name = fieldName, Properties = new NumberFieldProperties() };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
Assert.Equal(1, context.Result<long>());
}
[Fact]
public async Task UpdateField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new UpdateField { AggregateId = Id, FieldId = 1, Properties = new NumberFieldProperties() };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task HideField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new HideField { AggregateId = Id, FieldId = 1 };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task ShowField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new ShowField { AggregateId = Id, FieldId = 1 };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task DisableField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new DisableField { AggregateId = Id, FieldId = 1 };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task EnableField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new EnableField { AggregateId = Id, FieldId = 1 };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
[Fact]
public async Task DeleteField_should_update_domain_object()
{
CreateSchema();
CreateField();
var command = new DeleteField { AggregateId = Id, FieldId = 1 };
var context = new CommandContext(command);
await TestUpdate(schema, async _ =>
{
await sut.HandleAsync(context);
});
}
private void CreateSchema()
{
schema.Create(new CreateSchema { Name = schemaName });
}
private void CreateField()
{
schema.AddField(new AddField { Name = fieldName, Properties = new NumberFieldProperties() });
}
}
}

2
tests/Squidex.Write.Tests/Schemas/SchemaDomainObjectTests.cs
View File

@ -29,7 +29,7 @@ namespace Squidex.Write.Tests.Schemas
private readonly string appName = "schema";
private readonly FieldRegistry registry = new FieldRegistry();
private readonly SchemaDomainObject sut;
public SchemaDomainObjectTests()
{
sut = new SchemaDomainObject(Guid.NewGuid(), 0, registry);

Write Preview
Loading…
Cancel
Save