private string GetAtom(ODataOperation operation)
{
StringBuilder sb = new StringBuilder();
if (operation is ODataAction)
{
sb.Append("<action");
}
else if (operation is ODataFunction)
{
sb.Append("<function");
}
else { throw new ArgumentException(); }
sb.Append(" metadata=\"");
sb.Append(TestUriUtils.ToEscapedUriString(operation.Metadata));
sb.Append("\" title=\"");
sb.Append(operation.Title);
sb.Append("\" target=\"");
sb.Append(operation.Target.OriginalString);
sb.Append("\" xmlns=\"");
sb.Append(TestAtomConstants.ODataMetadataNamespace);
sb.Append("\" />");
return sb.ToString();
}
/// <summary>
/// Validates an <see cref="ODataOperation"/> to ensure its target is specified and valid.
/// </summary>
/// <param name="operation">The operation to validate.</param>
internal static void ValidateOperationTargetNotNull(ODataOperation operation)
{
Debug.Assert(operation != null, "operation != null");
// ODataOperation must have a Target property.
if (operation.Target == null)
{
throw new ODataException(Strings.ValidationUtils_ActionsAndFunctionsMustSpecifyTarget(operation.GetType().Name));
}
}
private void MakeOperationTargetRelativeFromMetadataUriIfJsonLight(ODataOperation operation)
{
Debug.Assert(operation != null, "operation != null");
Uri targetLink = operation.Target;
if (this.format == ODataFormat.Json && targetLink != null && targetLink.IsAbsoluteUri && this.metadataUri.IsBaseOf(targetLink))
{
operation.Target = this.metadataUri.MakeRelativeUri(targetLink);
}
}
private static void AssertEqual(ODataOperation expected, ODataOperation actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
AssertEqual(expected.Metadata, actual.Metadata);
AssertEqual(expected.Target, actual.Target);
Assert.Equal(expected.Title, actual.Title);
}
/// <summary>
/// Validates an <see cref="ODataOperation"/> to ensure it's not null.
/// </summary>
/// <param name="operation">The operation to ensure it's not null.</param>
/// <param name="isAction">Whether <paramref name="operation"/> is an <see cref="ODataAction"/>.</param>
internal static void ValidateOperationNotNull(ODataOperation operation, bool isAction)
{
// null action/function can not appear in the enumeration
if (operation == null)
{
string enumerableName = isAction ? "ODataEntry.Actions" : "ODataEntry.Functions";
throw new ODataException(Strings.ValidationUtils_EnumerableContainsANullItem(enumerableName));
}
}
internal static void EmitTitle(IEdmModel model, IEdmOperation operation, ODataOperation odataAction)
{
// The title should only be emitted in full metadata.
OperationTitleAnnotation titleAnnotation = model.GetOperationTitleAnnotation(operation);
if (titleAnnotation != null)
{
odataAction.Title = titleAnnotation.Title;
}
else
{
odataAction.Title = operation.Name;
}
}
public void ShouldWriteOneActionWithTitleAndTarget()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Title = "foo", Target = new Uri("http://www.example.com/foo") } };
const string expectedPayload = "{\"#foo\":{\"title\":\"foo\",\"target\":\"http://www.example.com/foo\"}}";
this.WriteOperationsAndValidatePayload(operations, expectedPayload);
}
public void ShouldWriteAbsoluteActionTargetOnWireWhenMetadataDocumentUriIsSetButMetadataAnnotationIsNotWritten()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("foo", UriKind.Relative) } };
const string expectedPayload = "{\"#foo\":{\"target\":\"http://odata.org/test/foo\"}}";
this.WriteOperationsAndValidatePayload(operations, expectedPayload, /*isAction*/ true, true /*setMetadataDocumentUri*/, false /*writeMetadataAnnotation*/);
}
public void ShouldWriteOneActionWithNoTitleNoTarget()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative) } };
const string expectedPayload = "{\"#foo\":{}}";
this.WriteOperationsAndValidatePayload(operations, expectedPayload);
}
public void ShouldWriteTwoActionsWithTwoBindingTargetsEach()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Title = "foo", Target = new Uri("http://www.example.com/1/foo") }, new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("http://www.example.com/2/foo") }, new ODataAction { Metadata = new Uri("#baz", UriKind.Relative), Title = "baz", Target = new Uri("http://www.example.com/1/baz") }, new ODataAction { Metadata = new Uri("#baz", UriKind.Relative), Target = new Uri("http://www.example.com/2/baz") } };
const string expectedPayload = "{\"#foo\":[{\"title\":\"foo\",\"target\":\"http://www.example.com/1/foo\"},{\"target\":\"http://www.example.com/2/foo\"}],\"#baz\":[{\"title\":\"baz\",\"target\":\"http://www.example.com/1/baz\"},{\"target\":\"http://www.example.com/2/baz\"}]}";
this.WriteOperationsAndValidatePayload(operations, expectedPayload);
}
public void ShouldThrowWhenWritingRelativeActionsTargetWhenMetadataDocumentUriIsNotSet()
{
IEnumerable<ODataOperation> operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("foo", UriKind.Relative) } };
Action test = () => this.WriteOperationsAndValidatePayload(operations, null, true, false /*setMetadataDocumentUri*/);
test.ShouldThrow<ODataException>().WithMessage(ErrorStrings.ODataOutputContext_MetadataDocumentUriMissing);
}
public void ShouldWriteOneActionWithTwoBindingTargets()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("http://www.example.com/foo") }, new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("http://www.example.com/baz/foo") } };
const string expectedPayload = "{\"#foo\":[{\"target\":\"http://www.example.com/foo\"},{\"target\":\"http://www.example.com/baz/foo\"}]}";
this.WriteOperationsAndValidatePayload(operations, expectedPayload);
}
public void ShouldThrowWhenWritingTwoActionsWithSameMetadataAndSameTargets()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("http://www.example.com/foo") }, new ODataAction { Metadata = new Uri("#foo", UriKind.Relative), Target = new Uri("http://www.example.com/foo") } };
Action test = () => this.WriteOperationsAndValidatePayload(operations, null);
test.ShouldThrow<ODataException>().WithMessage(ErrorStrings.ODataJsonLightEntryAndFeedSerializer_ActionsAndFunctionsGroupMustNotHaveDuplicateTarget("#foo", "http://www.example.com/foo"));
}
public void ShouldThrowWhenWritingTwoActionsWithSameMetadataAndTwoNullTargets()
{
var operations = new ODataOperation[] { new ODataAction { Metadata = new Uri("#foo", UriKind.Relative) }, new ODataAction { Metadata = new Uri("#foo", UriKind.Relative) } };
Action test = () => this.WriteOperationsAndValidatePayload(operations, null);
test.ShouldThrow<ODataException>().WithMessage(ErrorStrings.ODataJsonLightEntryAndFeedSerializer_ActionsAndFunctionsGroupMustSpecifyTarget("#foo"));
}
/// <summary>
/// Visits an ODataOperation.
/// </summary>
/// <param name="operation">The operation to visit.</param>
protected override void VisitODataOperation(ODataOperation operation)
{
this.ValidateUri(operation.Target);
base.VisitODataOperation(operation);
}
/// <summary>
/// Visits an ODataOperation.
/// </summary>
/// <param name="operation">The operation to visit.</param>
protected virtual void VisitODataOperation(ODataOperation operation)
{
}
/// <summary>
/// Validates that an <see cref="ODataOperation"/> can be written.
/// </summary>
/// <param name="operation">The operation (an action or a function) to validate.</param>
/// <param name="writingResponse">true if writing a response; otherwise false.</param>
internal static void ValidateCanWriteOperation(ODataOperation operation, bool writingResponse)
{
Debug.Assert(operation != null, "operation != null");
// Operations are only valid in responses; we fail on them in requests
if (!writingResponse)
{
throw new ODataException(Strings.WriterValidationUtils_OperationInRequest(operation.Metadata));
}
}
/// <summary>
/// Validates that an <see cref="ODataOperation"/> can be written.
/// </summary>
/// <param name="operation">The operation (an action or a function) to validate.</param>
/// <param name="writingResponse">true if writing a response; otherwise false.</param>
public void ValidateCanWriteOperation(ODataOperation operation, bool writingResponse)
{
}
/// <summary>
/// Validates that an <see cref="ODataOperation"/> can be written.
/// </summary>
/// <param name="operation">The operation (an action or a function) to validate.</param>
/// <param name="writingResponse">true if writing a response; otherwise false.</param>
public void ValidateCanWriteOperation(ODataOperation operation, bool writingResponse)
{
}
/// <summary>
/// Validates that an <see cref="ODataOperation"/> can be written.
/// </summary>
/// <param name="operation">The operation (an action or a function) to validate.</param>
/// <param name="writingResponse">true if writing a response; otherwise false.</param>
public void ValidateCanWriteOperation(ODataOperation operation, bool writingResponse)
{
WriterValidationUtils.ValidateCanWriteOperation(operation, writingResponse);
}
