private static async Task <IProducer <OrderKey, OrderEventRecord> > CreateProducer(
ISchemaRegistryClient registryClient,
AutomaticRegistrationBehavior automaticRegistrationBehavior)
{
var schemaBuilder = new SchemaBuilder(
SchemaBuilder.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderEventUnionSchemaBuilderCase(builder)));
using var serializerBuilder = new SchemaRegistrySerializerBuilder(
registryClient,
schemaBuilder,
serializerBuilder: new BinarySerializerBuilder(
BinarySerializerBuilder.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderEventUnionSerializerBuilderCase(builder))));
var producerBuilder = new ProducerBuilder <OrderKey, OrderEventRecord>(
new ProducerConfig
{
BootstrapServers = BootstrapServers,
});
await producerBuilder.SetAvroKeySerializer(
registryClient,
SubjectNameStrategy.Topic.ConstructKeySubjectName(Topic),
automaticRegistrationBehavior);
await producerBuilder.SetAvroValueSerializer(
serializerBuilder,
SubjectNameStrategy.Topic.ConstructKeySubjectName(Topic),
automaticRegistrationBehavior);
return(producerBuilder.Build());
}
public async Task BuildsSerializerWithAutoRegisteredSchema()
{
var subject = "new_subject";
var id = 40;
RegistryMock.Setup(r => r.GetLatestSchemaAsync(subject))
.ThrowsAsync(new SchemaRegistryException(
"Subject not found.",
HttpStatusCode.NotFound,
40401
))
.Verifiable();
RegistryMock.Setup(r => r.RegisterSchemaAsync(subject, It.IsAny <string>()))
.ReturnsAsync(id)
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await Assert.ThrowsAsync <SchemaRegistryException>(() => builder.Build <string>(subject));
await builder.Build <string>(subject, registerAutomatically : true);
RegistryMock.Verify(r => r.GetLatestSchemaAsync(subject), Times.Exactly(2));
RegistryMock.Verify(r => r.RegisterSchemaAsync(subject, It.IsAny <string>()), Times.Once());
RegistryMock.VerifyNoOtherCalls();
}
}
public async Task BuildsSerializerWithSchemaSubject()
{
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await builder.Build <string>(TestSubject);
RegistryMock.Verify(r => r.GetLatestSchemaAsync(TestSubject), Times.Once());
RegistryMock.VerifyNoOtherCalls();
}
}
public async Task SerializesUsingConfluentWireFormat(byte[] encoding, string data)
{
var context = new SerializationContext(MessageComponentType.Value, "test_topic");
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
var serializer = await builder.Build <string>(TestSubjectLatestId);
Assert.Equal(encoding, serializer.Serialize(data, context));
}
}
private void Start()
{
using (var registry = new CachedSchemaRegistryClient(registryConfig))
{
var typeResolver = new ReflectionResolver(resolveReferenceTypesAsNullable: true);
var schemaBuilder = new SchemaBuilder(typeResolver: typeResolver);
using (var serializerBuilder = new SchemaRegistrySerializerBuilder(registry, schemaBuilder: schemaBuilder))
{
var builder = new ProducerBuilder <TKey, TValue>(producerConfig);
Task t = builder.SetAvroValueSerializer(serializerBuilder, this.topic, registerAutomatically: AutomaticRegistrationBehavior.Always);
while (!t.IsCompletedSuccessfully)
{
;
}
using (var producer = builder.Build())
{
while (true)
{
if (KVPS.Count == 0)
{
Thread.Sleep(1);
}
else
{
lock (KVPS)
{
foreach (KeyValuePair <TKey, TValue> KVP in KVPS)
{
try
{
Task p = producer.ProduceAsync(topic, new Message <TKey, TValue>
{
Key = KVP.Key,
Value = KVP.Value
});
while (!t.IsCompleted)
{
Console.WriteLine(p.Status);
}
Console.WriteLine(p.Status);
}
catch (Exception e)
{
System.Console.WriteLine(e);
}
}
KVPS.Clear();
}
}
}
}
}
}
}
public async Task ThrowsOnNullableTombstoneSchema()
{
var id = 6;
var json = @"[""null"",""int""]";
registryMock.Setup(r => r.GetSchemaAsync(id, null))
.ReturnsAsync(new Schema(json, SchemaType.Avro))
.Verifiable();
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
await Assert.ThrowsAsync <UnsupportedSchemaException>(
() => builder.Build <int?>(id, TombstoneBehavior.Strict));
}
public async Task ThrowsOnInvalidTombstoneType()
{
var id = 4;
var json = @"""int""";
RegistryMock.Setup(r => r.GetSchemaAsync(id, null))
.ReturnsAsync(new Schema(json, SchemaType.Avro))
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await Assert.ThrowsAsync <UnsupportedTypeException>(
() => builder.Build <int>(id, TombstoneBehavior.Strict));
}
}
public async Task SerializesWithAutoRegistrationNever()
{
var subject = "test-subject";
registryMock.Setup(r => r.GetLatestSchemaAsync(subject))
.ReturnsAsync(new RegisteredSchema(subject, 1, 38, "\"int\"", SchemaType.Avro, null))
.Verifiable();
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
await Assert.ThrowsAsync <UnsupportedTypeException>(() => builder.Build <string>(subject, registerAutomatically: AutomaticRegistrationBehavior.Never));
registryMock.Verify();
registryMock.VerifyNoOtherCalls();
}
public async Task ThrowsOnNullTombstoneSchema()
{
var id = 1;
var json = @"""null""";
RegistryMock.Setup(r => r.GetSchemaAsync(id))
.ReturnsAsync(json)
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await Assert.ThrowsAsync <UnsupportedSchemaException>(
() => builder.Build <int?>(id, TombstoneBehavior.Strict));
}
}
public async Task BuildsSerializerWithSchemaId()
{
var id = 6;
var json = @"[""null"",""int""]";
registryMock.Setup(r => r.GetSchemaAsync(id, null))
.ReturnsAsync(new Schema(json, SchemaType.Avro))
.Verifiable();
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
await builder.Build <int?>(id);
registryMock.Verify();
registryMock.VerifyNoOtherCalls();
}
public async Task BuildsSerializerWithSchemaId()
{
var id = 6;
var json = @"[""null"",""int""]";
RegistryMock.Setup(r => r.GetSchemaAsync(id))
.ReturnsAsync(json)
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await builder.Build <int?>(id);
RegistryMock.Verify();
RegistryMock.VerifyNoOtherCalls();
}
}
public async Task SerializesWithAutoRegistrationAlways()
{
var id = 40;
var subject = "new_subject";
registryMock.Setup(r => r.RegisterSchemaAsync(subject, It.Is <Schema>(s => s.SchemaType == SchemaType.Avro)))
.ReturnsAsync(id)
.Verifiable();
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
await builder.Build <string>(subject, registerAutomatically : AutomaticRegistrationBehavior.Always);
registryMock.Verify(r => r.GetLatestSchemaAsync(subject), Times.Never());
registryMock.Verify(r => r.RegisterSchemaAsync(subject, It.IsAny <Schema>()), Times.Once());
registryMock.VerifyNoOtherCalls();
}
public async Task SerializesUsingConfluentWireFormat(byte[] encoding, string data)
{
var id = 12;
var json = @"""string""";
registryMock.Setup(r => r.GetSchemaAsync(id, null))
.ReturnsAsync(new Schema(json, SchemaType.Avro))
.Verifiable();
var context = new SerializationContext(MessageComponentType.Value, "test-topic");
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
var serializer = await builder.Build <string>(id);
Assert.Equal(encoding, serializer.Serialize(data, context));
}
public async Task BuildsSerializerWithSchemaSubject()
{
var id = 12;
var json = @"""string""";
var subject = "test-subject";
var version = 4;
registryMock.Setup(r => r.GetLatestSchemaAsync(subject))
.ReturnsAsync(new RegisteredSchema(subject, version, id, json, SchemaType.Avro, null))
.Verifiable();
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
await builder.Build <string>(subject);
registryMock.Verify();
registryMock.VerifyNoOtherCalls();
}
public async Task HandlesConfluentWireFormatBytesCase()
{
var id = 0;
var json = @"""bytes""";
registryMock.Setup(r => r.GetSchemaAsync(id, null))
.ReturnsAsync(new Schema(json, SchemaType.Avro))
.Verifiable();
var data = new byte[] { 0x02 };
var encoding = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
var context = new SerializationContext(MessageComponentType.Value, "test-topic");
using var builder = new SchemaRegistrySerializerBuilder(registryMock.Object);
var serializer = await builder.Build <byte[]>(id);
Assert.Equal(encoding, serializer.Serialize(data, context));
}
public async Task BuildsSerializerWithSchemaSubjectAndVersion()
{
var id = 12;
var json = @"""string""";
var subject = "test-subject";
var version = 4;
RegistryMock.Setup(r => r.GetRegisteredSchemaAsync(subject, version))
.ReturnsAsync(new RegisteredSchema(subject, version, id, json, SchemaType.Avro, null))
.Verifiable();
RegistryMock.Setup(r => r.GetSchemaIdAsync(subject, It.Is <Schema>(s => s.SchemaString == json)))
.ReturnsAsync(id)
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await builder.Build <string>(subject, version);
RegistryMock.Verify();
RegistryMock.VerifyNoOtherCalls();
}
}
public async Task BuildsSerializerWithSchemaSubjectAndVersion()
{
var id = 12;
var json = @"""string""";
var subject = "test-subject";
var version = 4;
RegistryMock.Setup(r => r.GetSchemaAsync(subject, version))
.ReturnsAsync(json)
.Verifiable();
RegistryMock.Setup(r => r.GetSchemaIdAsync(subject, json))
.ReturnsAsync(id)
.Verifiable();
using (var builder = new SchemaRegistrySerializerBuilder(RegistryMock.Object))
{
await builder.Build <string>(subject, version);
RegistryMock.Verify();
RegistryMock.VerifyNoOtherCalls();
}
}
