private static string WriteInstanceAnnotation(ODataInstanceAnnotation instanceAnnotation, IEdmModel model)
{
var stringWriter = new StringWriter();
var outputContext = new ODataJsonLightOutputContext(
ODataFormat.Json,
stringWriter,
new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") },
model);
var valueSerializer = new ODataJsonLightValueSerializer(outputContext);
// The JSON Writer will complain if there is no active scope, so start an object scope.
valueSerializer.JsonWriter.StartObjectScope();
var instanceAnnotationWriter = new JsonLightInstanceAnnotationWriter(valueSerializer, new JsonMinimalMetadataTypeNameOracle());
// The method under test.
instanceAnnotationWriter.WriteInstanceAnnotation(instanceAnnotation);
valueSerializer.JsonWriter.EndObjectScope();
return stringWriter.ToString();
}
public void WriteInstanceAnnotationShouldPassComplexTypeFromModelToUnderlyingWriter()
{
// Add a value term of a complex type to the model.
var complexTypeReference = new EdmComplexTypeReference(new EdmComplexType("My.Namespace", "ComplexType"), false /*isNullable*/);
this.referencedModel.AddElement(new EdmTerm("My.Namespace", "StructuredTerm", complexTypeReference));
var instanceAnnotation = new ODataInstanceAnnotation("My.Namespace.StructuredTerm", new ODataComplexValue { TypeName = "ComplexType" });
bool calledWriteComplex = false;
this.valueWriter.WriteComplexVerifier = (complexValue, typeReference, isTopLevel, isOpenProperty, dupChecker) =>
{
typeReference.Should().NotBeNull();
typeReference.IsComplex().Should().BeTrue();
typeReference.AsComplex().FullName().Should().Be("My.Namespace.ComplexType");
calledWriteComplex = true;
};
this.jsonLightInstanceAnnotationWriter.WriteInstanceAnnotation(instanceAnnotation);
calledWriteComplex.Should().BeTrue();
}
public void WriteInstanceAnnotationShouldPassCollectionTypeFromModelToUnderlyingWriter()
{
// Add a value term of type Collection(Edm.String) to the model.
this.referencedModel.AddElement(new EdmTerm(
"My.Namespace",
"CollectionTerm",
new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
var instanceAnnotation = new ODataInstanceAnnotation("My.Namespace.CollectionTerm", new ODataCollectionValue() { TypeName = "Collection(Edm.String)" });
bool calledWriteCollection = false;
this.valueWriter.WriteCollectionVerifier = (collectionValue, typeReference, isTopLevel, isOpenProperty, dupChecker) =>
{
typeReference.Should().NotBeNull();
typeReference.IsCollection().Should().BeTrue();
typeReference.AsCollection().ElementType().IsString().Should().BeTrue();
calledWriteCollection = true;
};
var result = WriteInstanceAnnotation(instanceAnnotation, this.referencedModel);
result.Should().Contain("{\"@My.Namespace.CollectionTerm\":[]}");
result.Should().NotContain("odata.type");
this.jsonLightInstanceAnnotationWriter.WriteInstanceAnnotation(instanceAnnotation);
calledWriteCollection.Should().BeTrue();
}
public void WriteTopLevelErrorWithDateTimeInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var primitiveValue = new ODataPrimitiveValue(new DateTimeOffset(2000, 1, 1, 12, 30, 0, new TimeSpan()));
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.primitive", primitiveValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"[email protected]\":\"#DateTimeOffset\",\"@sample.primitive\":\"2000-01-01T12:30:00Z\"");
}
public void WriteInstanceAnnotationShouldWriteValueTypeIfMoreDerivedThanMetadataType()
{
// Add a value term of type Geography to the model.
this.referencedModel.AddElement(new EdmTerm("My.Namespace", "GeographyTerm", EdmPrimitiveTypeKind.Geography));
var instanceAnnotation = new ODataInstanceAnnotation("My.Namespace.GeographyTerm", new ODataPrimitiveValue(GeographyPoint.Create(0.0, 0.0)));
bool writingTypeName = false;
bool wroteTypeName = false;
this.jsonWriter.WriteNameVerifier = s =>
{
writingTypeName = s.EndsWith("odata.type");
};
this.jsonWriter.WriteValueVerifier = s =>
{
if (writingTypeName)
{
s.Should().Be("#GeographyPoint");
wroteTypeName = true;
}
};
this.valueWriter.WritePrimitiveVerifier = (o, reference) => { };
this.jsonLightInstanceAnnotationWriter.WriteInstanceAnnotation(instanceAnnotation);
wroteTypeName.Should().BeTrue();
}
/// <summary>
/// Writes an ODataError with the given custom instance annotation to the test stream.
/// </summary>
private void WriteError(params KeyValuePair<string, ODataValue>[] annotations)
{
var writerSettings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true };
writerSettings.SetContentType(ODataFormat.Json);
writerSettings.SetServiceDocumentUri(new Uri("http://example.com/"));
IODataResponseMessage messageToWrite = new InMemoryMessage { StatusCode = 400, Stream = this.stream };
var error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
error.SetInstanceAnnotations(instanceAnnotations);
foreach (var pair in annotations)
{
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation(pair.Key, pair.Value);
instanceAnnotations.Add(annotation);
}
using (var writer = new ODataMessageWriter(messageToWrite, writerSettings, this.model))
{
writer.WriteError(error, false);
}
}
public void TheNamePropertyShouldReturnTheAnnotationName()
{
const string name = "instance.annotation";
var annotation = new ODataInstanceAnnotation(name, new ODataPrimitiveValue("value"));
annotation.Name.Should().Be(name);
}
public void WriteTopLevelErrorWithCollectionOfComplexInstanceAnnotationWithNoTypeNameShouldThrow()
{
SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var collection = new ODataCollectionValue
{
Items = new[] { new ODataComplexValue(), new ODataComplexValue { TypeName = "ns.ErrorDetails" } }
};
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.collection", collection);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
Action writeError = () => serializer.WriteTopLevelError(error, false);
writeError.ShouldThrow<ODataException>().WithMessage(Strings.WriterValidationUtils_MissingTypeNameWithMetadata);
});
}
public void WriteTopLevelErrorWithStringInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.primitive", new ODataPrimitiveValue("stringValue"));
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"@sample.primitive\":\"stringValue\"");
}
public void WriteTopLevelErrorWithComplexInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var complexValue = new ODataComplexValue();
complexValue.TypeName = "ns.ErrorDetails";
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.complex", complexValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"@sample.complex\":{\"@odata.type\":\"#ns.ErrorDetails\"}");
}
public void WriteTopLevelErrorWithCollectionOfComplexInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var collection = new ODataCollectionValue
{
TypeName = "Collection(ns.ErrorDetails)",
Items = new[] { new ODataComplexValue(), new ODataComplexValue { TypeName = "ns.ErrorDetails" } }
};
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.collection", collection);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"[email protected]\":\"#Collection(ns.ErrorDetails)\",\"@sample.collection\":[{},{}]");
}
public void WriteTopLevelErrorWithStringInstanceAnnotationWithTypeNameAttribute()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var primitiveValue = new ODataPrimitiveValue("stringValue");
primitiveValue.SetAnnotation(new SerializationTypeNameAnnotation() { TypeName = "Custom.Type" });
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.primitive", primitiveValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"[email protected]\":\"#Custom.Type\",\"@sample.primitive\":\"stringValue\"");
}
public void WriteTopLevelErrorWithTimeOfDayInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var primitiveValue = new ODataPrimitiveValue(new TimeOfDay(12, 30, 5, 90));
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.primitive", primitiveValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"[email protected]\":\"#TimeOfDay\",\"@sample.primitive\":\"12:30:05.0900000\"");
}
public void WriteTopLevelErrorWithDateInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var primitiveValue = new ODataPrimitiveValue(new Date(2014, 8, 8));
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.primitive", primitiveValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"[email protected]\":\"#Date\",\"@sample.primitive\":\"2014-08-08\"");
}
public void WriteInstanceAnnotationShouldSkipAnnotationsThatDoesNotPassTheAnnotationFilter()
{
var annotation = new ODataInstanceAnnotation("ns1.name", new ODataPrimitiveValue(123));
var verifierCalls = 0;
this.jsonWriter.WriteNameVerifier = (name) => verifierCalls++;
this.valueWriter.WritePrimitiveVerifier = (value, reference) => verifierCalls++;
this.valueWriter.Settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = name => name != "ns1.name" };
this.jsonLightInstanceAnnotationWriter.WriteInstanceAnnotation(annotation);
verifierCalls.Should().Be(0);
}
/// <summary>
/// Writes an instance annotation.
/// </summary>
/// <param name="instanceAnnotation">The instance annotation to write.</param>
/// <param name="ignoreFilter">Whether to ingore the filter in settings.</param>
/// <param name="propertyName">The name of the property this instance annotation applies to</param>
internal void WriteInstanceAnnotation(ODataInstanceAnnotation instanceAnnotation, bool ignoreFilter = false, string propertyName = null)
{
string name = instanceAnnotation.Name;
ODataValue value = instanceAnnotation.Value;
Debug.Assert(!string.IsNullOrEmpty(name), "name should not be null or empty");
Debug.Assert(!ODataAnnotationNames.IsODataAnnotationName(name), "A reserved name cannot be used as instance annotation key");
Debug.Assert(value != null, "value should not be null because we use ODataNullValue for null instead");
Debug.Assert(!(value is ODataStreamReferenceValue), "!(value is ODataStreamReferenceValue) -- ODataInstanceAnnotation and InstanceAnnotationCollection will throw if the value is a stream value.");
Debug.Assert(this.valueSerializer.Model != null, "this.valueSerializer.Model != null");
if (!ignoreFilter && this.valueSerializer.Settings.ShouldSkipAnnotation(name))
{
return;
}
IEdmTypeReference expectedType = MetadataUtils.LookupTypeOfValueTerm(name, this.valueSerializer.Model);
if (value is ODataNullValue)
{
if (expectedType != null && !expectedType.IsNullable)
{
throw new ODataException(ODataErrorStrings.ODataAtomPropertyAndValueSerializer_NullValueNotAllowedForInstanceAnnotation(instanceAnnotation.Name, expectedType.ODataFullName()));
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteNullValue();
return;
}
// If we didn't find an expected type from looking up the term in the model, treat this value the same way we would for open property values.
// That is, write the type name (unless its a primitive value with a JSON-native type). If we did find an expected type, treat the annotation value like a
// declared property with an expected type. This will still write out the type if the value type is more derived than the declared type, for example.
bool treatLikeOpenProperty = expectedType == null;
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteComplexValue(complexValue, expectedType, false /*isTopLevel*/, treatLikeOpenProperty, this.valueSerializer.CreateDuplicatePropertyNamesChecker());
return;
}
IEdmTypeReference typeFromValue = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.valueSerializer.Model, expectedType, value, treatLikeOpenProperty);
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
string collectionTypeNameToWrite = this.typeNameOracle.GetValueTypeNameForWriting(collectionValue, expectedType, typeFromValue, treatLikeOpenProperty);
if (collectionTypeNameToWrite != null)
{
ODataJsonLightWriterUtils.WriteODataTypePropertyAnnotation(this.JsonWriter, name, collectionTypeNameToWrite);
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteCollectionValue(collectionValue, expectedType, false /*isTopLevelProperty*/, false /*isInUri*/, treatLikeOpenProperty);
return;
}
ODataPrimitiveValue primitiveValue = value as ODataPrimitiveValue;
Debug.Assert(primitiveValue != null, "Did we add a new subclass of ODataValue?");
string primitiveTypeNameToWrite = this.typeNameOracle.GetValueTypeNameForWriting(primitiveValue, expectedType, typeFromValue, treatLikeOpenProperty);
if (primitiveTypeNameToWrite != null)
{
ODataJsonLightWriterUtils.WriteODataTypePropertyAnnotation(this.JsonWriter, name, primitiveTypeNameToWrite);
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WritePrimitiveValue(primitiveValue.Value, expectedType);
}
/// <summary>
/// Writes an instance annotation.
/// </summary>
/// <param name="instanceAnnotation">The instance annotation to write.</param>
/// <param name="ignoreFilter">Whether to ignore the filter in settings.</param>
/// <param name="propertyName">The name of the property this instance annotation applies to</param>
internal void WriteInstanceAnnotation(ODataInstanceAnnotation instanceAnnotation, bool ignoreFilter = false, string propertyName = null)
{
string name = instanceAnnotation.Name;
ODataValue value = instanceAnnotation.Value;
Debug.Assert(!string.IsNullOrEmpty(name), "name should not be null or empty");
Debug.Assert(!ODataAnnotationNames.IsODataAnnotationName(name), "A reserved name cannot be used as instance annotation key");
Debug.Assert(value != null, "value should not be null because we use ODataNullValue for null instead");
Debug.Assert(!(value is ODataStreamReferenceValue), "!(value is ODataStreamReferenceValue) -- ODataInstanceAnnotation and InstanceAnnotationCollection will throw if the value is a stream value.");
Debug.Assert(this.valueSerializer.Model != null, "this.valueSerializer.Model != null");
if (!ignoreFilter && this.valueSerializer.Settings.ShouldSkipAnnotation(name))
{
return;
}
IEdmTypeReference expectedType = MetadataUtils.LookupTypeOfValueTerm(name, this.valueSerializer.Model);
if (value is ODataNullValue)
{
if (expectedType != null && !expectedType.IsNullable)
{
throw new ODataException(ODataErrorStrings.ODataAtomPropertyAndValueSerializer_NullValueNotAllowedForInstanceAnnotation(instanceAnnotation.Name, expectedType.ODataFullName()));
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteNullValue();
return;
}
// If we didn't find an expected type from looking up the term in the model, treat this value the same way we would for open property values.
// That is, write the type name (unless its a primitive value with a JSON-native type). If we did find an expected type, treat the annotation value like a
// declared property with an expected type. This will still write out the type if the value type is more derived than the declared type, for example.
bool treatLikeOpenProperty = expectedType == null;
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteComplexValue(complexValue, expectedType, false /*isTopLevel*/, treatLikeOpenProperty, this.valueSerializer.CreateDuplicatePropertyNamesChecker());
return;
}
IEdmTypeReference typeFromValue = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.valueSerializer.Model, expectedType, value, treatLikeOpenProperty);
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
string collectionTypeNameToWrite = this.typeNameOracle.GetValueTypeNameForWriting(collectionValue, expectedType, typeFromValue, treatLikeOpenProperty);
if (collectionTypeNameToWrite != null)
{
ODataJsonLightWriterUtils.WriteODataTypePropertyAnnotation(this.JsonWriter, name, collectionTypeNameToWrite);
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WriteCollectionValue(collectionValue, expectedType, false /*isTopLevelProperty*/, false /*isInUri*/, treatLikeOpenProperty);
return;
}
ODataPrimitiveValue primitiveValue = value as ODataPrimitiveValue;
Debug.Assert(primitiveValue != null, "Did we add a new subclass of ODataValue?");
string primitiveTypeNameToWrite = this.typeNameOracle.GetValueTypeNameForWriting(primitiveValue, expectedType, typeFromValue, treatLikeOpenProperty);
if (primitiveTypeNameToWrite != null)
{
ODataJsonLightWriterUtils.WriteODataTypePropertyAnnotation(this.JsonWriter, name, primitiveTypeNameToWrite);
}
this.WriteInstanceAnnotationName(propertyName, name);
this.valueSerializer.WritePrimitiveValue(primitiveValue.Value, expectedType);
}
public void GetInstanceAnnotationsForWritingShouldReturnInstanceAnnotationsFromODataErrorWithInstanceAnnotations()
{
ODataInstanceAnnotation instanceAnnotation = new ODataInstanceAnnotation("namespace.name", new ODataPrimitiveValue("value"));
this.odataError.InstanceAnnotations.Add(instanceAnnotation);
this.odataError.InstanceAnnotations.Should().Contain(instanceAnnotation).And.HaveCount(1);
}
/// <summary>
/// Convert an instance annotation to clr object.
/// </summary>
/// <param name="instanceAnnotation">Instance annotation to be converted</param>
/// <param name="clrInstanceAnnotation">The clr object</param>
/// <returns>A dictionary of clr-typed instance annotation</returns>
private bool TryConvertToClrInstanceAnnotation(ODataInstanceAnnotation instanceAnnotation, out object clrInstanceAnnotation)
{
clrInstanceAnnotation = null;
var primitiveValue = instanceAnnotation.Value as ODataPrimitiveValue;
if (primitiveValue != null)
{
clrInstanceAnnotation = primitiveValue.Value;
return true;
}
var enumValue = instanceAnnotation.Value as ODataEnumValue;
if (enumValue != null)
{
var type = this.MaterializerContext.Context.ResolveTypeFromName(enumValue.TypeName);
if (type != null)
{
clrInstanceAnnotation = EnumValueMaterializationPolicy.MaterializeODataEnumValue(type, enumValue);
return true;
}
return false;
}
var complexValue = instanceAnnotation.Value as ODataComplexValue;
if (complexValue != null)
{
var type = this.MaterializerContext.Context.ResolveTypeFromName(complexValue.TypeName);
if (type != null)
{
ClientEdmModel edmModel = this.MaterializerContext.Model;
ClientTypeAnnotation complexType = edmModel.GetClientTypeAnnotation(edmModel.GetOrCreateEdmType(type));
// TODO: check if ComplexType inheritance will cause any issue
var complexInstance = this.ComplexValueMaterializationPolicy.CreateNewInstance(complexType.EdmTypeReference, complexType.ElementType);
this.ComplexValueMaterializationPolicy.MaterializeDataValues(complexType, complexValue.Properties, this.MaterializerContext.IgnoreMissingProperties);
this.ComplexValueMaterializationPolicy.ApplyDataValues(complexType, complexValue.Properties, complexInstance);
clrInstanceAnnotation = complexInstance;
return true;
}
return false;
}
var collectionValue = instanceAnnotation.Value as ODataCollectionValue;
if (collectionValue != null)
{
var serverSideModel = this.MaterializerContext.Context.Format.LoadServiceModel();
var valueTerm = serverSideModel.FindValueTerm(instanceAnnotation.Name);
if (valueTerm != null && valueTerm.Type != null && valueTerm.Type.Definition != null)
{
var edmCollectionType = valueTerm.Type.Definition as IEdmCollectionType;
if (edmCollectionType != null)
{
Type collectionItemType = null;
var elementType = edmCollectionType.ElementType;
PrimitiveType primitiveType;
if (PrimitiveType.TryGetPrimitiveType(elementType.FullName(), out primitiveType))
{
collectionItemType = primitiveType.ClrType;
}
else
{
collectionItemType = this.MaterializerContext.Context.ResolveTypeFromName(elementType.FullName());
}
if (collectionItemType != null)
{
Type collectionICollectionType = typeof(ICollection<>).MakeGenericType(new Type[] { collectionItemType });
ClientTypeAnnotation collectionClientTypeAnnotation = this.MaterializerContext.ResolveTypeForMaterialization(
collectionICollectionType,
collectionValue.TypeName);
bool isElementNullable = edmCollectionType.ElementType.IsNullable;
var collectionInstance = this.CollectionValueMaterializationPolicy.CreateCollectionInstance(
collectionClientTypeAnnotation.EdmTypeReference as IEdmCollectionTypeReference,
collectionClientTypeAnnotation.ElementType);
this.CollectionValueMaterializationPolicy.ApplyCollectionDataValues(
collectionValue.Items,
collectionValue.TypeName,
collectionInstance,
collectionItemType,
ClientTypeUtil.GetAddToCollectionDelegate(collectionICollectionType),
isElementNullable);
clrInstanceAnnotation = collectionInstance;
return true;
}
}
}
return false;
}
var nullValue = instanceAnnotation.Value as ODataNullValue;
if (nullValue != null)
{
clrInstanceAnnotation = null;
return true;
}
return false;
}
public void WriteInstanceAnnotationShouldPassPrimitiveTypeFromModelToUnderlyingWriter()
{
// Add a value term of type DateTimeOffset to the model.
this.referencedModel.AddElement(new EdmTerm("My.Namespace", "DateTimeTerm", EdmPrimitiveTypeKind.DateTimeOffset));
var instanceAnnotation = new ODataInstanceAnnotation("My.Namespace.DateTimeTerm", new ODataPrimitiveValue(DateTimeOffset.MinValue));
bool calledWritePrimitive = false;
this.valueWriter.WritePrimitiveVerifier = (o, reference) =>
{
reference.Should().NotBeNull();
reference.IsDateTimeOffset().Should().BeTrue();
calledWritePrimitive = true;
};
this.jsonLightInstanceAnnotationWriter.WriteInstanceAnnotation(instanceAnnotation);
calledWritePrimitive.Should().BeTrue();
}
public void TheValuePropertyShouldReturnTheAnnotationValue()
{
foreach(ODataValue value in new ODataValue[] {new ODataNullValue(), new ODataPrimitiveValue(1), new ODataComplexValue(), new ODataCollectionValue()})
{
var annotation = new ODataInstanceAnnotation("namespace.name", value);
annotation.Value.Should().BeSameAs(value);
}
}
private static ODataInstanceAnnotation GetNextAnnotation(string namePrefix = null)
{
var annotation = new ODataInstanceAnnotation(GetNextName(namePrefix), GetNextValue());
next++;
NextNameIndex++;
return annotation;
}
