private static Action WriteServiceDocumentShouldError(ODataServiceDocument serviceDocument, IODataUrlResolver resolver = null)
{
MemoryStream memoryStream = new MemoryStream();
ODataAtomServiceDocumentSerializer serializer = CreateAtomOutputContext(memoryStream, resolver);
return(new Action(() => serializer.WriteServiceDocument(serviceDocument)));
}
public void QueryServiceDocument()
{
string[] types = new string[]
{
"text/html, application/xhtml+xml, */*",
MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterMinimalMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterNoMetadata,
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in types)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
ODataServiceDocument workSpace = messageReader.ReadServiceDocument();
Assert.IsNotNull(workSpace.EntitySets.Single(c => c.Name == "People"));
}
}
}
}
public void ServiceDocument()
{
string[] types = new string[]
{
MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterMinimalMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterNoMetadata,
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in types)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
ODataServiceDocument workSpace = messageReader.ReadServiceDocument();
Assert.NotNull(workSpace.EntitySets.Single(c => c.Name == "Trucks"));
Assert.Equal("GetDefaultOutsideGeoFenceAlarm", workSpace.FunctionImports.First().Name);
}
}
}
}
public void GetODataServiceDocumentOnMetadataController_ReturnsODataODataServiceDocument()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType entity = new EdmEntityType("NS", "Entity");
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
container.AddSingleton("me", entity);
model.AddElement(entity);
model.AddElement(container);
HttpRequest reqest = RequestFactory.Create(model);
MetadataController metadataController = new MetadataController();
metadataController.ControllerContext.HttpContext = reqest.HttpContext;
// Act
ODataServiceDocument actual = metadataController.GetServiceDocument();
// Assert
Assert.NotNull(actual);
Assert.Empty(actual.EntitySets);
Assert.Empty(actual.FunctionImports);
ODataSingletonInfo singletonInfo = Assert.Single(actual.Singletons);
Assert.Equal("me", singletonInfo.Name);
}
/// <summary>
/// Read a service document.
/// This method reads the service document from the input and returns
/// an <see cref="ODataServiceDocument"/> that represents the read service document.
/// </summary>
/// <returns>An <see cref="ODataServiceDocument"/> representing the read service document.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.None: assumes that the JSON reader has not been used yet.
/// Post-Condition: JsonNodeType.EndOfInput
/// </remarks>
internal ODataServiceDocument ReadServiceDocument()
{
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.None, "Pre-Condition: expected JsonNodeType.None, the reader must not have been used yet.");
this.JsonReader.AssertNotBuffering();
// We use this to store annotations and check for duplicate annotation names, but we don't really store properties in it.
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
// Position the reader on the first node
this.ReadPayloadStart(
ODataPayloadKind.ServiceDocument,
duplicatePropertyNamesChecker,
/*isReadingNestedPayload*/false,
/*allowEmptyPayload*/false);
ODataServiceDocument serviceDocument = this.ReadServiceDocumentImplementation(duplicatePropertyNamesChecker);
// Read the end of the response.
this.ReadPayloadEnd(/*isReadingNestedPayload*/ false);
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndOfInput, "Post-Condition: expected JsonNodeType.EndOfInput");
this.JsonReader.AssertNotBuffering();
return serviceDocument;
}
public async Task WriteServiceDocumentAsync()
{
var serviceDocument = new ODataServiceDocument
{
EntitySets = new List <ODataEntitySetInfo>
{
new ODataEntitySetInfo {
Name = "Orders", Title = "Orders", Url = new Uri($"{ServiceUri}/Orders")
},
new ODataEntitySetInfo {
Name = "Customers", Title = "Customers", Url = new Uri($"{ServiceUri}/Customers")
}
}
};
var result = await SetupJsonLightOutputContextAndRunTestAsync(
(jsonLightOutputContext) => jsonLightOutputContext.WriteServiceDocumentAsync(serviceDocument));
Assert.Equal(
"{\"@odata.context\":\"http://tempuri.org/$metadata\"," +
"\"value\":[" +
"{\"name\":\"Orders\",\"kind\":\"EntitySet\",\"url\":\"http://tempuri.org/Orders\"}," +
"{\"name\":\"Customers\",\"kind\":\"EntitySet\",\"url\":\"http://tempuri.org/Customers\"}]}",
result);
}
public ODataServiceDocument GetServiceDocument()
{
IEdmModel model = GetModel();
ODataServiceDocument serviceDocument = new ODataServiceDocument();
IEdmEntityContainer container = model.EntityContainer;
// Add EntitySets into service document
serviceDocument.EntitySets = container.EntitySets().Select(
e => GetODataEntitySetInfo(model.GetNavigationSourceUrl(e).ToString(), e.Name));
// Add Singletons into the service document
IEnumerable <IEdmSingleton> singletons = container.Elements.OfType <IEdmSingleton>();
serviceDocument.Singletons = singletons.Select(
e => GetODataSingletonInfo(model.GetNavigationSourceUrl(e).ToString(), e.Name));
// Add FunctionImports into service document
// ODL spec says:
// The edm:FunctionImport for a parameterless function MAY include the IncludeInServiceDocument attribute
// whose Boolean value indicates whether the function import is advertised in the service document.
// If no value is specified for this attribute, its value defaults to false.
// Find all parameterless functions with "IncludeInServiceDocument = true"
IEnumerable <IEdmFunctionImport> functionImports = container.Elements.OfType <IEdmFunctionImport>()
.Where(f => !f.Function.Parameters.Any() && f.IncludeInServiceDocument);
serviceDocument.FunctionImports = functionImports.Distinct(new FunctionImportComparer())
.Select(f => GetODataFunctionImportInfo(f.Name));
return(serviceDocument);
}
private static Action WriteServiceDocumentShouldError(ODataServiceDocument serviceDocument, IODataPayloadUriConverter urlResolver = null)
{
MemoryStream memoryStream = new MemoryStream();
var serializer = CreateODataJsonLightServiceDocumentSerializer(memoryStream, urlResolver);
return(() => serializer.WriteServiceDocument(serviceDocument));
}
/// <summary>
/// Asynchronously read a service document.
/// This method reads the service document from the input and returns
/// an <see cref="ODataServiceDocument"/> that represents the read service document.
/// </summary>
/// <returns>A task which returns an <see cref="ODataServiceDocument"/> representing the read service document.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.None: assumes that the JSON reader has not been used yet.
/// Post-Condition: JsonNodeType.EndOfInput
/// </remarks>
internal async Task <ODataServiceDocument> ReadServiceDocumentAsync()
{
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.None, "Pre-Condition: expected JsonNodeType.None, the reader must not have been used yet.");
this.JsonReader.AssertNotBuffering();
// We use this to store annotations and check for duplicate annotation names, but we don't really store properties in it.
PropertyAndAnnotationCollector propertyAndAnnotationCollector = this.CreatePropertyAndAnnotationCollector();
await this.ReadPayloadStartAsync(
ODataPayloadKind.ServiceDocument,
propertyAndAnnotationCollector,
isReadingNestedPayload : false,
allowEmptyPayload : false).ConfigureAwait(false);
ODataServiceDocument serviceDocument = await this.ReadServiceDocumentImplementationAsync(propertyAndAnnotationCollector)
.ConfigureAwait(false);
// Read the end of the response.
await this.ReadPayloadEndAsync(isReadingNestedPayload : false)
.ConfigureAwait(false);
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndOfInput, "Post-Condition: expected JsonNodeType.EndOfInput");
this.JsonReader.AssertNotBuffering();
return(serviceDocument);
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
/// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks>
internal override void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
this.AssertSynchronous();
this.WriteServiceDocumentImplementation(serviceDocument);
this.Flush();
}
internal void WriteServiceDocumentMetadata(ODataServiceDocument serviceDocument)
{
Debug.Assert(serviceDocument != null, "serviceDocument != null");
AtomWorkspaceMetadata metadata = serviceDocument.GetAnnotation<AtomWorkspaceMetadata>();
AtomTextConstruct title = null;
if (metadata != null)
{
title = metadata.Title;
}
if (title == null)
{
title = new AtomTextConstruct { Text = AtomConstants.AtomWorkspaceDefaultTitle };
}
if (this.UseServerFormatBehavior && title.Kind == AtomTextConstructKind.Text)
{
// For WCF DS server we must not write the type attribute, just a simple <atom:title>Default<atom:title>
this.WriteElementWithTextContent(
AtomConstants.NonEmptyAtomNamespacePrefix,
AtomConstants.AtomTitleElementName,
AtomConstants.AtomNamespace,
title.Text);
}
else
{
// <atom:title>title</atom:title>
this.WriteTextConstruct(AtomConstants.NonEmptyAtomNamespacePrefix, AtomConstants.AtomTitleElementName, AtomConstants.AtomNamespace, title);
}
}
internal void WriteServiceDocumentMetadata(ODataServiceDocument serviceDocument)
{
Debug.Assert(serviceDocument != null, "serviceDocument != null");
AtomWorkspaceMetadata metadata = serviceDocument.GetAnnotation <AtomWorkspaceMetadata>();
AtomTextConstruct title = null;
if (metadata != null)
{
title = metadata.Title;
}
if (title == null)
{
title = new AtomTextConstruct {
Text = AtomConstants.AtomWorkspaceDefaultTitle
};
}
if (this.UseServerFormatBehavior && title.Kind == AtomTextConstructKind.Text)
{
// For WCF DS server we must not write the type attribute, just a simple <atom:title>Default<atom:title>
this.WriteElementWithTextContent(
AtomConstants.NonEmptyAtomNamespacePrefix,
AtomConstants.AtomTitleElementName,
AtomConstants.AtomNamespace,
title.Text);
}
else
{
// <atom:title>title</atom:title>
this.WriteTextConstruct(AtomConstants.NonEmptyAtomNamespacePrefix, AtomConstants.AtomTitleElementName, AtomConstants.AtomNamespace, title);
}
}
/// <summary>
/// Read a service document.
/// This method reads the service document from the input and returns
/// an <see cref="ODataServiceDocument"/> that represents the read service document.
/// </summary>
/// <returns>A task which returns an <see cref="ODataServiceDocument"/> representing the read service document.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.None: assumes that the JSON reader has not been used yet.
/// Post-Condition: JsonNodeType.EndOfInput
/// </remarks>
internal Task <ODataServiceDocument> ReadServiceDocumentAsync()
{
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.None, "Pre-Condition: expected JsonNodeType.None, the reader must not have been used yet.");
this.JsonReader.AssertNotBuffering();
// We use this to store annotations and check for duplicate annotation names, but we don't really store properties in it.
PropertyAndAnnotationCollector propertyAndAnnotationCollector = this.CreatePropertyAndAnnotationCollector();
// Position the reader on the first node
return(this.ReadPayloadStartAsync(
ODataPayloadKind.ServiceDocument,
propertyAndAnnotationCollector,
/*isReadingNestedPayload*/ false,
/*allowEmptyPayload*/ false)
.FollowOnSuccessWith(t =>
{
ODataServiceDocument serviceDocument = this.ReadServiceDocumentImplementation(propertyAndAnnotationCollector);
// Read the end of the response.
this.ReadPayloadEnd(/*isReadingNestedPayload*/ false);
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndOfInput, "Post-Condition: expected JsonNodeType.EndOfInput");
this.JsonReader.AssertNotBuffering();
return serviceDocument;
}));
}
private void TestEntitySetInServiceDocument(ODataServiceDocument serviceDocument)
{
Assert.NotNull(serviceDocument.EntitySets);
var entitySet = Assert.Single(serviceDocument.EntitySets);
Assert.Equal("entityset", entitySet.Name);
Assert.Equal("http://service/entityset", entitySet.Url.ToString());
}
public void PropertySettersNullTest()
{
ODataServiceDocument serviceDocument = new ODataServiceDocument();
serviceDocument.EntitySets = null;
this.Assert.IsNull(serviceDocument.EntitySets, "Expected null value for property 'EntitySets'.");
}
public void ShouldWriteServiceDocumentAsyncWithoutModel()
{
ODataServiceDocument serviceDocument = new ODataServiceDocument();
serviceDocument.EntitySets = new ODataEntitySetInfo[] { new ODataEntitySetInfo {
Name = "Customers", Url = new Uri("http://host/Customers")
} };
WriteAndValidate(outputContext => outputContext.WriteServiceDocumentAsync(serviceDocument).Wait(), "{\"@odata.context\":\"http://odata.org/test/$metadata\",\"value\":[{\"name\":\"Customers\",\"kind\":\"EntitySet\",\"url\":\"http://host/Customers\"}]}", writingResponse: true, synchronous: false);
}
private void TestEntitySetInServiceDocument(ODataServiceDocument serviceDocument)
{
serviceDocument.EntitySets.Should().NotBeNull();
var entitySets = serviceDocument.EntitySets.ToList();
entitySets.Count.Should().Be(1);
entitySets[0].Name.Should().Be("entityset");
entitySets[0].Url.ToString().Should().Be("http://service/entityset");
}
/// <summary>
/// Reads a service document.
/// This method reads the service document from the input and returns
/// an <see cref="ODataServiceDocument"/> that represents the read service document.
/// </summary>
/// <returns>An <see cref="ODataServiceDocument"/> representing the read service document.</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - The start element of the service document.
/// Post-Condtion: XmlNodeType.None - The reader must be at the end of the input.
/// </remarks>
internal ODataServiceDocument ReadServiceDocument()
{
Debug.Assert(this.ReadingResponse, "Service document can only appear in a response message");
Debug.Assert(this.XmlReader != null, "this.XmlReader != null");
this.ReadPayloadStart();
this.AssertXmlCondition(XmlNodeType.Element);
// read the 'service' element.
if (!this.XmlReader.NamespaceEquals(this.AtomPublishingNamespace) ||
!this.XmlReader.LocalNameEquals(this.AtomPublishingServiceElementName))
{
throw new ODataException(Strings.ODataAtomServiceDocumentDeserializer_ServiceDocumentRootElementWrongNameOrNamespace(
this.XmlReader.LocalName, this.XmlReader.NamespaceURI));
}
ODataServiceDocument serviceDocument = null;
if (!this.XmlReader.IsEmptyElement)
{
// read over the start tag of the 'service' element.
this.XmlReader.Read();
serviceDocument = this.ReadWorkspace();
}
if (serviceDocument == null)
{
throw new ODataException(Strings.ODataAtomServiceDocumentDeserializer_MissingWorkspaceElement);
}
// skip anything which is not in the ATOM publishing namespace.
this.SkipToElementInAtomPublishingNamespace();
this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.EndElement);
// When we reach here, we should be at the end-tag of the service element.
if (this.XmlReader.NodeType == XmlNodeType.Element)
{
Debug.Assert(this.XmlReader.NamespaceEquals(this.AtomPublishingNamespace), "The current Xml element should have been in the 'app' namespace");
// We only support a single serviceDocument inside a service document.
if (this.XmlReader.LocalNameEquals(this.AtomPublishingWorkspaceElementName))
{
throw new ODataException(Strings.ODataAtomServiceDocumentDeserializer_MultipleWorkspaceElementsFound);
}
// Throw error, if we encounter any other element in the ATOM publishing namespace.
throw new ODataException(Strings.ODataAtomServiceDocumentDeserializer_UnexpectedElementInServiceDocument(this.XmlReader.LocalName));
}
// read over the end tag of the 'service' element.
this.XmlReader.Read();
this.ReadPayloadEnd();
return(serviceDocument);
}
public async Task WriteServiceDocumentAsync_WritesExpectedOutput(ODataServiceDocument serviceDocument, string expected)
{
var result = await SetupJsonLightServiceDocumentSerializerAndRunTestAsync(
(jsonLightServiceDocumentSerializer) =>
{
return(jsonLightServiceDocumentSerializer.WriteServiceDocumentAsync(serviceDocument));
});
Assert.Equal(expected, result);
}
public void CategoryMetadataOnWorkspaceCollectionCategoriesWriterTest()
{
var testCases = this.CreateAtomCategoryTestCases();
// Convert test cases to test descriptions
var testDescriptors = testCases.Select(testCase =>
{
AtomResourceCollectionMetadata metadata = new AtomResourceCollectionMetadata
{
Categories = new AtomCategoriesMetadata
{
Categories = new[] { testCase.Category }
}
};
ODataEntitySetInfo collection = new ODataEntitySetInfo {
Url = new Uri("http://odata.org/collection")
};
collection.SetAnnotation(metadata);
ODataServiceDocument serviceDocument = new ODataServiceDocument {
EntitySets = new[] { collection }
};
return(new PayloadWriterTestDescriptor <ODataServiceDocument>(
this.Settings,
serviceDocument,
testConfiguration =>
new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = testCase.Xml,
ExpectedException2 = testCase.ExpectedException,
FragmentExtractor = result => result
.Element(TestAtomConstants.AtomPublishingXNamespace + TestAtomConstants.AtomPublishingWorkspaceElementName)
.Element(TestAtomConstants.AtomPublishingXNamespace + TestAtomConstants.AtomPublishingCollectionElementName)
.Element(TestAtomConstants.AtomPublishingXNamespace + TestAtomConstants.AtomPublishingCategoriesElementName)
.Element(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomCategoryElementName)
}));
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.WriterTestConfigurationProvider.AtomFormatConfigurations.Where(tc => !tc.IsRequest),
(testDescriptor, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
TestWriterUtils.WriteAndVerifyTopLevelContent(
testDescriptor,
testConfiguration,
(messageWriter) => messageWriter.WriteServiceDocument(testDescriptor.PayloadItems.Single()),
this.Assert,
baselineLogger: this.Logger);
});
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The default serviceDocument to write in the service document.</param>
public void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
if (this.testConfiguration.Synchronous)
{
this.messageWriter.WriteServiceDocument(serviceDocument);
}
else
{
this.messageWriter.WriteServiceDocumentAsync(serviceDocument).Wait();
}
}
private static void WriteServiceDocumentVerifyOutput(ODataServiceDocument serviceDocument, string expectedOutput)
{
MemoryStream memoryStream = new MemoryStream();
var serializer = CreateODataJsonLightServiceDocumentSerializer(memoryStream);
serializer.WriteServiceDocument(serviceDocument);
serializer.JsonWriter.Flush();
string actualResult = Encoding.UTF8.GetString(memoryStream.ToArray());
Assert.Equal(expectedOutput, actualResult);
}
public async Task WriteServiceDocumentAsync_ThrowsException(ODataServiceDocument serviceDocument, string exceptionMessage)
{
var exception = await Assert.ThrowsAsync <ODataException>(
() => SetupJsonLightServiceDocumentSerializerAndRunTestAsync(
(jsonLightServiceDocumentSerializer) =>
{
return(jsonLightServiceDocumentSerializer.WriteServiceDocumentAsync(serviceDocument));
}));
Assert.Equal(exceptionMessage, exception.Message);
}
/// <inheritdoc/>
public override Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
ODataServiceDocument serviceDocument = GetServiceDocument(graph, type);
return(messageWriter.WriteServiceDocumentAsync(serviceDocument));
}
/// <summary>
/// Asynchronously writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
/// <returns>A task representing the asynchronous operation of writing the service document.</returns>
/// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
internal override Task WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
{
this.AssertAsynchronous();
return(TaskUtils.GetTaskForSynchronousOperationReturningTask(
() =>
{
this.WriteServiceDocumentImplementation(serviceDocument);
return this.FlushAsync();
}));
}
/// <summary>
/// Visits a serviceDocument.
/// </summary>
/// <param name="serviceDocument">The serviceDocument to visit.</param>
protected virtual void VisitServiceDocument(ODataServiceDocument serviceDocument)
{
IEnumerable <ODataEntitySetInfo> collections = serviceDocument.EntitySets;
if (collections != null)
{
foreach (ODataEntitySetInfo collection in collections)
{
this.Visit(collection);
}
}
}
public void WriteFunctionImportShouldBeWrittenCorrectly()
{
var serviceDocument = new ODataServiceDocument()
{
FunctionImports = new ODataFunctionImportInfo[] {new ODataFunctionImportInfo() { Name = "functionImport", Url = new Uri("http://service/functionimport") }}
};
// Verifying the Href and name are written in the function Import element
WriteServiceDocumentVerifyOutput(
serviceDocument,
@"<?xml version=""1.0"" encoding=""utf-8""?><service xmlns=""http://www.w3.org/2007/app"" xmlns:atom=""http://www.w3.org/2005/Atom"" xmlns:m=""http://docs.oasis-open.org/odata/ns/metadata""><workspace><atom:title type=""text"">Default</atom:title><m:function-import href=""http://service/functionimport""><atom:title type=""text"">functionImport</atom:title></m:function-import></workspace></service>");
}
public void WriteNullFunctionImportShouldThrow()
{
var functionImports = new List<ODataFunctionImportInfo>();
functionImports.Add(null);
var serviceDocument = new ODataServiceDocument()
{
FunctionImports = functionImports
};
//Note: Only testing one of three exceptions that occurs in the Validate ServiceDocumentElements because if one throws then we know that the code path is going through
// the validation method. If the validation method is changed then in the future two exception tests might be needed.
WriteServiceDocumentShouldError(serviceDocument).ShouldThrow<ODataException>().WithMessage(ODataStrings.ValidationUtils_WorkspaceResourceMustNotContainNullItem);
}
public void WriteNullFunctionImportShouldThrow()
{
var functionImports = new List <ODataFunctionImportInfo>();
functionImports.Add(null);
var serviceDocument = new ODataServiceDocument()
{
FunctionImports = functionImports
};
//Note: Only testing one of three exceptions that occurs in the Validate ServiceDocumentElements because if one throws then we know that the code path is going through
// the validation method. If the validation method is changed then in the future two exception tests might be needed.
WriteServiceDocumentShouldError(serviceDocument).Throws <ODataException>(Strings.ValidationUtils_WorkspaceResourceMustNotContainNullItem);
}
private static void WriteServiceDocumentVerifyOutput(ODataServiceDocument serviceDocument, string expectedoutput = null, IODataUrlResolver resolver = null)
{
MemoryStream memoryStream = new MemoryStream();
ODataAtomServiceDocumentSerializer serializer = CreateAtomOutputContext(memoryStream, resolver);
serializer.WriteServiceDocument(serviceDocument);
serializer.XmlWriter.Flush();
var resultsWritten = Encoding.UTF8.GetString(memoryStream.GetBuffer());
if (expectedoutput != null)
{
resultsWritten.Should().Be(expectedoutput);
}
}
/// <summary>Determines an extension method to get the <see cref="T:System.Data.OData.Atom.AtomWorkspaceMetadata" /> for an annotatable serviceDocument.</summary>
/// <returns>An <see cref="T:Microsoft.OData.Core.Atom.AtomWorkspaceMetadata" /> instance or null if no annotation of that type exists.</returns>
/// <param name="serviceDocument">The serviceDocument to get the annotation from.</param>
public static AtomWorkspaceMetadata Atom(this ODataServiceDocument serviceDocument)
{
ExceptionUtils.CheckArgumentNotNull(serviceDocument, "serviceDocument");
AtomWorkspaceMetadata workspaceMetadata = serviceDocument.GetAnnotation <AtomWorkspaceMetadata>();
if (workspaceMetadata == null)
{
workspaceMetadata = new AtomWorkspaceMetadata();
serviceDocument.SetAnnotation(workspaceMetadata);
}
return(workspaceMetadata);
}
public void PropertyGettersAndSettersTest()
{
ODataEntitySetInfo collection1 = new ODataEntitySetInfo();
ODataEntitySetInfo collection2 = new ODataEntitySetInfo();
ODataEntitySetInfo collection3 = new ODataEntitySetInfo();
ODataEntitySetInfo[] collections = new ODataEntitySetInfo[] { collection1, collection2, collection3 };
ODataServiceDocument serviceDocument = new ODataServiceDocument()
{
EntitySets = collections
};
this.Assert.AreSame(collections, serviceDocument.EntitySets, "Expected reference equal values for property 'EntitySets'.");
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The default serviceDocument to write in the service document.</param>
public void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
if (this.testConfiguration.Synchronous)
{
this.messageWriter.WriteServiceDocument(serviceDocument);
}
else
{
#if SILVERLIGHT
throw new TaupoNotSupportedException("This test is not supported in aSynchronous mode in Silverlight");
#else
this.messageWriter.WriteServiceDocumentAsync(serviceDocument).Wait();
#endif
}
}
public void EnsureNonNullODataUrlResolverExecutedWhenWritingFunctionImportInServiceDocument()
{
var serviceDocument = new ODataServiceDocument()
{
FunctionImports = new ODataFunctionImportInfo[] { new ODataFunctionImportInfo() { Name = "functionImport", Url = new Uri("http://service/functionimport") } }
};
bool invoked = false;
var resolver = new ServiceDocumentTestUrlResolver();
resolver.ResolveUrlFunc = (uri, uri1) =>
{
invoked = true;
return uri;
};
WriteServiceDocumentVerifyOutput(serviceDocument, null, resolver);
invoked.Should().BeTrue();
}
private static Action WriteServiceDocumentShouldError(ODataServiceDocument serviceDocument, IODataUrlResolver urlResolver = null)
{
MemoryStream memoryStream = new MemoryStream();
var serializer = CreateODataJsonLightServiceDocumentSerializer(memoryStream, urlResolver);
return () => serializer.WriteServiceDocument(serviceDocument);
}
private static void WriteServiceDocumentVerifyOutput(ODataServiceDocument serviceDocument, string expectedOutput)
{
MemoryStream memoryStream = new MemoryStream();
var serializer = CreateODataJsonLightServiceDocumentSerializer(memoryStream);
serializer.WriteServiceDocument(serviceDocument);
serializer.JsonWriter.Flush();
string actualResult = Encoding.UTF8.GetString(memoryStream.ToArray());
actualResult.Should().Be(expectedOutput);
}
/// <summary>
/// Writes a service document in ATOM/XML format.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
internal void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
Debug.Assert(serviceDocument != null, "serviceDocument != null");
this.WritePayloadStart();
// <app:service>
this.XmlWriter.WriteStartElement(string.Empty, AtomConstants.AtomPublishingServiceElementName, AtomConstants.AtomPublishingNamespace);
// xml:base=...
if (this.MessageWriterSettings.PayloadBaseUri != null)
{
this.XmlWriter.WriteAttributeString(AtomConstants.XmlBaseAttributeName, AtomConstants.XmlNamespace, this.MessageWriterSettings.PayloadBaseUri.AbsoluteUri);
}
// xmlns=http://www.w3.org/2007/app
this.XmlWriter.WriteAttributeString(AtomConstants.XmlnsNamespacePrefix, AtomConstants.XmlNamespacesNamespace, AtomConstants.AtomPublishingNamespace);
// xmlns:atom="http://www.w3.org/2005/Atom"
this.XmlWriter.WriteAttributeString(
AtomConstants.NonEmptyAtomNamespacePrefix,
AtomConstants.XmlNamespacesNamespace,
AtomConstants.AtomNamespace);
this.XmlWriter.WriteAttributeString(
AtomConstants.ODataMetadataNamespacePrefix,
AtomConstants.XmlNamespacesNamespace,
AtomConstants.ODataMetadataNamespace);
// metadata:context=...
this.WriteContextUriProperty(this.contextUriBuilder.BuildContextUri(ODataPayloadKind.ServiceDocument));
// <app:serviceDocument>
this.XmlWriter.WriteStartElement(string.Empty, AtomConstants.AtomPublishingWorkspaceElementName, AtomConstants.AtomPublishingNamespace);
this.atomServiceDocumentMetadataSerializer.WriteServiceDocumentMetadata(serviceDocument);
if (serviceDocument.EntitySets != null)
{
foreach (ODataEntitySetInfo collectionInfo in serviceDocument.EntitySets)
{
this.WriteEntitySetInfo(collectionInfo);
}
}
if (serviceDocument.Singletons != null)
{
foreach (ODataSingletonInfo singletonInfo in serviceDocument.Singletons)
{
this.WriteSingletonInfo(singletonInfo);
}
}
HashSet<string> functionImportsWritten = new HashSet<string>(StringComparer.Ordinal);
if (serviceDocument.FunctionImports != null)
{
foreach (ODataFunctionImportInfo functionImportInfo in serviceDocument.FunctionImports)
{
if (functionImportInfo == null)
{
throw new ODataException(Strings.ValidationUtils_WorkspaceResourceMustNotContainNullItem);
}
if (!functionImportsWritten.Contains(functionImportInfo.Name))
{
functionImportsWritten.Add(functionImportInfo.Name);
this.WriteFunctionImportInfo(functionImportInfo);
}
}
}
// </app:serviceDocument>
this.XmlWriter.WriteEndElement();
// </app:service>
this.XmlWriter.WriteEndElement();
this.WritePayloadEnd();
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service dcument to write.</param>
/// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks>
internal override void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
this.AssertSynchronous();
this.WriteServiceDocumentImplementation(serviceDocument);
this.Flush();
}
/// <summary>
/// Writes a service document in JsonLight format.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
internal void WriteServiceDocument(ODataServiceDocument serviceDocument)
{
Debug.Assert(serviceDocument != null, "serviceDocument != null");
this.WriteTopLevelPayload(
() =>
{
// "{"
this.JsonWriter.StartObjectScope();
// "@odata.context":...
this.WriteContextUriProperty(ODataPayloadKind.ServiceDocument);
// "value":
this.JsonWriter.WriteValuePropertyName();
// "["
this.JsonWriter.StartArrayScope();
if (serviceDocument.EntitySets != null)
{
foreach (ODataEntitySetInfo collectionInfo in serviceDocument.EntitySets)
{
this.WriteServiceDocumentElement(collectionInfo, JsonLightConstants.ServiceDocumentEntitySetKindName);
}
}
if (serviceDocument.Singletons != null)
{
foreach (ODataSingletonInfo singletonInfo in serviceDocument.Singletons)
{
this.WriteServiceDocumentElement(singletonInfo, JsonLightConstants.ServiceDocumentSingletonKindName);
}
}
HashSet<string> functionImportsWritten = new HashSet<string>(StringComparer.Ordinal);
if (serviceDocument.FunctionImports != null)
{
foreach (ODataFunctionImportInfo functionImportInfo in serviceDocument.FunctionImports)
{
if (functionImportInfo == null)
{
throw new ODataException(Strings.ValidationUtils_WorkspaceResourceMustNotContainNullItem);
}
if (!functionImportsWritten.Contains(functionImportInfo.Name))
{
functionImportsWritten.Add(functionImportInfo.Name);
this.WriteServiceDocumentElement(functionImportInfo, JsonLightConstants.ServiceDocumentFunctionImportKindName);
}
}
}
// "]"
this.JsonWriter.EndArrayScope();
// "}"
this.JsonWriter.EndObjectScope();
});
}
/// <summary>
/// Asynchronously writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
/// <returns>A task representing the asynchronous operation of writing the service document.</returns>
/// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
internal override Task WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
{
this.AssertAsynchronous();
return TaskUtils.GetTaskForSynchronousOperationReturningTask(
() =>
{
this.WriteServiceDocumentImplementation(serviceDocument);
return this.FlushAsync();
});
}
private static void WriteServiceDocumentVerifyOutput(ODataServiceDocument serviceDocument, string expectedoutput = null, IODataUrlResolver resolver = null)
{
MemoryStream memoryStream = new MemoryStream();
ODataAtomServiceDocumentSerializer serializer = CreateAtomOutputContext(memoryStream, resolver);
serializer.WriteServiceDocument(serviceDocument);
serializer.XmlWriter.Flush();
var resultsWritten = Encoding.UTF8.GetString(memoryStream.GetBuffer());
if (expectedoutput != null)
{
resultsWritten.Should().Be(expectedoutput);
}
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
private void WriteServiceDocumentImplementation(ODataServiceDocument serviceDocument)
{
ODataAtomServiceDocumentSerializer atomServiceDocumentSerializer = new ODataAtomServiceDocumentSerializer(this);
atomServiceDocumentSerializer.WriteServiceDocument(serviceDocument);
}
public void ServiceDocument()
{
foreach (ODataFormat mimeType in mimeTypes)
{
string payload, contentType;
this.WriteAndValidateContextUri(mimeType, model, omWriter =>
{
ODataServiceDocument serviceDocument = new ODataServiceDocument();
serviceDocument.EntitySets = new ODataEntitySetInfo[] { new ODataEntitySetInfo { Name = "People", Url = new Uri(TestBaseUri + "People") } };
omWriter.WriteServiceDocument(serviceDocument);
}, string.Format("\"{0}$metadata\"", TestBaseUri), out payload, out contentType);
this.ReadPayload(payload, contentType, model, omReader => omReader.ReadServiceDocument());
}
}
private static Action WriteServiceDocumentShouldError(ODataServiceDocument serviceDocument, IODataUrlResolver resolver = null)
{
MemoryStream memoryStream = new MemoryStream();
ODataAtomServiceDocumentSerializer serializer = CreateAtomOutputContext(memoryStream, resolver);
return new Action(() => serializer.WriteServiceDocument(serviceDocument));
}
/// <summary>
/// Writes a service document with the specified <paramref name="serviceDocument"/>
/// as message payload.
/// </summary>
/// <param name="serviceDocument">The service document to write.</param>
private void WriteServiceDocumentImplementation(ODataServiceDocument serviceDocument)
{
ODataJsonLightServiceDocumentSerializer jsonLightServiceDocumentSerializer = new ODataJsonLightServiceDocumentSerializer(this);
jsonLightServiceDocumentSerializer.WriteServiceDocument(serviceDocument);
}
private void TestEntitySetInServiceDocument(ODataServiceDocument serviceDocument)
{
serviceDocument.EntitySets.Should().NotBeNull();
var entitySets = serviceDocument.EntitySets.ToList();
entitySets.Count.Should().Be(1);
entitySets[0].Name.Should().Be("entityset");
entitySets[0].Url.ToString().Should().Be("http://service/entityset");
}
public void ShouldWriteServiceDocumentAsyncWithoutModel()
{
ODataServiceDocument serviceDocument = new ODataServiceDocument();
serviceDocument.EntitySets = new ODataEntitySetInfo[] { new ODataEntitySetInfo { Name = "Customers", Url = new Uri("http://host/Customers") } };
WriteAndValidate(outputContext => outputContext.WriteServiceDocumentAsync(serviceDocument).Wait(), "{\"@odata.context\":\"http://odata.org/test/$metadata\",\"value\":[{\"name\":\"Customers\",\"kind\":\"EntitySet\",\"url\":\"http://host/Customers\"}]}", writingResponse: true, synchronous: false);
}
