http4k-testing-kotest/org.http4k.kotest

Package-level declarations

Functions

beHttpOnly

fun beHttpOnly(): Matcher<Cookie>

beSecure

fun beSecure(): Matcher<Cookie>

expireOn

fun expireOn(matcher: Matcher<Instant?>): Matcher<Cookie>

fun expireOn(expected: Instant): Matcher<Cookie>

haveAuthority

fun haveAuthority(expected: String): Matcher<Uri>

haveBody

@JvmName(name = "haveBodyNullableStringMatcher")

fun <T : HttpMessage> haveBody(expected: Matcher<String?>): Matcher<T>

@JvmName(name = "haveBodyStringMatcher")

fun <T : HttpMessage> haveBody(expected: Matcher<String>): Matcher<T>

fun <T : HttpMessage> haveBody(expected: Matcher<Body>): Matcher<T>

fun <T : HttpMessage> haveBody(expected: String): Matcher<T>

fun <T : HttpMessage> haveBody(expected: Regex): Matcher<T>

fun <T : HttpMessage, B> haveBody(lens: BodyLens<B>, matcher: Matcher<B>): Matcher<T>

haveBody

fun <NODE> Json<NODE>.haveBody(expected: NODE): Matcher<HttpMessage>

fun <NODE> Json<NODE>.haveBody(expected: Matcher<NODE>): Matcher<HttpMessage>

fun <NODE> Json<NODE>.haveBody(expected: String): Matcher<HttpMessage>

haveContentType

fun haveContentType(expected: ContentType): Matcher<HttpMessage>

haveCookie

fun haveCookie(expected: Cookie): Matcher<Request>

fun haveCookie(name: String, match: Matcher<Cookie?>): Matcher<Request>

fun haveCookie(name: String, expected: String): Matcher<Request>

fun haveCookie(name: String, expected: Regex): Matcher<Request>

haveCookiePath

fun haveCookiePath(expected: String): Matcher<Cookie>

haveDomain

fun haveDomain(expected: String): Matcher<Cookie>

haveForm

@JvmName(name = "haveFormNullableStringMatcher")

fun haveForm(name: String, matcher: Matcher<String?>): Matcher<Request>

fun haveForm(name: String, matcher: Matcher<String>): Matcher<Request>

fun haveForm(name: String, expected: CharSequence): Matcher<Request>

fun haveForm(name: String, expected: Regex): Matcher<Request>

haveFormField

fun <T> haveFormField(lens: Lens<WebForm, T>, matcher: Matcher<T>): Matcher<WebForm>

haveHeader

fun haveHeader(name: String): Matcher<HttpMessage>

@JvmName(name = "haveHeaderNullableString")

fun haveHeader(name: String, matcher: Matcher<String?>): Matcher<HttpMessage>

fun haveHeader(name: String, matcher: Matcher<String>): Matcher<HttpMessage>

fun haveHeader(name: String, expected: String): Matcher<HttpMessage>

fun haveHeader(name: String, expected: List<String?>): Matcher<HttpMessage>

fun haveHeader(name: String, expected: Regex): Matcher<HttpMessage>

fun <T> haveHeader(lens: HeaderLens<T>, matcher: Matcher<T>): Matcher<HttpMessage>

haveHost

fun haveHost(expected: String): Matcher<Uri>

haveMethod

fun haveMethod(expected: Method): Matcher<Request>

haveName

fun haveName(expected: String): Matcher<Cookie>

havePath

fun havePath(matcher: Matcher<String?>): Matcher<Uri>

fun havePath(expected: String?): Matcher<Uri>

fun havePath(expected: Regex): Matcher<Uri>

havePort

fun havePort(expected: Int): Matcher<Uri>

haveQuery

fun haveQuery(expected: String): Matcher<Uri>

@JvmName(name = "haveQueryNullableStringMatcher")

fun haveQuery(name: String, matcher: Matcher<String?>): Matcher<Request>

fun haveQuery(name: String, matcher: Matcher<String>): Matcher<Request>

fun haveQuery(name: String, expected: CharSequence): Matcher<Request>

fun haveQuery(name: String, expected: List<String?>): Matcher<Request>

fun haveQuery(name: String, expected: Regex): Matcher<Request>

fun <T> haveQuery(lens: QueryLens<T>, matcher: Matcher<T>): Matcher<Request>

haveRequest

fun haveRequest(match: Matcher<Request>): Matcher<HttpTransaction>

haveResponse

fun haveResponse(match: Matcher<Response>): Matcher<HttpTransaction>

haveSameSite

fun haveSameSite(expected: SameSite): Matcher<Cookie>

haveSetCookie

fun haveSetCookie(expected: Cookie): Matcher<Response>

fun haveSetCookie(name: String, expected: Matcher<Cookie?>): Matcher<Response>

haveStatus

fun haveStatus(expected: Status): Matcher<Response>

haveUri

fun haveUri(expected: Matcher<Uri>): Matcher<Request>

fun haveUri(expected: String): Matcher<Request>

fun haveUri(expected: Regex): Matcher<Request>

fun haveUri(expected: Uri): Matcher<Request>

haveValue

@JvmName(name = "haveCookieValueNullableString")

fun haveValue(matcher: Matcher<String?>): Matcher<Cookie?>

fun haveValue(matcher: Matcher<String>): Matcher<Cookie?>

fun haveValue(expected: String): Matcher<Cookie?>

httpMessageHas

fun <T : HttpMessage, R> httpMessageHas(name: String, extractValue: (T) -> R, match: Matcher<R>): Matcher<T>

LensMatcher

fun <R> LensMatcher(matcher: Matcher<R>): Matcher<R>

neverExpire

fun neverExpire(): Matcher<Cookie>

shouldBeHttpOnly

fun Cookie.shouldBeHttpOnly()

shouldBeSecure

fun Cookie.shouldBeSecure()

shouldHaveAuthority

infix fun Uri.shouldHaveAuthority(expected: String)

shouldHaveBody

@JvmName(name = "shouldHaveBodyNullableStringMatcher")

infix fun HttpMessage.shouldHaveBody(expected: Matcher<String?>)

@JvmName(name = "shouldHaveBodyStringMatcher")

infix fun HttpMessage.shouldHaveBody(expected: Matcher<String>)

infix fun HttpMessage.shouldHaveBody(expected: Matcher<Body>)

infix fun HttpMessage.shouldHaveBody(expected: String)

infix fun HttpMessage.shouldHaveBody(expected: Regex)

fun <T> HttpMessage.shouldHaveBody(lens: BodyLens<T>, matcher: Matcher<T>)

shouldHaveContentType

infix fun HttpMessage.shouldHaveContentType(expected: ContentType)

shouldHaveCookie

infix fun Request.shouldHaveCookie(expected: Cookie)

fun Request.shouldHaveCookie(name: String, match: Matcher<Cookie?>)

fun Request.shouldHaveCookie(name: String, expected: String)

fun Request.shouldHaveCookie(name: String, expected: Regex)

shouldHaveDomain

infix fun Cookie.shouldHaveDomain(expected: String)

shouldHaveExpiry

infix fun Cookie.shouldHaveExpiry(expected: Instant)

shouldHaveForm

@JvmName(name = "shouldHaveFormNullableStringMatcher")

fun Request.shouldHaveForm(name: String, matcher: Matcher<String?>)

fun Request.shouldHaveForm(name: String, matcher: Matcher<String>)

fun Request.shouldHaveForm(name: String, expected: CharSequence)

fun Request.shouldHaveForm(name: String, matcher: Regex)

shouldHaveFormField

fun <T> WebForm.shouldHaveFormField(field: Lens<WebForm, T>, matcher: Matcher<T>)

shouldHaveHeader

infix fun HttpMessage.shouldHaveHeader(name: String)

fun HttpMessage.shouldHaveHeader(name: String, matcher: Matcher<String>)

fun HttpMessage.shouldHaveHeader(name: String, expected: String)

fun HttpMessage.shouldHaveHeader(name: String, expected: List<String?>)

fun HttpMessage.shouldHaveHeader(name: String, expected: Regex)

fun <T> HttpMessage.shouldHaveHeader(lens: HeaderLens<T>, matcher: Matcher<T>)

shouldHaveHost

infix fun Uri.shouldHaveHost(expected: String)

shouldHaveMethod

infix fun Request.shouldHaveMethod(expected: Method)

shouldHaveName

infix fun Cookie.shouldHaveName(expected: String)

shouldHavePath

infix fun Uri.shouldHavePath(match: Matcher<String?>)

infix fun Uri.shouldHavePath(expected: String?)

infix fun Uri.shouldHavePath(expected: Regex)

infix fun Cookie.shouldHavePath(expected: String)

shouldHavePort

infix fun Uri.shouldHavePort(expected: Int)

shouldHaveQuery

infix fun Uri.shouldHaveQuery(expected: String)

@JvmName(name = "shouldHaveQueryNullableStringMatcher")

fun Request.shouldHaveQuery(name: String, matcher: Matcher<String?>)

fun Request.shouldHaveQuery(name: String, matcher: Matcher<String>)

fun Request.shouldHaveQuery(name: String, expected: CharSequence)

fun Request.shouldHaveQuery(name: String, expected: List<String?>)

fun Request.shouldHaveQuery(name: String, expected: Regex)

fun <T> Request.shouldHaveQuery(lens: QueryLens<T>, matcher: Matcher<T>)

shouldHaveRequest

infix fun HttpTransaction.shouldHaveRequest(match: Matcher<Request>)

shouldHaveResponse

infix fun HttpTransaction.shouldHaveResponse(match: Matcher<Response>)

shouldHaveSameSite

infix fun Cookie.shouldHaveSameSite(expected: SameSite)

shouldHaveSetCookie

infix fun Response.shouldHaveSetCookie(expected: Cookie)

fun Response.shouldHaveSetCookie(name: String, match: Matcher<Cookie?>)

shouldHaveStatus

infix fun Response.shouldHaveStatus(expected: Status)

shouldHaveUri

infix fun Request.shouldHaveUri(match: Matcher<Uri>)

infix fun Request.shouldHaveUri(expected: String)

infix fun Request.shouldHaveUri(expected: Regex)

infix fun Request.shouldHaveUri(expected: Uri)

shouldHaveValue

infix fun Cookie.shouldHaveValue(expected: String)

shouldNeverExpire

fun Cookie.shouldNeverExpire()

shouldNotBeHttpOnly

fun Cookie.shouldNotBeHttpOnly()

shouldNotBeSecure

fun Cookie.shouldNotBeSecure()

shouldNotHaveAuthority

infix fun Uri.shouldNotHaveAuthority(expected: String)

shouldNotHaveBody

@JvmName(name = "shouldNotHaveBodyNullableStringMatcher")

infix fun HttpMessage.shouldNotHaveBody(expected: Matcher<String?>)

@JvmName(name = "shouldNotHaveBodyStringMatcher")

infix fun HttpMessage.shouldNotHaveBody(expected: Matcher<String>)

infix fun HttpMessage.shouldNotHaveBody(expected: Matcher<Body>)

infix fun HttpMessage.shouldNotHaveBody(expected: String)

infix fun HttpMessage.shouldNotHaveBody(expected: Regex)

fun <T> HttpMessage.shouldNotHaveBody(lens: BodyLens<T>, matcher: Matcher<T>)

shouldNotHaveContentType

infix fun HttpMessage.shouldNotHaveContentType(expected: ContentType)

shouldNotHaveCookie

infix fun Request.shouldNotHaveCookie(expected: Cookie)

fun Request.shouldNotHaveCookie(name: String, match: Matcher<Cookie?>)

fun Request.shouldNotHaveCookie(name: String, expected: String)

fun Request.shouldNotHaveCookie(name: String, expected: Regex)

shouldNotHaveDomain

infix fun Cookie.shouldNotHaveDomain(expected: String)

shouldNotHaveExpiry

infix fun Cookie.shouldNotHaveExpiry(expected: Instant)

shouldNotHaveForm

@JvmName(name = "shouldNotHaveFormNullableStringMatcher")

fun Request.shouldNotHaveForm(name: String, matcher: Matcher<String?>)

fun Request.shouldNotHaveForm(name: String, matcher: Matcher<String>)

fun Request.shouldNotHaveForm(name: String, expected: CharSequence)

fun Request.shouldNotHaveForm(name: String, matcher: Regex)

shouldNotHaveFormField

fun <T> WebForm.shouldNotHaveFormField(field: Lens<WebForm, T>, matcher: Matcher<T>)

shouldNotHaveHeader

infix fun HttpMessage.shouldNotHaveHeader(name: String)

fun HttpMessage.shouldNotHaveHeader(name: String, matcher: Matcher<String>)

fun HttpMessage.shouldNotHaveHeader(name: String, expected: String)

fun HttpMessage.shouldNotHaveHeader(name: String, expected: List<String?>)

fun HttpMessage.shouldNotHaveHeader(name: String, expected: Regex)

fun <T> HttpMessage.shouldNotHaveHeader(lens: HeaderLens<T>, matcher: Matcher<T>)

shouldNotHaveHost

infix fun Uri.shouldNotHaveHost(expected: String)

shouldNotHaveMethod

infix fun Request.shouldNotHaveMethod(expected: Method)

shouldNotHaveName

infix fun Cookie.shouldNotHaveName(expected: String)

shouldNotHavePath

infix fun Uri.shouldNotHavePath(match: Matcher<String?>)

infix fun Uri.shouldNotHavePath(expected: String?)

infix fun Uri.shouldNotHavePath(expected: Regex)

infix fun Cookie.shouldNotHavePath(expected: String)

shouldNotHavePort

infix fun Uri.shouldNotHavePort(expected: Int)

shouldNotHaveQuery

infix fun Uri.shouldNotHaveQuery(expected: String)

@JvmName(name = "shouldNotHaveQueryNullableStringMatcher")

fun Request.shouldNotHaveQuery(name: String, matcher: Matcher<String?>)

fun Request.shouldNotHaveQuery(name: String, matcher: Matcher<String>)

fun Request.shouldNotHaveQuery(name: String, expected: CharSequence)

fun Request.shouldNotHaveQuery(name: String, expected: List<String?>)

fun Request.shouldNotHaveQuery(name: String, expected: Regex)

fun <T> Request.shouldNotHaveQuery(lens: QueryLens<T>, matcher: Matcher<T>)

shouldNotHaveRequest

infix fun HttpTransaction.shouldNotHaveRequest(match: Matcher<Request>)

shouldNotHaveResponse

infix fun HttpTransaction.shouldNotHaveResponse(match: Matcher<Response>)

shouldNotHaveSameSite

infix fun Cookie.shouldNotHaveSameSite(expected: SameSite)

shouldNotHaveSetCookie

infix fun Response.shouldNotHaveSetCookie(expected: Cookie)

fun Response.shouldNotHaveSetCookie(name: String, match: Matcher<Cookie?>)

shouldNotHaveStatus

infix fun Response.shouldNotHaveStatus(expected: Status)

shouldNotHaveUri

infix fun Request.shouldNotHaveUri(match: Matcher<Uri>)

infix fun Request.shouldNotHaveUri(expected: String)

infix fun Request.shouldNotHaveUri(expected: Regex)

infix fun Request.shouldNotHaveUri(expected: Uri)

shouldNotHaveValue

infix fun Cookie.shouldNotHaveValue(expected: String)