com.github.mjeanroy.restassert.assertj.api.AbstractHttpResponseAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rest-assert-assertj Show documentation
There is a newer version: 0.2.0
/**
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 Mickael Jeanroy
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package com.github.mjeanroy.restassert.assertj.api;

import org.assertj.core.api.AbstractAssert;

/**
 * Base class for all implementations of assertions for {@link com.github.mjeanroy.restassert.core.internal.data.HttpResponse}.
 *
 * @param  the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation"
 *          for more details.
 *
 * This class is generated.
 */
public abstract class AbstractHttpResponseAssert> extends AbstractAssert {

	private final com.github.mjeanroy.restassert.assertj.internal.HttpResponses assertions = com.github.mjeanroy.restassert.assertj.internal.HttpResponses.instance();

	protected AbstractHttpResponseAssert(com.github.mjeanroy.restassert.core.internal.data.HttpResponse actual, Class selfType) {
		super(actual, selfType);
	}

	public S doesNotHaveAccessControlAllowCredentials() {
		assertions.assertDoesNotHaveAccessControlAllowCredentials(info, actual);
		return myself;
	}

	public S doesNotHaveAccessControlAllowHeaders() {
		assertions.assertDoesNotHaveAccessControlAllowHeaders(info, actual);
		return myself;
	}

	public S doesNotHaveAccessControlAllowMaxAge() {
		assertions.assertDoesNotHaveAccessControlAllowMaxAge(info, actual);
		return myself;
	}

	public S doesNotHaveAccessControlAllowMethods() {
		assertions.assertDoesNotHaveAccessControlAllowMethods(info, actual);
		return myself;
	}

	public S doesNotHaveAccessControlAllowOrigin() {
		assertions.assertDoesNotHaveAccessControlAllowOrigin(info, actual);
		return myself;
	}

	public S doesNotHaveAccessControlExposeHeaders() {
		assertions.assertDoesNotHaveAccessControlExposeHeaders(info, actual);
		return myself;
	}

	public S doesNotHaveCacheControl() {
		assertions.assertDoesNotHaveCacheControl(info, actual);
		return myself;
	}

	public S doesNotHaveContentDisposition() {
		assertions.assertDoesNotHaveContentDisposition(info, actual);
		return myself;
	}

	public S doesNotHaveContentEncoding() {
		assertions.assertDoesNotHaveContentEncoding(info, actual);
		return myself;
	}

	public S doesNotHaveContentSecurityPolicy() {
		assertions.assertDoesNotHaveContentSecurityPolicy(info, actual);
		return myself;
	}

	public S doesNotHaveContentTypeOptions() {
		assertions.assertDoesNotHaveContentTypeOptions(info, actual);
		return myself;
	}

	public S doesNotHaveCookie(java.lang.String name) {
		assertions.assertDoesNotHaveCookie(info, actual, name);
		return myself;
	}

	public S doesNotHaveCookie() {
		assertions.assertDoesNotHaveCookie(info, actual);
		return myself;
	}

	public S doesNotHaveETag() {
		assertions.assertDoesNotHaveETag(info, actual);
		return myself;
	}

	public S doesNotHaveExpires() {
		assertions.assertDoesNotHaveExpires(info, actual);
		return myself;
	}

	public S doesNotHaveFrameOptions() {
		assertions.assertDoesNotHaveFrameOptions(info, actual);
		return myself;
	}

	public S doesNotHaveHeader(java.lang.String headerName) {
		assertions.assertDoesNotHaveHeader(info, actual, headerName);
		return myself;
	}

	public S doesNotHaveLastModified() {
		assertions.assertDoesNotHaveLastModified(info, actual);
		return myself;
	}

	public S doesNotHaveLocation() {
		assertions.assertDoesNotHaveLocation(info, actual);
		return myself;
	}

	public S doesNotHavePragma() {
		assertions.assertDoesNotHavePragma(info, actual);
		return myself;
	}

	public S doesNotHaveStrictTransportSecurity() {
		assertions.assertDoesNotHaveStrictTransportSecurity(info, actual);
		return myself;
	}

	public S doesNotHaveXssProtection() {
		assertions.assertDoesNotHaveXssProtection(info, actual);
		return myself;
	}

	public S hasAccessControlAllowCredentials() {
		assertions.assertHasAccessControlAllowCredentials(info, actual);
		return myself;
	}

	public S hasAccessControlAllowHeaders() {
		assertions.assertHasAccessControlAllowHeaders(info, actual);
		return myself;
	}

	public S hasAccessControlAllowMaxAge() {
		assertions.assertHasAccessControlAllowMaxAge(info, actual);
		return myself;
	}

	public S hasAccessControlAllowMethods() {
		assertions.assertHasAccessControlAllowMethods(info, actual);
		return myself;
	}

	public S hasAccessControlAllowOrigin() {
		assertions.assertHasAccessControlAllowOrigin(info, actual);
		return myself;
	}

	public S hasAccessControlExposeHeaders() {
		assertions.assertHasAccessControlExposeHeaders(info, actual);
		return myself;
	}

	public S hasCacheControl() {
		assertions.assertHasCacheControl(info, actual);
		return myself;
	}

	public S hasCharset(java.lang.String expectedCharset) {
		assertions.assertHasCharset(info, actual, expectedCharset);
		return myself;
	}

	public S hasCharset(java.nio.charset.Charset expectedCharset) {
		assertions.assertHasCharset(info, actual, expectedCharset);
		return myself;
	}

	public S hasContentDisposition() {
		assertions.assertHasContentDisposition(info, actual);
		return myself;
	}

	public S hasContentEncoding() {
		assertions.assertHasContentEncoding(info, actual);
		return myself;
	}

	public S hasContentLength() {
		assertions.assertHasContentLength(info, actual);
		return myself;
	}

	public S hasContentSecurityPolicy() {
		assertions.assertHasContentSecurityPolicy(info, actual);
		return myself;
	}

	public S hasContentType() {
		assertions.assertHasContentType(info, actual);
		return myself;
	}

	public S hasContentTypeOptions() {
		assertions.assertHasContentTypeOptions(info, actual);
		return myself;
	}

	public S hasCookie(java.lang.String name) {
		assertions.assertHasCookie(info, actual, name);
		return myself;
	}

	public S hasCookie(java.lang.String name, java.lang.String value) {
		assertions.assertHasCookie(info, actual, name, value);
		return myself;
	}

	public S hasCookie(com.github.mjeanroy.restassert.core.internal.data.Cookie cookie) {
		assertions.assertHasCookie(info, actual, cookie);
		return myself;
	}

	public S hasETag() {
		assertions.assertHasETag(info, actual);
		return myself;
	}

	public S hasExpires() {
		assertions.assertHasExpires(info, actual);
		return myself;
	}

	public S hasFrameOptions() {
		assertions.assertHasFrameOptions(info, actual);
		return myself;
	}

	public S hasHeader(java.lang.String headerName) {
		assertions.assertHasHeader(info, actual, headerName);
		return myself;
	}

	public S hasLastModified() {
		assertions.assertHasLastModified(info, actual);
		return myself;
	}

	public S hasLocation() {
		assertions.assertHasLocation(info, actual);
		return myself;
	}

	public S hasMimeType(com.github.mjeanroy.restassert.core.data.MediaType expectedMimeType) {
		assertions.assertHasMimeType(info, actual, expectedMimeType);
		return myself;
	}

	public S hasMimeType(java.lang.String expectedMimeType) {
		assertions.assertHasMimeType(info, actual, expectedMimeType);
		return myself;
	}

	public S hasPragma() {
		assertions.assertHasPragma(info, actual);
		return myself;
	}

	public S hasStrictTransportSecurity() {
		assertions.assertHasStrictTransportSecurity(info, actual);
		return myself;
	}

	public S hasXssProtection() {
		assertions.assertHasXssProtection(info, actual);
		return myself;
	}

	public S isAccepted() {
		assertions.assertIsAccepted(info, actual);
		return myself;
	}

	public S isAccessControlAllowCredentialsEqualTo(boolean flag) {
		assertions.assertIsAccessControlAllowCredentialsEqualTo(info, actual, flag);
		return myself;
	}

	public S isAccessControlAllowHeadersEqualTo(java.lang.Iterable accessControlAllowHeaders) {
		assertions.assertIsAccessControlAllowHeadersEqualTo(info, actual, accessControlAllowHeaders);
		return myself;
	}

	public S isAccessControlAllowHeadersEqualTo(java.lang.String value, java.lang.String... other) {
		assertions.assertIsAccessControlAllowHeadersEqualTo(info, actual, value, other);
		return myself;
	}

	public S isAccessControlAllowMaxAgeEqualTo(long maxAge) {
		assertions.assertIsAccessControlAllowMaxAgeEqualTo(info, actual, maxAge);
		return myself;
	}

	public S isAccessControlAllowMethodsEqualTo(java.lang.Iterable methods) {
		assertions.assertIsAccessControlAllowMethodsEqualTo(info, actual, methods);
		return myself;
	}

	public S isAccessControlAllowMethodsEqualTo(com.github.mjeanroy.restassert.core.data.RequestMethod method, com.github.mjeanroy.restassert.core.data.RequestMethod... other) {
		assertions.assertIsAccessControlAllowMethodsEqualTo(info, actual, method, other);
		return myself;
	}

	public S isAccessControlAllowOriginEqualTo(java.lang.String accessControlAllowOrigin) {
		assertions.assertIsAccessControlAllowOriginEqualTo(info, actual, accessControlAllowOrigin);
		return myself;
	}

	public S isAccessControlExposeHeadersEqualTo(java.lang.String value, java.lang.String... other) {
		assertions.assertIsAccessControlExposeHeadersEqualTo(info, actual, value, other);
		return myself;
	}

	public S isAccessControlExposeHeadersEqualTo(java.lang.Iterable accessControlExposeHeaders) {
		assertions.assertIsAccessControlExposeHeadersEqualTo(info, actual, accessControlExposeHeaders);
		return myself;
	}

	public S isBadRequest() {
		assertions.assertIsBadRequest(info, actual);
		return myself;
	}

	public S isCacheControlEqualTo(com.github.mjeanroy.restassert.core.data.CacheControl cacheControl) {
		assertions.assertIsCacheControlEqualTo(info, actual, cacheControl);
		return myself;
	}

	public S isCacheControlEqualTo(java.lang.String cacheControl) {
		assertions.assertIsCacheControlEqualTo(info, actual, cacheControl);
		return myself;
	}

	public S isClientError() {
		assertions.assertIsClientError(info, actual);
		return myself;
	}

	public S isConflict() {
		assertions.assertIsConflict(info, actual);
		return myself;
	}

	public S isContentDispositionEqualTo(java.lang.String contentDispositionValue) {
		assertions.assertIsContentDispositionEqualTo(info, actual, contentDispositionValue);
		return myself;
	}

	public S isContentEncodingEqualTo(com.github.mjeanroy.restassert.core.data.ContentEncoding contentEncoding) {
		assertions.assertIsContentEncodingEqualTo(info, actual, contentEncoding);
		return myself;
	}

	public S isContentEncodingEqualTo(java.lang.String contentEncodingValue) {
		assertions.assertIsContentEncodingEqualTo(info, actual, contentEncodingValue);
		return myself;
	}

	public S isContentSecurityPolicyEqualTo(com.github.mjeanroy.restassert.core.data.ContentSecurityPolicy contentSecurityPolicy) {
		assertions.assertIsContentSecurityPolicyEqualTo(info, actual, contentSecurityPolicy);
		return myself;
	}

	public S isContentSecurityPolicyEqualTo(java.lang.String contentSecurityPolicy) {
		assertions.assertIsContentSecurityPolicyEqualTo(info, actual, contentSecurityPolicy);
		return myself;
	}

	public S isContentTypeEqualTo(com.github.mjeanroy.restassert.core.data.ContentType contentTypeValue) {
		assertions.assertIsContentTypeEqualTo(info, actual, contentTypeValue);
		return myself;
	}

	public S isContentTypeEqualTo(java.lang.String contentTypeValue) {
		assertions.assertIsContentTypeEqualTo(info, actual, contentTypeValue);
		return myself;
	}

	public S isContentTypeOptionsEqualTo(java.lang.String contentTypeOptions) {
		assertions.assertIsContentTypeOptionsEqualTo(info, actual, contentTypeOptions);
		return myself;
	}

	public S isContentTypeOptionsEqualTo(com.github.mjeanroy.restassert.core.data.ContentTypeOptions contentTypeOptions) {
		assertions.assertIsContentTypeOptionsEqualTo(info, actual, contentTypeOptions);
		return myself;
	}

	public S isCreated() {
		assertions.assertIsCreated(info, actual);
		return myself;
	}

	public S isCss() {
		assertions.assertIsCss(info, actual);
		return myself;
	}

	public S isCsv() {
		assertions.assertIsCsv(info, actual);
		return myself;
	}

	public S isETagEqualTo(java.lang.String etagValue) {
		assertions.assertIsETagEqualTo(info, actual, etagValue);
		return myself;
	}

	public S isExpiresEqualTo(java.lang.String expiresValue) {
		assertions.assertIsExpiresEqualTo(info, actual, expiresValue);
		return myself;
	}

	public S isExpiresEqualTo(java.util.Date expiresValue) {
		assertions.assertIsExpiresEqualTo(info, actual, expiresValue);
		return myself;
	}

	public S isForbidden() {
		assertions.assertIsForbidden(info, actual);
		return myself;
	}

	public S isFrameOptionsEqualTo(com.github.mjeanroy.restassert.core.data.FrameOptions frameOptions) {
		assertions.assertIsFrameOptionsEqualTo(info, actual, frameOptions);
		return myself;
	}

	public S isFrameOptionsEqualTo(java.lang.String frameOptions) {
		assertions.assertIsFrameOptionsEqualTo(info, actual, frameOptions);
		return myself;
	}

	public S isGzipped() {
		assertions.assertIsGzipped(info, actual);
		return myself;
	}

	public S isHeaderEqualTo(java.lang.String headerName, java.lang.String headerValue) {
		assertions.assertIsHeaderEqualTo(info, actual, headerName, headerValue);
		return myself;
	}

	public S isHtml() {
		assertions.assertIsHtml(info, actual);
		return myself;
	}

	public S isInternalServerError() {
		assertions.assertIsInternalServerError(info, actual);
		return myself;
	}

	public S isJavascript() {
		assertions.assertIsJavascript(info, actual);
		return myself;
	}

	public S isJson() {
		assertions.assertIsJson(info, actual);
		return myself;
	}

	public S isLastModifiedEqualTo(java.util.Date lastModifiedDate) {
		assertions.assertIsLastModifiedEqualTo(info, actual, lastModifiedDate);
		return myself;
	}

	public S isLastModifiedEqualTo(java.lang.String lastModifiedValue) {
		assertions.assertIsLastModifiedEqualTo(info, actual, lastModifiedValue);
		return myself;
	}

	public S isLocationEqualTo(java.lang.String locationValue) {
		assertions.assertIsLocationEqualTo(info, actual, locationValue);
		return myself;
	}

	public S isMethodNotAllowed() {
		assertions.assertIsMethodNotAllowed(info, actual);
		return myself;
	}

	public S isMovedPermanently() {
		assertions.assertIsMovedPermanently(info, actual);
		return myself;
	}

	public S isMovedTemporarily() {
		assertions.assertIsMovedTemporarily(info, actual);
		return myself;
	}

	public S isNoContent() {
		assertions.assertIsNoContent(info, actual);
		return myself;
	}

	public S isNotAcceptable() {
		assertions.assertIsNotAcceptable(info, actual);
		return myself;
	}

	public S isNotClientError() {
		assertions.assertIsNotClientError(info, actual);
		return myself;
	}

	public S isNotFound() {
		assertions.assertIsNotFound(info, actual);
		return myself;
	}

	public S isNotImplemented() {
		assertions.assertIsNotImplemented(info, actual);
		return myself;
	}

	public S isNotModified() {
		assertions.assertIsNotModified(info, actual);
		return myself;
	}

	public S isNotRedirection() {
		assertions.assertIsNotRedirection(info, actual);
		return myself;
	}

	public S isNotServerError() {
		assertions.assertIsNotServerError(info, actual);
		return myself;
	}

	public S isNotSuccess() {
		assertions.assertIsNotSuccess(info, actual);
		return myself;
	}

	public S isOk() {
		assertions.assertIsOk(info, actual);
		return myself;
	}

	public S isPartialContent() {
		assertions.assertIsPartialContent(info, actual);
		return myself;
	}

	public S isPdf() {
		assertions.assertIsPdf(info, actual);
		return myself;
	}

	public S isPragmaEqualTo(java.lang.String pragma) {
		assertions.assertIsPragmaEqualTo(info, actual, pragma);
		return myself;
	}

	public S isPreConditionFailed() {
		assertions.assertIsPreConditionFailed(info, actual);
		return myself;
	}

	public S isRedirection() {
		assertions.assertIsRedirection(info, actual);
		return myself;
	}

	public S isResetContent() {
		assertions.assertIsResetContent(info, actual);
		return myself;
	}

	public S isServerError() {
		assertions.assertIsServerError(info, actual);
		return myself;
	}

	public S isStatusBetween(int start, int end) {
		assertions.assertIsStatusBetween(info, actual, start, end);
		return myself;
	}

	public S isStatusEqual(int status) {
		assertions.assertIsStatusEqual(info, actual, status);
		return myself;
	}

	public S isStatusOutOf(int start, int end) {
		assertions.assertIsStatusOutOf(info, actual, start, end);
		return myself;
	}

	public S isStrictTransportSecurityEqualTo(com.github.mjeanroy.restassert.core.data.StrictTransportSecurity strictTransportSecurity) {
		assertions.assertIsStrictTransportSecurityEqualTo(info, actual, strictTransportSecurity);
		return myself;
	}

	public S isStrictTransportSecurityEqualTo(java.lang.String strictTransportSecurity) {
		assertions.assertIsStrictTransportSecurityEqualTo(info, actual, strictTransportSecurity);
		return myself;
	}

	public S isSuccess() {
		assertions.assertIsSuccess(info, actual);
		return myself;
	}

	public S isText() {
		assertions.assertIsText(info, actual);
		return myself;
	}

	public S isUnauthorized() {
		assertions.assertIsUnauthorized(info, actual);
		return myself;
	}

	public S isUnsupportedMediaType() {
		assertions.assertIsUnsupportedMediaType(info, actual);
		return myself;
	}

	public S isUtf8() {
		assertions.assertIsUtf8(info, actual);
		return myself;
	}

	public S isXml() {
		assertions.assertIsXml(info, actual);
		return myself;
	}

	public S isXssProtectionEqualTo(java.lang.String xssProtection) {
		assertions.assertIsXssProtectionEqualTo(info, actual, xssProtection);
		return myself;
	}

	public S isXssProtectionEqualTo(com.github.mjeanroy.restassert.core.data.XssProtection xssProtection) {
		assertions.assertIsXssProtectionEqualTo(info, actual, xssProtection);
		return myself;
	}

}