public void Convert_WithJsonBody_CallsHttpBodyContentMapperAndCorrectlySetsBody() { var headers = new Dictionary <string, IEnumerable <string> > { { "Content-Type", new List <string> { "application/json", "charset=utf-8" } } }; var body = new { Test = "tester", test2 = 1 }; const string content = "{\"Test\":\"tester\",\"test2\":1}"; var contentBytes = Encoding.UTF8.GetBytes(content); var request = GetPreCannedRequest(headers: headers, content: content); var httpBodyContent = new HttpBodyContent(content: contentBytes, contentType: "application/json", encoding: Encoding.UTF8); var mockHttpVerbMapper = Substitute.For <IHttpVerbMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpVerbMapper.Convert("GET").Returns(HttpVerb.Get); mockHttpBodyContentMapper.Convert(content: Arg.Any <byte[]>(), headers: Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); var mapper = new ProviderServiceRequestMapper(mockHttpVerbMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); Assert.Equal(body.Test, (string)result.Body.Test); Assert.Equal(body.test2, (int)result.Body.test2); mockHttpBodyContentMapper.Received(1).Convert(content: Arg.Any <byte[]>(), headers: Arg.Any <IDictionary <string, string> >()); }
public void Convert_WithPlainContentTypeHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue(contentTypeString) { CharSet = "utf-8" }); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Empty(result.Headers); _mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Ctor2_WithContentType_SetsContentType() { const string contentTypeString = "text/html"; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: contentTypeString, encoding: null); Assert.Equal(contentTypeString, httpBodyContent.ContentType); }
public void Convert_WithContentLengthHeader_ContentLengthHeaderIsAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Length", "12" } }, Body = "Some content" }; var httpBodyContent = new HttpBodyContent(contentType: new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); httpBodyContent.GenerateContent(request.Body); var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain"); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <string>(), Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent); var result = mapper.Convert(request); Assert.Equal(request.Headers.Last().Key, result.Content.Headers.Last().Key); Assert.Equal(request.Headers.Last().Value, result.Content.Headers.Last().Value.First()); }
public void Ctor2_WithContentType_SetsContentType() { var contentTypeString = "text/html"; var httpBodyContent = new HttpBodyContent(content: String.Empty, contentType: contentTypeString, encoding: null); Assert.Equal(contentTypeString, httpBodyContent.ContentType); }
public void Convert_WithContentTypeAndCustomHeader_OnlyCustomHeadersIsAddedToHttpRequestMessage() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString }, { "X-Custom", "My Custom header" } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue(contentTypeString) { CharSet = "utf-8" }); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Equal(request.Headers.Last().Key, result.Headers.First().Key); Assert.Equal(request.Headers.Last().Value, result.Headers.First().Value.First()); }
public ProviderServiceRequest Convert(Request from) { if (from == null) { return(null); } var httpVerb = _httpVerbMapper.Convert(from.Method.ToUpper()); var to = new ProviderServiceRequest { Method = httpVerb, Path = from.Path, Query = !String.IsNullOrEmpty(from.Url.Query) ? from.Url.Query.TrimStart('?') : null }; if (from.Headers != null && from.Headers.Any()) { var fromHeaders = from.Headers.ToDictionary(x => x.Key, x => String.Join(", ", x.Value)); to.Headers = fromHeaders; } if (from.Body != null && from.Body.Length > 0) { var streamArray = ConvertStreamToBytes(from.Body); HttpBodyContent httpBodyContent = _httpBodyContentMapper.Convert(content: streamArray, headers: to.Headers); to.Body = httpBodyContent.Body; } return(to); }
public void Convert_WithContentTypeSpecifiedAndAlsoBeingSetByStringContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, Body = "Some content" }; var httpBodyContent = new HttpBodyContent(body: request.Body, contentType: new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain"); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <string>(), Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent); var result = mapper.Convert(request); Assert.Equal(1, result.Content.Headers.Count()); Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key); Assert.Equal("text/plain; charset=utf-8", result.Content.Headers.First().Value.First()); }
public void Convert_WithPlainContentTypeAndUtf8CharsetHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithEncodingAndContentType() { const string contentTypeString = "text/plain"; const string encodingString = "utf-8"; var encoding = Encoding.UTF8; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, encoding); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Empty(result.Headers); _mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers); _mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Convert_WithPlainContentTypeHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString } }, Body = new {} }; var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, null); var mockHttpMethodMapper = Substitute.For <IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For <IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); Assert.Empty(result.Headers); mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public Response Convert(ProviderServiceResponse from) { if (from == null) { return(null); } var to = new Response { StatusCode = (HttpStatusCode)from.Status, Headers = from.Headers ?? new Dictionary <string, string>() }; if (from.Body != null) { HttpBodyContent bodyContent = _httpBodyContentMapper.Convert(body: from.Body, headers: from.Headers); to.ContentType = bodyContent.ContentType; to.Contents = s => { byte[] bytes = bodyContent.ContentBytes; s.Write(bytes, 0, bytes.Length); s.Flush(); }; } return(to); }
public void Convert_WithJsonContentTypeAndUnicodeCharsetHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithEncodingAndContentType() { const string contentTypeString = "application/json"; const string encodingString = "utf-16"; var encoding = Encoding.Unicode; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, encoding); var mockHttpMethodMapper = Substitute.For <IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For <IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); Assert.Empty(result.Headers); mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers); mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Convert_WithContentTypeAndCustomHeader_OnlyCustomHeadersIsAddedToHttpRequestMessage() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString }, { "X-Custom", "My Custom header" } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, null); var mockHttpMethodMapper = Substitute.For <IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For <IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); Assert.Equal(request.Headers.Last().Key, result.Headers.First().Key); Assert.Equal(request.Headers.Last().Value, result.Headers.First().Value.First()); }
public void Convert_WithPlainTextBody_CallsHttpBodyContentMapperAndCorrectlySetsBody() { const string content = "Plain text body"; Request request = GetPreCannedRequest(content: content); var httpBodyContent = new HttpBodyContent(new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); httpBodyContent.GenerateContent(request.Body); var mockHttpVerbMapper = Substitute.For <IHttpVerbMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpVerbMapper.Convert("GET").Returns(HttpVerb.Get); mockHttpBodyContentMapper.Convert(content: Arg.Any <byte[]>(), headers: null).Returns(httpBodyContent); var mapper = new ProviderServiceRequestMapper(mockHttpVerbMapper, mockHttpBodyContentMapper); ProviderServiceRequest result = mapper.Convert(request); Assert.Equal(content, result.Body); mockHttpBodyContentMapper.Received(1).Convert(content: Arg.Any <byte[]>(), headers: null); }
public void Ctor1_WithContentType_SetsContentType() { const string contentTypeString = "text/html"; var httpBodyContent = new HttpBodyContent(body: new {}, contentType: contentTypeString, encoding: null); Assert.Equal(contentTypeString, httpBodyContent.ContentType); }
public void Ctor2_WithEncoding_SetsEncoding() { var encoding = Encoding.Unicode; var httpBodyContent = new HttpBodyContent(body: String.Empty, contentType: null, encoding: encoding); Assert.Equal(encoding, httpBodyContent.Encoding); }
public void Convert_WithContentTypeSpecifiedButNotBeingSetByByteArrayContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", "application/octet-stream" } }, Body = Encoding.UTF8.GetBytes("Some content") }; var httpBodyContent = new HttpBodyContent(body: request.Body, contentType: new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); var byteArrayContent = new ByteArrayContent(request.Body as byte[]); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(body: Arg.Any <byte[]>(), headers: Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(byteArrayContent); var result = mapper.Convert(request); Assert.Equal(1, result.Content.Headers.Count()); Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key); Assert.Equal("application/octet-stream", result.Content.Headers.First().Value.First()); }
public void Convert_WithTheWorks_CorrectlyMappedHttpRequestMessageIsReturned() { const string encodingString = "utf-8"; var encoding = Encoding.UTF8; const string contentTypeString = "application/json"; const string bodyJson = "{\"Test\":\"tester\",\"Testing\":1}"; var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString }, { "X-Custom", "My Custom header" }, { "Content-Length", "10000" }, //This header is removed and replace with the correct value of 29 }, Body = new { Test = "tester", Testing = 1 } }; var httpBodyContent = new HttpBodyContent(bodyJson, contentTypeString, encoding); var mockHttpMethodMapper = Substitute.For <IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For <IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get); mockHttpContentMapper.Convert(httpBodyContent).Returns(new StringContent(bodyJson, encoding, contentTypeString)); mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); var requestContent = result.Content.ReadAsStringAsync().Result; var contentTypeHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Type")); var customHeader = result.Headers.First(x => x.Key.Equals("X-Custom")); var contentLengthHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Length")); Assert.Equal(bodyJson, requestContent); //Content-Type header Assert.Equal(request.Headers.First().Key, contentTypeHeader.Key); Assert.Equal(request.Headers.First().Value, contentTypeHeader.Value.First()); //X-Custom header Assert.Equal(request.Headers.Skip(1).First().Key, customHeader.Key); Assert.Equal(request.Headers.Skip(1).First().Value, customHeader.Value.First()); //Content-Length header Assert.Equal(request.Headers.Last().Key, contentLengthHeader.Key); Assert.Equal("29", contentLengthHeader.Value.First()); }
public void Ctor2_WithPlainTextContent_SetsBodyAndContent() { const string content = "Some plain text"; var httpBodyContent = new HttpBodyContent(content: content, contentType: "application/plain", encoding: null); Assert.Equal(content, httpBodyContent.Content); Assert.Equal(content, httpBodyContent.Body); }
public void Ctor1_WithPlainTextBody_SetsBodyAndContent() { const string body = "Some plain text"; var httpBodyContent = new HttpBodyContent(body: body, contentType: "application/plain", encoding: null); Assert.Equal(body, httpBodyContent.Content); Assert.Equal(body, httpBodyContent.Body); }
public void Ctor1_WithBinaryBody_SetsBodyAndContent() { var body = new byte[] { 1, 2, 3 }; var httpBodyContent = new HttpBodyContent(body, "application/octet-stream", Encoding.UTF8); Assert.Equal(body, httpBodyContent.Body); Assert.Equal(Encoding.UTF8.GetString(body), httpBodyContent.Content); }
public HttpContent Convert(HttpBodyContent from) { if (from == null) { return(null); } return(new StringContent(from.Content, from.Encoding, from.ContentType)); }
public void Convert_WithEmptyContent_ReturnsNull() { var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: "text/plain", encoding: Encoding.UTF8); var mapper = GetSubject(); var result = mapper.Convert(httpBodyContent); Assert.Empty(result.ReadAsStringAsync().Result); }
public void Ctor2_WithBinaryContent_SetsBodyAndContent() { const string content = "LOL"; var httpBodyContent = new HttpBodyContent(content, "application/octet-stream", Encoding.UTF8); Assert.Equal(content, httpBodyContent.Content); Assert.IsType <byte[]>(httpBodyContent.Body); Assert.Equal(new byte[] { 76, 79, 76 }, httpBodyContent.Body); }
public void Ctor2_WithEmptyContent_ReturnsEmptyUtf8ByteArray() { var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); Assert.Empty(httpBodyContent.ContentBytes); }
public void Ctor1_WithBinaryBody_SetsBodyAndAndBase64EncodesTheContent() { var body = new byte[] { 1, 2, 3 }; var httpBodyContent = new HttpBodyContent(body: body, contentType: "application/octet-stream", encoding: Encoding.UTF8); Assert.Equal(body, httpBodyContent.Body); Assert.Equal(Convert.ToBase64String(body), httpBodyContent.Content); }
public void Convert_WithTheWorks_CorrectlyMappedHttpRequestMessageIsReturned() { const string encodingString = "utf-8"; const string contentTypeString = "application/json"; const string bodyJson = "{\"Test\":\"tester\",\"Testing\":1}"; var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString }, { "X-Custom", "My Custom header" }, { "Content-Length", "1000" } }, Body = new { Test = "tester", Testing = 1 } }; var httpBodyContent = new HttpBodyContent(new MediaTypeHeaderValue(contentTypeString) { CharSet = encodingString }); httpBodyContent.GenerateContent(bodyJson); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get); _mockHttpContentMapper.Convert(httpBodyContent).Returns(new StringContent(bodyJson, Encoding.UTF8, contentTypeString)); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); var requestContent = result.Content.ReadAsStringAsync().Result; var contentTypeHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Type")); var customHeader = result.Headers.First(x => x.Key.Equals("X-Custom")); var contentLengthHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Length")); Assert.Equal(bodyJson, requestContent); //Content-Type header Assert.Equal(request.Headers.First().Key, contentTypeHeader.Key); Assert.Equal(request.Headers.First().Value, contentTypeHeader.Value.First()); //X-Custom header Assert.Equal(request.Headers.Skip(1).First().Key, customHeader.Key); Assert.Equal(request.Headers.Skip(1).First().Value, customHeader.Value.First()); //Content-Length header Assert.Equal(request.Headers.Last().Key, contentLengthHeader.Key); Assert.Equal(request.Headers.Last().Value, contentLengthHeader.Value.First()); }
public void Ctor2_WithBinaryContent_SetsBodyAndBase64EncodesContent() { const string content = "LOL"; var contentBytes = Encoding.UTF8.GetBytes(content); var httpBodyContent = new HttpBodyContent(content: contentBytes, contentType: "application/octet-stream", encoding: Encoding.UTF8); Assert.Equal(content, httpBodyContent.Content); Assert.IsType <string>(httpBodyContent.Body); Assert.Equal(Convert.ToBase64String(contentBytes), httpBodyContent.Body); }
public HttpRequestMessage Convert(ProviderServiceRequest from) { if (from == null) { return(null); } var requestHttpMethod = _httpMethodMapper.Convert(from.Method); var requestPath = from.PathWithQuery(); var to = new HttpRequestMessage(requestHttpMethod, requestPath); var contentRelatedHeaders = new Dictionary <string, string>(); if (from.Headers != null && from.Headers.Any()) { foreach (var requestHeader in from.Headers) { //Strip any Content- headers as they need to be attached to Request content when using a HttpRequestMessage if (requestHeader.Key.IndexOf("Content-", StringComparison.InvariantCultureIgnoreCase) == 0) { contentRelatedHeaders.Add(requestHeader.Key, requestHeader.Value); continue; } to.Headers.Add(requestHeader.Key, requestHeader.Value); } } if (from.Body != null) { HttpBodyContent bodyContent = _httpBodyContentMapper.Convert(body: from.Body, headers: from.Headers); var httpContent = _httpContentMapper.Convert(bodyContent); //Set the content related headers if (httpContent != null && contentRelatedHeaders.Any()) { foreach (var contentHeader in contentRelatedHeaders) { if (contentHeader.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase) && httpContent.Headers.Any(x => x.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase))) { continue; } httpContent.Headers.Add(contentHeader.Key, contentHeader.Value); } } to.Content = httpContent; } return(to); }
public HttpBodyContent Convert(byte[] content, IDictionary <string, string> headers) { if (content == null) { return(null); } var bodyContent = new HttpBodyContent(content, ParseContentTypeHeader(headers)); return(bodyContent); }