/// <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;
}
