public void CanCreate_should_throw_exception_if_nested_field_properties_null()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <UpsertSchemaField>
{
new UpsertSchemaField
{
Name = "array",
Properties = new ArrayFieldProperties(),
Partitioning = Partitioning.Invariant.Key,
Nested = new List <UpsertSchemaNestedField>
{
new UpsertSchemaNestedField
{
Name = "nested1",
Properties = null
}
}
}
},
Name = "new-schema"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Field properties is required.",
"Fields[1].Nested[1].Properties"));
}
public void CanCreate_should_throw_exception_if_ui_field_is_invalid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <UpsertSchemaField>
{
new UpsertSchemaField
{
Name = "field1",
Properties = new UIFieldProperties
{
IsListField = true,
IsReferenceField = true
},
IsHidden = true,
IsDisabled = true,
Partitioning = Partitioning.Invariant.Key
}
},
Name = "new-schema"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("UI field cannot be a list field.",
"Fields[1].Properties.IsListField"),
new ValidationError("UI field cannot be a reference field.",
"Fields[1].Properties.IsReferenceField"),
new ValidationError("UI field cannot be hidden.",
"Fields[1].IsHidden"),
new ValidationError("UI field cannot be disabled.",
"Fields[1].IsDisabled"));
}
private async Task <string?> CheckSchemaAsync(ISchemasCacheGrain cache, CreateSchema command)
{
var token = await cache.ReserveAsync(command.SchemaId, command.Name);
if (token == null)
{
throw new ValidationException(T.Get("schemas.nameAlreadyExists"));
}
try
{
var existingId = await GetSchemaIdAsync(command.AppId.Id, command.Name);
if (existingId != default)
{
throw new ValidationException(T.Get("schemas.nameAlreadyExists"));
}
}
catch
{
// Catch our own exception, just in case something went wrong before.
await cache.RemoveReservationAsync(token);
throw;
}
return(token);
}
public Task CanCreate_should_throw_exception_if_fields_not_valid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = null,
Properties = null,
Partitioning = "invalid",
},
new CreateSchemaField
{
Name = null,
Properties = InvalidProperties(),
Partitioning = "invalid",
}
},
Name = "new-schema"
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardSchema.CanCreate(command, schemas)));
}
public static CreateSchema ToCommand(this CreateSchemaDto dto)
{
var command = new CreateSchema();
SimpleMapper.Map(dto, command);
if (dto.Properties != null)
{
command.Properties = new SchemaProperties();
SimpleMapper.Map(dto.Properties, command.Properties);
}
if (dto.Fields != null)
{
command.Fields = new List <CreateSchemaField>();
foreach (var fieldDto in dto.Fields)
{
var fieldProperties = fieldDto?.Properties.ToProperties();
var fieldInstance = SimpleMapper.Map(fieldDto, new CreateSchemaField {
Properties = fieldProperties
});
command.Fields.Add(fieldInstance);
}
}
return(command);
}
public Task CanCreate_should_throw_exception_if_nested_field_properties_not_valid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "array",
Properties = new ArrayFieldProperties(),
Partitioning = Partitioning.Invariant.Key,
Nested = new List <CreateSchemaNestedField>
{
new CreateSchemaNestedField
{
Name = "nested1",
Properties = new StringFieldProperties {
MinLength = 10, MaxLength = 5
}
}
}
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Max length must be greater than min length.",
"Fields[1].Nested[1].Properties.MinLength",
"Fields[1].Nested[1].Properties.MaxLength")));
}
public Task CanCreate_should_throw_exception_if_nested_field_is_array()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "array",
Properties = new ArrayFieldProperties(),
Partitioning = Partitioning.Invariant.Key,
Nested = new List <CreateSchemaNestedField>
{
new CreateSchemaNestedField
{
Name = "nested1",
Properties = new ArrayFieldProperties()
}
}
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Nested field cannot be array fields.",
"Fields[1].Nested[1].Properties")));
}
public async Task Create_should_create_schema_with_initial_fields()
{
var properties = new SchemaProperties();
var fields = new List <CreateSchemaField>
{
new CreateSchemaField {
Name = "field1", Properties = ValidProperties()
},
new CreateSchemaField {
Name = "field2", Properties = ValidProperties()
}
};
var command = new CreateSchema {
Name = SchemaName, SchemaId = SchemaId, Properties = properties, Fields = fields
};
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 0));
var @event = (SchemaCreated)LastEvents.Single().Payload;
Assert.Equal(AppId, sut.Snapshot.AppId.Id);
Assert.Equal(SchemaName, sut.Snapshot.Name);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.Equal(2, @event.Fields.Count);
}
public async Task Create_should_create_events_and_set_intitial_state()
{
var properties = new SchemaProperties();
var command = new CreateSchema {
Name = SchemaName, SchemaId = SchemaId, Properties = properties, IsSingleton = true
};
var result = await PublishAsync(command);
result.ShouldBeEquivalent(sut.Snapshot);
Assert.Equal(AppId, sut.Snapshot.AppId.Id);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.True(sut.Snapshot.SchemaDef.IsSingleton);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new SchemaCreated {
Schema = new Schema(command.Name, command.Properties, command.IsSingleton)
})
);
}
public Task CanCreate_should_throw_exception_if_fields_contains_duplicate_name()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "field1",
Properties = new StringFieldProperties(),
Partitioning = Partitioning.Invariant.Key
},
new CreateSchemaField
{
Name = "field1",
Properties = new StringFieldProperties(),
Partitioning = Partitioning.Invariant.Key
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Fields cannot have duplicate names.",
"Fields")));
}
public Task CanCreate_should_throw_exception_if_fields_contain_duplicate_names()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "field1",
Properties = ValidProperties(),
Partitioning = "invariant"
},
new CreateSchemaField
{
Name = "field1",
Properties = ValidProperties(),
Partitioning = "invariant"
}
},
Name = "new-schema"
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardSchema.CanCreate(command, appProvider)));
}
public async Task Create_should_create_schema_with_initial_fields()
{
var properties = new SchemaProperties();
var fields = new List<UpsertSchemaField>
{
new UpsertSchemaField { Name = "field1", Properties = ValidProperties() },
new UpsertSchemaField { Name = "field2", Properties = ValidProperties() },
new UpsertSchemaField
{
Name = "field3",
Partitioning = Partitioning.Language.Key,
Properties = new ArrayFieldProperties(),
Nested = new List<UpsertSchemaNestedField>
{
new UpsertSchemaNestedField { Name = "nested1", Properties = ValidProperties() },
new UpsertSchemaNestedField { Name = "nested2", Properties = ValidProperties() }
}
}
};
var command = new CreateSchema { Name = SchemaName, SchemaId = SchemaId, Properties = properties, Fields = fields };
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(sut.Snapshot);
var @event = (SchemaCreated)LastEvents.Single().Payload;
Assert.Equal(AppId, sut.Snapshot.AppId.Id);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.Equal(3, @event.Schema.Fields.Count);
}
public SchemaDomainObject Create(CreateSchema command)
{
Guard.Valid(command, nameof(command), () => "Cannot create schema");
VerifyNotCreated();
var @event = SimpleMapper.Map(command, new SchemaCreated {
SchemaId = new NamedId <Guid>(Id, command.Name)
});
if (command.Fields != null)
{
@event.Fields = new List <SchemaCreatedField>();
foreach (var commandField in command.Fields)
{
var eventField = SimpleMapper.Map(commandField, new SchemaCreatedField());
@event.Fields.Add(eventField);
}
}
RaiseEvent(@event);
return(this);
}
public async Task Create_should_create_schema_and_create_events()
{
var properties = new SchemaProperties();
var command = new CreateSchema {
Name = SchemaName, SchemaId = SchemaId, Properties = properties, Singleton = true
};
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(EntityCreatedResult.Create(Id, 0));
Assert.Equal(AppId, sut.Snapshot.AppId.Id);
Assert.Equal(SchemaName, sut.Snapshot.Name);
Assert.Equal(SchemaName, sut.Snapshot.SchemaDef.Name);
Assert.True(sut.Snapshot.IsSingleton);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new SchemaCreated {
Name = SchemaName, Properties = properties, Singleton = true
})
);
}
/// <summary>
/// Provides a general-purpose way to save QueryTraces. Use this in <see cref="Query{TResult}.TraceCallback"/> or
/// <see cref="SqlDb{TKey}.TraceCallback"/> handlers
/// </summary>
public static void SaveTrace(IDbConnection connection, QueryTrace trace, SqlDb <int> db)
{
if (!db.Syntax.TableExists(connection, typeof(QueryTrace)))
{
var tableInfo = db.Syntax.GetTableInfoFromType(typeof(QueryTrace));
if (!db.Syntax.SchemaExists(connection, tableInfo.Schema))
{
CreateSchema cs = new CreateSchema(db.Syntax, tableInfo.Schema);
foreach (var cmd in cs.SqlCommands(connection))
{
connection.Execute(cmd);
}
}
CreateTable ct = new CreateTable(db.Syntax, db.Syntax.GetTableInfoFromType(typeof(QueryTrace)));
foreach (var cmd in ct.SqlCommands(connection))
{
connection.Execute(cmd);
}
}
var callback = db.TraceCallback;
// prevent infinite loop
db.TraceCallback = null;
db.Save(connection, trace);
// restore original callback
db.TraceCallback = callback;
}
public void Create(CreateSchema command)
{
var @event = SimpleMapper.Map(command, new SchemaCreated {
SchemaId = NamedId.Of(command.SchemaId, command.Name)
});
if (command.Fields != null)
{
@event.Fields = new List <SchemaCreatedField>();
foreach (var commandField in command.Fields)
{
var eventField = SimpleMapper.Map(commandField, new SchemaCreatedField());
@event.Fields.Add(eventField);
if (commandField.Nested != null)
{
eventField.Nested = new List <SchemaCreatedNestedField>();
foreach (var nestedField in commandField.Nested)
{
var eventNestedField = SimpleMapper.Map(nestedField, new SchemaCreatedNestedField());
eventField.Nested.Add(eventNestedField);
}
}
}
}
RaiseEvent(@event);
}
public Task CanCreate_should_throw_exception_if_nested_field_name_invalid()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = "array",
Properties = new ArrayFieldProperties(),
Partitioning = Partitioning.Invariant.Key,
Nested = new List <CreateSchemaNestedField>
{
new CreateSchemaNestedField
{
Name = "invalid name",
Properties = new StringFieldProperties()
}
}
}
},
Name = "new-schema"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Field name must be a valid javascript property name.",
"Fields[1].Nested[1].Name")));
}
public void CanCreate_should_throw_exception_if_nested_field_have_duplicate_names()
{
var command = new CreateSchema
{
AppId = appId,
Fields = new List <UpsertSchemaField>
{
new UpsertSchemaField
{
Name = "array",
Properties = new ArrayFieldProperties(),
Partitioning = Partitioning.Invariant.Key,
Nested = new List <UpsertSchemaNestedField>
{
new UpsertSchemaNestedField
{
Name = "nested1",
Properties = new StringFieldProperties()
},
new UpsertSchemaNestedField
{
Name = "nested1",
Properties = new StringFieldProperties()
}
}
}
},
Name = "new-schema"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Fields cannot have duplicate names.",
"Fields[1].Nested"));
}
public Task CanCreate_should_throw_exception_if_name_not_valid()
{
var command = new CreateSchema {
AppId = appId, Name = "INVALID NAME"
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardSchema.CanCreate(command, appProvider)));
}
public Task CanCreate_should_not_throw_exception_if_command_is_valid()
{
var command = new CreateSchema {
AppId = appId, Name = "new-schema"
};
return(GuardSchema.CanCreate(command, appProvider));
}
public void CanCreate_should_throw_exception_if_name_not_valid()
{
var command = new CreateSchema {
AppId = appId, Name = "INVALID NAME"
};
ValidationAssert.Throws(() => GuardSchema.CanCreate(command),
new ValidationError("Name is not a valid slug.", "Name"));
}
public Task CanCreate_should_throw_exception_if_name_not_valid()
{
var command = new CreateSchema {
AppId = appId, Name = "INVALID NAME"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("Name is not a valid slug.", "Name")));
}
public Task CanCreate_should_throw_exception_if_name_already_in_use()
{
var command = new CreateSchema {
AppId = appId, Name = "existing"
};
return(ValidationAssert.ThrowsAsync(() => GuardSchema.CanCreate(command, appProvider),
new ValidationError("A schema with the same name already exists.")));
}
protected Task On(CreateSchema command, CommandContext context)
{
return(handler.CreateSyncedAsync <SchemaDomainObject>(context, async s =>
{
await GuardSchema.CanCreate(command, appProvider);
s.Create(command);
context.Complete(EntityCreatedResult.Create(command.SchemaId, s.Version));
}));
}
public async Task Should_not_override_schema_id()
{
var command = new CreateSchema {
SchemaId = Guid.NewGuid()
};
var context = new CommandContext(command, commandBus);
await sut.HandleAsync(context);
Assert.NotEqual(schemaId.Id, command.SchemaId);
}
public Task CanCreate_should_throw_exception_if_name_already_in_use()
{
A.CallTo(() => appProvider.GetSchemaAsync(A <Guid> .Ignored, "new-schema"))
.Returns(Task.FromResult(A.Fake <ISchemaEntity>()));
var command = new CreateSchema {
AppId = appId, Name = "new-schema"
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardSchema.CanCreate(command, appProvider)));
}
public static Task CanCreate(CreateSchema command, IAppProvider appProvider)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(() => "Cannot create schema.", async error =>
{
if (!command.Name.IsSlug())
{
error(new ValidationError("Name must be a valid slug.", nameof(command.Name)));
}
if (await appProvider.GetSchemaAsync(command.AppId.Id, command.Name) != null)
{
error(new ValidationError($"A schema with name '{command.Name}' already exists", nameof(command.Name)));
}
if (command.Fields != null && command.Fields.Any())
{
var index = 0;
foreach (var field in command.Fields)
{
var prefix = $"Fields.{index}";
if (!field.Partitioning.IsValidPartitioning())
{
error(new ValidationError("Partitioning is not valid.", $"{prefix}.{nameof(field.Partitioning)}"));
}
if (!field.Name.IsPropertyName())
{
error(new ValidationError("Name must be a valid property name.", $"{prefix}.{nameof(field.Name)}"));
}
if (field.Properties == null)
{
error(new ValidationError("Properties is required.", $"{prefix}.{nameof(field.Properties)}"));
}
var propertyErrors = FieldPropertiesValidator.Validate(field.Properties);
foreach (var propertyError in propertyErrors)
{
error(propertyError);
}
}
if (command.Fields.Select(x => x.Name).Distinct().Count() != command.Fields.Count)
{
error(new ValidationError("Fields cannot have duplicate names.", nameof(command.Fields)));
}
}
}));
}
public SchemaDomainObject Create(CreateSchema command)
{
Guard.Valid(command, nameof(command), () => "Cannot create schema");
VerifyNotCreated();
RaiseEvent(SimpleMapper.Map(command, new SchemaCreated {
SchemaId = new NamedId <Guid>(Id, command.Name)
}));
return(this);
}
public async Task Should_not_override_schema_id()
{
httpContext.Features.Set <ISchemaFeature>(new SchemaFeature(schemaId));
var command = new CreateSchema {
SchemaId = DomainId.NewGuid()
};
var context = Ctx(command);
await sut.HandleAsync(context);
Assert.NotEqual(schemaId.Id, command.SchemaId);
}
public async Task Should_not_create_content_if_non_singleton_schema_is_created()
{
var command = new CreateSchema();
var context =
new CommandContext(command, commandBus)
.Complete();
await sut.HandleAsync(context);
A.CallTo(() => commandBus.PublishAsync(A <ICommand> ._))
.MustNotHaveHappened();
}
public string visit(CreateSchema ddl)
{
return "";
}
