/// <summary>Constructor.</summary> /// <param name="dataContext">The data context to apply the changes to.</param> /// <param name="metadata">The metadata describing the types to work with.</param> public DSPUpdateProvider(DSPContext dataContext, DSPMetadata metadata) { this.dataContext = dataContext; this.metadata = metadata; this.pendingChanges = new List <Action>(); this.propertyValuesModified = new Dictionary <object, Dictionary <string, object> >(); }
private static DSPServiceDefinition SetupService() { DSPMetadata metadata = new DSPMetadata("ActionsWithLargePayload", "AstoriaUnitTests.ActionTestsWithLargePayload"); var customer = metadata.AddEntityType("Customer", null, null, false); metadata.AddKeyProperty(customer, "ID", typeof(int)); var customers = metadata.AddResourceSet("Customers", customer); ComplexType = metadata.AddComplexType("AddressComplexType", null, null, false); metadata.AddPrimitiveProperty(ComplexType, "ZipCode", typeof(int)); metadata.AddPrimitiveProperty(ComplexType, "City", typeof(string)); DSPContext context = new DSPContext(); metadata.SetReadOnly(); DSPResource customer1 = new DSPResource(customer); customer1.SetValue("ID", 1); context.GetResourceSetEntities("Customers").Add(customer1); MyDSPActionProvider actionProvider = new MyDSPActionProvider(); SetUpActionWithLargeParameterPayload(actionProvider, metadata, customer); SetUpActionWithLargeCollectionParameterPayload(actionProvider, metadata, customer); SetupLargeNumberOfActions(actionProvider, metadata, customer); DSPServiceDefinition service = new DSPServiceDefinition() { Metadata = metadata, CreateDataSource = (m) => context, ForceVerboseErrors = true, Writable = true, ActionProvider = actionProvider, }; return service; }
/// <summary>Constructor.</summary> /// <param name="dataContext">The data context to apply the changes to.</param> /// <param name="metadata">The metadata describing the types to work with.</param> public DSPUpdateProvider(DSPContext dataContext, DSPMetadata metadata) { this.dataContext = dataContext; this.metadata = metadata; this.pendingChanges = new List<Action>(); this.propertyValuesModified = new Dictionary<object, Dictionary<string, object>>(); }
/// <summary>Returns a resource type as specified by the test.</summary> /// <param name="metadata">The DSPMetadata to use.</param> /// <param name="typeSpecification">The type specification. If it's a string, then it means the name of the type to get. If it's a Type it means /// to return a primitive resource type of that type.</param> /// <returns>The ResourceType specified by the test.</returns> public static providers.ResourceType GetResourceTypeFromTestSpecification(this DSPMetadata metadata, object typeSpecification) { if (metadata == null) { return(null); } if (typeSpecification is Type) { return(providers.ResourceType.GetPrimitiveResourceType(typeSpecification as Type)); } else { string typeName = typeSpecification as string; providers.ResourceType type = metadata.GetResourceType(typeName); if (type == null) { metadata.TryResolveResourceType(typeName, out type); } if (type == null) { type = UnitTestsUtil.GetPrimitiveResourceTypes().FirstOrDefault(rt => rt.FullName == typeName); } if (type == null) { type = UnitTestsUtil.GetPrimitiveResourceTypes().FirstOrDefault(rt => rt.Name == typeName); } return(type); } }
public void TypesMustBeReadOnlyTest() { var typesToTest = new Func<DSPMetadata, ResourceType>[] { (metadata) => metadata.AddEntityType("EntityType", null, null, false), (metadata) => metadata.AddComplexType("ComplexType", null, null, false) }; AstoriaTestNS.TestUtil.RunCombinations( typesToTest, (typeCreate) => { var metadataProvider = new DSPMetadata("Test", "TestNS"); var type = typeCreate(metadataProvider); var wrapper = new DataServiceMetadataProviderWrapper(metadataProvider); ExceptionUtils.ExpectedException<DataServiceException>( () => wrapper.TryResolveResourceType(type.FullName), "The resource type '" + type.FullName + "' returned by the provider is not read-only. Please make sure that all the types are set to read-only.", "Resolving resource type to writable type should fail."); }); }
private static DSPMetadata CreateMetadataForXFeatureEntity(bool isMLE = false) { DSPMetadata metadata = new DSPMetadata("CollectionCrossFeatureTests", "AstoriaUnitTests.Tests"); var entityType = metadata.AddEntityType("XFeatureTestsEntity", typeof(DSPResourceWithCollectionProperty), null, false); if (isMLE) { entityType.IsMediaLinkEntry = true; } metadata.AddKeyProperty(entityType, "ID", typeof(int)); metadata.AddPrimitiveProperty(entityType, "Description", typeof(string)); metadata.AddCollectionProperty(entityType, "Strings", typeof(string)); var complexType = metadata.AddComplexType("UnitTestModule+CollectionTest+XFeatureTestsComplexType", typeof(DSPResourceWithCollectionProperty), null, false); metadata.AddPrimitiveProperty(complexType, "Text", typeof(string)); metadata.AddCollectionProperty(entityType, "Structs", complexType); var resourceSet = metadata.AddResourceSet("Entities", entityType); metadata.AddResourceReferenceProperty(entityType, "NextTestEntity", resourceSet, entityType); metadata.SetReadOnly(); return metadata; }
public DSPUnitTestServiceDefinition(DSPMetadata metadata, DSPDataProviderKind kind, DSPContext context) { this.Metadata = metadata; if (kind == DSPDataProviderKind.CustomProvider) { this.DataServiceType = typeof(DSPDataService); this.ProviderKind = DSPDataProviderKind.CustomProvider; this.CreateDataSource = (m) => context; } else { Type contextType = GenerateAssemblyAndGetContextType(metadata, kind); this.ProviderKind = kind; this.DataServiceType = typeof(OpenWebDataService<>).MakeGenericType(contextType); if (kind == DSPDataProviderKind.EF || kind == DSPDataProviderKind.Reflection) { PopulateContextWithDefaultData(contextType, context, kind); } } }
public void SetsMustBeReadOnlyTest() { var resourceSetEntryPoints = new Action<DataServiceMetadataProviderWrapper, string>[] { (wrapper, name) => wrapper.TryResolveResourceSet(name), (wrapper, name) => wrapper.ResourceSets.Cast<object>().Count() }; AstoriaTestNS.TestUtil.RunCombinations( resourceSetEntryPoints, (resourceSetEntryPoint) => { var metadataProvider = new DSPMetadata("Test", "TestNS"); var resourceType = metadataProvider.AddEntityType("EntityType", null, null, false); var resourceSet = metadataProvider.AddResourceSet("Entities", resourceType); resourceType.SetReadOnly(); var wrapper = new DataServiceMetadataProviderWrapper(metadataProvider); ExceptionUtils.ExpectedException<DataServiceException>( () => resourceSetEntryPoint(wrapper, resourceSet.Name), "The resource set '" + resourceSet.Name + "' returned by the provider is not read-only. Please make sure that all the resource sets are set to read-only.", "Accessing writable resource set should fail."); }); }
internal static DSPResource CreateAmusementParkResource(DSPMetadata roadTripMetadata, int id, ITestGeography location, string name, bool useComplexType, Action<string, List<KeyValuePair<string, object>>> modifyPropertyValues) { List<KeyValuePair<string, object>> amusementParkPropertyValues = new List<KeyValuePair<string, object>>() { new KeyValuePair<string, object>("GeographyProperty", location.AsGeography()), new KeyValuePair<string, object>("Name", name), }; if (modifyPropertyValues != null) { modifyPropertyValues("AmusementPark", amusementParkPropertyValues); } DSPResource amusementParkResource = CreateResource(roadTripMetadata, "AmusementPark", id, amusementParkPropertyValues.ToArray(), useComplexType); return amusementParkResource; }
internal static DSPResource CreateTripLegResource(DSPMetadata roadTripMetadata, int id, ITestGeography geography1, ITestGeography geography2, bool useComplexType, Action<string, List<KeyValuePair<string, object>>> modifyPropertyValues) { List<KeyValuePair<string, object>> tripLegPropertyValues = new List<KeyValuePair<string, object>>() { new KeyValuePair<string, object>("GeographyProperty1", geography1.AsGeography()), new KeyValuePair<string, object>("GeographyProperty2", geography2.AsGeography()), }; if (modifyPropertyValues != null) { modifyPropertyValues("TripLeg", tripLegPropertyValues); } DSPResource tripLegResource = CreateResource(roadTripMetadata, "TripLeg", id, tripLegPropertyValues.ToArray(), useComplexType); return tripLegResource; }
public void EdmValidNamesNotAllowedInUri() { DSPMetadata metadata = new DSPMetadata("Test", "TestNS"); var entityType = metadata.AddEntityType("MyType", null, null, false); metadata.AddKeyProperty(entityType, "ID", typeof(int)); metadata.AddPrimitiveProperty(entityType, "Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", typeof(string)); var resourceSet = metadata.AddResourceSet("EntitySet", entityType); metadata.SetReadOnly(); DSPServiceDefinition service = new DSPServiceDefinition() { Metadata = metadata, Writable = true }; DSPContext data = new DSPContext(); service.CreateDataSource = (m) => { return data; }; using (TestWebRequest request = service.CreateForInProcessWcf()) { request.StartService(); DataServiceContext context = new DataServiceContext(request.ServiceRoot); context.EnableAtom = true; context.Format.UseAtom(); string value = "value of Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ"; context.AddObject("EntitySet", new MyType() { ID = 1, Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ = value, }); context.SaveChanges(); var result = context.Execute<MyType>(new Uri("EntitySet?$orderby=Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", UriKind.Relative)).First(); Assert.AreEqual(value, result.Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ, "The roundtrip value not as expected"); } }
private static DSPMetadata GetModel(bool openType, bool namedStreams, Action<DSPMetadata> metadataModifier = null) { #region Model Definition // Navigation Collection Property: Client - Entity, Server - NonEntity DSPMetadata metadata = new DSPMetadata("ModelWithNonNullableProperties", "AstoriaUnitTests.Tests"); // Define people type having non-nullable properties var peopleType = metadata.AddEntityType("PeopleType", null, null, false); var officeType = metadata.AddComplexType("OfficeType", null, null, false); metadata.AddPrimitiveProperty(officeType, "Building", typeof(string)); metadata.AddPrimitiveProperty(officeType, "OfficeNumber", typeof(int)); peopleType.IsOpenType = openType; metadata.AddKeyProperty(peopleType, "ID", typeof(int)); if (!openType) { metadata.AddPrimitiveProperty(peopleType, "Name", typeof(string)); metadata.AddPrimitiveProperty(peopleType, "Body", typeof(byte[])); metadata.AddPrimitiveProperty(peopleType, "Age", typeof(Nullable<int>)); metadata.AddComplexProperty(peopleType, "Office", officeType); } var peopleSet = metadata.AddResourceSet("People", peopleType); if (metadataModifier != null) { metadataModifier(metadata); } metadata.SetReadOnly(); #endregion Model Definition return metadata; }
internal static void AddEntityType(DSPMetadata metadata, string entityTypeName, KeyValuePair<string, Type>[] properties, bool useComplexType, bool useOpenTypes) { var entityType = metadata.AddEntityType(entityTypeName, null, null, false); metadata.AddKeyProperty(entityType, "ID", typeof(int)); entityType.IsOpenType = useOpenTypes; if (!useOpenTypes) { Microsoft.OData.Service.Providers.ResourceType resourceTypeForProps; if (useComplexType) { string complexTypeName = GetComplexTypeName(entityTypeName); resourceTypeForProps = metadata.AddComplexType(complexTypeName, null, null, false); metadata.AddComplexProperty(entityType, "ComplexProperty", resourceTypeForProps); } else { resourceTypeForProps = entityType; } foreach (KeyValuePair<string, Type> property in properties) { metadata.AddPrimitiveProperty(resourceTypeForProps, property.Key, property.Value); } } string resourceSetName = GetResourceSetName(entityTypeName); metadata.AddResourceSet(resourceSetName, entityType); }
private static DSPContext GetDefaultData(DSPMetadata metadata) { var peopleType = metadata.GetResourceType("PeopleType"); var employeeType = metadata.GetResourceType("EmployeeType"); var managerType = metadata.GetResourceType("ManagerType"); var customerType = metadata.GetResourceType("CustomerType"); var employeeAddressType = metadata.GetResourceType("EmployeeAddressType"); var customerAddressType = metadata.GetResourceType("CustomerAddressType"); #region Default Data for the Model var context = new DSPContext(); DSPResource people1 = new DSPResource(peopleType); people1.SetValue("ID", 1); people1.SetValue("Name", "Foo"); DSPResource andyAddress = new DSPResource(employeeAddressType); andyAddress.SetValue("ID", 1); andyAddress.SetValue("Street", "Andy's address"); andyAddress.SetValue("City", "Sammamish"); andyAddress.SetValue("State", "WA"); DSPResource andy = new DSPResource(managerType); andy.SetValue("ID", 2); andy.SetValue("Name", "Andy"); andy.SetValue("FullName", "Andy Conrad"); andy.SetValue("Address", andyAddress); DSPResource pratikAddress = new DSPResource(employeeAddressType); pratikAddress.SetValue("ID", 2); pratikAddress.SetValue("Street", "pratik's address"); pratikAddress.SetValue("City", "Bothell"); pratikAddress.SetValue("State", "WA"); DSPResource pratik = new DSPResource(employeeType); pratik.SetValue("ID", 3); pratik.SetValue("Name", "Pratik"); pratik.SetValue("FullName", "Pratik Patel"); pratik.SetValue("Manager", andy); pratik.SetValue("Address", pratikAddress); DSPResource jimmyAddress = new DSPResource(employeeAddressType); jimmyAddress.SetValue("ID", 3); jimmyAddress.SetValue("Street", "jimmy's address"); jimmyAddress.SetValue("City", "somewhere in seattle"); jimmyAddress.SetValue("State", "WA"); DSPResource jimmy = new DSPResource(employeeType); jimmy.SetValue("ID", 4); jimmy.SetValue("Name", "Jimmy"); jimmy.SetValue("FullName", "Jian Li"); jimmy.SetValue("Manager", andy); jimmy.SetValue("Address", jimmyAddress); andy.SetValue("DirectReports", new List<DSPResource>() { pratik, jimmy }); DSPResource shyamAddress = new DSPResource(employeeAddressType); shyamAddress.SetValue("ID", 4); shyamAddress.SetValue("Street", "shyam's address"); shyamAddress.SetValue("City", "university district"); shyamAddress.SetValue("State", "WA"); DSPResource shyam = new DSPResource(managerType); shyam.SetValue("ID", 5); shyam.SetValue("Name", "Shyam"); shyam.SetValue("FullName", "Shyam Pather"); shyam.SetValue("Address", shyamAddress); DSPResource marceloAddress = new DSPResource(employeeAddressType); marceloAddress.SetValue("ID", 5); marceloAddress.SetValue("Street", "marcelo's address"); marceloAddress.SetValue("City", "kirkland"); marceloAddress.SetValue("State", "WA"); DSPResource marcelo = new DSPResource(employeeType); marcelo.SetValue("ID", 6); marcelo.SetValue("Name", "Marcelo"); marcelo.SetValue("FullName", "Marcelo Lopez Ruiz"); marcelo.SetValue("Manager", shyam); marcelo.SetValue("Address", marceloAddress); andy.SetValue("Manager", shyam); shyam.SetValue("DirectReports", new List<DSPResource>() { andy, marcelo }); DSPResource customer1Address = new DSPResource(customerAddressType); customer1Address.SetValue("ID", 6); customer1Address.SetValue("Street", "customer1's address"); customer1Address.SetValue("City", "somewhere"); customer1Address.SetValue("State", "WA"); var customer1 = new DSPResource(customerType); customer1.SetValue("ID", 7); customer1.SetValue("FullName", "Customer FullName"); customer1.SetValue("Address", customer1Address); var people = context.GetResourceSetEntities("People"); people.AddRange(new object[] { people1, andy, pratik, jimmy, shyam, marcelo, customer1 }); var addresses = context.GetResourceSetEntities("Addresses"); addresses.AddRange(new object[] { andyAddress, pratikAddress, jimmyAddress, shyamAddress, marceloAddress, customer1Address }); #endregion Default Data for the Model return context; }
private static DSPMetadata GetModel(bool openType, bool namedStreams, Action<DSPMetadata> metadataModifier = null) { #region Model Definition // Navigation Collection Property: Client - Entity, Server - NonEntity DSPMetadata metadata = new DSPMetadata("ModelWithDerivedNavProperties", "AstoriaUnitTests.Tests"); var peopleType = metadata.AddEntityType("PeopleType", null, null, false); peopleType.IsOpenType = openType; metadata.AddKeyProperty(peopleType, "ID", typeof(int)); if (!openType) { metadata.AddPrimitiveProperty(peopleType, "Name", typeof(string)); } var peopleSet = metadata.AddResourceSet("People", peopleType); var employeeType = metadata.AddEntityType("EmployeeType", null, peopleType, false); if (namedStreams) { metadata.AddNamedStreamProperty(employeeType, "Photo"); } ResourceProperty fullNameProperty = null; if (!openType) { fullNameProperty = new ResourceProperty("FullName", ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(string))) { CanReflectOnInstanceTypeProperty = false }; employeeType.AddProperty(fullNameProperty); } var managerType = metadata.AddEntityType("ManagerType", null, employeeType, false); var customerType = metadata.AddEntityType("CustomerType", null, peopleType, false); if (namedStreams) { metadata.AddNamedStreamProperty(customerType, "Photo"); } if (!openType) { Assert.IsTrue(fullNameProperty != null, "fullNameProperty != null"); customerType.AddProperty(fullNameProperty); } var baseAddressType = metadata.AddEntityType("AddressType", null, null, false); baseAddressType.IsOpenType = openType; metadata.AddKeyProperty(baseAddressType, "ID", typeof(int)); if (!openType) { metadata.AddPrimitiveProperty(baseAddressType, "Street", typeof(string)); metadata.AddPrimitiveProperty(baseAddressType, "City", typeof(string)); metadata.AddPrimitiveProperty(baseAddressType, "State", typeof(string)); metadata.AddPrimitiveProperty(baseAddressType, "ZipCode", typeof(string)); } var customerAddressType = metadata.AddEntityType("CustomerAddressType", null, baseAddressType, false); var employeeAddressType = metadata.AddEntityType("EmployeeAddressType", null, baseAddressType, false); var addressSet = metadata.AddResourceSet("Addresses", baseAddressType); var drProperty = metadata.AddResourceSetReferenceProperty(managerType, "DirectReports", employeeType); var managerProperty = metadata.AddResourceReferenceProperty(employeeType, "Manager", managerType); metadata.AddResourceAssociationSet(new ResourceAssociationSet( "Manager_DirectReports", new ResourceAssociationSetEnd(peopleSet, employeeType, managerProperty), new ResourceAssociationSetEnd(peopleSet, managerType, drProperty))); var customerAddressProperty = metadata.AddResourceReferenceProperty(customerType, "Address", customerAddressType); metadata.AddResourceAssociationSet(new ResourceAssociationSet( "Customer_Address", new ResourceAssociationSetEnd(peopleSet, customerType, customerAddressProperty), new ResourceAssociationSetEnd(addressSet, customerAddressType, null))); var employeeAddressProperty = metadata.AddResourceReferenceProperty(employeeType, "Address", employeeAddressType); metadata.AddResourceAssociationSet(new ResourceAssociationSet( "Employee_Address", new ResourceAssociationSetEnd(peopleSet, employeeType, employeeAddressProperty), new ResourceAssociationSetEnd(addressSet, employeeAddressType, null))); if (metadataModifier != null) { metadataModifier(metadata); } metadata.SetReadOnly(); #endregion Model Definition return metadata; }
internal static DSPServiceDefinition SetUpNamedStreamService() { DSPMetadata metadata = new DSPMetadata("NamedStreamIDSPContainer", "NamedStreamTest"); // entity with streams ResourceType entityWithNamedStreams = metadata.AddEntityType("EntityWithNamedStreams", null, null, false); metadata.AddKeyProperty(entityWithNamedStreams, "ID", typeof(int)); metadata.AddPrimitiveProperty(entityWithNamedStreams, "Name", typeof(string)); ResourceProperty streamInfo1 = new ResourceProperty("Stream1", ResourcePropertyKind.Stream, ResourceType.GetPrimitiveResourceType(typeof(Stream))); entityWithNamedStreams.AddProperty(streamInfo1); ResourceProperty streamInfo2 = new ResourceProperty("Stream2", ResourcePropertyKind.Stream, ResourceType.GetPrimitiveResourceType(typeof(Stream))); entityWithNamedStreams.AddProperty(streamInfo2); // entity1 with streams ResourceType entityWithNamedStreams1 = metadata.AddEntityType("EntityWithNamedStreams1", null, null, false); metadata.AddKeyProperty(entityWithNamedStreams1, "ID", typeof(int)); metadata.AddPrimitiveProperty(entityWithNamedStreams1, "Name", typeof(string)); ResourceProperty refStreamInfo1 = new ResourceProperty("RefStream1", ResourcePropertyKind.Stream, ResourceType.GetPrimitiveResourceType(typeof(Stream))); entityWithNamedStreams1.AddProperty(refStreamInfo1); // entity2 with streams ResourceType entityWithNamedStreams2 = metadata.AddEntityType("EntityWithNamedStreams2", null, null, false); metadata.AddKeyProperty(entityWithNamedStreams2, "ID", typeof(string)); metadata.AddPrimitiveProperty(entityWithNamedStreams2, "Name", typeof(string)); ResourceProperty collectionStreamInfo = new ResourceProperty("ColStream", ResourcePropertyKind.Stream, ResourceType.GetPrimitiveResourceType(typeof(Stream))); entityWithNamedStreams2.AddProperty(collectionStreamInfo); ResourceSet set1 = metadata.AddResourceSet("MySet1", entityWithNamedStreams); ResourceSet set2 = metadata.AddResourceSet("MySet2", entityWithNamedStreams1); ResourceSet set3 = metadata.AddResourceSet("MySet3", entityWithNamedStreams2); // add navigation property to entityWithNamedStreams metadata.AddResourceReferenceProperty(entityWithNamedStreams, "Ref", set2, entityWithNamedStreams1); metadata.AddResourceSetReferenceProperty(entityWithNamedStreams, "Collection", set3, entityWithNamedStreams2); metadata.AddResourceSetReferenceProperty(entityWithNamedStreams2, "Collection1", set2, entityWithNamedStreams1); DSPServiceDefinition service = new DSPServiceDefinition(); service.Metadata = metadata; service.MediaResourceStorage = new DSPMediaResourceStorage(); service.SupportMediaResource = true; service.SupportNamedStream = true; service.ForceVerboseErrors = true; service.PageSizeCustomizer = (config, type) => { config.SetEntitySetPageSize("MySet3", 1); }; // populate data DSPContext context = new DSPContext(); DSPResource entity1 = new DSPResource(entityWithNamedStreams); { context.GetResourceSetEntities("MySet1").Add(entity1); entity1.SetValue("ID", 1); entity1.SetValue("Name", "Foo"); DSPMediaResource namedStream1 = service.MediaResourceStorage.CreateMediaResource(entity1, streamInfo1); namedStream1.ContentType = "image/jpeg"; byte[] data1 = new byte[] { 0, 1, 2, 3, 4 }; namedStream1.GetWriteStream().Write(data1, 0, data1.Length); DSPMediaResource namedStream2 = service.MediaResourceStorage.CreateMediaResource(entity1, streamInfo2); namedStream2.ContentType = "image/jpeg"; byte[] data2 = new byte[] { 0, 1, 2, 3, 4 }; namedStream2.GetWriteStream().Write(data2, 0, data2.Length); } DSPResource entity2 = new DSPResource(entityWithNamedStreams1); { context.GetResourceSetEntities("MySet2").Add(entity2); entity2.SetValue("ID", 3); entity2.SetValue("Name", "Bar"); DSPMediaResource refNamedStream1 = service.MediaResourceStorage.CreateMediaResource(entity2, refStreamInfo1); refNamedStream1.ContentType = "image/jpeg"; byte[] data1 = new byte[] { 0, 1, 2, 3, 4 }; refNamedStream1.GetWriteStream().Write(data1, 0, data1.Length); // set the navigation property entity1.SetValue("Ref", entity2); } { DSPResource entity3 = new DSPResource(entityWithNamedStreams2); context.GetResourceSetEntities("MySet3").Add(entity3); entity3.SetValue("ID", "ABCDE"); entity3.SetValue("Name", "Bar"); DSPMediaResource stream = service.MediaResourceStorage.CreateMediaResource(entity3, collectionStreamInfo); stream.ContentType = "image/jpeg"; byte[] data1 = new byte[] { 0, 1, 2, 3, 4 }; stream.GetWriteStream().Write(data1, 0, data1.Length); entity3.SetValue("Collection1", new List<DSPResource>() { entity2 }); DSPResource entity4 = new DSPResource(entityWithNamedStreams2); context.GetResourceSetEntities("MySet3").Add(entity4); entity4.SetValue("ID", "XYZ"); entity4.SetValue("Name", "Foo"); DSPMediaResource stream1 = service.MediaResourceStorage.CreateMediaResource(entity3, collectionStreamInfo); stream1.ContentType = "image/jpeg"; stream1.GetWriteStream().Write(data1, 0, data1.Length); entity4.SetValue("Collection1", new List<DSPResource>() { entity2 }); entity1.SetValue("Collection", new List<DSPResource>() { entity3, entity4 }); } service.DataSource = context; return service; }
public void ServiceOperationsMustBeReadOnlyTest() { var serviceOperationEntryPoints = new Action<DataServiceMetadataProviderWrapper, string>[] { (wrapper, name) => wrapper.TryResolveServiceOperation(name), }; AstoriaTestNS.TestUtil.RunCombinations( serviceOperationEntryPoints, (serviceOperationEntryPoint) => { var metadataProvider = new DSPMetadata("Test", "TestNS"); var serviceOperation = metadataProvider.AddServiceOperation("ServiceOperation", ServiceOperationResultKind.DirectValue, ResourceType.GetPrimitiveResourceType(typeof(string)), null, "GET", new ServiceOperationParameter[0]); var wrapper = new DataServiceMetadataProviderWrapper(metadataProvider); ExceptionUtils.ExpectedException<DataServiceException>( () => serviceOperationEntryPoint(wrapper, serviceOperation.Name), "The service operation '" + serviceOperation.Name + "' returned by the provider is not read-only. Please make sure that all the service operations are set to read-only.", "Accessing writable service operation should fail."); }); }
public DataServiceMetadataProviderWrapper(DSPMetadata metadataProvider) { DataServiceConfiguration config = (DataServiceConfiguration)Activator.CreateInstance( typeof(DataServiceConfiguration), BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { metadataProvider }, null); config.SetEntitySetAccessRule("*", EntitySetRights.All); config.SetServiceOperationAccessRule("*", ServiceOperationRights.All); Type staticConfigurationType = typeof(ResourceType).Assembly.GetType("Microsoft.OData.Service.DataServiceStaticConfiguration"); object staticConfig = (object)Activator.CreateInstance( staticConfigurationType, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { typeof(DummyServiceType), metadataProvider }, null); Type cacheItemType = typeof(ResourceType).Assembly.GetType("Microsoft.OData.Service.Caching.DataServiceCacheItem"); object cacheItem = Activator.CreateInstance( cacheItemType, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { config, staticConfig }, null); Type dspProviderBehaviorType = typeof(ResourceType).Assembly.GetType("Microsoft.OData.Service.Providers.DataServiceProviderBehavior"); IDataServiceProviderBehavior providerBehavior = (IDataServiceProviderBehavior)Activator.CreateInstance( dspProviderBehaviorType, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { new ProviderBehavior(ProviderQueryBehaviorKind.CustomProviderQueryBehavior) }, null); Type type = typeof(ResourceType).Assembly.GetType("Microsoft.OData.Service.Providers.DataServiceProviderWrapper"); instance = Activator.CreateInstance( type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { cacheItem, metadataProvider, new DSPResourceQueryProvider(metadataProvider, false), /*dataService*/ null, false }, null); type.GetField("providerBehavior", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(instance, providerBehavior); }
internal static DSPResource CreateRestStopResource(DSPMetadata roadTripMetadata, int id, ITestGeography location, bool useComplexType, Action<string, List<KeyValuePair<string, object>>> modifyPropertyValues) { List<KeyValuePair<string, object>> restStopPropertyValues = new List<KeyValuePair<string, object>>() { new KeyValuePair<string, object>("GeographyProperty", location.AsGeography()), }; if (modifyPropertyValues != null) { modifyPropertyValues("RestStop", restStopPropertyValues); } DSPResource restStopResource = CreateResource(roadTripMetadata, "RestStop", id, restStopPropertyValues.ToArray(), useComplexType); return restStopResource; }
private static DSPResource CreateResource(DSPMetadata metadata, string entityTypeName, int idValue, KeyValuePair<string, object>[] propertyValues, bool useComplexType) { var entityType = metadata.GetResourceType(entityTypeName); DSPResource entity; if (useComplexType) { entity = new DSPResource(entityType); } else { entity = new DSPResource(entityType, propertyValues); } entity.SetValue("ID", idValue); DSPResource resourceForProperties; if (useComplexType) { string complexTypeName = GetComplexTypeName(entityTypeName); var complexType = metadata.GetResourceType(complexTypeName); resourceForProperties = new DSPResource(complexType, propertyValues); entity.SetValue("ComplexProperty", resourceForProperties); } else { resourceForProperties = entity; } return entity; }
/// <summary> /// Creates a datasource from the given metadata. /// </summary> /// <param name="metadata">The metadata against which the datasource is created.</param> /// <returns>DSPContext representing the data source.</returns> private static DSPContext CreateDataSource(DSPMetadata metadata) { DSPContext context = new DSPContext(); ResourceType customerType = metadata.GetResourceType("CustomerEntity"); DSPResource entity1 = new DSPResource(customerType); entity1.SetValue("ID", 1); entity1.SetValue("Name", "Vineet"); DSPResource entity2 = new DSPResource(customerType); entity2.SetValue("ID", 2); entity2.SetValue("Name", "Jimmy"); context.GetResourceSetEntities("CustomerEntities").Add(entity1); context.GetResourceSetEntities("CustomerEntities").Add(entity2); return context; }
internal static DSPMetadata CreateRoadTripMetadata(Type geographyPropertyType, bool useComplexType = false, bool useOpenTypes = false, Action<DSPMetadata> modifyMetadata = null) { Assert.IsTrue(typeof(ISpatial).IsAssignableFrom(geographyPropertyType), "geographyPropertyType passed to CreateRoadTripMetadata is not a type derived from Geography."); string modelName = string.Format("RoadTripModelWith{0}", geographyPropertyType.Name); DSPMetadata metadata = new DSPMetadata(modelName, "AstoriaUnitTests.Tests"); // Geography property followed by another geography property KeyValuePair<string, Type>[] tripLegProperties = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("GeographyProperty1", geographyPropertyType), new KeyValuePair<string, Type>("GeographyProperty2", geographyPropertyType), }; AddEntityType(metadata, "TripLeg", tripLegProperties, useComplexType, useOpenTypes); // Geography property followed by another non-geography property KeyValuePair<string, Type>[] amusementParkProperties = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("GeographyProperty", geographyPropertyType), new KeyValuePair<string, Type>("Name", typeof(string)), }; AddEntityType(metadata, "AmusementPark", amusementParkProperties, useComplexType, useOpenTypes); // Geography property at the end of the entry KeyValuePair<string, Type>[] restStopProperties = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("GeographyProperty", geographyPropertyType), }; AddEntityType(metadata, "RestStop", restStopProperties, useComplexType, useOpenTypes); if (modifyMetadata != null) { modifyMetadata(metadata); } metadata.SetReadOnly(); return metadata; }
public static void ClassInitialize(TestContext context) { Metadata = new DSPMetadata(ServiceName, ServiceNamespace); CustomerResourceType = Metadata.AddEntityType("CustomerEntity", null, null, false); Metadata.AddKeyProperty(CustomerResourceType, "ID", typeof(int)); Metadata.AddPrimitiveProperty(CustomerResourceType, "Name", typeof(string), false); Metadata.AddResourceSet("CustomerEntities", CustomerResourceType); Metadata.SetReadOnly(); }
private static DSPContext GetDefaultData(DSPMetadata metadata) { var peopleType = metadata.GetResourceType("PeopleType"); var officeType = metadata.GetResourceType("OfficeType"); #region Default Data for the Model var context = new DSPContext(); DSPResource people1 = new DSPResource(peopleType); people1.SetValue("ID", 1); people1.SetValue("Name", "Foo"); people1.SetValue("Body", Encoding.UTF8.GetBytes("a byte array")); people1.SetValue("Age", 23); var office = new DSPResource(officeType); office.SetValue("Building", "Building 18"); office.SetValue("OfficeNumber", 100); people1.SetValue("Office", office); var people = context.GetResourceSetEntities("People"); people.Add( people1 ); #endregion Default Data for the Model return context; }
private DSPServiceDefinition PreferHeader_CreateService(DSPMetadata metadata, object existingItem, object existingCollection, object existingStream, object existingNamedStream) { DSPMediaResourceStorage mrStorage = new DSPMediaResourceStorage(); DSPServiceDefinition service = new DSPServiceDefinition() { Metadata = metadata, CreateDataSource = (m) => { DSPContext context = new DSPContext(); context.GetResourceSetEntities("Items").Add(existingItem); if (existingCollection != null) { context.GetResourceSetEntities("Collection").Add(existingCollection); } if (existingStream != null) { DSPMediaResource defaultStream = mrStorage.CreateMediaResource(existingStream, null); defaultStream.ContentType = UnitTestsUtil.MimeTextPlain; defaultStream.GetWriteStream().WriteByte((int)'c'); context.GetResourceSetEntities("Streams").Add(existingStream); } if (existingNamedStream != null) { DSPMediaResource namedStream1 = mrStorage.CreateMediaResource(existingNamedStream, m.GetResourceType("NamedStream").GetNamedStreams().First(ns => ns.Name == "NamedStream1")); namedStream1.ContentType = UnitTestsUtil.MimeTextPlain; namedStream1.GetWriteStream().WriteByte((int)'d'); context.GetResourceSetEntities("NamedStreams").Add(existingNamedStream); } return context; }, Writable = true, HostInterfaceType = typeof(IDataServiceHost2), SupportMediaResource = true, SupportNamedStream = true, MediaResourceStorage = mrStorage }; return service; }
private static Type GenerateAssemblyAndGetContextType(DSPMetadata metadata, DSPDataProviderKind providerKind) { Assert.IsTrue(providerKind == DSPDataProviderKind.EF || providerKind == DSPDataProviderKind.Reflection, "expecting only EF and reflection provider"); StringBuilder stringBuilder = new StringBuilder(); // Generate context class stringBuilder.Append("namespace " + metadata.ContainerNamespace); stringBuilder.AppendLine(" { "); stringBuilder.AppendLine("using System.Linq;"); string contextBaseType = (providerKind == DSPDataProviderKind.EF) ? " : System.Data.Entity.DbContext" : String.Empty; stringBuilder.Append("public class " + metadata.ContainerName + contextBaseType); stringBuilder.AppendLine(" { "); foreach (var set in metadata.ResourceSets) { if (providerKind == DSPDataProviderKind.EF) { stringBuilder.AppendLine(String.Format("public System.Data.Entity.DbSet<{0}> {1} {{ get; set; }}", set.ResourceType.FullName, set.Name)); } else { stringBuilder.AppendLine(String.Format("public static System.Collections.Generic.List<{0}> _{1} = new System.Collections.Generic.List<{0}>();", set.ResourceType.FullName, set.Name)); stringBuilder.AppendLine(String.Format("public System.Linq.IQueryable<{0}> {1} {{ get {{ return _{1}.AsQueryable(); }}}}", set.ResourceType.FullName, set.Name)); } } stringBuilder.AppendLine(" } "); // context class end stringBuilder.AppendLine(" } "); // end namespace // Generate C# code for the given metadata foreach (var resource in metadata.Types) { stringBuilder.Append("namespace " + resource.Namespace); stringBuilder.AppendLine(" { "); if (resource.ETagProperties.Any()) { stringBuilder.AppendFormat("[global::Microsoft.OData.Service.ETag({0})]", String.Join(",", resource.ETagProperties.Where(etagProp => resource.PropertiesDeclaredOnThisType.Contains(etagProp)).Select(etagProperty => string.Format("\"{0}\"", etagProperty.Name)))); } stringBuilder.Append("public class " + resource.Name); if (resource.BaseType != null) { stringBuilder.Append(" : " + resource.BaseType.FullName); } stringBuilder.AppendLine(" { "); // write the default constructor stringBuilder.AppendLine("public " + resource.Name + "()"); stringBuilder.AppendLine("{"); foreach (var property in resource.PropertiesDeclaredOnThisType.Where(p => p.Kind == ResourcePropertyKind.ResourceSetReference)) { stringBuilder.AppendLine(String.Format("this.{0} = new System.Collections.Generic.List<{1}>();", property.Name, property.ResourceType.FullName)); } stringBuilder.AppendLine(" } "); // constructor end // write all the properties foreach (var property in resource.PropertiesDeclaredOnThisType) { if (IsPropertyKind(property, ResourcePropertyKind.Primitive)) { if (providerKind == DSPDataProviderKind.EF && IsPropertyKind(property, ResourcePropertyKind.Key)) { stringBuilder.AppendLine("[System.ComponentModel.DataAnnotations.DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.None)]"); } // Entity Framework's spatial types are not currently the same as the type we use, so we need to use their type for the entity property Type resourcePropertyType = property.ResourceType.InstanceType; #if !EFRTM Type efPropertyType = typeof(Geography).IsAssignableFrom(resourcePropertyType) ? typeof(System.Data.Spatial.DbGeography) : resourcePropertyType; #else Type efPropertyType = resourcePropertyType; #endif stringBuilder.AppendLine(String.Format("public {0} {1} {{ get; set; }}", efPropertyType.ToCSharpString(), property.Name)); } else if (IsPropertyKind(property, ResourcePropertyKind.ComplexType) || property.Kind == ResourcePropertyKind.ResourceReference) { stringBuilder.AppendLine(String.Format("public {0} {1} {{ get; set; }}", property.ResourceType.FullName, property.Name)); } else if (property.Kind == ResourcePropertyKind.ResourceSetReference) { stringBuilder.AppendLine(String.Format("public System.Collections.Generic.List<{0}> {1} {{ get; set; }}", property.ResourceType.FullName, property.Name)); } else { throw new Exception("Invalid Property encountered"); } } stringBuilder.AppendLine(" } "); // class end stringBuilder.AppendLine(" } "); // end namespace } string contextTypeName = metadata.ContainerNamespace + "." + metadata.ContainerName; string assemblyName = contextTypeName + (providerKind == DSPDataProviderKind.EF ? "_EF" : "_Reflection"); string assemblyFullPath = Path.Combine(test.TestUtil.GeneratedFilesLocation, assemblyName + ".dll"); // Modify the generated code if (DSPUnitTestServiceDefinition.ModifyGeneratedCode != null) { stringBuilder = ModifyGeneratedCode(stringBuilder); } // compile the assembly test.TestUtil.GenerateAssembly(stringBuilder.ToString(), assemblyFullPath, new string[] { Path.Combine(test.TestUtil.GreenBitsReferenceAssembliesDirectory, "System.ComponentModel.DataAnnotations.dll"), "EntityFramework.dll" }); Assembly assembly = Assembly.LoadFrom(assemblyFullPath); return assembly.GetType(contextTypeName); }
private static void TestSpatialMetadata(DSPDataProviderKind providerKind) { DSPMetadata metadata = new DSPMetadata("SpatialMetadata", "AstoriaUnitTests.Tests"); // Entity with all types of geography properties KeyValuePair<string, Type>[] geographyProperties = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("GeographyProperty", typeof(Geography)), new KeyValuePair<string, Type>("PointProperty", typeof(GeographyPoint)), new KeyValuePair<string, Type>("LineStringProperty", typeof(GeographyLineString)), }; string entityTypeName = "AllGeographyTypes"; SpatialTestUtil.AddEntityType(metadata, entityTypeName, geographyProperties, useComplexType: false, useOpenTypes: false); metadata.SetReadOnly(); var service = new DSPUnitTestServiceDefinition(metadata, providerKind, new DSPContext()); using (TestWebRequest request = service.CreateForInProcess()) { request.StartService(); request.HttpMethod = "GET"; XDocument response = UnitTestsUtil.GetResponseAsAtomXLinq(request, "/$metadata"); XElement schemaElement = response.Root.Element(UnitTestsUtil.EdmxNamespace + "DataServices").Elements().Single(e => e.Name.LocalName == "Schema"); XNamespace edmNs = schemaElement.Name.Namespace; XElement entityElement = schemaElement.Elements(edmNs + "EntityType").Single(e => (string)e.Attribute("Name") == entityTypeName); foreach (KeyValuePair<string, Type> property in geographyProperties) { XElement propertyElement = entityElement.Elements(edmNs + "Property").Single(e => (string)e.Attribute("Name") == property.Key); // EF provider currently represents all types as Edm.Geography in metadata (property is DbGeography on the entity), otherwise it should reflect the actual type string expectedEdmTypeName = providerKind == DSPDataProviderKind.EF ? "Edm.Geography" : GetExpectedEdmTypeName(property.Value); Assert.AreEqual(expectedEdmTypeName, propertyElement.Attribute("Type").Value, "Wrong property type for property {0},", property.Key); XAttribute attribute = propertyElement.Attributes().Where(a => a.Name == "SRID").Single(); Assert.AreEqual("Variable", attribute.Value); } } }
private DSPMetadata PreferHeader_CreateMetadata() { DSPMetadata metadata = new DSPMetadata("Test", "TestNS"); var entityType = metadata.AddEntityType("Item", typeof(DSPSelfmodifyingResource), null, false); metadata.AddKeyProperty(entityType, "ID", typeof(int)); metadata.AddPrimitiveProperty(entityType, "ETagProperty", typeof(int?), true); metadata.AddPrimitiveProperty(entityType, "TriggerModification", typeof(string)); var entitySet = metadata.AddResourceSet("Items", entityType); metadata.AddResourceReferenceProperty(entityType, "Self", entitySet, entityType); var collectionEntity = metadata.AddEntityType("Collection", null, null, false); metadata.AddKeyProperty(collectionEntity, "ID", typeof(int)); metadata.AddPrimitiveProperty(collectionEntity, "Rating", typeof(int?)); metadata.AddPrimitiveProperty(collectionEntity, "Description", typeof(string)); metadata.AddCollectionProperty(collectionEntity, "CollectionProperty", typeof(int?)); metadata.AddResourceSet("Collection", collectionEntity); var streamEntity = metadata.AddEntityType("Stream", typeof(DSPSelfmodifyingResource), null, false); metadata.AddKeyProperty(streamEntity, "ID", typeof(int)); metadata.AddPrimitiveProperty(streamEntity, "ETagProperty", typeof(int?), true); metadata.AddPrimitiveProperty(streamEntity, "TriggerModification", typeof(string)); streamEntity.IsMediaLinkEntry = true; metadata.AddResourceSet("Streams", streamEntity); var namedStreamEntity = metadata.AddEntityType("NamedStream", typeof(DSPSelfmodifyingResource), null, false); metadata.AddKeyProperty(namedStreamEntity, "ID", typeof(int)); namedStreamEntity.AddProperty(new provider.ResourceProperty("NamedStream1", provider.ResourcePropertyKind.Stream, provider.ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)))); metadata.AddResourceSet("NamedStreams", namedStreamEntity); return metadata; }
public void AllowRedefiningConcurrencyTokenOnDerivedType() { var metadataProvider = new DSPMetadata("DefaultContainer", "Default"); var entityType = metadataProvider.AddEntityType("EntityType", null, null, false /*isAbstract*/); metadataProvider.AddKeyProperty(entityType, "ID", typeof(int)); metadataProvider.AddPrimitiveProperty(entityType, "LastUpdatedAuthor", typeof(string), true /*eTag*/); var derivedType = metadataProvider.AddEntityType("DerivedType", null, entityType, false /*isAbstract*/); metadataProvider.AddPrimitiveProperty(derivedType, "LastModifiedAuthor", typeof(string), true /*eTag*/); metadataProvider.AddResourceSet("Customers", entityType); var wrapper = new DataServiceMetadataProviderWrapper(metadataProvider); DSPResource baseTypeInstance = new DSPResource(entityType); baseTypeInstance.SetValue("ID", 1); baseTypeInstance.SetValue("LastUpdatedAuthor", "Phani"); DSPResource derivedTypeInstance = new DSPResource(derivedType); derivedTypeInstance.SetValue("ID", 1); derivedTypeInstance.SetValue("LastModifiedAuthor", "Raj"); DSPContext dataContext = new DSPContext(); var entities = dataContext.GetResourceSetEntities("Customers"); entities.AddRange(new object[] { baseTypeInstance, derivedTypeInstance }); var service = new DSPUnitTestServiceDefinition(metadataProvider, DSPDataProviderKind.Reflection, dataContext); using (TestWebRequest request = service.CreateForInProcess()) { try { request.StartService(); request.RequestUriString = "/$metadata"; request.SendRequestAndCheckResponse(); } finally { request.StopService(); } } }
/// <summary>Constructor.</summary> /// <param name="metadata">The metadata provider.</param> public DSPResourceQueryProvider(DSPMetadata metadata, bool enableCustomPaging) { this.metadata = metadata; this.customPagingEnabled = enableCustomPaging; }
internal static DSPUnitTestServiceDefinition CreateRoadTripServiceDefinition(DSPMetadata roadTripMetadata, GeographyPropertyValues defaultValues, DSPDataProviderKind providerKind, bool useComplexType = false, Action<string, List<KeyValuePair<string, object>>> modifyPropertyValues = null) { Assert.IsFalse(useComplexType, "Complex type support is not yet added to the property population in DSPUnitTestServiceDefinition."); DSPContext defaultData = PopulateRoadTripData(roadTripMetadata, defaultValues, useComplexType, modifyPropertyValues); var service = new DSPUnitTestServiceDefinition(roadTripMetadata, providerKind, defaultData); service.HostInterfaceType = typeof(IDataServiceHost2); service.DataServiceBehavior.AcceptSpatialLiteralsInQuery = true; service.Writable = true; service.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4; return service; }
private static void TestRestStopUpdate(ResourceVerification verification, string httpMethod, string preferHeader, bool useBatch, DSPMetadata roadTripMetadata) { var restStop = SpatialTestUtil.CreateRestStopResource( roadTripMetadata, verification.Id, verification.PropertyValues.RestStopGeography, useComplexType: false, modifyPropertyValues: null); ExecuteUpdate(restStop, verification.Id, verification.Request, httpMethod, preferHeader, useBatch, verification.PayloadFormat); // Verify that the operation was successful by querying the same data again verification.GetAndVerifyRestStop(); }
internal static DSPContext PopulateRoadTripData(DSPMetadata roadTripMetadata, GeographyPropertyValues defaultValues, bool useComplexType, Action<string, List<KeyValuePair<string, object>>> modifyPropertyValues = null) { var context = new DSPContext(); DSPResource tripLegResource = CreateTripLegResource(roadTripMetadata, DefaultId, defaultValues.TripLegGeography1, defaultValues.TripLegGeography2, useComplexType, modifyPropertyValues); PopulateResourceSet(context, tripLegResource); DSPResource amusementParkResource = CreateAmusementParkResource(roadTripMetadata, DefaultId, defaultValues.AmusementParkGeography, "Disneyland", useComplexType, modifyPropertyValues); PopulateResourceSet(context, amusementParkResource); DSPResource restStopResource = CreateRestStopResource(roadTripMetadata, DefaultId, defaultValues.RestStopGeography, useComplexType, modifyPropertyValues); PopulateResourceSet(context, restStopResource); return context; }