/// <summary> /// Tests whether action result contains the same content type as the provided MediaTypeHeaderValue. /// </summary> /// <param name="contentType">Expected content type as <see cref="MediaTypeHeaderValue"/>.</param> protected void ValidateContainingOfContentType(MediaTypeHeaderValue contentType) { ContentTypeValidator.ValidateContainingOfContentType( this.ActionResult, contentType, this.ThrowNewFailedValidationException); }
internal void SiteCollectionContentTypeAdding(string url) { using (var cc = TestCommon.CreateClientContext(url)) { // Add supporting files, note that files validation will be done in the files test cases TestProvisioningTemplate(cc, "contenttype_files.xml", Handlers.Files | Handlers.Features); // Ensure we can test clean DeleteContentTypes(cc); // Add content types var result = TestProvisioningTemplate(cc, "contenttype_add.xml", Handlers.ContentTypes | Handlers.Fields); // Ensure the needed tokens are added to the target token parser, this is needed due to the tokenparser perf optimalizations result.TargetTokenParser.Tokens.Add(new SiteToken(cc.Web)); ContentTypeValidator cv = new ContentTypeValidator(cc.Web); Assert.IsTrue(cv.Validate(result.SourceTemplate.ContentTypes, result.TargetTemplate.ContentTypes, result.TargetTokenParser)); // change content types var result2 = TestProvisioningTemplate(cc, "contenttype_delta_1.xml", Handlers.ContentTypes); // Ensure the needed tokens are added to the target token parser, this is needed due to the tokenparser perf optimalizations result2.TargetTokenParser.Tokens.Add(new SiteToken(cc.Web)); Assert.IsTrue(cv.Validate(result2.SourceTemplate.ContentTypes, result2.TargetTemplate.ContentTypes, result2.TargetTokenParser)); } }
/// <summary> /// Validates whether file result has the provided content type. /// </summary> /// <param name="contentType">Content type as string.</param> protected void ValidateContentType(string contentType) { ContentTypeValidator.ValidateContentType( this.ActionResult, contentType, this.ThrowNewFileResultAssertionException); }
/// <summary> /// Tests whether action result contains the same content types as the provided ones. /// </summary> /// <param name="contentTypes">Expected content types as collection of <see cref="MediaTypeHeaderValue"/>.</param> protected void ValidateContentTypes(IEnumerable <MediaTypeHeaderValue> contentTypes) { ContentTypeValidator.ValidateContentTypes( this.ActionResult, contentTypes, this.ThrowNewFailedValidationException); }
/// <summary> /// Creates a new instance of the <see cref="CloudEvent{T}"/> class. /// </summary> /// <typeparam name="T">Type of data.</typeparam> /// <param name="contentType">Content type.</param> /// <param name="data">Event data.</param> /// <param name="cloudEventsVersion"><see cref="CloudEventsVersion"/> value.</param> /// <returns>Returns the <see cref="CloudEvent{T}"/> instance created.</returns> public static CloudEvent <T> Create <T>(string contentType, T data, string cloudEventsVersion = CloudEventsVersion.Version01) { if (IsJson(contentType)) { var objectEventised = new ObjectEvent <T>(cloudEventsVersion) { ContentType = contentType, Data = data }; return(objectEventised); } if (ContentTypeValidator.IsText(contentType)) { var stringified = data as string; var stringEventised = new StringEvent(cloudEventsVersion) { ContentType = contentType, Data = stringified }; return(stringEventised as CloudEvent <T>); } var binarified = data as byte[]; var binaryEventised = new BinaryEvent(cloudEventsVersion) { ContentType = contentType, Data = binarified }; return(binaryEventised as CloudEvent <T>); }
public void Given_Type_Should_IsDataString_ReturnValue() { var result = ContentTypeValidator.IsDataString(1); result.Should().BeFalse(); result = ContentTypeValidator.IsDataString("hello world"); result.Should().BeTrue(); }
public void Given_Type_Should_IsTypeByteArray_ReturnValue() { var result = ContentTypeValidator.IsTypeByteArray(typeof(int)); result.Should().BeFalse(); result = ContentTypeValidator.IsTypeByteArray(typeof(byte[])); result.Should().BeTrue(); }
public void Given_Type_Should_IsTypeString_ReturnValue() { var result = ContentTypeValidator.IsTypeString(typeof(int)); result.Should().BeFalse(); result = ContentTypeValidator.IsTypeString(typeof(string)); result.Should().BeTrue(); }
public void Given_Type_Should_IsText_ReturnValue() { var result = ContentTypeValidator.IsText("lorem ipsum"); result.Should().BeFalse(); result = ContentTypeValidator.IsText("text/plain"); result.Should().BeTrue(); }
public void Given_Type_Should_ImpliesJson_ReturnValue() { var result = ContentTypeValidator.ImpliesJson("lorem ipsum"); result.Should().BeFalse(); result = ContentTypeValidator.ImpliesJson("text/json"); result.Should().BeTrue(); }
public void Given_Type_Should_HasJsonSuffix_ReturnValue() { var result = ContentTypeValidator.HasJsonSuffix("lorem ipsum"); result.Should().BeFalse(); result = ContentTypeValidator.HasJsonSuffix("application/cloudevents+json"); result.Should().BeTrue(); }
public void Given_Type_Should_IsDataByteArray_ReturnValue() { var result = ContentTypeValidator.IsDataByteArray(1); result.Should().BeFalse(); result = ContentTypeValidator.IsDataByteArray(Encoding.UTF8.GetBytes("hello world")); result.Should().BeTrue(); }
/// <inheritdoc /> public IAndContentTestBuilder WithContentType(string contentType) { ContentTypeValidator.ValidateContentType( contentType, this.ActionResult.ContentType, this.ThrowNewContentResultAssertionException); return(this); }
/// <inheritdoc /> public IAndViewTestBuilder WithContentType(string contentType) { ContentTypeValidator.ValidateContentType( this.TestContext.MethodResult, contentType, this.ThrowNewViewResultAssertionException); return(this); }
/// <inheritdoc /> public IAndJsonTestBuilder WithContentType(string contentType) { ContentTypeValidator.ValidateContentType( contentType, this.GetJsonResult().ContentType, this.ThrowNewJsonResultAssertionException); return(this); }
/// <inheritdoc /> protected override bool IsValidDataType(string data) { if (ContentTypeValidator.ImpliesJson(this.ContentType)) { return(false); } if (ContentTypeValidator.IsText(this.ContentType)) { return(true); } return(false); }
/// <summary> /// Tests whether the <see cref="Microsoft.AspNetCore.Mvc.ActionResult"/> /// has the same content type as the provided string. /// </summary> /// <param name="baseTestBuilderWithContentTypeResult"> /// Instance of <see cref="IBaseTestBuilderWithContentTypeResult{TContentTypeResultTestBuilder}"/> type. /// </param> /// <param name="contentType">Content type as string.</param> /// <returns>The same content type <see cref="Microsoft.AspNetCore.Mvc.ActionResult"/> test builder.</returns> public static TContentTypeResultTestBuilder WithContentType <TContentTypeResultTestBuilder>( this IBaseTestBuilderWithContentTypeResult <TContentTypeResultTestBuilder> baseTestBuilderWithContentTypeResult, string contentType) where TContentTypeResultTestBuilder : IBaseTestBuilderWithActionResult { var actualBuilder = GetActualBuilder(baseTestBuilderWithContentTypeResult); ContentTypeValidator.ValidateContentType( actualBuilder.TestContext.MethodResult, contentType, actualBuilder.ThrowNewFailedValidationException); return(actualBuilder.ResultTestBuilder); }
/// <summary> /// Tests whether the <see cref="ActionResult"/> /// contains the same content types provided as collection of <see cref="MediaTypeHeaderValue"/>. /// </summary> /// <param name="baseTestBuilderWithOutputResult"> /// Instance of <see cref="IBaseTestBuilderWithOutputResult{TOutputResultTestBuilder}"/> type. /// </param> /// <param name="contentTypes">Content types as collection of <see cref="MediaTypeHeaderValue"/>.</param> /// <returns>The same output <see cref="ActionResult"/> test builder.</returns> public static TOutputResultTestBuilder ContainingContentTypes <TOutputResultTestBuilder>( this IBaseTestBuilderWithOutputResult <TOutputResultTestBuilder> baseTestBuilderWithOutputResult, IEnumerable <MediaTypeHeaderValue> contentTypes) where TOutputResultTestBuilder : IBaseTestBuilderWithActionResult { var actualBuilder = GetActualBuilder(baseTestBuilderWithOutputResult); ValidateObjectResult(actualBuilder); ContentTypeValidator.ValidateContentTypes( actualBuilder.TestContext.MethodResult, contentTypes, actualBuilder.ThrowNewFailedValidationException); return(actualBuilder.ResultTestBuilder); }
/// <summary> /// Checks whether the content type of the <see cref="CloudEvent{T}"/> instance indicates structured or not. /// </summary> /// <param name="ce"><see cref="CloudEvent{T}"/> instance.</param> /// <returns>Returns <c>True</c>, if the content type indicates structured; otherwise returns <c>False</c>.</returns> protected static bool IsStructuredCloudEventContentType(CloudEvent <T> ce) { if (ContentTypeValidator.IsJson(ce.ContentType)) { return(true); } if (ContentTypeValidator.HasJsonSuffix(ce.ContentType)) { return(true); } if (ContentTypeValidator.ImpliesJson(ce.ContentType)) { return(true); } return(false); }
private static bool IsJson(string contentType) { if (ContentTypeValidator.IsJson(contentType)) { return(true); } if (ContentTypeValidator.HasJsonSuffix(contentType)) { return(true); } if (ContentTypeValidator.ImpliesJson(contentType)) { return(true); } return(false); }
public void SiteCollectionContentTypeAddingTest() { using (var cc = TestCommon.CreateClientContext(centralSiteCollectionUrl)) { // Add supporting files, note that files validation will be done in the files test cases TestProvisioningTemplate(cc, "contenttype_files.xml", Handlers.Files); // Ensure we can test clean DeleteContentTypes(cc); // Add content types var result = TestProvisioningTemplate(cc, "contenttype_add.xml", Handlers.ContentTypes | Handlers.Fields); ContentTypeValidator cv = new ContentTypeValidator(cc.Web); Assert.IsTrue(cv.Validate(result.SourceTemplate.ContentTypes, result.TargetTemplate.ContentTypes, result.TargetTokenParser)); // change content types var result2 = TestProvisioningTemplate(cc, "contenttype_delta_1.xml", Handlers.ContentTypes); Assert.IsTrue(cv.Validate(result2.SourceTemplate.ContentTypes, result2.TargetTemplate.ContentTypes, result2.TargetTokenParser)); } }
/// <summary> /// Tests whether the collected attributes contain <see cref="ProducesAttribute"/>. /// </summary> /// <param name="controllerActionAttributesTestBuilder"> /// Instance of <see cref="IControllerActionAttributesTestBuilder{TAttributesTestBuilder}"/> type. /// </param> /// <param name="ofContentTypes">Expected content types.</param> /// <returns>The same attributes test builder.</returns> public static TAttributesTestBuilder SpecifyingProduction <TAttributesTestBuilder>( this IControllerActionAttributesTestBuilder <TAttributesTestBuilder> controllerActionAttributesTestBuilder, IEnumerable <string> ofContentTypes) where TAttributesTestBuilder : IControllerActionAttributesTestBuilder <TAttributesTestBuilder> { var actualBuilder = (BaseAttributesTestBuilder <TAttributesTestBuilder>)controllerActionAttributesTestBuilder; actualBuilder.ContainingAttributeOfType <ProducesAttribute>(); actualBuilder.Validations.Add(attrs => { var consumesAttribute = actualBuilder.GetAttributeOfType <ProducesAttribute>(attrs); ContentTypeValidator.ValidateAttributeContentTypes( consumesAttribute, ofContentTypes, actualBuilder.ThrowNewAttributeAssertionException); }); return(actualBuilder.AttributesTestBuilder); }