public void Should_update_schema()
{
var properties = new SchemaProperties {
Hints = "my-hint", Label = "my-label"
};
sut = sut.Update(properties);
Assert.Equal(properties, sut.Properties);
}
public void Should_instantiate_field()
{
var properties = new SchemaProperties {
Hints = "my-hint", Label = "my-label"
};
var schema = Schema.Create("my-name", properties);
Assert.Equal("my-name", schema.Name);
Assert.Equal(properties, schema.Properties);
}
public static Schema Create(string name, SchemaProperties newProperties)
{
if (!name.IsSlug())
{
var error = new ValidationError("Name must be a valid slug", "Name");
throw new ValidationException("Cannot create a new schema", error);
}
return(new Schema(name, false, newProperties, ImmutableDictionary <long, Field> .Empty));
}
public void Should_update_schema()
{
var properties = new SchemaProperties {
Hints = "my-hint", Label = "my-label"
};
var schema_1 = schema_0.Update(properties);
Assert.NotSame(properties, schema_0.Properties);
Assert.Same(properties, schema_1.Properties);
}
public Schema(string name, bool isPublished, SchemaProperties properties, ImmutableDictionary <long, Field> fields)
{
Guard.NotNull(fields, nameof(fields));
Guard.NotNull(properties, nameof(properties));
Guard.ValidSlug(name, nameof(name));
fieldsById = fields;
fieldsByName = fields.Values.ToImmutableDictionary(x => x.Name, StringComparer.OrdinalIgnoreCase);
this.name = name;
this.properties = properties;
this.properties.Freeze();
this.isPublished = isPublished;
}
public async Task CanGetSchemaId()
{
var client = CreateClient();
var schemaName = "test1";
var groupName = TestEnvironment.SchemaRegistryGroup;
var format = SchemaFormat.Avro;
SchemaProperties registerProperties = await client.RegisterSchemaAsync(groupName, schemaName, SchemaContent, format);
AssertSchemaProperties(registerProperties);
SchemaProperties schemaProperties = await client.GetSchemaPropertiesAsync(groupName, schemaName, SchemaContent, format);
AssertSchemaProperties(schemaProperties);
AssertPropertiesAreEqual(registerProperties, schemaProperties);
}
public void Create_should_create_schema_and_create_events()
{
var properties = new SchemaProperties();
sut.Create(CreateCommand(new CreateSchema {
Name = SchemaName, Properties = properties
}));
Assert.Equal(SchemaName, sut.Schema.Name);
sut.GetUncomittedEvents()
.ShouldHaveSameEvents(
CreateEvent(new SchemaCreated {
Name = SchemaName, Properties = properties
})
);
}
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 PublishAsync(command);
result.ShouldBeEquivalent2(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 void Update_should_refresh_properties_and_create_events()
{
var properties = new SchemaProperties();
CreateSchema();
sut.Update(CreateCommand(new UpdateSchema {
Properties = properties
}));
Assert.Equal(properties, sut.Schema.Properties);
sut.GetUncomittedEvents()
.ShouldHaveSameEvents(
CreateEvent(new SchemaUpdated {
Properties = properties
})
);
}
public async Task Create_should_create_schema_and_create_events()
{
var properties = new SchemaProperties();
var command = new CreateSchema { Name = SchemaName, SchemaId = SchemaId, Properties = properties, IsSingleton = true };
var result = await sut.ExecuteAsync(CreateCommand(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 async Task CanRegisterNewVersionOfSchema()
{
var client = CreateClient();
var schemaName = GenerateSchemaName();
var groupName = TestEnvironment.SchemaRegistryGroup;
var format = SchemaFormat.Avro;
SchemaProperties registerProperties = await client.RegisterSchemaAsync(groupName, schemaName, SchemaContent, format);
AssertSchemaProperties(registerProperties, schemaName);
SchemaProperties schemaProperties = await client.GetSchemaPropertiesAsync(groupName, schemaName, SchemaContent, format);
AssertSchemaProperties(schemaProperties, schemaName);
AssertPropertiesAreEqual(registerProperties, schemaProperties);
SchemaProperties newVersion = await client.RegisterSchemaAsync(schemaProperties.GroupName, schemaProperties.Name, SchemaContent_V2, schemaProperties.Format);
AssertSchemaProperties(newVersion, schemaName);
Assert.AreNotEqual(registerProperties.Id, newVersion.Id);
}
public void Create_should_throw_exception_if_fields_are_not_valid()
{
var properties = new SchemaProperties();
var fields = new List <CreateSchemaField>
{
new CreateSchemaField
{
Name = null,
Properties = null,
Partitioning = "invalid"
}
};
Assert.Throws <ValidationException>(() =>
{
sut.Create(CreateCommand(new CreateSchema {
Name = SchemaName, Properties = properties, Fields = fields
}));
});
}
public void TestComplexConstraints()
{
var props = new SchemaProperties<string, Object>();
// Use the shortcut for defining type properties.
props.SetConstraint("intKey", typeof(int));
props.AddConstraint("intKey", val => (int)val > 10 ? "Too large!" : null);
props.AddConstraint("intKey", val => (int)val < 0 ? "Too small!" : null);
props["intKey"] = 5;
try
{
// Can't use non-integer keys.
props["intKey"] = "quux";
Assert.Fail("Exception not triggered.");
}
catch (ArgumentException)
{}
try
{
// Range constraint 1
props["intKey"] = 15;
Assert.Fail("Exception not triggered.");
}
catch (ArgumentException)
{}
try
{
// Range constraint 2
props["intKey"] = -10;
Assert.Fail("Exception not triggered.");
}
catch (ArgumentException)
{}
}
public void Create_should_create_schema_with_initial_fields()
{
var properties = new SchemaProperties();
var fields = new List <CreateSchemaField>
{
new CreateSchemaField {
Name = "field1", Properties = new GeolocationFieldProperties()
},
new CreateSchemaField {
Name = "field2", Properties = new StringFieldProperties()
}
};
sut.Create(CreateCommand(new CreateSchema {
Name = SchemaName, Properties = properties, Fields = fields
}));
var @event = (SchemaCreated)sut.GetUncomittedEvents().Single().Payload;
Assert.Equal(SchemaName, sut.Schema.Name);
Assert.Equal(2, @event.Fields.Count);
}
public async Task Create_should_create_schema_and_create_events()
{
var properties = new SchemaProperties();
var command = new CreateSchema {
Name = SchemaName, SchemaId = SchemaId, Properties = properties
};
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);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new SchemaCreated {
Name = SchemaName, Properties = properties
})
);
}
public void TestConstraints()
{
var props = new SchemaProperties<string, Object>();
props.SetConstraint("intKey", Alg.TypeP<Object>(typeof(int)));
props["fooKey"] = "bar";
props["intKey"] = 123;
try
{
// Can't use non-integer keys.
props["intKey"] = "quux";
Assert.Fail("Exception not triggered.");
}
catch (ArgumentException)
{}
}
public Schema Update(SchemaProperties newProperties)
{
Guard.NotNull(newProperties, nameof(newProperties));
return(new Schema(name, isPublished, newProperties, fieldsById));
}
private void AssertSchemaProperties(SchemaProperties properties)
{
Assert.IsNotNull(properties);
Assert.IsNotNull(properties.Id);
Assert.IsTrue(Guid.TryParse(properties.Id, out Guid _));
}
private void AssertPropertiesAreEqual(SchemaProperties registeredSchema, SchemaProperties schema)
{
Assert.AreEqual(registeredSchema.Id, schema.Id);
Assert.AreEqual(registeredSchema.Format, schema.Format);
}
internal SchemaRegistrySchema(SchemaProperties properties, string definition)
{
Properties = properties;
Definition = definition;
}
public void Update(SchemaProperties newProperties)
{
properties = newProperties;
}
internal SchemaRegistrySchema(SchemaProperties properties, string content)
{
Properties = properties;
Content = content;
}