private void VerifyStream(AstoriaQueryStreamValue streamValue, string contentType, ODataRequest request, ODataResponse response) { this.AssertAreEqual(contentType, streamValue.ContentType, "Stream content type did not match", request, response); var expectedPayload = (byte[])((PrimitiveValue)request.Body.RootElement).ClrValue; this.AssertAreEqual(expectedPayload, streamValue.Value, "Stream content did not match", request, response); }
private static void InitMemberStreamTypes(QueryEntityType type, QueryStructuralValue structural) { // initialize named streams foreach (var namedStream in type.Properties.Streams()) { AstoriaQueryStreamValue qsv = new AstoriaQueryStreamValue((AstoriaQueryStreamType)namedStream.PropertyType, (byte[])null, null, type.EvaluationStrategy); structural.SetStreamValue(namedStream.Name, qsv); } }
private static void UpdateStreamValueFromHeaders(AstoriaQueryStreamValue expectedStreamValue, DataServiceStreamResponse response) { expectedStreamValue.ContentType = response.Headers[HttpHeaders.ContentType]; string etag; response.Headers.TryGetValue(HttpHeaders.ETag, out etag); expectedStreamValue.ETag = etag; }
private static Uri GetExpectedReadStreamUri(AstoriaQueryStreamValue expectedStreamValue) { var expectedReadStreamUri = expectedStreamValue.SelfLink; if (expectedReadStreamUri == null) { expectedReadStreamUri = expectedStreamValue.EditLink; } return(expectedReadStreamUri); }
/// <summary> /// Initializes the given query type by creating a queryStreamValue to hold the expected values /// </summary> /// <param name="queryType">A QueryEntityType</param> /// <returns>a QueryStructurvalValue</returns> protected override QueryStructuralValue InitializeEntityValue(QueryEntityType queryType) { var entity = base.InitializeEntityValue(queryType); foreach (var namedStream in queryType.Properties.Streams()) { AstoriaQueryStreamValue qsv = new AstoriaQueryStreamValue((AstoriaQueryStreamType)namedStream.PropertyType, (byte[])null, null, queryType.EvaluationStrategy); entity.SetStreamValue(namedStream.Name, qsv); } return entity; }
/// <summary> /// Initializes the given query type by creating a queryStreamValue to hold the expected values /// </summary> /// <param name="queryType">A QueryEntityType</param> /// <returns>a QueryStructurvalValue</returns> protected override QueryStructuralValue InitializeEntityValue(QueryEntityType queryType) { var entity = base.InitializeEntityValue(queryType); foreach (var namedStream in queryType.Properties.Streams()) { AstoriaQueryStreamValue qsv = new AstoriaQueryStreamValue((AstoriaQueryStreamType)namedStream.PropertyType, (byte[])null, null, queryType.EvaluationStrategy); entity.SetStreamValue(namedStream.Name, qsv); } return(entity); }
/// <summary> /// Gets the expected etag for the stream value, taking into account that empty etags become null /// </summary> /// <param name="streamValue">The stream value to get the expected etag for</param> /// <returns>The expected etag</returns> internal static string GetExpectedETag(this AstoriaQueryStreamValue streamValue) { ExceptionUtilities.CheckArgumentNotNull(streamValue, "streamValue"); // empty stream etags are not written out var streamETag = streamValue.ETag; if (string.IsNullOrEmpty(streamETag)) { streamETag = null; } return(streamETag); }
/// <summary> /// Compares properties of a structural object with expected value. Overridden here to handle named streams. /// </summary> /// <param name="structuralValue">The structural object containing the property to compare</param> /// <param name="expectedName">The name of the property to compare</param> /// <param name="expectedPropertyType">The expected type of the property</param> /// <param name="actualValue">The actual value of the property</param> /// <param name="path">The path to the compared object (for debugging purposes)</param> /// <param name="shouldThrow">Should exception be thrown if error is encountered</param> /// <returns>The comparison result</returns> protected override ComparisonResult CompareProperty(QueryStructuralValue structuralValue, string expectedName, QueryType expectedPropertyType, object actualValue, string path, bool shouldThrow) { if (this.CodeGenerator.GetType() == typeof(RemoteClientCodeLayerGenerator)) { if (structuralValue.GetValue(expectedName).IsNull&& expectedPropertyType is QueryComplexType) { return(ComparisonResult.Success); } } if (expectedPropertyType is AstoriaQueryStreamType) { #if WINDOWS_PHONE return(ComparisonResult.Success); #else DataServiceStreamLink actualStreamLink = (DataServiceStreamLink)actualValue; AstoriaQueryStreamValue expectedStreamValue = (AstoriaQueryStreamValue)structuralValue.GetStreamValue(expectedName); if (actualStreamLink == null) { if (!expectedStreamValue.IsNull) { this.ThrowOrLogError(shouldThrow, "Expected DataServiceStreamLink property to be null. Actual: {0}", actualStreamLink); return(ComparisonResult.Failure); } else { return(ComparisonResult.Success); } } try { this.VerifyStreamLink(expectedStreamValue, actualStreamLink); return(ComparisonResult.Success); } catch (TestFailedException e) { this.ThrowOrLogError(shouldThrow, e.ToString()); return(ComparisonResult.Failure); } #endif } else { return(base.CompareProperty(structuralValue, expectedName, expectedPropertyType, actualValue, path, shouldThrow)); } }
/// <summary> /// Creates a copy of the given value recursively /// </summary> /// <param name="value">The value to copy</param> /// <returns>The copied value</returns> public QueryValue Visit(AstoriaQueryStreamValue value) { ExceptionUtilities.CheckArgumentNotNull(value, "value"); if (value.EvaluationError != null) { return(value.Type.CreateErrorValue(value.EvaluationError)); } if (value.IsNull) { return(value.Type.NullValue); } return(value.Type.CreateValue(value.Value, value.ContentType, value.ETag, value.EditLink, value.SelfLink)); }
/// <summary> /// Verifies the streams data. /// </summary> /// <param name="expectedStreamValue">The expected stream value.</param> /// <param name="response">The stream response.</param> /// <returns>The result of stream verification</returns> protected bool VerifyStreams(AstoriaQueryStreamValue expectedStreamValue, DataServiceStreamResponse response) { var expectedBytes = new byte[0]; if (!expectedStreamValue.IsNull) { expectedBytes = expectedStreamValue.Value; } var expectedStream = new MemoryStream(expectedBytes); try { ExceptionUtilities.Assert(response.Stream.CanRead, "Cannot read from the stream"); return(StreamHelpers.CompareStream(response.Stream, expectedStream)); } finally { response.Stream.Dispose(); expectedStream.Dispose(); } }
private void VerifyStreamDescriptorValues(AstoriaQueryStreamValue expected, string name, string contentType, string etag, Uri editLink, Uri selfLink) { if (!this.SkipStreamDescriptorValuesVerification) { string message; if (name == null) { message = "default stream"; } else { message = "named stream " + name; } if (name != null) { this.Assert.AreEqual(expected.ContentType, contentType, "Content type did not match for {0}", message); } this.Assert.AreEqual(expected.GetExpectedETag(), etag, "ETag did not match for {0}", message); this.Assert.AreEqual(expected.EditLink, editLink, "Edit link did not match for {0}", message); this.Assert.AreEqual(expected.SelfLink, selfLink, "Self link did not match for {0}", message); } }
private void VerifyStreamLink(AstoriaQueryStreamValue expected, DataServiceStreamLink actual) { this.VerifyStreamDescriptorValues(expected, actual.Name, actual.ContentType, actual.ETag, actual.EditLink, actual.SelfLink); }
private void CompareStreamETag(AstoriaQueryStreamValue queryStreamValue, string actualETag) { this.parent.Assert.AreEqual(queryStreamValue.GetExpectedETag(), actualETag, "ETag did not match"); }
public static void SetStreamValue(this QueryStructuralValue instance, string namedStream, AstoriaQueryStreamValue value) { ExceptionUtilities.CheckArgumentNotNull(instance, "instance"); ExceptionUtilities.CheckStringArgumentIsNotNullOrEmpty(namedStream, "namedStream"); instance.AssertPropertyType <AstoriaQueryStreamType>(namedStream); instance.SetValue(namedStream, value); }
public static void SetDefaultStreamValue(this QueryStructuralValue instance, AstoriaQueryStreamValue value) { ExceptionUtilities.CheckArgumentNotNull(instance, "instance"); instance.SetStreamValue(AstoriaQueryStreamType.DefaultStreamPropertyName, value); }