public virtual void TestAllowNullBytesSchemaEncodeAndDecode()
{
var fooAvroSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build());
var barAvroSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build());
var bar = new Bar
{
Field1 = true
};
var foo = new Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = "3",
Field4 = bar,
Color = Color.RED
};
var fooBytes = fooAvroSchema.Encode(foo);
var barBytes = barAvroSchema.Encode(bar);
var encodeBytes = ISchema <object> .KvBytes().Encode(new KeyValue <byte[], byte[]>(fooBytes, barBytes));
var decodeKV = ISchema <object> .KvBytes().Decode(encodeBytes);
var fooBack = fooAvroSchema.Decode(decodeKV.Key);
var barBack = barAvroSchema.Decode(decodeKV.Value);
Assert.True(foo.Equals(fooBack));
Assert.True(bar.Equals(barBack));
}
public virtual void TestInlineKeyValueEncodingTypeSchemaEncodeAndDecode()
{
var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build());
var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build());
var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.INLINE);
var bar = new Bar
{
Field1 = true
};
var foo = new Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = "3",
Field4 = bar,
Color = Color.RED
};
// Check kv.encoding.type INLINE
var encodeBytes = keyValueSchema.Encode(new KeyValue <Foo, Bar>(foo, bar));
Assert.True(encodeBytes.Length > 0);
var keyValue = keyValueSchema.Decode(encodeBytes);
var fooBack = keyValue.Key;
var barBack = keyValue.Value;
Assert.True(foo.Equals(fooBack));
Assert.True(bar.Equals(barBack));
}
public virtual void TestJsonSchemaCreate()
{
var fooSchema = JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build());
var barSchema = JSONSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build());
var keyValueSchema1 = ISchema <object> .KeyValue(fooSchema, barSchema);
var keyValueSchema2 = ISchema <object> .KeyValue(JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build()), JSONSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build()));
var keyValueSchema3 = ISchema <object> .KeyValue(JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build()), JSONSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build()));
Assert.Equal(keyValueSchema1.SchemaInfo.Type, SchemaType.KeyValue);
Assert.Equal(keyValueSchema2.SchemaInfo.Type, SchemaType.KeyValue);
Assert.Equal(keyValueSchema3.SchemaInfo.Type, SchemaType.KeyValue);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema1).KeySchema.SchemaInfo.Type, SchemaType.JSON);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema1).ValueSchema.SchemaInfo.Type, SchemaType.JSON);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema2).KeySchema.SchemaInfo.Type, SchemaType.JSON);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema2).ValueSchema.SchemaInfo.Type, SchemaType.JSON);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema3).KeySchema.SchemaInfo.Type, SchemaType.JSON);
Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema3).ValueSchema.SchemaInfo.Type, SchemaType.JSON);
var schemaInfo1 = Encoding.UTF8.GetString(keyValueSchema1.SchemaInfo.Schema);
var schemaInfo2 = Encoding.UTF8.GetString(keyValueSchema2.SchemaInfo.Schema);
var schemaInfo3 = Encoding.UTF8.GetString(keyValueSchema3.SchemaInfo.Schema);
Assert.Equal(schemaInfo1, schemaInfo2);
Assert.Equal(schemaInfo1, schemaInfo3);
}
public static JSONSchema <T> Of(ISchemaDefinition <T> schemaDefinition)
{
ISchemaReader <T> Reader = schemaDefinition.SchemaReaderOpt.GetOrElse(new JsonReader <T>(_jsonMapper));
ISchemaWriter <T> Writer = schemaDefinition.SchemaWriterOpt.GetOrElse(new JsonWriter <T>(_jsonMapper));
return(new JSONSchema <T>(SchemaUtils.ParseSchemaInfo(schemaDefinition, SchemaType.JSON), schemaDefinition.Pojo, Reader, Writer));
}
public virtual void TestNotAllowNullSchemaEncodeAndDecode()
{
var keyValueSchema = ISchema <object> .KeyValue(JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build())
, JSONSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build()));
var bar = new Bar
{
Field1 = true
};
var foo = new Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = "3",
Field4 = bar,
Color = Color.RED
};
var encodeBytes = keyValueSchema.Encode(new KeyValue <Foo, Bar>(foo, bar));
Assert.True(encodeBytes.Length > 0);
var keyValue = keyValueSchema.Decode(encodeBytes);
var fooBack = keyValue.Key;
var barBack = keyValue.Value;
Assert.True(foo.Equals(fooBack));
Assert.True(bar.Equals(barBack));
}
public virtual void TestSeparatedGetProducerDataAssigned()
{
var fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithPojo(typeof(SchemaTestUtils.Foo)).Build());
var barSchema = AvroSchema <SchemaTestUtils.Bar> .Of(ISchemaDefinition <SchemaTestUtils.Bar> .Builder().WithPojo(typeof(SchemaTestUtils.Bar)).Build());
var keyValueSchema = ISchema <int> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.SEPARATED);
var foo = new SchemaTestUtils.Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = 3
};
var bar = new SchemaTestUtils.Bar
{
Field1 = true
};
// Check kv.encoding.type SPRAERATE
var encodeBytes = keyValueSchema.Encode(new KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar>(foo, bar));
var builder = new MessageMetadata();
builder.ProducerName = "separated";
builder.PartitionKey = Convert.ToBase64String(fooSchema.Encode(foo));
builder.PartitionKeyB64Encoded = true;
var msg = Message <KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar> > .Create(builder, new ReadOnlySequence <byte>(encodeBytes), keyValueSchema);
var keyValue = msg.Value;
Assert.Equal(keyValue.Key, foo);
Assert.Equal(keyValue.Value, bar);
Assert.True(builder.ShouldSerializePartitionKey());
}
public virtual void TestDefaultGetProducerDataAssigned()
{
var fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithPojo(typeof(SchemaTestUtils.Foo)).Build());
var barSchema = AvroSchema <SchemaTestUtils.Bar> .Of(ISchemaDefinition <SchemaTestUtils.Bar> .Builder().WithPojo(typeof(SchemaTestUtils.Bar)).Build());
var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema);
var foo = new SchemaTestUtils.Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = 3
};
var bar = new SchemaTestUtils.Bar
{
Field1 = true
};
// // Check kv.encoding.type default, not set value
var encodeBytes = keyValueSchema.Encode(new KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar>(foo, bar));
var builder = new MessageMetadata();
builder.ProducerName = "default";
var msg = Message <KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar> > .Create(builder, new ReadOnlySequence <byte>(encodeBytes), keyValueSchema);
var keyValue = msg.Value;
Assert.Equal(keyValue.Key, foo);
Assert.Equal(keyValue.Value, bar);
Assert.False(builder.ShouldSerializePartitionKey());
}
public void AddUndefinedObjects( ISchemaDefinition src,
ISchemaDefinition edustructuresSchema )
{
IDictionary srcHash = src.GetAllEnums();
foreach ( string enumKey in srcHash.Keys ) {
if ( edustructuresSchema.GetEnum( enumKey ) == null ) {
// Exclude YesNo enums
EnumDef srcDef = src.GetEnum( enumKey );
if( srcDef.Values.Count < 4 && srcDef.ContainsValue( "Yes") && srcDef.ContainsValue( "No" ) )
{
continue;
}
AddUndefinedEnum( srcHash[enumKey] as EnumDef, edustructuresSchema.Version );
}
}
srcHash = src.GetAllObjects();
foreach ( string key in srcHash.Keys ) {
if ( key.StartsWith( "State" ) || key.StartsWith( "Country" ) ) {
continue;
}
System.Diagnostics.Debug.Assert(key != "LAInfo");
if ( edustructuresSchema.GetObject( key ) == null ) {
AddUndefinedObject( srcHash[key] as ObjectDef, edustructuresSchema.Version );
}
}
saveChanges();
}
public GenericAvroReaderTest()
{
fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(typeof(SchemaTestUtils.Foo));
fooV2Schema = AvroSchema <SchemaTestUtils.FooV2> .Of(typeof(SchemaTestUtils.FooV2));
fooSchemaNotNull = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.Foo)).Build());
fooOffsetSchema = AvroSchema <SchemaTestUtils.Foo> .Of(typeof(SchemaTestUtils.Foo));
fooOffsetSchema.SchemaInfo.Properties.Add(GenericAvroSchema.OFFSET_PROP, "5");
var prop = fooOffsetSchema.AvroSchema.GetProperty(GenericAvroSchema.OFFSET_PROP);
foo = new SchemaTestUtils.Foo
{
Field1 = "foo1",
Field2 = "bar1",
Field4 = new SchemaTestUtils.Bar(),
FieldUnableNull = "notNull"
};
fooV2 = new SchemaTestUtils.FooV2
{
Field1 = ("foo1"),
Field3 = (10)
};
}
public virtual void TestSchemaDefinition()
{
var schema1 = typeof(DefaultStruct).GetSchema();
var schema2 = AvroSchema <StructWithAnnotations> .Of(typeof(StructWithAnnotations));
var schemaDef1 = schema1.ToString();
var schemaDef2 = Encoding.UTF8.GetString(schema2.SchemaInfo.Schema);
Assert.NotEqual(schemaDef1, schemaDef2);
var schema3 = AvroSchema <StructWithAnnotations> .Of(ISchemaDefinition <StructWithAnnotations> .Builder().WithJsonDef(schemaDef1).Build());
var schemaDef3 = Encoding.UTF8.GetString(schema3.SchemaInfo.Schema);
Assert.True(schemaDef1.Contains("DefaultStruct") && schemaDef3.Contains("DefaultStruct"));
Assert.NotEqual(schemaDef2, schemaDef3);
var @struct = new StructWithAnnotations
{
Field1 = 5678
};
// schema2 is using the schema generated from POJO,
// it allows field2 to be nullable, and field3 has default value.
schema2.Encode(@struct);
// schema3 is using the schema passed in, which doesn't allow nullable
schema3.Encode(@struct);
}
public virtual void TestNotAllowNullEncodeAndDecode()
{
var jsonSchema = JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build());
var foo1 = new Foo
{
Field1 = "foo1",
Field2 = "bar1",
Field4 = new Bar()
};
var foo2 = new Foo
{
Field1 = "foo2",
Field2 = "bar2"
};
var bytes1 = jsonSchema.Encode(foo1);
var object1 = jsonSchema.Decode(bytes1);
Assert.True(bytes1.Length > 0);
Assert.True(object1.Equals(foo1));
try
{
jsonSchema.Encode(foo2);
}
catch (Exception e)
{
Assert.True(e is SchemaSerializationException);
}
}
public virtual void TestFillParametersToSchemainfo()
{
var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build());
var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build());
fooSchema.SchemaInfo.Name = "foo";
fooSchema.SchemaInfo.Type = SchemaType.AVRO;
IDictionary <string, string> keyProperties = new Dictionary <string, string>
{
["foo.key1"] = "value",
["foo.key2"] = "value"
};
fooSchema.SchemaInfo.Properties = keyProperties;
barSchema.SchemaInfo.Name = "bar";
barSchema.SchemaInfo.Type = SchemaType.AVRO;
IDictionary <string, string> valueProperties = new Dictionary <string, string>
{
["bar.key"] = "key"
};
barSchema.SchemaInfo.Properties = valueProperties;
var keyValueSchema1 = ISchema <object> .KeyValue(fooSchema, barSchema);
Assert.Equal("foo", keyValueSchema1.SchemaInfo.Properties["key.schema.name"]);
Assert.Equal(SchemaType.AVRO.ToString(), keyValueSchema1.SchemaInfo.Properties["key.schema.type"]);
Assert.Equal(@"{""foo.key1"":""value"",""foo.key2"":""value""}", keyValueSchema1.SchemaInfo.Properties["key.schema.properties"]);
Assert.Equal("bar", keyValueSchema1.SchemaInfo.Properties["value.schema.name"]);
Assert.Equal(SchemaType.AVRO.ToString(), keyValueSchema1.SchemaInfo.Properties["value.schema.type"]);
Assert.Equal(@"{""bar.key"":""key""}", keyValueSchema1.SchemaInfo.Properties["value.schema.properties"]);
}
private IFieldSet BuildExternalMetadataFieldSet(IContentLibraryItem eclItem)
{
string externalMetadataXml = eclItem.MetadataXml;
if (string.IsNullOrEmpty(externalMetadataXml))
{
// No external metadata available; nothing to do.
return(null);
}
ISchemaDefinition externalMetadataSchema = eclItem.MetadataXmlSchema;
if (externalMetadataSchema == null)
{
_log.Warning(string.Format("ECL Item '{0}' has external metadata, but no schema defining it.", eclItem.Id));
return(null);
}
try
{
XmlDocument externalMetadataDoc = new XmlDocument();
externalMetadataDoc.LoadXml(externalMetadataXml);
IFieldSet result = CreateExternalMetadataFieldSet(externalMetadataSchema.Fields, externalMetadataDoc.DocumentElement);
_log.Debug(string.Format("ECL Item '{0}' has external metadata: {1}", eclItem.Id, string.Join(", ", result.Keys)));
return(result);
}
catch (Exception ex)
{
_log.Error("An error occurred while parsing the external metadata for ECL Item " + eclItem.Id);
_log.Error(ex.Message);
return(null);
}
}
public GenericAvroSchemaTest()
{
var avroFooV2Schema = AvroSchema <SchemaTestUtils.FooV2> .Of(ISchemaDefinition <SchemaTestUtils.FooV2> .Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.FooV2)).Build());
//var avroFooSchema = AvroSchema<SchemaTestUtils.Foo>.Of(ISchemaDefinition<SchemaTestUtils.Foo>.Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.Foo)).Build());
writerSchema = new GenericAvroSchema(avroFooV2Schema.SchemaInfo);
readerSchema = new GenericAvroSchema(avroFooV2Schema.SchemaInfo);
}
protected override void BuildMetadataXmlSchema(ISchemaDefinition schema)
{
schema.Fields.Add(EclProvider.HostServices.CreateMultiLineTextFieldDefinition("Description", "Description", 0, 1, 7));
schema.Fields.Add(EclProvider.HostServices.CreateSingleLineTextFieldDefinition("Manufacturer", "Manufacturer", 0, 1));
schema.Fields.Add(EclProvider.HostServices.CreateSingleLineTextFieldDefinition("Purchasable", "Purchasable", 0, 1));
schema.Fields.Add(EclProvider.HostServices.CreateNumberFieldDefinition("Price", "Price", 0, 1));
schema.Fields.Add(EclProvider.HostServices.CreateNumberFieldDefinition("StockLevel", "StockLevel", 0, 1));
schema.Fields.Add(EclProvider.HostServices.CreateNumberFieldDefinition("AverageRating", "AverageRating", 0, 1));
}
public static AvroSchema <T> Of(ISchemaDefinition <T> schemaDefinition)
{
if (schemaDefinition.SchemaReaderOpt.HasValue && schemaDefinition.SchemaWriterOpt.HasValue)
{
return(new AvroSchema <T>(schemaDefinition.SchemaReaderOpt.Value, schemaDefinition.SchemaWriterOpt.Value, SchemaUtils.ParseSchemaInfo(schemaDefinition, SchemaType.AVRO)));
}
return(new AvroSchema <T>(SchemaUtils.ParseSchemaInfo(schemaDefinition, SchemaType.AVRO)));
}
internal ExtensionSchemaDefinition(ISchemaDefinition definition, ISchema extendedSchema, SchemaConstraintExtensionMode mode)
: base(definition.SchemaName)
{
DebugContract.Requires(extendedSchema, "extendedSchema");
DebugContract.Requires(definition, "definition");
_definition = definition;
_extendedSchema = extendedSchema;
_mode = mode;
}
public virtual void TestNotAllowNullSchema()
{
var jsonSchema = JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build());
Assert.Equal(jsonSchema.SchemaInfo.Type, SchemaType.JSON);
var schemaJson = jsonSchema.SchemaInfo.SchemaDefinition;
var schema = Avro.Schema.Parse(schemaJson);
Assert.NotNull(schema);
}
public static Avro.Schema ExtractAvroSchema<T>(ISchemaDefinition<T> schemaDefinition, Type pojo)
{
try
{
return ParseAvroSchema(pojo.GetField("SCHEMA$").GetValue(null).ToString());
}
catch (Exception ignored) when (ignored is ArgumentException)
{
//return schemaDefinition.AlwaysAllowNull ? ReflectData.AllowNull.get().getSchema(pojo) : ReflectData.get().getSchema(pojo);
return Avro.Schema.Parse(pojo.GetSchema());
}
}
public static Avro.Schema CreateAvroSchema<T>(ISchemaDefinition<T> schemaDefinition)
{
var pojo = schemaDefinition.Pojo;
if (!string.IsNullOrWhiteSpace(schemaDefinition.JsonDef))
{
return ParseAvroSchema(schemaDefinition.JsonDef);
}
var schema = pojo.GetSchema();
return ParseAvroSchema(schema);
}
public void TestDateTimeDecimalLogicalType()
{
var avroSchema = AvroSchema <LogicalMessage> .Of(ISchemaDefinition <LogicalMessage> .Builder().WithPojo(typeof(LogicalMessage)).WithJSR310ConversionEnabled(true).Build());
var logMsg = new LogicalMessage {
Schema = Avro.Schema.Parse(avroSchema.SchemaInfo.SchemaDefinition), CreatedTime = DateTime.Now, DayOfWeek = "Saturday", Size = new AvroDecimal(102.65M)
};
var bytes1 = avroSchema.Encode(logMsg);
Assert.True(bytes1.Length > 0);
var msg = avroSchema.Decode(bytes1);
Assert.NotNull(msg);
Assert.True(msg.Size == 102.65M);
}
protected override void BuildMetadataXmlSchema(ISchemaDefinition schema)
{
schema.Fields.Add(EclProvider.HostServices.CreateMultiLineTextFieldDefinition("Description", "Description", 0, 1, 7));
schema.Fields.Add(EclProvider.HostServices.CreateSingleLineTextFieldDefinition("Price", "Price", 0, 1));
var fhProduct = (FredhopperProduct)this.product;
foreach (var attribute in fhProduct.AdditionalAttributes)
{
var name = getSchemaAttributeName(attribute.Key);
if (attribute.Value.GetType() == typeof(string))
{
schema.Fields.Add(EclProvider.HostServices.CreateSingleLineTextFieldDefinition(name, name, 0, 1));
}
else if (attribute.Value.GetType() == typeof(List <string>))
{
schema.Fields.Add(EclProvider.HostServices.CreateSingleLineTextFieldDefinition(name, name, 0, 100));
}
}
}
public virtual void TestSeparatedKeyValueEncodingTypeSchemaEncodeAndDecode()
{
var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build());
var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build());
var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.SEPARATED);
var bar = new Bar
{
Field1 = true
};
var foo = new Foo
{
Field1 = "field1",
Field2 = "field2",
Field3 = "3",
Field4 = bar,
Color = Color.RED
};
// Check kv.encoding.type SEPARATED
var encodeBytes = keyValueSchema.Encode(new KeyValue <Foo, Bar>(foo, bar));
Assert.True(encodeBytes.Length > 0);
try
{
keyValueSchema.Decode(encodeBytes);
Assert.True(false, "This method cannot be used under this SEPARATED encoding type");
}
catch (SchemaSerializationException e)
{
Assert.Contains("This method cannot be used under this SEPARATED encoding type", e.Message);
}
var keyValue = ((KeyValueSchema <Foo, Bar>)keyValueSchema).Decode(fooSchema.Encode(foo), encodeBytes, null);
var fooBack = keyValue.Key;
var barBack = keyValue.Value;
Assert.True(foo.Equals(fooBack));
Assert.True(bar.Equals(barBack));
}
public void TestAvroSchemaUserDefinedReadAndWriter()
{
var reader = new JsonReader <Foo>();
var writer = new JsonWriter <Foo>();
var schemaDefinition = ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Bar)).WithSchemaReader(reader).WithSchemaWriter(writer).Build();
var schema = AvroSchema <Foo> .Of(schemaDefinition);
var foo = new Foo();
foo.Color = Color.RED;
var field1 = "test";
foo.Field1 = field1;
var encoded = schema.Encode(foo);
foo = schema.Decode(encoded);
Assert.Equal(Color.RED, foo.Color);
Assert.Equal(field1, foo.Field1);
}
public void TestLogicalType()
{
var avroSchema = AvroSchema <SchemaLogicalType> .Of(ISchemaDefinition <SchemaLogicalType> .Builder().WithPojo(typeof(SchemaLogicalType)).WithJSR310ConversionEnabled(true).Build());
var schemaLogicalType = new SchemaLogicalType
{
TimestampMicros = DateTimeHelper.CurrentUnixTimeMillis() * 1000,
TimestampMillis = DateTime.Parse("2019-03-26T04:39:58.469Z").Ticks,
Decimal = 12.34D,
Date = DateTimeOffset.Now.ToUnixTimeMilliseconds(),
TimeMicros = DateTimeHelper.CurrentUnixTimeMillis() * 1000,
TimeMillis = (DateTime.Now - DateTime.Today).Ticks
};
var bytes1 = avroSchema.Encode(schemaLogicalType);
Assert.True(bytes1.Length > 0);
var object1 = avroSchema.Decode(bytes1);
Assert.True(schemaLogicalType.Equals(object1));
}
public void AddUndefinedObjects(ISchemaDefinition src,
ISchemaDefinition edustructuresSchema)
{
IDictionary srcHash = src.GetAllEnums();
foreach (string enumKey in srcHash.Keys)
{
if (edustructuresSchema.GetEnum(enumKey) == null)
{
// Exclude YesNo enums
EnumDef srcDef = src.GetEnum(enumKey);
if (srcDef.Values.Count < 4 && srcDef.ContainsValue("Yes") && srcDef.ContainsValue("No"))
{
continue;
}
AddUndefinedEnum(srcHash[enumKey] as EnumDef, edustructuresSchema.Version);
}
}
srcHash = src.GetAllObjects();
foreach (string key in srcHash.Keys)
{
if (key.StartsWith("State") || key.StartsWith("Country"))
{
continue;
}
System.Diagnostics.Debug.Assert(key != "LAInfo");
if (edustructuresSchema.GetObject(key) == null)
{
AddUndefinedObject(srcHash[key] as ObjectDef, edustructuresSchema.Version);
}
}
saveChanges();
}
public void Compare(ISchemaDefinition officialSpec,
ISchemaDefinition unofficialSpec,
ICompareOutput output,
bool detailedCheck)
{
if (officialSpec.Version != unofficialSpec.Version)
{
output.ComparisonFailed
(officialSpec.Name, "SifVersion", "ToString", officialSpec.Version.ToString(),
unofficialSpec.Name, unofficialSpec.Version.ToString(), "");
}
CompareObjectDictionary
(officialSpec.GetAllObjects(), officialSpec.Name, unofficialSpec.GetAllObjects(),
unofficialSpec.Name, output, detailedCheck);
// Only compare enums that are defined in the official spec, but not in the unofficial spec
// TODO: Provide warnings for undocumented members
CompareEnumDictionary
(officialSpec.GetAllEnums(), officialSpec.Name, unofficialSpec.GetAllEnums(),
unofficialSpec.Name, output);
}
public virtual void TestAllowNullEncodeAndDecode()
{
var jsonSchema = JSONSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build());
var bar = new Bar
{
Field1 = true
};
var foo1 = new Foo
{
Field1 = "foo1",
Field2 = "bar1",
Field4 = bar,
Color = Color.BLUE
};
var foo2 = new Foo
{
Field1 = "foo2",
Field2 = "bar2"
};
var bytes1 = jsonSchema.Encode(foo1);
Assert.True(bytes1.Length > 0);
var bytes2 = jsonSchema.Encode(foo2);
Assert.True(bytes2.Length > 0);
var object1 = jsonSchema.Decode(bytes1);
var object2 = jsonSchema.Decode(bytes2);
Assert.True(object1.Equals(foo1));
Assert.True(object2.Equals(foo2));
}
public static AvroSchema <T> Of(Type pojo, IDictionary <string, string> properties)
{
return(Of(ISchemaDefinition <T> .Builder().WithPojo(pojo).WithProperties(properties).Build()));
}
public ISchemaDefinition[] GetSchemaDefinitions()
{
ISchemaDefinition[] dbs = new ISchemaDefinition[fDBs.Count];
fDBs.Values.CopyTo( dbs, 0 );
return dbs;
}
/// <summary> /// Append to metadata XML schema with implementation specific metadata definitions /// </summary> /// <param name="schema"></param> protected abstract void BuildMetadataXmlSchema(ISchemaDefinition schema);
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Specialised constructor for use only by derived classes.
/// </summary>
/// <param name="name">
/// The name.
/// </param>
/// <param name="behavior">
/// (Optional) the behavior.
/// </param>
/// <param name="desc">
/// (Optional) the description.
/// </param>
///-------------------------------------------------------------------------------------------------
protected SchemaDefinition(string name, DomainBehavior behavior = DomainBehavior.Standard, ISchemaDefinition desc = null)
: base(desc)
{
Contract.Requires(name, "name");
Conventions.CheckValidDomainName(name);
_name = name;
Behavior = behavior;
}
