public static EdmModel ComplexNamespaceOverlappingModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction simpleOperationAction = new EdmAction("Default", "SimpleFunction", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(simpleOperationAction);
EdmActionImport simpleOperation = new EdmActionImport(container, "SimpleFunction", simpleOperationAction);
container.AddElement(simpleOperation);
model.AddElement(container);
XElement annotationElement =
new XElement("{http://foo}Annotation",
new XElement("{http://foo}Child",
new XElement("{http://foo1}GrandChild",
new XElement("{http://foo}GreatGrandChild",
"1"
)
)
),
new XElement("{http://foo1}Child",
new XElement("{http://foo}GrandChild",
"1"
)
)
);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleOperation, "http://foo", "Annotation", annotation);
return(model);
}
public void ValidateEntitySetAtttributeCorrectlyWritesOutEntitySet()
{
EdmActionImport actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("Customers"));
this.EdmModelCsdlSchemaWriterTest(writer => writer.WriteActionImportElementHeader(actionImport),
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""Customers""");
}
public void ValidateCorrectActionImportNameAndActionAttributeValueWrittenCorrectly()
{
EdmActionImport actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, null);
this.EdmModelCsdlSchemaWriterTest(writer => writer.WriteActionImportElementHeader(actionImport),
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut""");
}
public Task ExtendModelAsync(
ModelContext context,
CancellationToken cancellationToken)
{
var model = context.Model;
var entityContainer = model.EntityContainer as EdmEntityContainer;
foreach (ActionMethodInfo actionInfo in this.ActionInfos)
{
var returnTypeReference = ConventionalActionProvider.GetReturnTypeReference(actionInfo.Method.ReturnType);
var action = new EdmAction(entityContainer.Namespace, actionInfo.ActionName, returnTypeReference);
foreach (ParameterInfo parameter in actionInfo.Method.GetParameters())
{
EdmOperationParameter actionParam = new EdmOperationParameter(
action,
parameter.Name,
ConventionalActionProvider.GetTypeReference(parameter.ParameterType));
action.AddParameter(actionParam);
}
model.AddElement(action);
if (!action.IsBound)
{
EdmActionImport actionImport = new EdmActionImport(entityContainer, action.Name, action);
entityContainer.AddElement(actionImport);
}
}
return(Task.FromResult <object>(null));
}
public OpenApiRequestBodyGeneratorTest()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
EdmEntityType customer = new EdmEntityType("NS", "Customer", null, false, false, true);
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
var boolType = EdmCoreModel.Instance.GetBoolean(false);
var actionEntitySetPath = new EdmPathExpression("Param1/Nav");
var edmAction = new EdmAction("NS", "Checkout", boolType, true, actionEntitySetPath);
edmAction.AddParameter(new EdmOperationParameter(edmAction, "bindingParameter", new EdmEntityTypeReference(customer, true)));
edmAction.AddParameter("param", EdmCoreModel.Instance.GetString(true));
model.AddElement(edmAction);
var actionImportEntitySetPath = new EdmPathExpression("Param1/Nav2");
var edmActionImport = new EdmActionImport(container, "CheckoutImport", edmAction, actionImportEntitySetPath);
container.AddElement(edmActionImport);
_model = model;
_entityType = customer;
_action = edmAction;
_actionImport = edmActionImport;
}
public void ValidateIncorrectEdmExpressionThrows()
{
EdmActionImport actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmIntegerConstant(EdmCoreModel.Instance.GetInt32(true), 1));
Action errorTest = () => CreateEdmModelCsdlSchemaWriterForErrorTest().WriteActionImportElementHeader(actionImport);
errorTest.ShouldThrow <InvalidOperationException>().WithMessage(Strings.EdmModel_Validator_Semantic_OperationImportEntitySetExpressionIsInvalid(actionImport.Name));
}
public void VerifyActionImportWrittenCorrectly()
{
var actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, null);
VisitAndVerifyXml(
(visitor) => visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { actionImport }),
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" />");
}
public void EdmActionImportShouldBeActionImport()
{
var action = new EdmAction("d.s", "checkout", null);
var actionImport = new EdmActionImport(new EdmEntityContainer("d", "c"), "checkout", action);
actionImport.IsActionImport().Should().BeTrue();
actionImport.IsFunctionImport().Should().BeFalse();
}
private static ActionImportSegmentTemplate GetSegmentTemplate(out IEdmActionImport actionImport)
{
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
EdmAction action = new EdmAction("NS", "action", null);
actionImport = new EdmActionImport(container, "actionImport", action);
return(new ActionImportSegmentTemplate(actionImport, null));
}
public SelectedPropertiesNodeTests()
{
this.edmModel = new EdmModel();
this.defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
this.edmModel.AddElement(this.defaultContainer);
this.townType = new EdmEntityType("TestModel", "Town");
this.edmModel.AddElement(townType);
EdmStructuralProperty townIdProperty = townType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
townType.AddKeys(townIdProperty);
townType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
townType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
this.cityType = new EdmEntityType("TestModel", "City", this.townType);
cityType.AddStructuralProperty("Photo", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.edmModel.AddElement(cityType);
this.districtType = new EdmEntityType("TestModel", "District");
EdmStructuralProperty districtIdProperty = districtType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
districtType.AddKeys(districtIdProperty);
districtType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
districtType.AddStructuralProperty("Thumbnail", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.edmModel.AddElement(districtType);
cityType.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Districts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many
},
new EdmNavigationPropertyInfo {
Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.One
});
this.defaultContainer.AddEntitySet("Cities", cityType);
this.defaultContainer.AddEntitySet("Districts", districtType);
this.metropolisType = new EdmEntityType("TestModel", "Metropolis", this.cityType);
this.metropolisType.AddStructuralProperty("MetropolisStream", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.edmModel.AddElement(metropolisType);
metropolisType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "MetropolisNavigation", Target = districtType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.action = new EdmAction("TestModel", "Action", new EdmEntityTypeReference(this.cityType, true));
this.action.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(action);
this.actionImport = new EdmActionImport(this.defaultContainer, "Action", action);
this.actionConflictingWithPropertyName = new EdmAction("TestModel", "Zip", new EdmEntityTypeReference(this.districtType, true));
this.actionConflictingWithPropertyName.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(actionConflictingWithPropertyName);
this.actionImportConflictingWithPropertyName = new EdmActionImport(this.defaultContainer, "Zip", actionConflictingWithPropertyName);
this.openType = new EdmEntityType("TestModel", "OpenCity", this.cityType, false, true);
}
public void EdmActionImportConstructorShouldDefaultNonSpecifiedPropertiesCorrectly()
{
var edmAction = new EdmAction("DefaultNamespace", "Checkout", this.boolType);
var edmActionImport = new EdmActionImport(this.entityContainer, "CheckoutImport", edmAction, null);
edmActionImport.Name.Should().Be("CheckoutImport");
edmActionImport.EntitySet.Should().BeNull();
edmActionImport.Container.Should().Be(this.entityContainer);
edmActionImport.Action.Should().Be(edmAction);
}
/// <summary>
/// Initializes a new <see cref="IEdmActionImport"/> instance.
/// </summary>
/// <param name="name">name of the service operation.</param>
/// <param name="action">Action that the action import is importing into the container.</param>
/// <param name="resultSet">EntitySet of the result expected from this operation.</param>
/// <returns>An ActionImport</returns>
public EdmActionImport AddActionImport(string name, IEdmAction action, IEdmEntitySet resultSet)
{
EdmActionImport actionImport = new EdmActionImport(this,
name,
action,
resultSet == null ? null : new EdmEntitySetReferenceExpression(resultSet));
this.AddOperationImport(name, actionImport);
return(actionImport);
}
public void VerifyTwoIdenticalNamedActionImportsWithSameEdmPathOnlyWrittenOnce()
{
var actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("path1", "path2"));
var actionImport2 = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("path1", "path2"));
VisitAndVerifyXml(
(visitor) =>
{
visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { actionImport, actionImport2 });
},
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""path1/path2"" />");
}
public void VerifyTwoIdenticalNamedActionImportsWithNoEntitySetPropertyOnlyWrittenOnce()
{
var actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, null);
var actionImport2 = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, null);
VisitAndVerifyXml(
(visitor) =>
{
visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { actionImport, actionImport2 });
},
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" />");
}
public void VerifyTwoIdenticalNamedActionImportsWithSameEntitySetOnlyWrittenOnce()
{
var actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmEntitySetReferenceExpression(new EdmEntitySet(defaultContainer, "Set", new EdmEntityType("foo", "type"))));
var actionImport2 = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmEntitySetReferenceExpression(new EdmEntitySet(defaultContainer, "Set", new EdmEntityType("foo", "type"))));
VisitAndVerifyXml(
(visitor) =>
{
visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { actionImport, actionImport2 });
},
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""Set"" />");
}
public void KindPropertyReturnsOperationImport()
{
// Arrange
IEdmEntityContainer container = new EdmEntityContainer("NS", "default");
IEdmAction action = new EdmAction("NS", "MyAction", null);
var operationImport = new EdmActionImport(container, "MyAction", action);
ODataOperationImportSegment segment = new ODataOperationImportSegment(operationImport);
ODataPath path = new ODataPath(segment);
// Act & Assert
Assert.Equal(ODataPathKind.OperationImport, path.Kind);
}
public static IEdmModel AddDynamicModel(this EdmModel model)
{
var addressType = new EdmComplexType(Namespace, "address");
addressType.AddStructuralProperty("street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("city", EdmPrimitiveTypeKind.String);
var addressTypeRef = new EdmComplexTypeReference(addressType, isNullable: false);
var addressesTypeRef = EdmCoreModel.GetCollection(addressTypeRef);
var nonNullableStringTypeRef = EdmCoreModel.Instance.GetString(isNullable: false);
var tagsTypeRef = EdmCoreModel.GetCollection(nonNullableStringTypeRef);
var docEntityType = new EdmEntityType(Namespace, DocEntityTypeName);
EdmStructuralProperty key = docEntityType.AddStructuralProperty("id", EdmPrimitiveTypeKind.String);
docEntityType.AddKeys(key);
docEntityType.AddStructuralProperty("addresses", addressesTypeRef);
docEntityType.AddStructuralProperty("tags", tagsTypeRef);
var docEntitySetType = EdmCoreModel.GetCollection(new EdmEntityTypeReference(docEntityType, isNullable: true));
var docComplexType = new EdmComplexType(Namespace, DocComplexTypeName);
foreach (IEdmStructuralProperty property in docEntityType.StructuralProperties())
{
docComplexType.AddStructuralProperty(property.Name, property.Type);
}
var valueParameterTypeRef =
EdmCoreModel.GetCollection(new EdmComplexTypeReference(docComplexType, isNullable: false));
var container = (EdmEntityContainer)model.EntityContainer;
container.AddEntitySet("Docs", docEntityType);
var indexAction =
new EdmAction(
Namespace,
"Index",
returnType: null,
isBound: true,
entitySetPathExpression: null);
indexAction.AddParameter("bindingParameter", docEntitySetType);
indexAction.AddParameter("value", valueParameterTypeRef);
var indexActionImport = new EdmActionImport(container, indexAction.Name, indexAction);
model.AddElements(new IEdmSchemaElement[] { addressType, docEntityType, docComplexType, indexActionImport.Operation });
return(model);
}
public void AmbigiousOperationBindingShouldReferToFirstOperationAlwaysWhenNotNull()
{
var container1 = new EdmEntityContainer("n", "d");
var container2 = new EdmEntityContainer("n", "d");
var action1Import = new EdmActionImport(container1, "name", new EdmAction("n", "name", null));
var functionImport = new EdmFunctionImport(container2, "name", new EdmFunction("n", "name", EdmCoreModel.Instance.GetString(true)));
var ambigiousOperationBinding = new AmbiguousOperationImportBinding(action1Import, functionImport);
Assert.Equal(EdmContainerElementKind.ActionImport, ambigiousOperationBinding.ContainerElementKind);
Assert.Equal("name", ambigiousOperationBinding.Name);
Assert.Null(ambigiousOperationBinding.EntitySet);
Assert.Same(container1, ambigiousOperationBinding.Container);
}
public void VerifyIdenticalNamedActionImportsWithDifferentEntitySetPropertiesAreWritten()
{
var actionImportOnSet = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("Set"));
var actionImportOnSet2 = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("Set2"));
var actionImportWithNoEntitySet = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, null);
var actionImportWithUniqueEdmPath = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmPathExpression("path1", "path2"));
VisitAndVerifyXml(
(visitor) =>
{
visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { actionImportOnSet, actionImportOnSet2, actionImportWithNoEntitySet, actionImportWithUniqueEdmPath });
},
@"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""Set"" /><ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""Set2"" /><ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" /><ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""path1/path2"" />");
}
public void EdmActionImportConstructorShouldHaveSpecifiedConstructorValues()
{
var actionEntitySetPath = new EdmPathExpression("Param1/Nav");
var edmAction = new EdmAction("DefaultNamespace", "Checkout", this.boolType, true, actionEntitySetPath);
edmAction.AddParameter(new EdmOperationParameter(edmAction, "Param1", new EdmEntityTypeReference(personType, true)));
var actionImportEntitySetPath = new EdmPathExpression("Param1/Nav2");
var edmActionImport = new EdmActionImport(this.entityContainer, "checkoutImport", edmAction, actionImportEntitySetPath);
edmActionImport.Name.Should().Be("checkoutImport");
edmActionImport.Container.Should().Be(this.entityContainer);
edmActionImport.EntitySet.Should().Be(actionImportEntitySetPath);
edmActionImport.Action.Should().Be(edmAction);
}
public void CommonProperties_ReturnsAsExpected()
{
// Assert
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
EdmAction action = new EdmAction("NS", "action", null);
EdmActionImport actionImport = new EdmActionImport(container, "actionImport", action);
ActionImportSegmentTemplate template = new ActionImportSegmentTemplate(actionImport, null);
// Act & Assert
Assert.Equal(ODataSegmentKind.ActionImport, template.Kind);
Assert.Equal("actionImport", template.Literal);
Assert.False(template.IsSingle);
Assert.Null(template.EdmType);
Assert.Null(template.NavigationSource);
}
public void ODataPathSegmentHandler_Handles_ActionImportSegment()
{
// Arrange
ODataPathSegmentHandler handler = new ODataPathSegmentHandler();
IEdmTypeReference intType = EdmCoreModel.Instance.GetInt32(false);
EdmEntityContainer entityContainer = new EdmEntityContainer("NS", "Default");
IEdmAction action = new EdmAction("NS", "action", intType);
IEdmActionImport actionImport = new EdmActionImport(entityContainer, "action", action);
OperationImportSegment segment = new OperationImportSegment(actionImport, null);
// Act
handler.Handle(segment);
// Assert
Assert.Equal("action", handler.PathLiteral);
Assert.Null(handler.NavigationSource);
}
public void Translate_ReturnsODataActionImportSegment()
{
// Arrange
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
EdmAction action = new EdmAction("NS", "action", null);
EdmActionImport actionImport = new EdmActionImport(container, "name", action);
ActionImportSegmentTemplate template = new ActionImportSegmentTemplate(actionImport, null);
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext();
// Act
ODataPathSegment actual = template.Translate(context);
// Assert
Assert.NotNull(actual);
OperationImportSegment actionImportSegment = Assert.IsType <OperationImportSegment>(actual);
Assert.Same(actionImport, actionImportSegment.OperationImports.First());
}
public void ODataPathSegmentToTemplateHandler_Handles_ActionImport()
{
// Arrange
ODataPathSegmentToTemplateHandler handler = new ODataPathSegmentToTemplateHandler(null);
IEdmTypeReference intType = EdmCoreModel.Instance.GetInt32(false);
EdmEntityContainer entityContainer = new EdmEntityContainer("NS", "Default");
IEdmAction action = new EdmAction("NS", "action", intType);
IEdmActionImport actionImport = new EdmActionImport(entityContainer, "action", action);
OperationImportSegment segment = new OperationImportSegment(actionImport, null);
// Act
handler.Handle(segment);
// Assert
ODataSegmentTemplate segmentTemplate = Assert.Single(handler.Templates);
Assert.IsType <ActionImportSegmentTemplate>(segmentTemplate);
}
static ODataJsonLightEntryAndFeedDeserializerTests()
{
EdmModel tmpModel = new EdmModel();
EdmComplexType complexType = new EdmComplexType("TestNamespace", "TestComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
tmpModel.AddElement(complexType);
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
tmpModel.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
defaultContainer.AddElement(EntitySet);
Action = new EdmAction("TestNamespace", "DoSomething", null, true, null);
Action.AddParameter("p1", new EdmEntityTypeReference(EntityType, false));
tmpModel.AddElement(Action);
ActionImport = defaultContainer.AddActionImport("DoSomething", Action);
var serviceOperationFunction = new EdmFunction("TestNamespace", "ServiceOperation", EdmCoreModel.Instance.GetInt32(true));
defaultContainer.AddFunctionImport("ServiceOperation", serviceOperationFunction);
tmpModel.AddElement(serviceOperationFunction);
tmpModel.AddElement(new EdmTerm("custom", "DateTimeOffsetAnnotation", EdmPrimitiveTypeKind.DateTimeOffset));
tmpModel.AddElement(new EdmTerm("custom", "DateAnnotation", EdmPrimitiveTypeKind.Date));
tmpModel.AddElement(new EdmTerm("custom", "TimeOfDayAnnotation", EdmPrimitiveTypeKind.TimeOfDay));
EdmModel = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", tmpModel);
MessageReaderSettingsReadAndValidateCustomInstanceAnnotations = new ODataMessageReaderSettings {
ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*")
};
MessageReaderSettingsIgnoreInstanceAnnotations = new ODataMessageReaderSettings();
}
public void CreateOperationForEdmActionReturnsCorrectOperationId(bool enableOperationId)
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(customer);
EdmAction action = new EdmAction("NS", "MyAction", EdmCoreModel.Instance.GetString(false), false, null);
action.AddParameter("param", EdmCoreModel.Instance.GetString(false));
model.AddElement(action);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = new EdmEntitySet(container, "Customers", customer);
EdmActionImport actionImport = new EdmActionImport(container, "MyAction", action);
model.AddElement(container);
OpenApiConvertSettings settings = new OpenApiConvertSettings
{
EnableOperationId = enableOperationId
};
ODataContext context = new ODataContext(model, settings);
ODataPath path = new ODataPath(new ODataOperationImportSegment(actionImport));
// Act
var operation = _operationHandler.CreateOperation(context, path);
// Assert
Assert.NotNull(operation);
if (enableOperationId)
{
Assert.Equal("OperationImport.MyAction", operation.OperationId);
}
else
{
Assert.Null(operation.OperationId);
}
}
static ODataEntryMetadataContextTest()
{
ActualEntityType = new EdmEntityType("ns", "TypeName");
ActualEntityType.AddKeys(new IEdmStructuralProperty[] { ActualEntityType.AddStructuralProperty("ID2", EdmPrimitiveTypeKind.Int32), ActualEntityType.AddStructuralProperty("ID3", EdmPrimitiveTypeKind.Int32) });
ActualEntityType.AddStructuralProperty("Name2", EdmCoreModel.Instance.GetString(isNullable: true), /*defaultValue*/ null);
ActualEntityType.AddStructuralProperty("Name3", EdmCoreModel.Instance.GetString(isNullable: true), /*defaultValue*/ null);
ActualEntityType.AddStructuralProperty("StreamProp1", EdmPrimitiveTypeKind.Stream);
ActualEntityType.AddStructuralProperty("StreamProp2", EdmPrimitiveTypeKind.Stream);
var navProp1 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = ActualEntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "NavProp1"
});
var navProp2 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = ActualEntityType,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Name = "NavProp2"
});
var container = new EdmEntityContainer("Namespace", "Container");
EdmEntitySet entitySet = container.AddEntitySet("EntitySet", ActualEntityType);
entitySet.AddNavigationTarget(navProp1, entitySet);
entitySet.AddNavigationTarget(navProp2, entitySet);
Action1 = new EdmAction("Namespace", "Action1", null, true /*isBound*/, null /*entitySetPath*/);
Action2 = new EdmAction("Namespace", "Action2", null, true /*isBound*/, null /*entitySetPath*/);
ActionImport1 = new EdmActionImport(container, "ActionImport1", Action1);
ActionImport2 = new EdmActionImport(container, "ActionImport2", Action2);
Function1 = new EdmFunction("Namespace", "Function1", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/);
Function2 = new EdmFunction("Namespace", "Function2", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/);
FunctionImport1 = new EdmFunctionImport(container, "FunctionImport1", Function1);
FunctionImport2 = new EdmFunctionImport(container, "FunctionImport2", Function2);
}
public void SplitOperationImports_Works_OperationImports()
{
// Arrange
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
IEdmTypeReference strType = EdmCoreModel.Instance.GetString(false);
EdmFunction function = new EdmFunction("NS", "Function", strType);
EdmFunctionImport functionImport = new EdmFunctionImport(container, "functionImport", function);
EdmAction action = new EdmAction("NS", "Action", strType);
EdmActionImport actionImport = new EdmActionImport(container, "actionImport", action);
IEnumerable <IEdmOperationImport> operationImports = new List <IEdmOperationImport>
{
functionImport,
actionImport
};
// Act
(var actionImports, var functionImports) = operationImports.SplitOperationImports();
// Assert
Assert.Same(actionImport, Assert.Single(actionImports));
Assert.Same(functionImport, Assert.Single(functionImports));
}
public static EdmModel OperationImportParameterWithAnnotationModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction simpleOperationAction = new EdmAction("Default", "SimpleFunction", EdmCoreModel.Instance.GetInt32(false));
EdmOperationParameter simpleOperationName = new EdmOperationParameter(simpleOperationAction, "Name", EdmCoreModel.Instance.GetString(true));
simpleOperationAction.AddParameter(simpleOperationName);
model.AddElement(simpleOperationAction);
EdmOperationImport simpleOperation = new EdmActionImport(container, "SimpleFunction", simpleOperationAction);
container.AddElement(simpleOperation);
model.AddElement(container);
var annotationElement =
new XElement("{http://foo}Annotation", 1);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleOperationName, "http://foo", "Annotation", annotation);
return(model);
}
public void ValidateEntitySetAtttributeCorrectlyWritesOutEntitySet()
{
EdmActionImport actionImport = new EdmActionImport(defaultContainer, "Checkout", defaultCheckoutAction, new EdmEntitySetReferenceExpression(new EdmEntitySet(defaultContainer, "Customers", new EdmEntityType("DefaultNamespace", "Customer"))));
TestWriteActionImportElementHeaderMethod(actionImport, @"<ActionImport Name=""Checkout"" Action=""Default.NameSpace2.CheckOut"" EntitySet=""Customers""");
}
