public void CreateAmbiguousBinding()
{
EdmModel model = new EdmModel();
EdmComplexType c1 = new EdmComplexType("Ambiguous", "Binding");
EdmComplexType c2 = new EdmComplexType("Ambiguous", "Binding");
EdmComplexType c3 = new EdmComplexType("Ambiguous", "Binding");
model.AddElement(c1);
Assert.AreEqual(c1, model.FindType("Ambiguous.Binding"), "Single item resolved");
model.AddElement(c2);
model.AddElement(c3);
IEdmNamedElement ambiguous = model.FindType("Ambiguous.Binding");
Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad");
Assert.AreEqual(EdmErrorCode.BadAmbiguousElementBinding, ambiguous.Errors().First().ErrorCode, "Ambiguous");
c1 = null;
c2 = new EdmComplexType("Ambiguous", "Binding2");
Assert.IsTrue
(
model.SchemaElements.OfType<IEdmComplexType>().Count() == 3 && model.SchemaElements.OfType<IEdmComplexType>().All(n => n.FullName() == "Ambiguous.Binding"),
"The model must be immutable."
);
}
private void VerifyTimeOfDayValueReader(string payload, string edmTypeName, object expectedResult)
{
IEdmModel model = new EdmModel();
IEdmPrimitiveTypeReference typeReference = new EdmPrimitiveTypeReference((IEdmPrimitiveType)model.FindType(edmTypeName), true);
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
object actualValue;
using (ODataJsonLightInputContext inputContext = new ODataJsonLightInputContext(
ODataFormat.Json,
stream,
JsonLightUtils.JsonLightStreamingMediaType,
Encoding.UTF8,
new ODataMessageReaderSettings(),
/*readingResponse*/ true,
/*synchronous*/ true,
model,
/*urlResolver*/ null))
{
ODataJsonLightPropertyAndValueDeserializer deserializer = new ODataJsonLightPropertyAndValueDeserializer(inputContext);
deserializer.JsonReader.Read();
actualValue = deserializer.ReadNonEntityValue(
/*payloadTypeName*/ null,
typeReference,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ true,
/*insideComplexValue*/ false,
/*propertyName*/ null);
}
actualValue.Should().Be(expectedResult, "payload ->{0}<- for type '{1}'", payload, edmTypeName);
}
private IEdmVocabularyAnnotatable ConvertToStockVocabularyAnnotatable(IEdmElement edmAnnotatable, EdmModel stockModel)
{
// TODO: Need to provide a better way to get more details on IEdmVocabularyAnnotation.Target.
IEdmVocabularyAnnotatable stockAnnotatable = null;
if (edmAnnotatable is IEdmEntityType)
{
var edmEntityType = edmAnnotatable as IEdmEntityType;
stockAnnotatable = stockModel.FindType(edmEntityType.FullName()) as IEdmVocabularyAnnotatable;
ExceptionUtilities.CheckObjectNotNull(stockAnnotatable, "The FindType method must be successful.");
}
else if (edmAnnotatable is IEdmProperty)
{
var edmProperty = edmAnnotatable as IEdmProperty;
if (edmProperty.DeclaringType is IEdmSchemaElement)
{
var stockSchemaElement = stockModel.FindType(((IEdmSchemaElement)edmProperty.DeclaringType).FullName());
ExceptionUtilities.CheckObjectNotNull(stockAnnotatable, "The FindType method must be successful.");
stockAnnotatable = ((IEdmStructuredType)stockSchemaElement).FindProperty(edmProperty.Name);
}
else
{
throw new NotImplementedException();
}
}
else if (edmAnnotatable is IEdmEntitySet)
{
var edmEntitySet = edmAnnotatable as IEdmEntitySet;
// TODO: No backpointer to the Entity Container from EntitySet in the API. Is this OK?
stockAnnotatable = stockModel.EntityContainer.EntitySets().Single(m => m.Name == edmEntitySet.Name);
}
else if (edmAnnotatable is IEdmEnumType)
{
var edmEnumType = edmAnnotatable as IEdmEnumType;
stockAnnotatable = stockModel.FindType(edmEnumType.FullName());
}
else
{
throw new NotImplementedException();
}
return stockAnnotatable;
}
public void AddOperationWhileTypeHasSameName()
{
EdmModel model = new EdmModel();
EdmComplexType c1 = new EdmComplexType("Ambiguous", "Binding");
IEdmOperation o1 = new EdmFunction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
IEdmOperation o2 = new EdmFunction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
IEdmOperation o3 = new EdmFunction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
model.AddElement(o1);
Assert.AreEqual(1, model.FindOperations("Ambiguous.Binding").Count(), "First function was correctly added to operation group");
model.AddElement(o2);
Assert.AreEqual(2, model.FindOperations("Ambiguous.Binding").Count(), "Second function was correctly added to operation group");
model.AddElement(c1);
model.AddElement(o3);
Assert.AreEqual(3, model.FindOperations("Ambiguous.Binding").Count(), "Third function was correctly added to operation group");
Assert.AreEqual(c1, model.FindType("Ambiguous.Binding"), "Single item resolved");
}
public void AmbiguousTypeTest()
{
EdmModel model = new EdmModel();
IEdmSchemaType type1 = new StubEdmComplexType("Foo", "Bar");
IEdmSchemaType type2 = new StubEdmComplexType("Foo", "Bar");
IEdmSchemaType type3 = new StubEdmComplexType("Foo", "Bar");
model.AddElement(type1);
Assert.AreEqual(type1, model.FindType("Foo.Bar"), "Correct item.");
model.AddElement(type2);
model.AddElement(type3);
IEdmSchemaType ambiguous = model.FindType("Foo.Bar");
Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, ambiguous.SchemaElementKind, "Correct schema element kind.");
Assert.AreEqual("Foo", ambiguous.Namespace, "Correct Namespace");
Assert.AreEqual("Bar", ambiguous.Name, "Correct Name");
Assert.AreEqual(EdmTypeKind.None, ambiguous.TypeKind, "Correct type kind.");
}
public void PropertyInStreamErrorTests()
{
EdmModel model = new EdmModel();
ODataProperty property = ObjectModelUtils.CreateDefaultPrimitiveProperties(model)[0];
var container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
var entityType = model.FindType("TestModel.EntryWithPrimitiveProperties") as EdmEntityType;
this.Assert.AreEqual("Null", property.Name, "Expected null property to be the first primitive property.");
PayloadWriterTestDescriptor<ODataProperty>[] testDescriptors = new PayloadWriterTestDescriptor<ODataProperty>[]
{
new PayloadWriterTestDescriptor<ODataProperty>(this.Settings, property, (string)null, (string)null)
{
Model = model,
PayloadEdmElementContainer = entityType
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
TestWriterUtils.InvalidSettingSelectors,
this.WriterTestConfigurationProvider.ExplicitFormatConfigurationsWithIndent,
(testDescriptor, selector, testConfiguration) =>
{
TestWriterUtils.WriteWithStreamErrors(
testDescriptor,
selector,
testConfiguration,
(messageWriter) => messageWriter.WriteProperty(testDescriptor.PayloadItems.Single()),
this.Assert);
});
}
private IEdmEnumMember ConvertToStockMember(IEdmEnumMember edmMember, IEdmModel edmModel, EdmModel stockModel)
{
var stockMemberDeclaringType = stockModel.FindType(GetFullName(edmMember.DeclaringType)) as IEdmEnumType;
var stockMember = new EdmEnumMember(
stockMemberDeclaringType,
edmMember.Name,
edmMember.Value
);
((EdmEnumType)stockMemberDeclaringType).AddMember(stockMember);
// TODO: Documentation
this.SetImmediateAnnotations(edmMember, stockMember, edmModel, stockModel);
return stockMember;
}
private IEdmStructuralProperty ConvertToStockStructuralProperty(IEdmStructuralProperty edmProperty, IEdmModel edmModel, EdmModel stockModel)
{
var stockPropertyDeclaringType = stockModel.FindType(GetFullName(edmProperty.DeclaringType)) as IEdmStructuredType;
var stockProperty = new EdmStructuralProperty(
stockPropertyDeclaringType,
edmProperty.Name,
ConvertToStockTypeReference(edmProperty.Type, stockModel),
edmProperty.DefaultValueString,
edmProperty.ConcurrencyMode
);
((EdmStructuredType)stockPropertyDeclaringType).AddProperty(stockProperty);
// TODO: Documentation
this.SetImmediateAnnotations(edmProperty, stockProperty, edmModel, stockModel);
return stockProperty;
}
private PayloadWriterTestDescriptor<ODataItem>[] CreateFeedQueryCountDescriptors()
{
Func<long?, ODataFeed> feedCreator = (c) =>
{
ODataFeed feed = ObjectModelUtils.CreateDefaultFeed();
feed.Count = c;
return feed;
};
long?[] counts = new long?[] { 0, 1, 2, 1000, -1 - 10, long.MaxValue, long.MinValue, null };
EdmModel model = new EdmModel();
ODataEntry entry = ObjectModelUtils.CreateDefaultEntryWithAtomMetadata("DefaultEntitySet", "DefaultEntityType", model);
var container = model.FindEntityContainer("DefaultContainer");
var entitySet = container.FindEntitySet("DefaultEntitySet") as EdmEntitySet;
var entityType = model.FindType("TestModel.DefaultEntityType") as EdmEntityType;
var descriptors = counts.Select(count => new PayloadWriterTestDescriptor<ODataItem>(this.Settings, feedCreator(count),
(testConfiguration) =>
{
if (testConfiguration.IsRequest && count.HasValue)
{
return new WriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedException2 = ODataExpectedExceptions.ODataException("ODataWriterCore_QueryCountInRequest")
};
}
if (testConfiguration.Format == ODataFormat.Atom)
{
if (count.HasValue)
{
return new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = @"<m:count xmlns:m =""" + TestAtomConstants.ODataMetadataNamespace + @""">" + count + "</m:count>",
FragmentExtractor = (result) => result.Elements(XName.Get("count", TestAtomConstants.ODataMetadataNamespace)).Single()
};
}
else
{
return new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = @"<nocount xmlns=""" + TestAtomConstants.ODataMetadataNamespace + @"""/>",
FragmentExtractor = (result) =>
{
var countElement = result.Elements(XName.Get("count", TestAtomConstants.ODataMetadataNamespace)).SingleOrDefault();
if (countElement == null)
{
countElement = new XElement(TestAtomConstants.ODataMetadataXNamespace + "nocount");
}
return countElement;
}
};
}
}
else if (testConfiguration.Format == ODataFormat.Json)
{
if (count.HasValue)
{
return new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = "$(Indent)$(Indent)\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataCountAnnotationName + "\":\"" + count + "\"",
FragmentExtractor = (result) => result.Object().Property(JsonLightConstants.ODataCountAnnotationName)
};
}
else
{
return new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = string.Join("$(NL)",
"[",
string.Empty,
"]"),
FragmentExtractor = (result) =>
{
return JsonLightWriterUtils.GetTopLevelFeedItemsArray(testConfiguration, result).RemoveAllAnnotations(true);
}
};
}
}
else
{
string formatName = testConfiguration.Format == null ? "null" : testConfiguration.Format.GetType().Name;
throw new NotSupportedException("Invalid format detected: " + formatName);
}
})
{
Model = model,
PayloadEdmElementContainer = entitySet,
PayloadEdmElementType = entityType,
});
return descriptors.ToArray();
}
public void ComplexValueIgnorePropertyNullValuesTest()
{
var versions = new Version[] {
null,
new Version(4, 0),
};
EdmModel edmModel = new EdmModel();
IEdmComplexType countryRegionType = edmModel.ComplexType("CountryRegion")
.Property("Name", EdmPrimitiveTypeKind.String)
.Property("CountryRegionCode", EdmPrimitiveTypeKind.String);
IEdmComplexType countryRegionNullType = edmModel.ComplexType("CountryRegionNull")
.Property("Name", EdmPrimitiveTypeKind.String)
.Property("CountryRegionCode", EdmPrimitiveTypeKind.String);
IEdmComplexType addressType = edmModel.ComplexType("Address")
.Property("Street", EdmPrimitiveTypeKind.String)
.Property("StreetNull", EdmCoreModel.Instance.GetString(true) as EdmTypeReference)
.Property("Numbers", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(false)) as EdmTypeReference)
.Property("CountryRegion", new EdmComplexTypeReference(countryRegionType, false))
.Property("CountryRegionNull", new EdmComplexTypeReference(countryRegionNullType, true));
edmModel.EntityType("Customer")
.KeyProperty("ID", EdmCoreModel.Instance.GetInt32(false) as EdmTypeReference)
.Property("Address", new EdmComplexTypeReference(addressType, false));
edmModel.Fixup();
this.CombinatorialEngineProvider.RunCombinations(
new ODataNullValueBehaviorKind[] { ODataNullValueBehaviorKind.Default, ODataNullValueBehaviorKind.DisableValidation, ODataNullValueBehaviorKind.IgnoreValue },
versions,
versions,
TestReaderUtils.ODataBehaviorKinds,
(nullPropertyValueReaderBehavior, dataServiceVersion, edmVersion, behaviorKind) =>
{
edmModel.SetEdmVersion(edmVersion);
// Now we set the 'IgnoreNullValues' annotation on all properties
IEdmComplexType edmAddressType = (IEdmComplexType)edmModel.FindType("TestModel.Address");
foreach (IEdmStructuralProperty edmProperty in edmAddressType.StructuralProperties())
{
edmModel.SetNullValueReaderBehavior(edmProperty, nullPropertyValueReaderBehavior);
}
EntityInstance customerPayload = PayloadBuilder.Entity("TestModel.Customer")
.PrimitiveProperty("ID", 1)
.Property("Address", PayloadBuilder.ComplexValue("TestModel.Address")
.PrimitiveProperty("Street", "One Microsoft Way")
.PrimitiveProperty("StreetNull", "One Microsoft Way")
.Property("Numbers", PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)").Item(1).Item(2))
.Property("CountryRegion", PayloadBuilder.ComplexValue("TestModel.CountryRegion")
.PrimitiveProperty("Name", "Austria")
.PrimitiveProperty("CountryRegionCode", "AUT"))
.Property("CountryRegionNull", PayloadBuilder.ComplexValue("TestModel.CountryRegionNull")
.PrimitiveProperty("Name", "Austria")
.PrimitiveProperty("CountryRegionCode", "AUT")));
var testCases = new[]
{
// Complex types that are not nullable should not allow null values.
// Null primitive property in the payload and non-nullable property in the model
new IgnoreNullValueTestCase
{
PropertyName = "Street",
ExpectedResponseException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "Street", "Edm.String"),
},
// Null complex property in the payload and non-nullable property in the model
new IgnoreNullValueTestCase
{
PropertyName = "CountryRegion",
ExpectedResponseException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "CountryRegion", "TestModel.CountryRegion"),
},
// Null collection property in the payload and non-nullable property in the model
new IgnoreNullValueTestCase
{
PropertyName = "Numbers",
ExpectedResponseException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "Numbers", "Collection(Edm.Int32)"),
},
// Complex types that are nullable should allow null values.
// Null primitive property in the payload and nullable property in the model
new IgnoreNullValueTestCase
{
PropertyName = "StreetNull",
},
// Null complex property in the payload and nullable property in the model
new IgnoreNullValueTestCase
{
PropertyName = "CountryRegionNull",
},
};
Func<IgnoreNullValueTestCase, ReaderTestConfiguration, PayloadReaderTestDescriptor> createTestDescriptor =
(testCase, testConfig) =>
{
EntityInstance payloadValue = customerPayload.DeepCopy();
ComplexInstance payloadAddressValue = ((ComplexProperty)payloadValue.GetProperty("Address")).Value;
SetToNull(payloadAddressValue, testCase.PropertyName);
ComplexInstance resultValue = payloadValue;
if (testConfig.IsRequest && nullPropertyValueReaderBehavior == ODataNullValueBehaviorKind.IgnoreValue)
{
resultValue = customerPayload.DeepCopy();
ComplexInstance resultAddressValue = ((ComplexProperty)resultValue.GetProperty("Address")).Value;
resultAddressValue.Remove(resultAddressValue.GetProperty(testCase.PropertyName));
}
return new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = payloadValue,
PayloadEdmModel = edmModel,
ExpectedResultPayloadElement =
tc =>
{
if (tc.Format == ODataFormat.Json)
{
// under the client knob ODL will compute edit links, ids, etc
// so we need to update the expected payload
if (tc.RunBehaviorKind == TestODataBehaviorKind.WcfDataServicesClient)
{
var entity = resultValue as EntityInstance;
if (entity != null)
{
if (!tc.IsRequest)
{
entity.Id = "http://odata.org/test/Customer(1)";
entity.EditLink = "http://odata.org/test/Customer(1)";
entity.WithSelfLink("http://odata.org/test/Customer(1)");
}
}
}
var tempDescriptor = new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = resultValue,
PayloadEdmModel = edmModel,
};
JsonLightPayloadElementFixup.Fixup(tempDescriptor);
return tempDescriptor.PayloadElement;
}
return resultValue;
},
ExpectedException = (testConfig.IsRequest && nullPropertyValueReaderBehavior != ODataNullValueBehaviorKind.Default) ? null : testCase.ExpectedResponseException
};
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testCase, testConfiguration) =>
{
testConfiguration = testConfiguration.CloneAndApplyBehavior(behaviorKind);
testConfiguration.MessageReaderSettings.BaseUri = null;
PayloadReaderTestDescriptor testDescriptor = createTestDescriptor(testCase, testConfiguration);
testDescriptor.RunTest(testConfiguration);
});
});
}
private void FillStockContentsForEnum(IEdmEnumType edmType, IEdmModel edmModel, EdmModel stockModel)
{
var stockType = (IEdmEnumType)stockModel.FindType(edmType.FullName());
this.SetImmediateAnnotations(edmType, stockType, edmModel, stockModel);
foreach (var edmMember in edmType.Members)
{
ConvertToStockMember((IEdmEnumMember)edmMember, edmModel, stockModel);
}
}
private void FillStockContentsForComplex(IEdmComplexType edmType, IEdmModel edmModel, EdmModel stockModel)
{
var stockType = (EdmComplexType)stockModel.FindType(edmType.FullName());
this.SetImmediateAnnotations(edmType, stockType, edmModel, stockModel);
foreach (var edmProperty in edmType.DeclaredStructuralProperties())
{
ConvertToStockStructuralProperty((IEdmStructuralProperty)edmProperty, edmModel, stockModel);
}
}
private void FillStockContentsForEntityContainer(IEdmEntityContainer edmContainer, IEdmModel edmModel, EdmModel stockModel)
{
var stockContainer = (EdmEntityContainer)stockModel.FindEntityContainer(edmContainer.FullName());
this.SetImmediateAnnotations(edmContainer, stockContainer, edmModel, stockModel);
foreach (var edmNavigationSource in edmContainer.Elements.OfType<IEdmNavigationSource>())
{
var stockEntityType = (EdmEntityType)stockModel.FindType(GetFullName(edmNavigationSource.EntityType()));
if (edmNavigationSource is IEdmSingleton)
{
stockContainer.AddSingleton(edmNavigationSource.Name, stockEntityType);
}
else
{
stockContainer.AddEntitySet(edmNavigationSource.Name, stockEntityType);
}
}
foreach (var stockNavigationSource in stockContainer.Elements.OfType<EdmNavigationSource>())
{
var stockEntityType = (EdmEntityType)stockModel.FindType(GetFullName(stockNavigationSource.EntityType()));
IEdmNavigationSource edmNavigationSource = edmContainer.FindEntitySet(stockNavigationSource.Name);
if (edmNavigationSource == null)
{
edmNavigationSource = edmContainer.FindSingleton(stockNavigationSource.Name);
}
var stockDerivedNavigations = GetAllNavigationFromDerivedTypesAndSelf(stockEntityType, stockModel);
foreach (var stockNavigationProperty in stockDerivedNavigations)
{
var edmNavigationProperty = edmNavigationSource.NavigationPropertyBindings.Select(n => n.NavigationProperty).SingleOrDefault(n => n.Name == stockNavigationProperty.Name);
if (edmNavigationProperty != null)
{
var targetEdmEntitySet = edmNavigationSource.FindNavigationTarget(edmNavigationProperty);
if (null != targetEdmEntitySet)
{
var targetEntitySetFromContainer = stockContainer.Elements.OfType<EdmEntitySet>().SingleOrDefault
(
n =>
GetBaseTypesAndSelf(((IEdmNavigationProperty)stockNavigationProperty).ToEntityType()).Select(m => GetFullName(m)).Contains(n.EntityType().FullName()) && n.Name == targetEdmEntitySet.Name
);
if (null == targetEntitySetFromContainer)
{
targetEntitySetFromContainer = stockContainer.Elements.OfType<EdmEntitySet>().SingleOrDefault
(
n =>
GetAllDerivedTypesAndSelf(((IEdmNavigationProperty)stockNavigationProperty).ToEntityType(), stockModel).Select(m => GetFullName(m)).Contains(n.EntityType().FullName()) && n.Name == targetEdmEntitySet.Name
);
}
stockNavigationSource.AddNavigationTarget(stockNavigationProperty, targetEntitySetFromContainer);
}
}
}
}
foreach (var edmOperationImport in edmContainer.OperationImports())
{
EdmOperationImport stockEdmOperationImport = null;
var edmActionImport = edmOperationImport as IEdmActionImport;
if (edmActionImport != null)
{
var newEdmAction = stockModel.FindDeclaredOperations(edmActionImport.Action.FullName()).OfType<IEdmAction>().FirstOrDefault() as EdmAction;
ExceptionUtilities.CheckObjectNotNull(newEdmAction, "cannot find action");
stockEdmOperationImport = stockContainer.AddActionImport(edmOperationImport.Name, newEdmAction, edmActionImport.EntitySet);
}
else
{
IEdmFunctionImport edmFunctionImport = edmOperationImport as IEdmFunctionImport;
ExceptionUtilities.CheckArgumentNotNull(edmFunctionImport, "edmFunctionImport");
var newEdmFunction = edmModel.FindDeclaredOperations(edmFunctionImport.Function.FullName()).OfType<IEdmFunction>().FirstOrDefault();
ExceptionUtilities.CheckObjectNotNull(newEdmFunction, "Expected to find an function: " + edmFunctionImport.Function.FullName());
stockEdmOperationImport = stockContainer.AddFunctionImport(edmFunctionImport.Name, newEdmFunction, edmFunctionImport.EntitySet, edmFunctionImport.IncludeInServiceDocument);
}
this.SetImmediateAnnotations(edmOperationImport, stockEdmOperationImport, edmModel, stockModel);
}
}
private void CreateNavigationPropertiesForStockEntity(IEdmEntityType edmType, IEdmModel edmModel, EdmModel stockModel)
{
var stockType = (EdmEntityType)stockModel.FindType(edmType.FullName());
foreach (var edmNavigation in edmType.DeclaredNavigationProperties())
{
var stockToRoleType = (EdmEntityType)stockModel.FindType(edmNavigation.ToEntityType().FullName());
if (stockType.FindProperty(edmNavigation.Name) == null)
{
Func<IEnumerable<IEdmStructuralProperty>, IEnumerable<IEdmStructuralProperty>> createDependentProperties = (dependentProps) =>
{
if (dependentProps == null)
{
return null;
}
var stockDependentProperties = new List<IEdmStructuralProperty>();
foreach (var dependentProperty in dependentProps)
{
var stockDepProp = edmNavigation.DependentProperties() != null ? stockType.FindProperty(dependentProperty.Name) : stockToRoleType.FindProperty(dependentProperty.Name);
stockDependentProperties.Add((IEdmStructuralProperty)stockDepProp);
}
return stockDependentProperties;
};
Func<IEdmReferentialConstraint, IEdmEntityType, IEnumerable<IEdmStructuralProperty>> createPrincipalProperties = (refConstraint, principalType) =>
{
if (refConstraint == null)
{
return null;
}
return refConstraint.PropertyPairs.Select(p => (IEdmStructuralProperty)principalType.FindProperty(p.PrincipalProperty.Name));
};
var propertyInfo = new EdmNavigationPropertyInfo()
{
Name = edmNavigation.Name,
Target = stockToRoleType,
TargetMultiplicity = edmNavigation.TargetMultiplicity(),
DependentProperties = createDependentProperties(edmNavigation.DependentProperties()),
PrincipalProperties = createPrincipalProperties(edmNavigation.ReferentialConstraint, stockToRoleType),
ContainsTarget = edmNavigation.ContainsTarget,
OnDelete = edmNavigation.OnDelete
};
bool bidirectional = edmNavigation.Partner != null && edmNavigation.ToEntityType().FindProperty(edmNavigation.Partner.Name) != null;
if (bidirectional)
{
var partnerInfo = new EdmNavigationPropertyInfo()
{
Name = edmNavigation.Partner.Name,
TargetMultiplicity = edmNavigation.Partner.TargetMultiplicity(),
DependentProperties = createDependentProperties(edmNavigation.Partner.DependentProperties()),
PrincipalProperties = createPrincipalProperties(edmNavigation.Partner.ReferentialConstraint, stockType),
ContainsTarget = edmNavigation.Partner.ContainsTarget,
OnDelete = edmNavigation.Partner.OnDelete
};
stockType.AddBidirectionalNavigation(propertyInfo, partnerInfo);
}
else
{
stockType.AddUnidirectionalNavigation(propertyInfo);
}
}
}
}
private void FillStockContentsForEntityWithoutNavigation(IEdmEntityType edmType, IEdmModel edmModel, EdmModel stockModel)
{
var stockType = (EdmEntityType)stockModel.FindType(edmType.FullName());
this.SetImmediateAnnotations(edmType, stockType, edmModel, stockModel);
foreach (var edmProperty in edmType.DeclaredStructuralProperties())
{
ConvertToStockStructuralProperty((IEdmStructuralProperty)edmProperty, edmModel, stockModel);
}
if (edmType.DeclaredKey != null)
{
stockType.AddKeys(edmType.DeclaredKey.Select(n => stockType.FindProperty(n.Name) as IEdmStructuralProperty).ToArray());
}
}
private PayloadWriterTestDescriptor<ODataItem>[] CreateFeedNextLinkDescriptors()
{
string[] nextLinkUris = new string[]
{
"http://my.customers.com/?skiptoken=1234",
"http://my.customers.com/?",
"http://my.customers.com/",
"http://my.customers.com/?$filter=3.14E%2B%20ne%20null",
"http://my.customers.com/?$filter='foo%20%26%20'%20ne%20null",
"http://my.customers.com/?$filter=not%20endswith(Name,'%2B')",
"http://my.customers.com/?$filter=geo.distance(Point,%20geometry'SRID=0;Point(6.28E%2B3%20-2.1e%2B4)')%20eq%20null",
};
Func<string, ODataFeed> feedCreator = (nextLink) =>
{
ODataFeed feed = ObjectModelUtils.CreateDefaultFeed();
feed.NextPageLink = new Uri(nextLink);
return feed;
};
EdmModel model = new EdmModel();
ODataFeed dummyFeed = ObjectModelUtils.CreateDefaultFeed("CustomersSet", "CustomerType", model);
var container = model.FindEntityContainer("DefaultContainer");
var customerSet = container.FindEntitySet("CustomersSet") as EdmEntitySet;
var customerType = model.FindType("TestModel.CustomerType") as EdmEntityType;
return nextLinkUris.Select(nextLink => new PayloadWriterTestDescriptor<ODataItem>(
this.Settings,
feedCreator(nextLink),
(testConfiguration) =>
{
if (testConfiguration.IsRequest)
{
return new WriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedException2 = ODataExpectedExceptions.ODataException("WriterValidationUtils_NextPageLinkInRequest")
};
}
if (testConfiguration.Format == ODataFormat.Atom)
{
return new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = @"<link rel=""next"" href=""" + nextLink + @""" xmlns=""" + TestAtomConstants.AtomNamespace + @""" />",
FragmentExtractor = (result) => result.Elements(XName.Get("link", TestAtomConstants.AtomNamespace)).Single()
};
}
else if (testConfiguration.Format == ODataFormat.Json)
{
return new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = "\"" + JsonLightConstants.ODataNextLinkAnnotationName + "\":\"" + nextLink + "\"",
FragmentExtractor = (result) => result.Object().Property(JsonLightConstants.ODataNextLinkAnnotationName)
};
}
else
{
string formatName = testConfiguration.Format == null ? "null" : testConfiguration.Format.GetType().Name;
throw new NotSupportedException("Invalid format detected: " + formatName);
}
})
{
Model = model,
PayloadEdmElementContainer = customerSet,
PayloadEdmElementType = customerType,
}).ToArray();
}
private IEdmTypeReference ConvertToStockTypeReference(IEdmTypeReference edmTypeReference, EdmModel stockModel)
{
IEdmTypeReference stockTypeReference = null;
switch (edmTypeReference.Definition.TypeKind)
{
case EdmTypeKind.Entity:
var stockEntity = (IEdmEntityType)stockModel.FindType(edmTypeReference.FullName());
stockTypeReference = new EdmEntityTypeReference(stockEntity, edmTypeReference.IsNullable);
break;
case EdmTypeKind.Complex:
var stockComplex = (IEdmComplexType)stockModel.FindType(edmTypeReference.FullName());
stockTypeReference = new EdmComplexTypeReference(stockComplex, edmTypeReference.IsNullable);
break;
case EdmTypeKind.Primitive:
stockTypeReference = CreatePrimitveStockTypeReference(edmTypeReference, stockModel);
break;
case EdmTypeKind.Collection:
stockTypeReference = CreateCollectionStockTypeReference(edmTypeReference, stockModel);
break;
case EdmTypeKind.EntityReference:
stockTypeReference = CreateEntityReference(edmTypeReference, stockModel);
break;
case EdmTypeKind.Enum:
var stockEnum = (IEdmEnumType)stockModel.FindType(edmTypeReference.FullName());
stockTypeReference = new EdmEnumTypeReference(stockEnum, edmTypeReference.IsNullable);
break;
default:
throw new NotImplementedException("EdmTypeKind.None are not implemented.");
}
return stockTypeReference;
}
private IEdmTypeReference CreateEntityReference(IEdmTypeReference edmTypeReference, EdmModel stockModel)
{
var edmEntityReferenceTypeReference = edmTypeReference.AsEntityReference();
var stockEntityReference = new EdmEntityReferenceType((IEdmEntityType)stockModel.FindType(edmEntityReferenceTypeReference.EntityType().FullName()));
return new EdmEntityReferenceTypeReference(stockEntityReference, edmEntityReferenceTypeReference.IsNullable);
}
private void VerifyPrimitiveValueRoundtrips(object clrValue, string edmTypeName, ODataVersion version, string description)
{
IEdmModel model = new EdmModel();
IEdmPrimitiveTypeReference typeReference = new EdmPrimitiveTypeReference((IEdmPrimitiveType)model.FindType(edmTypeName), true);
MemoryStream stream = new MemoryStream();
using (ODataAtomOutputContext outputContext = new ODataAtomOutputContext(
ODataFormat.Atom,
new NonDisposingStream(stream),
Encoding.UTF8,
new ODataMessageWriterSettings() { Version = version },
/*writingResponse*/ true,
/*synchronous*/ true,
model,
/*urlResolver*/ null))
{
ODataAtomPropertyAndValueSerializer serializer = new ODataAtomPropertyAndValueSerializer(outputContext);
serializer.XmlWriter.WriteStartElement("ValueElement");
serializer.WritePrimitiveValue(
clrValue,
/*collectionValidator*/ null,
typeReference,
/*serializationTypeNameAnnotation*/ null);
serializer.XmlWriter.WriteEndElement();
}
stream.Position = 0;
object actualValue;
using (ODataAtomInputContext inputContext = new ODataAtomInputContext(
ODataFormat.Atom,
stream,
Encoding.UTF8,
new ODataMessageReaderSettings(),
/*readingResponse*/ true,
/*synchronous*/ true,
model,
/*urlResolver*/ null))
{
ODataAtomPropertyAndValueDeserializer deserializer = new ODataAtomPropertyAndValueDeserializer(inputContext);
deserializer.XmlReader.MoveToContent();
actualValue = deserializer.ReadNonEntityValue(
typeReference,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true);
}
if (clrValue is byte[])
{
((byte[])actualValue).Should().Equal((byte[])clrValue, description);
}
else
{
actualValue.Should().Be(clrValue, description);
}
}
private IEdmModel CreateTestMetadata(out IEdmEntityType entityType, out IEdmComplexType complexType)
{
EdmModel model = new EdmModel();
EdmEntityType modelEntityType = model.EntityType("EntityType", "TestNS")
.KeyProperty("Id", EdmCoreModel.Instance.GetInt32(false) as EdmTypeReference);
EdmComplexType modelComplexType = model.ComplexType("ComplexType", "TestNS")
.Property("EntityProp", modelEntityType.ToTypeReference() as EdmTypeReference)
.Property("EntityCollectionProp", EdmCoreModel.GetCollection(modelEntityType.ToTypeReference()) as EdmTypeReference);
EdmEntityContainer container = new EdmEntityContainer("TestNS", "TestContainer");
container.AddFunctionAndFunctionImport(model, "FunctionImport1", EdmCoreModel.Instance.GetInt32(false));
container.AddFunctionAndFunctionImport(model, "PrimitiveValueFunctionImport", EdmCoreModel.Instance.GetInt32(false));
container.AddFunctionAndFunctionImport(model, "EntityValueFunctionImport", modelEntityType.ToTypeReference());
container.AddFunctionAndFunctionImport(model, "CollectionOfEntitiesFunctionImport", EdmCoreModel.GetCollection(modelEntityType.ToTypeReference()));
model.AddElement(container);
model.Fixup();
entityType = (IEdmEntityType)model.FindType("TestNS.EntityType");
ExceptionUtilities.Assert(entityType != null, "entityType != null");
complexType = (IEdmComplexType)model.FindType("TestNS.ComplexType");
ExceptionUtilities.Assert(complexType != null, "complexType != null");
return model;
}
