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);
}
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);
}
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);
}
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 DSPServiceDefinition CreateCollectionReadService(Dictionary <Type, object> data)
{
DSPMetadata metadata = new DSPMetadata("SpatialServerIntegration", "AstoriaUnitTests.Tests");
var entityType = metadata.AddEntityType("EntityType", null, null, false);
metadata.AddResourceSet("Entities", entityType);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
foreach (Type t in data.Keys)
{
metadata.AddCollectionProperty(entityType, "Collection" + t.Name, t);
}
DSPContext dataSource = new DSPContext();
var entities = dataSource.GetResourceSetEntities("Entities");
var resource = new DSPResource(entityType);
resource.SetValue("ID", 0);
foreach (KeyValuePair <Type, object> d in data)
{
resource.SetValue("Collection" + d.Key.Name, d.Value);
}
entities.Add(resource);
return(new DSPServiceDefinition()
{
Metadata = metadata,
DataSource = dataSource
});
}
public DSPQueryableContext CreateContext(DSPMetadata metadata, Dictionary <string, Type> providerTypes, string connectionString)
{
Func <string, IQueryable> queryProviders = x => GetQueryableCollection(connectionString, providerTypes, x);
var dspContext = new DSPQueryableContext(metadata, queryProviders);
return(dspContext);
}
protected override DSPMetadata CreateDSPMetadata()
{
DSPMetadata metadata = new DSPMetadata("DemoService", "DataServiceProviderDemo");
ResourceType product = metadata.AddEntityType("Product");
metadata.AddKeyProperty(product, "ID", typeof(int));
metadata.AddPrimitiveProperty(product, "Name", typeof(string));
metadata.AddPrimitiveProperty(product, "Description", typeof(string));
metadata.AddPrimitiveProperty(product, "ReleaseDate", typeof(DateTime));
metadata.AddPrimitiveProperty(product, "DiscontinueDate", typeof(DateTime?));
metadata.AddPrimitiveProperty(product, "Rating", typeof(int));
ResourceSet products = metadata.AddResourceSet("Products", product);
ResourceType category = metadata.AddEntityType("Category");
metadata.AddKeyProperty(category, "ID", typeof(int));
metadata.AddPrimitiveProperty(category, "Name", typeof(string));
ResourceSet categories = metadata.AddResourceSet("Categories", category);
// Add reference properties between category and product
metadata.AddResourceReferenceProperty(product, "Category", categories);
metadata.AddResourceSetReferenceProperty(category, "Products", products);
return(metadata);
}
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);
}
protected override void PopulateMetadata(DSPMetadata metadata, MongoContext context)
{
foreach (var collectionName in GetCollectionNames(context))
{
var collection = context.Database.GetCollection(collectionName);
var document = collection.FindOne();
if (document != null)
{
var collectionType = metadata.AddEntityType(collectionName);
foreach (var element in document.Elements)
{
var elementType = GetElementType(context, element);
if (element.Name == "_id")
{
metadata.AddKeyProperty(collectionType, "ID", elementType);
}
else if (elementType == typeof(BsonDocument))
{
string referencedCollectionName = GetDocumentCollection(context, element.Value.AsBsonDocument).Name;
resourceReferences.Add(new Tuple <ResourceType, string, string>(collectionType, element.Name, referencedCollectionName));
}
else if (elementType == typeof(BsonArray))
{
var bsonArray = element.Value.AsBsonArray;
if (bsonArray != null && bsonArray.Count > 0)
{
string referencedCollectionName = GetDocumentCollection(context, bsonArray[0].AsBsonDocument).Name;
resourceSetReferences.Add(new Tuple <ResourceType, string, string>(collectionType, element.Name, referencedCollectionName));
}
}
else
{
metadata.AddPrimitiveProperty(collectionType, element.Name, elementType);
}
}
metadata.AddResourceSet(collectionName, collectionType);
}
}
foreach (var reference in resourceReferences)
{
var referencedResourceSet = metadata.ResourceSets.Where(x => x.Name == reference.Item3).SingleOrDefault();
if (referencedResourceSet != null)
{
metadata.AddResourceSetReferenceProperty(reference.Item1, reference.Item2, referencedResourceSet);
}
}
foreach (var reference in resourceSetReferences)
{
var referencedResourceSet = metadata.ResourceSets.Where(x => x.Name == reference.Item3).SingleOrDefault();
if (referencedResourceSet != null)
{
metadata.AddResourceSetReferenceProperty(reference.Item1, reference.Item2, referencedResourceSet);
}
}
}
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();
}
public DSPMetadata CreateMetadata()
{
var metadata = new DSPMetadata("MongoContext", "Northwind");
using (MongoContext context = new MongoContext(ConfigurationManager.ConnectionStrings["NorthwindContext.MongoDB"].ConnectionString))
{
PopulateMetadata(metadata, context);
}
return(metadata);
}
public DSPInMemoryContext CreateContext(DSPMetadata metadata, string connectionString)
{
var dspContext = new DSPInMemoryContext();
using (MongoContext mongoContext = new MongoContext(connectionString))
{
PopulateData(dspContext, mongoContext, metadata);
}
return(dspContext);
}
/// <summary>
/// Create a service for a specific spatial property type.
/// </summary>
/// <remarks>
/// DEVNOTE(pqian):
/// The service will populate with properties named after the property type, with a sequence number
/// indicating which test sample it holds. For example, if the method is called with 3 sample data,
/// and the target type is GeographyPoint, then the service will look like
/// EntityType:
/// ID
/// GeographyPoint1
/// GeographyPoint2
/// GeographyPoint3
/// </remarks>
/// <typeparam name="T">The target type</typeparam>
/// <param name="data">Sample Data</param>
/// <param name="overrideType">Use this type instead of typeof(T)</param>
/// <param name="openProperty">Use Open Type</param>
/// <param name="writable">Writable service</param>
/// <returns>The constructed service definition</returns>
private DSPServiceDefinition CreateSpatialPropertyService <T>(T[] data, Type overrideType = null, bool openProperty = false, bool writable = false)
{
Type propertyType = overrideType ?? typeof(T);
DSPMetadata metadata = new DSPMetadata("SpatialServerIntegration", "AstoriaUnitTests.Tests");
var entityType = metadata.AddEntityType("EntityType", null, null, false);
metadata.AddResourceSet("Entities", entityType);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
if (!openProperty)
{
for (int i = 0; i < data.Length; ++i)
{
metadata.AddPrimitiveProperty(entityType, propertyType.Name + i, propertyType);
}
}
entityType.IsOpenType = openProperty;
var definition = new DSPServiceDefinition()
{
Metadata = metadata
};
if (writable)
{
definition.CreateDataSource = (m) => new DSPContext();
definition.Writable = true;
}
else
{
DSPContext dataSource = new DSPContext();
var entities = dataSource.GetResourceSetEntities("Entities");
var resource = new DSPResource(entityType);
resource.SetValue("ID", 0);
for (int i = 0; i < data.Length; ++i)
{
if (!openProperty)
{
metadata.AddPrimitiveProperty(entityType, propertyType.Name + i, propertyType);
}
resource.SetValue(propertyType.Name + i, data[i]);
}
entities.Add(resource);
definition.DataSource = dataSource;
}
return(definition);
}
protected override void PopulateMetadata(DSPMetadata metadata, MongoContext context)
{
var itemsType = new ResourceType(typeof(Dictionary <string, object>),
ResourceTypeKind.ComplexType, null, "Northwind", "Items", false);
foreach (var collectionName in GetCollectionNames(context))
{
var collectionType = metadata.AddEntityType(collectionName);
metadata.AddKeyProperty(collectionType, "Id", typeof(string));
metadata.AddComplexProperty(collectionType, "Items", itemsType);
metadata.AddResourceSet(collectionName, collectionType);
}
}
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);
}
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();
}
}
}
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);
}
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 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 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 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);
}
/// <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);
}
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);
string value = "value of Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ";
context.AddObject("EntitySet", new MyType()
{
ID = 1,
Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ = value,
});
try
{
context.SaveChanges();
}
catch (DataServiceRequestException exception)
{
Assert.AreEqual(exception.Message, "An error occurred while processing this request.");
}
}
}
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 void SpatialAsKeys()
{
var types = testData.Select(kvp => SpatialTestUtil.GeographyTypeFor(kvp.Key))
.Union(testData.Select(kvp => SpatialTestUtil.GeometryTypeFor(kvp.Key)))
.Union(new Type[] { typeof(Geography), typeof(Geometry) })
.ToArray();
TestUtil.RunCombinations(types, (t) =>
{
DSPMetadata metadata = new DSPMetadata("SpatialServerIntegration", "AstoriaUnitTests.Tests");
var entityType = metadata.AddEntityType("EntityType", null, null, false);
metadata.AddResourceSet("Entities", entityType);
Exception ex = TestUtil.RunCatching <InvalidOperationException>(
() => metadata.AddKeyProperty(entityType, "ID", t));
Assert.IsNotNull(ex);
Assert.AreEqual(DataServicesResourceUtil.GetString("ResourceType_SpatialKeyOrETag", "ID", "EntityType"), ex.Message);
});
}
private DSPServiceDefinition CreateCollectionWriteService(List <Type> types)
{
DSPMetadata metadata = new DSPMetadata("SpatialServerIntegration", "AstoriaUnitTests.Tests");
var entityType = metadata.AddEntityType("EntityType", null, null, false);
metadata.AddResourceSet("Entities", entityType);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
foreach (Type t in types)
{
metadata.AddCollectionProperty(entityType, "Collection" + t.Name, t);
}
return(new DSPServiceDefinition()
{
Metadata = metadata,
Writable = true,
CreateDataSource = (m) => new DSPContext()
});
}
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);
}
}
}
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.");
});
}
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");
}
}
public DSPContext CreateContext(DSPMetadata metadata)
{
if (cachedContext == null)
{
lock (this)
{
var dspContext = new DSPContext();
using (MongoContext mongoContext = new MongoContext(ConfigurationManager.ConnectionStrings["NorthwindContext.MongoDB"].ConnectionString))
{
foreach (var resourceSet in metadata.ResourceSets)
{
var entities = dspContext.GetResourceSetEntities(resourceSet.Name);
foreach (var bsonDocument in mongoContext.Database.GetCollection(resourceSet.Name).FindAll())
{
var resource = CreateDSPResource(resourceSet.ResourceType, bsonDocument);
entities.Add(resource);
}
}
}
foreach (var reference in resourceReferences)
{
resourceMap[reference.Item1].SetValue(reference.Item2, resourceMap[reference.Item3]);
}
foreach (var reference in resourceSetReferences)
{
var referencedCollection = new List <DSPResource>();
resourceMap[reference.Item1].SetValue(reference.Item2, referencedCollection);
foreach (var objectId in reference.Item3)
{
referencedCollection.Add(resourceMap[objectId]);
}
}
cachedContext = dspContext;
}
}
return(cachedContext);
}
