public void accept___assignment_standard_orders_byquality() { var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5"; AcceptHeader header = value; header.Should().NotBeNull(); header.Value.Should().Be(value); header.Values.Should().NotBeNull(); header.Values.Should().HaveCount(4); header.Values[0].MediaType.Should().Be("text/xml"); header.Values[0].Type.Should().Be("text"); header.Values[0].SubType.Should().Be("xml"); header.Values[0].Quality.Should().Be(1f); header.Values[1].MediaType.Should().Be("text/plain"); header.Values[1].Type.Should().Be("text"); header.Values[1].SubType.Should().Be("plain"); header.Values[1].Quality.Should().Be(0.7f); header.Values[2].MediaType.Should().Be("*/*"); header.Values[2].Type.Should().Be("*"); header.Values[2].SubType.Should().Be("*"); header.Values[2].Quality.Should().Be(0.5f); header.Values[3].MediaType.Should().Be("text/json"); header.Values[3].Type.Should().Be("text"); header.Values[3].SubType.Should().Be("json"); header.Values[3].Quality.Should().Be(0.1f); }
/// <summary>Gets the acceptable formatter.</summary> /// <param name="acceptHeader">The accept header.</param> /// <param name="objType">Type of the object.</param> /// <param name="formatterType">Type of the formatter.</param> /// <param name="writeableFormatters">The overriding formatters.</param> /// <param name="writeableMediaTypes">The writeable media types.</param> /// <returns></returns> public virtual Task <IDeepSleepMediaSerializer> GetAcceptableFormatter( AcceptHeader acceptHeader, Type objType, out string formatterType, IList <IDeepSleepMediaSerializer> writeableFormatters = null, IList <string> writeableMediaTypes = null) { formatterType = string.Empty; IDeepSleepMediaSerializer formatter = null; foreach (var mediaHeader in acceptHeader.Values.Where(m => m.Quality > 0)) { formatter = this.Get( contentType: $"{mediaHeader.Type}/{mediaHeader.SubType}", objType: objType, parameters: mediaHeader.ParameterString(), forRead: false, overridingFormatters: writeableFormatters, overridingMediaTypes: writeableMediaTypes, formatterType: out formatterType); if (formatter != null) { break; } } return(Task.FromResult(formatter)); }
public void accept___assignment_qualities_modified_when_outofrange() { var value = "text/json;q=-1, text/xml; q=1.1, text/plain; q=0.7, */*; q=0.5"; AcceptHeader header = value; header.Should().NotBeNull(); header.Value.Should().Be(value); header.Values.Should().NotBeNull(); header.Values.Should().HaveCount(4); header.Values[0].MediaType.Should().Be("text/xml"); header.Values[0].Type.Should().Be("text"); header.Values[0].SubType.Should().Be("xml"); header.Values[0].Quality.Should().Be(1f); header.Values[1].MediaType.Should().Be("text/plain"); header.Values[1].Type.Should().Be("text"); header.Values[1].SubType.Should().Be("plain"); header.Values[1].Quality.Should().Be(0.7f); header.Values[2].MediaType.Should().Be("*/*"); header.Values[2].Type.Should().Be("*"); header.Values[2].SubType.Should().Be("*"); header.Values[2].Quality.Should().Be(0.5f); header.Values[3].MediaType.Should().Be("text/json"); header.Values[3].Type.Should().Be("text"); header.Values[3].SubType.Should().Be("json"); header.Values[3].Quality.Should().Be(0f); }
public void accept___assignment_charsets_quality_set_to_0_when_quality_invalid() { var value = "text/json;q=0.1, text/xml; q=ABC, text/plain; q=0.7, */*; q=0.5"; AcceptHeader header = value; header.Should().NotBeNull(); header.Value.Should().Be(value); header.Values.Should().NotBeNull(); header.Values.Should().HaveCount(4); header.Values[0].MediaType.Should().Be("text/plain"); header.Values[0].Type.Should().Be("text"); header.Values[0].SubType.Should().Be("plain"); header.Values[0].Quality.Should().Be(0.7f); header.Values[1].MediaType.Should().Be("*/*"); header.Values[1].Type.Should().Be("*"); header.Values[1].SubType.Should().Be("*"); header.Values[1].Quality.Should().Be(0.5f); header.Values[2].MediaType.Should().Be("text/json"); header.Values[2].Type.Should().Be("text"); header.Values[2].SubType.Should().Be("json"); header.Values[2].Quality.Should().Be(0.1f); header.Values[3].MediaType.Should().Be("text/xml"); header.Values[3].Type.Should().Be("text"); header.Values[3].SubType.Should().Be("xml"); header.Values[3].Quality.Should().Be(0f); }
public bool IsAcceptable(AcceptHeader acceptHeader, out string transferSyntax) { transferSyntax = null; // Check if payload type match if ((PayloadType & acceptHeader.PayloadType) == PayloadTypes.None) { return(false); } if (!StringSegment.Equals(acceptHeader.MediaType, MediaType, StringComparison.InvariantCultureIgnoreCase)) { return(false); } if (StringSegment.IsNullOrEmpty(acceptHeader.TransferSyntax)) { if (IsTransferSyntaxMandatory) { return(false); } // when transfer syntax is missed from accept header, use default one transferSyntax = TransferSyntaxWhenMissing; return(true); } if (AcceptableTransferSyntaxes.Contains(acceptHeader.TransferSyntax.Value)) { transferSyntax = acceptHeader.TransferSyntax.Value; return(true); } return(false); }
public void GivenNoMatchedAcceptHeaders_WhenGetTransferSyntax_ThenShouldThrowNotAcceptableException() { // Use content type that GetStudy doesn't support AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeaderForGetStudy(mediaType: KnownContentTypes.ImageJpeg); AcceptHeaderDescriptor acceptHeaderDescriptor; Assert.ThrowsAny <NotAcceptableException>(() => _handler.GetTransferSyntax(ResourceType.Study, new[] { acceptHeader }, out acceptHeaderDescriptor)); }
public void WhenConstructedSetsTheValueProperty() { string expectedValue = "application/json"; var header = new AcceptHeader(expectedValue); header.Value.Should().Be(expectedValue); }
public void GivenMultipleAcceptHeaders_WhenGetTransferSyntax_ThenShouldThrowNotAcceptableException() { AcceptHeader acceptHeader1 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.5, transferSyntax: DicomTransferSyntaxUids.Original); AcceptHeader acceptHeader2 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.9, transferSyntax: DicomTransferSyntaxUids.Original); AcceptHeaderDescriptor acceptHeaderDescriptor; Assert.ThrowsAny <NotAcceptableException>(() => _handler.GetTransferSyntax(ResourceType.Study, new[] { acceptHeader1, acceptHeader2 }, out acceptHeaderDescriptor)); }
public void GivenDescriptorsIsNotNull_WhenConstructAcceptHeaderDescriptors_ThenShouldSucceed() { AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(); AcceptHeaderDescriptor descriptor = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: true); AcceptHeaderDescriptors descriptors = new AcceptHeaderDescriptors(descriptor); Assert.Single(descriptors.Descriptors); Assert.Same(descriptor, descriptors.Descriptors.First()); }
public void accept___equals_overload_not_string_or_equivelent_sccess() { AcceptHeader header1 = "en-us;"; var other = 2; var equals = header1.Equals(other); equals.Should().BeFalse(); }
public void accept___equals_overload_null_sccess() { AcceptHeader header1 = "en-us;"; AcceptHeader header2 = null; var equals = header1.Equals(header2); equals.Should().BeFalse(); }
public void GivenMediaType_WhenCheckIsAcceptable_ShouldSucceed(string descriptorMediaType, string acceptHeaderMediaType, bool isAcceptable) { (AcceptHeader, AcceptHeaderDescriptor)testData = CreateAcceptHeaderAndDescriptorForMediaType(descriptorMediaType, acceptHeaderMediaType); string transferSyntax; AcceptHeader acceptHeader = testData.Item1; AcceptHeaderDescriptor descriptor = testData.Item2; Assert.Equal(isAcceptable, descriptor.IsAcceptable(acceptHeader, out transferSyntax)); }
public void accept___ctor_basic_returns_type(string value, int expectedCount) { var header = new AcceptHeader($"{value}"); header.Should().NotBeNull(); header.Value.Should().Be(value); header.Values.Should().NotBeNull(); header.Values.Should().HaveCount(expectedCount); }
public void accept___ctor_returns_default_for_null_or_whitespace(string value) { var header = new AcceptHeader(value); header.Should().NotBeNull(); header.Value.Should().Be(value); header.Values.Should().NotBeNull(); header.Values.Should().BeEmpty(); }
public void accept___gethashcode_success() { AcceptHeader header = "en-us;"; header.Should().NotBeNull(); var hashCode = header.GetHashCode(); hashCode.Should().NotBe(0); }
public void GivenValidInput_WhenToString_ThenShouldReturnExpectedContent() { StringSegment mediaType = KnownContentTypes.ApplicationDicom; PayloadTypes payloadType = PayloadTypes.MultipartRelated; StringSegment transferSytnax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID; double quality = 0.5; AcceptHeader header = new AcceptHeader(mediaType, payloadType, transferSytnax, quality); Assert.Equal($"MediaType:'{mediaType}', PayloadType:'{payloadType}', TransferSyntax:'{transferSytnax}', Quality:'{quality}'", header.ToString()); }
public void accept___notequals_operator_header_success(string encoding) { var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5, text/*"; var header1 = new AcceptHeader(encoding); var header2 = new AcceptHeader(value); var equals = header1 != header2; equals.Should().Be(true); }
public void GivenAcceptHeaders_WhenNoMatch_ThenShouldReturnFalse() { AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(); AcceptHeaderDescriptor notMatchDescriptor1 = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: false); AcceptHeaderDescriptor notMatchDescriptor2 = AcceptHeaderDescriptorHelpers.CreateAcceptHeaderDescriptor(acceptHeader, match: false); AcceptHeaderDescriptors acceptHeaderDescriptors = new AcceptHeaderDescriptors(notMatchDescriptor1, notMatchDescriptor2); AcceptHeaderDescriptor result; string transferSyntax; Assert.False(acceptHeaderDescriptors.TryGetMatchedDescriptor(acceptHeader, out result, out transferSyntax)); }
public void GivenMultipleMatchedAcceptHeadersWithDifferentQuality_WhenGetTransferSyntax_ThenShouldReturnLargestQuality() { string expectedTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID; AcceptHeader acceptHeader1 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.5, transferSyntax: DicomTransferSyntaxUids.Original); AcceptHeader acceptHeader2 = AcceptHeaderHelpers.CreateAcceptHeaderForGetFrame(quality: 0.9, transferSyntax: expectedTransferSyntax); AcceptHeaderDescriptor acceptHeaderDescriptor; string transferSyntax = _handler.GetTransferSyntax(ResourceType.Frames, new[] { acceptHeader1, acceptHeader2 }, out acceptHeaderDescriptor); Assert.Equal(expectedTransferSyntax, transferSyntax); Assert.Equal(acceptHeader2.MediaType, acceptHeaderDescriptor.MediaType); }
public static AcceptHeaderDescriptor CreateAcceptHeaderDescriptor(AcceptHeader acceptHeader, bool match = true) { return(new AcceptHeaderDescriptor( payloadType: acceptHeader.PayloadType, mediaType: acceptHeader.MediaType.Value, isTransferSyntaxMandatory: true, transferSyntaxWhenMissing: string.Empty, acceptableTransferSyntaxes: match ? new HashSet <string>() { acceptHeader.TransferSyntax.Value } : new HashSet <string>())); }
public void GivenValidInput_WhenConstructAcceptHeader_ThenShouldSucceed() { StringSegment mediaType = KnownContentTypes.ApplicationDicom; PayloadTypes payloadType = PayloadTypes.MultipartRelated; StringSegment transferSytnax = DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID; double quality = 0.5; AcceptHeader header = new AcceptHeader(mediaType, payloadType, transferSytnax, quality); Assert.Equal(mediaType, header.MediaType); Assert.Equal(payloadType, header.PayloadType); Assert.Equal(transferSytnax, header.TransferSyntax); Assert.Equal(quality, header.Quality); }
public void accept___equals_operator_string_success(string encoding) { var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5"; var header = new AcceptHeader(encoding); var equals = header == value; equals.Should().Be(true); equals = value == header; equals.Should().Be(true); }
public void GivenSinglePartHeader_WhenGetAcceptHeader_ShouldSucceed() { string mediaType = KnownContentTypes.ApplicationDicom; string transferSyntax = DicomTransferSyntaxUids.Original; double quality = 0.9; MediaTypeHeaderValue headerValue = CreateMediaTypeHeaderValue(mediaType, string.Empty, transferSyntax, quality); AcceptHeader acceptHeader = headerValue.ToAcceptHeader(); Assert.Equal(PayloadTypes.SinglePart, acceptHeader.PayloadType); Assert.Equal(mediaType, acceptHeader.MediaType); Assert.Equal(transferSyntax, acceptHeader.TransferSyntax); Assert.Equal(quality, acceptHeader.Quality); }
public void accept___equals_override_success(string encoding) { var value = "text/json;q=0.1, text/xml; q=1, text/plain; q=0.7, */*; q=0.5"; var header = new AcceptHeader(encoding); var equals = header.Equals(value); equals.Should().Be(true); equals = header.Equals(new AcceptHeader(value)); equals.Should().Be(true); }
public void GivenTransferSyntaxMandatory_WhenCheckIsAcceptable_ShouldSucceed(bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, string acceptHeaderTransferSyntax, bool isAcceptable, string expectedTransferSyntax) { (AcceptHeader, AcceptHeaderDescriptor)testData = CreateAcceptHeaderAndDescriptorForTransferSyntaxMandatory(isTransferSyntaxMandatory, transferSyntaxWhenMissing, acceptHeaderTransferSyntax); string transferSyntax; AcceptHeader acceptHeader = testData.Item1; AcceptHeaderDescriptor descriptor = testData.Item2; Assert.Equal(isAcceptable, descriptor.IsAcceptable(acceptHeader, out transferSyntax)); if (isAcceptable) { Assert.Equal(expectedTransferSyntax, transferSyntax); } }
public void GivenMultiPartRelatedHeader_WhenGetAcceptHeader_ShouldSucceed() { string type = KnownContentTypes.ApplicationOctetStream; string transferSyntax = DicomTransferSyntaxUids.Original; double quality = 0.9; MediaTypeHeaderValue headerValue = CreateMediaTypeHeaderValue(KnownContentTypes.MultipartRelated, type, transferSyntax, quality); AcceptHeader acceptHeader = headerValue.ToAcceptHeader(); Assert.Equal(PayloadTypes.MultipartRelated, acceptHeader.PayloadType); Assert.Equal(type, acceptHeader.MediaType); Assert.Equal(transferSyntax, acceptHeader.TransferSyntax); Assert.Equal(quality, acceptHeader.Quality); }
private (AcceptHeader, AcceptHeaderDescriptor) CreateAcceptHeaderAndDescriptorForPayloadType(PayloadTypes descriptorPayloadType, PayloadTypes acceptHeaderPayloadType) { AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(payloadType: acceptHeaderPayloadType); AcceptHeaderDescriptor descriptor = new AcceptHeaderDescriptor( payloadType: descriptorPayloadType, mediaType: acceptHeader.MediaType.Value, isTransferSyntaxMandatory: true, transferSyntaxWhenMissing: string.Empty, acceptableTransferSyntaxes: new HashSet <string>() { acceptHeader.TransferSyntax.Value }); return(acceptHeader, descriptor); }
private (AcceptHeader, AcceptHeaderDescriptor) CreateAcceptHeaderAndDescriptorForTransferSyntaxMandatory(bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, string acceptHeaderTransferSyntax) { AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(transferSyntax: acceptHeaderTransferSyntax); AcceptHeaderDescriptor descriptor = new AcceptHeaderDescriptor( payloadType: acceptHeader.PayloadType, mediaType: acceptHeader.MediaType.Value, isTransferSyntaxMandatory: isTransferSyntaxMandatory, transferSyntaxWhenMissing: transferSyntaxWhenMissing, acceptableTransferSyntaxes: new HashSet <string>() { acceptHeader.TransferSyntax.Value }); return(acceptHeader, descriptor); }
public void Must_parse_correctly(string headerValue) { AcceptHeader[] headers = AcceptHeader.ParseMany(headerValue).ToArray(); Assert.That(headers, Has.Length.EqualTo(5)); Assert.That(headers[0].Type, Is.EqualTo("text")); Assert.That(headers[0].Subtype, Is.EqualTo("html")); Assert.That(headers[0].Qvalue, Is.Null); Assert.That(headers[0].EffectiveQvalue, Is.EqualTo(1m)); Assert.That(headers[0].Extensions, Is.Empty); Assert.That(headers[1].Type, Is.EqualTo("text")); Assert.That(headers[1].Subtype, Is.EqualTo("plain")); Assert.That(headers[1].Qvalue, Is.EqualTo(0.9m)); Assert.That(headers[1].EffectiveQvalue, Is.EqualTo(0.9m)); Assert.That(headers[1].Extensions.Count(), Is.EqualTo(1)); Assert.That(headers[1].Extensions.ElementAt(0).Name, Is.EqualTo("extension1")); Assert.That(headers[1].Extensions.ElementAt(0).Value, Is.EqualTo("value1")); Assert.That(headers[2].Type, Is.EqualTo("application")); Assert.That(headers[2].Subtype, Is.EqualTo("json")); Assert.That(headers[2].Parameters.Count(), Is.EqualTo(2)); Assert.That(headers[2].Parameters.ElementAt(0).Name, Is.EqualTo("param1")); Assert.That(headers[2].Parameters.ElementAt(0).Value, Is.EqualTo("value1")); Assert.That(headers[2].Parameters.ElementAt(1).Name, Is.EqualTo("param2")); Assert.That(headers[2].Parameters.ElementAt(1).Value, Is.EqualTo("value2")); Assert.That(headers[2].Qvalue, Is.EqualTo(1m)); Assert.That(headers[2].EffectiveQvalue, Is.EqualTo(1m)); Assert.That(headers[2].Extensions.Count(), Is.EqualTo(2)); Assert.That(headers[2].Extensions.ElementAt(0).Name, Is.EqualTo("extension1")); Assert.That(headers[2].Extensions.ElementAt(0).Value, Is.EqualTo("value1")); Assert.That(headers[2].Extensions.ElementAt(1).Name, Is.EqualTo("extension2")); Assert.That(headers[2].Extensions.ElementAt(1).Value, Is.EqualTo("value2")); Assert.That(headers[3].Type, Is.EqualTo("text")); Assert.That(headers[3].Subtype, Is.EqualTo("*")); Assert.That(headers[3].Qvalue, Is.Null); Assert.That(headers[3].EffectiveQvalue, Is.EqualTo(1m)); Assert.That(headers[3].Extensions, Is.Empty); Assert.That(headers[4].Type, Is.EqualTo("*")); Assert.That(headers[4].Subtype, Is.EqualTo("*")); Assert.That(headers[4].Qvalue, Is.EqualTo(1m)); Assert.That(headers[4].EffectiveQvalue, Is.EqualTo(1m)); Assert.That(headers[4].Extensions, Is.Empty); }
public async Task <ResponseHandlerResult> HandleResponseAsync(HttpContextBase context, IResponse suggestedResponse, ICache cache, string cacheKey) { context.ThrowIfNull("context"); suggestedResponse.ThrowIfNull("suggestedResponse"); StatusAndSubStatusCode statusCode = suggestedResponse.StatusCode; if (!_statusCodes.Contains(statusCode)) { return(ResponseHandlerResult.ResponseNotHandled()); } AcceptHeader[] acceptHeaders = AcceptHeader.ParseMany(context.Request.Headers["Accept"]).ToArray(); if (acceptHeaders.Any() && !acceptHeaders.Any(arg => arg.MediaTypeMatches("text/html"))) { return(ResponseHandlerResult.ResponseNotHandled()); } const string format = @"<!DOCTYPE html> <html> <head> <title>{0}</title> <style>h1 {{ margin: 0; padding: 0; }}</style> </head> <body> <h1>{0}</h1> <hr/> HTTP {1}{2} </body> </html>"; Response response = new Response(statusCode) .TextHtml() .Content(String.Format(format, statusCode.StatusDescription, statusCode.StatusCode, statusCode.SubStatusCode == 0 ? "" : "." + statusCode.SubStatusCode)); response.CachePolicy.NoClientCaching(); await new CacheResponse(response).WriteResponseAsync(context.Response); context.Response.TrySkipIisCustomErrors = true; return(ResponseHandlerResult.ResponseWritten()); }
/// <summary> /// Helper method for adding an Accept header to the request. /// </summary> /// <param name="acceptHeader">The <see cref="AcceptHeader"/>.</param> /// <returns>The current instance of <see cref="WebApiRequest"/>.</returns> public WebApiRequest AddAcceptHeader(AcceptHeader acceptHeader) { string headerValue = string.Empty; switch (acceptHeader) { case AcceptHeader.Json: headerValue += "application/json"; break; case AcceptHeader.Xml: headerValue = "text/xml"; break; } headers.Add("Accept", headerValue); return this; }
/// <summary> /// Helper method for adding an Accept header to the request. /// </summary> /// <param name="acceptHeader">The <see cref="AcceptHeader"/>.</param> /// <returns>The current instance of <see cref="RestClient"/>.</returns> public virtual IRestClient AddAcceptHeader(AcceptHeader acceptHeader) { string headerValue = string.Empty; switch (acceptHeader) { case AcceptHeader.Json: headerValue += "application/json"; break; case AcceptHeader.Xml: headerValue = "text/xml"; break; } foreach (var httpRequestMessage in httpRequestMessageList) { httpRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(headerValue)); } return this; }