public void ComplexTypeShouldBeEscaped() { var edmType = ComplexType.Create("string", "Transient", DataSpace.CSSpace, Enumerable.Empty <EdmMember>(), null); var typeUsage = TypeUsage.Create(edmType, Enumerable.Empty <Facet>()); this.escaper.Escape(typeUsage).Should().Be("@string"); }
public void Crate_creates_store_function_for_complex_type_function_import() { var model = new DbModelBuilder() .Build(new DbProviderInfo("System.Data.SqlClient", "2012")); var complexType = ComplexType.Create("CT", "ns", DataSpace.CSpace, new[] { EdmProperty.Create("Street", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))), EdmProperty.Create("ZipCode", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))), }, null); var functionDescriptor = new FunctionDescriptor( "f", new[] { new ParameterDescriptor("p1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), null, false) }, new EdmType[] { complexType }, "ResultCol", "dbo", StoreFunctionKind.StoredProcedure); var storeFunction = new StoreFunctionBuilder(model, "docs", "ns").Create(functionDescriptor); Assert.Null(storeFunction.ReturnParameter); Assert.Equal(1, storeFunction.Parameters.Count); Assert.Equal("p1", storeFunction.Parameters[0].Name); Assert.Equal("nvarchar(max)", storeFunction.Parameters[0].TypeName); Assert.Equal(ParameterMode.In, storeFunction.Parameters[0].Mode); Assert.False(storeFunction.IsComposableAttribute); }
public void Can_create_mapping_and_get_property() { var complexType = ComplexType.Create("CT", "NS", DataSpace.CSpace, new EdmMember[0], null); var property = EdmProperty.CreateComplex("P", complexType); var mapping = new ComplexPropertyMapping(property); Assert.Same(property, mapping.Property); }
private static ComplexType CreateComplexType() { var prop1 = EdmProperty.Create( "Prop1", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var prop2 = EdmProperty.Create( "Prop2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))); return (ComplexType.Create("TestComplexType", "Model", DataSpace.CSpace, new[] { prop1, prop2 }, null)); }
public async Task WriteToStreamAsync_WritesComplexType() { // Arrange var input = ComplexType.Create(); // Act await _formatter.WriteToStreamAsync(typeof(ComplexType), input, _content.Stream, _content, _context); // Assert var result = await _content.ReadObjectAsync <ComplexType>(); Assert.NotEqual(0, _content.Headers.ContentLength); result.Verify(); }
public async Task WriteToStreamAsync_WritesComplexType() { // Arrange var input = ComplexType.Create(); var content = new StreamMessagePackHttpContent(); // Act await _formatter.WriteToStreamAsync(typeof(ComplexType), input, content.Stream, content, _context); // Assert var result = await content.ReadObjectAsync <ComplexType>(_serializerOptions); result.Verify(); }
public void SetReadOnly_is_called_on_child_mapping_items() { var complexType = ComplexType.Create("CT", "NS", DataSpace.CSpace, new EdmMember[0], null); var property = EdmProperty.CreateComplex("P", complexType); var mapping = new ComplexPropertyMapping(property); var typeMapping = new ComplexTypeMapping(isPartial: false); mapping.AddTypeMapping(typeMapping); Assert.False(typeMapping.IsReadOnly); mapping.SetReadOnly(); Assert.True(typeMapping.IsReadOnly); }
public async Task ReadFromStreamAsync_ReadsComplexTypes() { // Arrange var input = ComplexType.Create(); await _content.WriteObjectAsync(input); // Act var result = await _formatter.ReadFromStreamAsync(typeof(ComplexType), _content.Stream, _content, _logger); // Assert Assert.NotNull(result); var model = Assert.IsType <ComplexType>(result); model.Verify(); }
public void SerializationWorks_ComplexType(IByteConverter <ComplexType> byteConverter) { var complexType = ComplexType.Create(3, 3); var serialized = byteConverter.GetBytes(complexType); var deserialized = byteConverter.GetObject(serialized); var expected = complexType.BreadthFirstEnumeration().ToArray(); var actual = deserialized.BreadthFirstEnumeration().ToArray(); for (var i = 0; i < expected.Length; i++) { var e = expected[i]; var a = actual[i]; Assert.Equal(e.Id, a.Id); } }
public void Cannot_add_type_mapping_when_read_only() { var complexType = ComplexType.Create("CT", "NS", DataSpace.CSpace, new EdmMember[0], null); var property = EdmProperty.CreateComplex("P", complexType); var mapping = new ComplexPropertyMapping(property); mapping.SetReadOnly(); Assert.True(mapping.IsReadOnly); var typeMapping = new ComplexTypeMapping(isPartial: false); Assert.Equal( Strings.OperationOnReadOnlyItem, Assert.Throws <InvalidOperationException>( () => mapping.AddTypeMapping(typeMapping)).Message); }
// internal for testing internal ComplexType CreateComplexTypeFromRowType(SimpleMappingContext mappingContext, RowType rowType, string typeName) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(!string.IsNullOrEmpty(typeName), "typeName cannot be null or empty string."); Debug.Assert(rowType != null, "rowType != null"); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(typeName); return (ComplexType.Create( typeName, _namespaceName, DataSpace.CSpace, rowType.Properties.Select(p => GenerateScalarProperty(mappingContext, p, uniquePropertyNameService)), null)); }
public void Can_add_get_remove_type_mappings() { var complexType = ComplexType.Create("CT", "NS", DataSpace.CSpace, new EdmMember[0], null); var property = EdmProperty.CreateComplex("P", complexType); var mapping = new ComplexPropertyMapping(property); Assert.Equal(0, mapping.TypeMappings.Count); var typeMapping = new ComplexTypeMapping(isPartial: false); mapping.AddTypeMapping(typeMapping); Assert.Equal(1, mapping.TypeMappings.Count); Assert.Same(typeMapping, mapping.TypeMappings[0]); mapping.RemoveTypeMapping(typeMapping); Assert.Equal(0, mapping.TypeMappings.Count); }
public void Crate_creates_store_function_for_complex_type_withEnum_in_TableValuedFunction() { var model = new DbModelBuilder() .Build(new DbProviderInfo("System.Data.SqlClient", "2012")); var enumType = EnumType.Create("TestEnum", "TestNs", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, new EnumMember[] { EnumMember.Create("foo", 1, null) }, null); var complexType = ComplexType.Create("CT", "ns", DataSpace.CSpace, new[] { EdmProperty.Create("Street", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))), EdmProperty.Create("ZipCode", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))), EdmProperty.Create("MyEnum", TypeUsage.CreateDefaultTypeUsage(enumType)) }, null); var functionDescriptor = new FunctionDescriptor( "f", new[] { new ParameterDescriptor("p1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), null, false) }, new EdmType[] { complexType }, "ResultCol", "dbo", StoreFunctionKind.TableValuedFunction, isBuiltIn: null, isNiladic: null); var storeFunction = new StoreFunctionBuilder(model, "docs", "ns").Create(functionDescriptor); Assert.Equal( BuiltInTypeKind.CollectionType, storeFunction.ReturnParameter.TypeUsage.EdmType.BuiltInTypeKind); Assert.Single(storeFunction.Parameters); Assert.Equal("p1", storeFunction.Parameters[0].Name); Assert.Equal("nvarchar(max)", storeFunction.Parameters[0].TypeName); Assert.Equal(ParameterMode.In, storeFunction.Parameters[0].Mode); Assert.True(storeFunction.IsComposableAttribute); }
public void Can_create_composable_function_import_with_complex_type_collection_result() { DbProviderManifest providerManifest; var containerMapping = GetContainerMapping(out providerManifest); var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString); var complexType = ComplexType.Create( "RT", "N", DataSpace.CSpace, new[] { EdmProperty.Create("P1", cTypeUsageString), EdmProperty.Create("P2", cTypeUsageString) }, null); var rowType = RowType.Create( new[] { EdmProperty.Create("C1", sTypeUsageString), EdmProperty.Create("C2", sTypeUsageString) }, null); var functionImport = EdmFunction.Create( "F", "N", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", complexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var targetFunction = EdmFunction.Create( "SF", "N", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", rowType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var typeMapping = new FunctionImportComplexTypeMapping( complexType, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"), new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"), }); var resultMapping = new FunctionImportResultMapping(); resultMapping.AddTypeMapping(typeMapping); var functionImportMapping = new FunctionImportMappingComposable( functionImport, targetFunction, resultMapping, containerMapping); Assert.Same(resultMapping, functionImportMapping.ResultMapping); Assert.Equal(1, functionImportMapping.StructuralTypeMappings.Count); Assert.Null(functionImportMapping.TvfKeys); }
public void Build_builds_valid_DbDatabaseMapping_for_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "CT", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = true, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], new[] { functionImport }, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Equal(new[] { "f_c" }, entityModel.Containers.Single().FunctionImports.Select(f => f.Name)); Assert.Equal(new[] { "CT" }, entityModel.ComplexTypes.Select(t => t.Name)); }
public void BuildComposableFunctionMapping_creates_valid_function_mapping() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "c", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); var functionImportMapping = DbDatabaseMappingBuilder.BuildComposableFunctionMapping(storeFunction, mappingContext); Assert.NotNull(functionImportMapping); Assert.Same(storeFunction, functionImportMapping.TargetFunction); Assert.Same(functionImport, functionImportMapping.FunctionImport); var structuralTypeMappings = functionImportMapping.StructuralTypeMappings; Assert.NotNull(structuralTypeMappings); Assert.Same(functionImportReturnComplexType, structuralTypeMappings.Single().Item1); Assert.Empty(structuralTypeMappings.Single().Item2); Assert.Same(complexTypeProperty, structuralTypeMappings.Single().Item3.Single().Property); Assert.Same(rowTypeProperty, ((ScalarPropertyMapping)structuralTypeMappings.Single().Item3.Single()).Column); }
public void Can_create_non_composable_function_with_multiple_results() { DbProviderManifest providerManifest; var containerMapping = GetContainerMapping(out providerManifest); var cTypeUsageInt = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var sTypeUsageInt = TypeUsage.Create( providerManifest.GetStoreType(cTypeUsageInt).EdmType, new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString); var complexType = ComplexType.Create( "RT1", "N", DataSpace.CSpace, new[] { EdmProperty.Create("P1", cTypeUsageInt), EdmProperty.Create("P2", cTypeUsageString) }, null); var entityType = EntityType.Create( "RT2", "N", DataSpace.CSpace, new[] { "P3" }, new[] { EdmProperty.Create("P3", cTypeUsageInt), EdmProperty.Create("P4", cTypeUsageString), }, null); var rowType1 = RowType.Create( new[] { EdmProperty.Create("C1", sTypeUsageInt), EdmProperty.Create("C2", sTypeUsageString) }, null); var rowType2 = RowType.Create( new[] { EdmProperty.Create("C3", sTypeUsageInt), EdmProperty.Create("C4", sTypeUsageString) }, null); var functionImport = EdmFunction.Create( "F", "N", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = false, ReturnParameters = new[] { FunctionParameter.Create("R1", complexType.GetCollectionType(), ParameterMode.ReturnValue), FunctionParameter.Create("R2", entityType.GetCollectionType(), ParameterMode.ReturnValue) }, EntitySets = new[] { new EntitySet(), new EntitySet() } }, null); var targetFunction = EdmFunction.Create( "SF", "N", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = false, ReturnParameters = new[] { FunctionParameter.Create("R1", rowType1.GetCollectionType(), ParameterMode.ReturnValue), FunctionParameter.Create("R2", rowType2.GetCollectionType(), ParameterMode.ReturnValue) }, EntitySets = new [] { new EntitySet(), new EntitySet() } }, null); var resultMappings = new List <FunctionImportResultMapping> { new FunctionImportResultMapping(), new FunctionImportResultMapping() }; resultMappings[0].AddTypeMapping(new FunctionImportComplexTypeMapping( complexType, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"), new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"), })); resultMappings[1].AddTypeMapping(new FunctionImportEntityTypeMapping( Enumerable.Empty <EntityType>(), new [] { entityType }, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P3", "C3"), new FunctionImportReturnTypeScalarPropertyMapping("P4", "C4") }, Enumerable.Empty <FunctionImportEntityTypeMappingCondition>())); var functionImportMapping = new FunctionImportMappingNonComposable( functionImport, targetFunction, resultMappings, containerMapping); Assert.Equal(resultMappings.Count, functionImportMapping.ResultMappings.Count); functionImportMapping.ResultMappings.Each(m => Assert.False(m.IsReadOnly)); functionImportMapping.SetReadOnly(); functionImportMapping.ResultMappings.Each(m => Assert.True(m.IsReadOnly)); }