android/okhttp
1
0
Fork 0
mirror of https://github.com/square/okhttp.git synced 2025-07-31 05:04:26 +03:00
Code Releases Activity

Switch to a Builder for mockwebserver3.MockResponse (#7578)

Browse Source 
* Switch to a Builder for mockwebserver3.MockResponse

* Migrate lots of tests to MockResponse.Builder

* Improve some code style

* Follow naming conventions in MockResponse.Builder

* Apply side-effects for inTunnel=true

* Update the API
This commit is contained in:
Jesse Wilson
2022-12-28 10:13:49 -05:00
committed by GitHub
parent 4468abf499
commit fe15ccda5b
47 changed files with 3735 additions and 3111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
mockwebserver-deprecated/src/main/kotlin/okhttp3/mockwebserver/bridge.kt
View File

@ -39,23 +39,23 @@ internal fun Dispatcher.wrap(): mockwebserver3.Dispatcher {
}
internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
val result = mockwebserver3.MockResponse()
val result = mockwebserver3.MockResponse.Builder()
val copyFromWebSocketListener = webSocketListener
if (copyFromWebSocketListener != null) {
result.withWebSocketUpgrade(copyFromWebSocketListener)
result.webSocketUpgrade(copyFromWebSocketListener)
}
val body = getBody()
if (body != null) result.setBody(body)
if (body != null) result.body(body)
for (pushPromise in pushPromises) {
result.withPush(pushPromise.wrap())
result.addPush(pushPromise.wrap())
}
result.withSettings(settings)
result.settings(settings)
result.status = status
result.headers = headers
result.trailers = trailers
result.headers(headers)
result.trailers(trailers)
result.socketPolicy = when (socketPolicy) {
SocketPolicy.EXPECT_CONTINUE, SocketPolicy.CONTINUE_ALWAYS -> {
result.add100Continue()
@ -69,9 +69,9 @@ internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
}
result.http2ErrorCode = http2ErrorCode
result.throttleBody(throttleBytesPerPeriod, getThrottlePeriod(MILLISECONDS), MILLISECONDS)
result.setBodyDelay(getBodyDelay(MILLISECONDS), MILLISECONDS)
result.setHeadersDelay(getHeadersDelay(MILLISECONDS), MILLISECONDS)
return result
result.bodyDelay(getBodyDelay(MILLISECONDS), MILLISECONDS)
result.headersDelay(getHeadersDelay(MILLISECONDS), MILLISECONDS)
return result.build()
}
private fun PushPromise.wrap(): mockwebserver3.PushPromise {

4
mockwebserver-junit5/src/test/java/mockwebserver3/junit5/internal/ExtensionLifecycleTest.kt
View File

@ -37,14 +37,14 @@ class ExtensionLifecycleTest {
fun setup(server: MockWebServer) {
_server = server
assertThat(server.started).isTrue()
server.enqueue(MockResponse().setResponseCode(200))
server.enqueue(MockResponse())
}
@AfterEach
fun tearDown(server: MockWebServer) {
assertThat(_server).isSameAs(server)
assertThat(server.started).isTrue()
server.enqueue(MockResponse().setResponseCode(200))
server.enqueue(MockResponse())
}
@Test

97
mockwebserver/api/mockwebserver3.api
View File

@ -5,22 +5,17 @@ public abstract class mockwebserver3/Dispatcher {
public fun shutdown ()V
}
public final class mockwebserver3/MockResponse : java/lang/Cloneable {
public final class mockwebserver3/MockResponse {
public static final field Companion Lmockwebserver3/MockResponse$Companion;
public final fun -deprecated_getHeaders ()Lokhttp3/Headers;
public final fun -deprecated_getHttp2ErrorCode ()I
public final fun -deprecated_getSocketPolicy ()Lmockwebserver3/SocketPolicy;
public final fun -deprecated_getStatus ()Ljava/lang/String;
public final fun -deprecated_getTrailers ()Lokhttp3/Headers;
public fun <init> ()V
public final fun add100Continue ()Lmockwebserver3/MockResponse;
public final fun addHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse;
public final fun addHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
public final fun addHeaderLenient (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse;
public final fun clearHeaders ()Lmockwebserver3/MockResponse;
public synthetic fun clone ()Ljava/lang/Object;
public fun clone ()Lmockwebserver3/MockResponse;
public fun <init> (I)V
public fun <init> (ILokhttp3/Headers;)V
public fun <init> (ILokhttp3/Headers;Ljava/lang/String;)V
public fun <init> (ILokhttp3/Headers;Ljava/lang/String;Z)V
public fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;)V
public fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;I)V
public synthetic fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;IILkotlin/jvm/internal/DefaultConstructorMarker;)V
public synthetic fun <init> (Lmockwebserver3/MockResponse$Builder;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
public final fun getBody ()Lokio/Buffer;
public final fun getBodyDelay (Ljava/util/concurrent/TimeUnit;)J
public final fun getCode ()I
@ -39,33 +34,57 @@ public final class mockwebserver3/MockResponse : java/lang/Cloneable {
public final fun getThrottlePeriod (Ljava/util/concurrent/TimeUnit;)J
public final fun getTrailers ()Lokhttp3/Headers;
public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
public final fun headers (Lokhttp3/Headers;)V
public final fun http2ErrorCode (I)V
public final fun inTunnel ()Lmockwebserver3/MockResponse;
public final fun isDuplex ()Z
public final fun removeHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse;
public final fun setBody (Ljava/lang/String;)Lmockwebserver3/MockResponse;
public final fun setBody (Lmockwebserver3/internal/duplex/DuplexResponseBody;)Lmockwebserver3/MockResponse;
public final fun setBody (Lokio/Buffer;)Lmockwebserver3/MockResponse;
public final fun setBodyDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
public final fun setChunkedBody (Ljava/lang/String;I)Lmockwebserver3/MockResponse;
public final fun setChunkedBody (Lokio/Buffer;I)Lmockwebserver3/MockResponse;
public final fun setHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
public final fun setHeaders (Lokhttp3/Headers;)Lmockwebserver3/MockResponse;
public final fun setHeadersDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
public final fun setHttp2ErrorCode (I)Lmockwebserver3/MockResponse;
public final fun setResponseCode (I)Lmockwebserver3/MockResponse;
public final fun setSocketPolicy (Lmockwebserver3/SocketPolicy;)Lmockwebserver3/MockResponse;
public final fun setStatus (Ljava/lang/String;)Lmockwebserver3/MockResponse;
public final fun setTrailers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse;
public final fun socketPolicy (Lmockwebserver3/SocketPolicy;)V
public final fun status (Ljava/lang/String;)V
public final fun throttleBody (JJLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
public final fun newBuilder ()Lmockwebserver3/MockResponse$Builder;
public fun toString ()Ljava/lang/String;
public final fun trailers (Lokhttp3/Headers;)V
public final fun withPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse;
public final fun withSettings (Lokhttp3/internal/http2/Settings;)Lmockwebserver3/MockResponse;
public final fun withWebSocketUpgrade (Lokhttp3/WebSocketListener;)Lmockwebserver3/MockResponse;
}
public final class mockwebserver3/MockResponse$Builder : java/lang/Cloneable {
public fun <init> ()V
public final fun add100Continue ()Lmockwebserver3/MockResponse$Builder;
public final fun addHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
public final fun addHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
public final fun addHeaderLenient (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse$Builder;
public final fun addPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse$Builder;
public final fun body (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
public final fun body (Lmockwebserver3/internal/duplex/DuplexResponseBody;)Lmockwebserver3/MockResponse$Builder;
public final fun body (Lokio/Buffer;)Lmockwebserver3/MockResponse$Builder;
public final fun bodyDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
public final fun build ()Lmockwebserver3/MockResponse;
public final fun chunkedBody (Ljava/lang/String;I)Lmockwebserver3/MockResponse$Builder;
public final fun chunkedBody (Lokio/Buffer;I)Lmockwebserver3/MockResponse$Builder;
public final fun clearHeaders ()Lmockwebserver3/MockResponse$Builder;
public synthetic fun clone ()Ljava/lang/Object;
public fun clone ()Lmockwebserver3/MockResponse$Builder;
public final fun code (I)Lmockwebserver3/MockResponse$Builder;
public final fun getCode ()I
public final fun getDuplexResponseBody ()Lmockwebserver3/internal/duplex/DuplexResponseBody;
public final fun getHttp2ErrorCode ()I
public final fun getInTunnel ()Z
public final fun getInformationalResponses ()Ljava/util/List;
public final fun getPushPromises ()Ljava/util/List;
public final fun getSettings ()Lokhttp3/internal/http2/Settings;
public final fun getSocketPolicy ()Lmockwebserver3/SocketPolicy;
public final fun getStatus ()Ljava/lang/String;
public final fun getThrottleBytesPerPeriod ()J
public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
public final fun headers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;
public final fun headersDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
public final fun http2ErrorCode (I)Lmockwebserver3/MockResponse$Builder;
public final fun inTunnel ()Lmockwebserver3/MockResponse$Builder;
public final fun removeHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
public final fun setCode (I)V
public final fun setHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
public final fun setHttp2ErrorCode (I)V
public final fun setSocketPolicy (Lmockwebserver3/SocketPolicy;)V
public final fun setStatus (Ljava/lang/String;)V
public final fun settings (Lokhttp3/internal/http2/Settings;)Lmockwebserver3/MockResponse$Builder;
public final fun socketPolicy (Lmockwebserver3/SocketPolicy;)Lmockwebserver3/MockResponse$Builder;
public final fun status (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
public final fun throttleBody (JJLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
public final fun trailers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;
public final fun webSocketUpgrade (Lokhttp3/WebSocketListener;)Lmockwebserver3/MockResponse$Builder;
}
public final class mockwebserver3/MockResponse$Companion {

2
mockwebserver/src/main/kotlin/mockwebserver3/Dispatcher.kt
View File

@ -31,7 +31,7 @@ abstract class Dispatcher {
* request bodies.
*/
open fun peek(): MockResponse {
return MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }
return MockResponse(socketPolicy = SocketPolicy.KEEP_OPEN)
}
/**

406
mockwebserver/src/main/kotlin/mockwebserver3/MockResponse.kt
View File

@ -18,22 +18,17 @@ package mockwebserver3
import java.util.concurrent.TimeUnit
import mockwebserver3.internal.duplex.DuplexResponseBody
import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okhttp3.WebSocketListener
import okhttp3.internal.addHeaderLenient
import okhttp3.internal.http2.Settings
import okio.Buffer
/** A scripted response to be replayed by the mock web server. */
class MockResponse : Cloneable {
var inTunnel = false
private set
var informationalResponses: List<MockResponse> = listOf()
private set
class MockResponse {
/** Returns the HTTP response line, such as "HTTP/1.1 200 OK". */
@set:JvmName("status")
var status: String = ""
val status: String
val code: Int
get() {
@ -49,96 +44,116 @@ class MockResponse : Cloneable {
return statusParts[2]
}
private var headersBuilder = Headers.Builder()
private var trailersBuilder = Headers.Builder()
val headers: Headers
val trailers: Headers
/** The HTTP headers, such as "Content-Length: 0". */
@set:JvmName("headers")
var headers: Headers
get() = headersBuilder.build()
set(value) {
this.headersBuilder = value.newBuilder()
}
val body: Buffer?
get() { return field?.clone() }
@set:JvmName("trailers")
var trailers: Headers
get() = trailersBuilder.build()
set(value) {
this.trailersBuilder = value.newBuilder()
}
val inTunnel: Boolean
val informationalResponses: List<MockResponse>
private var body: Buffer? = null
val throttleBytesPerPeriod: Long
private val throttlePeriodAmount: Long
private val throttlePeriodUnit: TimeUnit
var throttleBytesPerPeriod: Long = Long.MAX_VALUE
private set
private var throttlePeriodAmount = 1L
private var throttlePeriodUnit = TimeUnit.SECONDS
@set:JvmName("socketPolicy")
var socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN
val socketPolicy: SocketPolicy
/**
* Sets the [HTTP/2 error code](https://tools.ietf.org/html/rfc7540#section-7) to be
* returned when resetting the stream.
* This is only valid with [SocketPolicy.RESET_STREAM_AT_START] and
* [SocketPolicy.DO_NOT_READ_REQUEST_BODY].
* returned when resetting the stream. This is only valid with
* [SocketPolicy.RESET_STREAM_AT_START] and [SocketPolicy.DO_NOT_READ_REQUEST_BODY].
*/
@set:JvmName("http2ErrorCode")
var http2ErrorCode: Int = -1
val http2ErrorCode: Int
private var bodyDelayAmount = 0L
private var bodyDelayUnit = TimeUnit.MILLISECONDS
private val bodyDelayAmount: Long
private val bodyDelayUnit: TimeUnit
private var headersDelayAmount = 0L
private var headersDelayUnit = TimeUnit.MILLISECONDS
private val headersDelayAmount: Long
private var headersDelayUnit: TimeUnit
val pushPromises: List<PushPromise>
val settings: Settings
val webSocketListener: WebSocketListener?
val duplexResponseBody: DuplexResponseBody?
private var promises = mutableListOf<PushPromise>()
var settings: Settings = Settings()
private set
var webSocketListener: WebSocketListener? = null
private set
var duplexResponseBody: DuplexResponseBody? = null
private set
val isDuplex: Boolean
get() = duplexResponseBody != null
/** Returns the streams the server will push with this response. */
val pushPromises: List<PushPromise>
get() = promises
@JvmOverloads
constructor(
code: Int = 200,
headers: Headers = headersOf(),
body: String = "",
inTunnel: Boolean = false,
socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN,
http2ErrorCode: Int = -1,
) : this(Builder()
.apply {
this.code = code
this.headers.addAll(headers)
if (inTunnel) inTunnel()
this.body(body)
this.socketPolicy = socketPolicy
this.http2ErrorCode = http2ErrorCode
}
)
/** Creates a new mock response with an empty body. */
init {
setResponseCode(200)
setHeader("Content-Length", 0L)
private constructor(builder: Builder) {
this.status = builder.status
this.headers = builder.headers.build()
this.trailers = builder.trailers.build()
this.body = builder.body?.clone()
this.inTunnel = builder.inTunnel
this.informationalResponses = builder.informationalResponses.toList()
this.throttleBytesPerPeriod = builder.throttleBytesPerPeriod
this.throttlePeriodAmount = builder.throttlePeriodAmount
this.throttlePeriodUnit = builder.throttlePeriodUnit
this.socketPolicy = builder.socketPolicy
this.http2ErrorCode = builder.http2ErrorCode
this.bodyDelayAmount = builder.bodyDelayAmount
this.bodyDelayUnit = builder.bodyDelayUnit
this.headersDelayAmount = builder.headersDelayAmount
this.headersDelayUnit = builder.headersDelayUnit
this.pushPromises = builder.pushPromises.toList()
this.settings = Settings().apply {
merge(builder.settings)
}
this.webSocketListener = builder.webSocketListener
this.duplexResponseBody = builder.duplexResponseBody
}
public override fun clone(): MockResponse {
val result = super.clone() as MockResponse
result.headersBuilder = headersBuilder.build().newBuilder()
result.promises = promises.toMutableList()
return result
fun getThrottlePeriod(unit: TimeUnit): Long =
unit.convert(throttlePeriodAmount, throttlePeriodUnit)
fun getBodyDelay(unit: TimeUnit): Long =
unit.convert(bodyDelayAmount, bodyDelayUnit)
fun getHeadersDelay(unit: TimeUnit): Long =
unit.convert(headersDelayAmount, headersDelayUnit)
fun newBuilder(): Builder = Builder(this)
override fun toString(): String = status
class Builder : Cloneable {
var inTunnel: Boolean
internal set
val informationalResponses: MutableList<MockResponse>
var status: String
var code: Int
get() {
val statusParts = status.split(' ', limit = 3)
require(statusParts.size >= 2) { "Unexpected status: $status" }
return statusParts[1].toInt()
}
@JvmName("-deprecated_getStatus")
@Deprecated(
message = "moved to var",
replaceWith = ReplaceWith(expression = "status"),
level = DeprecationLevel.ERROR)
fun getStatus(): String = status
/**
* Sets the status and returns this.
*
* This was deprecated in OkHttp 4.0 in favor of the [status] val. In OkHttp 4.3 it is
* un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
* deprecated).
*/
fun setStatus(status: String) = apply {
this.status = status
}
fun setResponseCode(code: Int): MockResponse {
val reason = when (code) {
set(value) {
val reason = when (value) {
in 100..199 -> "Informational"
in 200..299 -> "OK"
in 300..399 -> "Redirection"
@ -146,7 +161,93 @@ class MockResponse : Cloneable {
in 500..599 -> "Server Error"
else -> "Mock Response"
}
return apply { status = "HTTP/1.1 $code $reason" }
status = "HTTP/1.1 $value $reason"
}
internal var headers: Headers.Builder
internal var trailers: Headers.Builder
internal var body: Buffer?
var throttleBytesPerPeriod: Long
private set
internal var throttlePeriodAmount: Long
internal var throttlePeriodUnit: TimeUnit
var socketPolicy: SocketPolicy
var http2ErrorCode: Int
internal var bodyDelayAmount: Long
internal var bodyDelayUnit: TimeUnit
internal var headersDelayAmount: Long
internal var headersDelayUnit: TimeUnit
/** The streams the server will push with this response. */
val pushPromises: MutableList<PushPromise>
val settings: Settings
var webSocketListener: WebSocketListener?
private set
var duplexResponseBody: DuplexResponseBody?
private set
constructor() {
this.inTunnel = false
this.informationalResponses = mutableListOf()
this.status = "HTTP/1.1 200 OK"
this.body = null
this.headers = Headers.Builder()
.add("Content-Length", "0")
this.trailers = Headers.Builder()
this.throttleBytesPerPeriod = Long.MAX_VALUE
this.throttlePeriodAmount = 1L
this.throttlePeriodUnit = TimeUnit.SECONDS
this.socketPolicy = SocketPolicy.KEEP_OPEN
this.http2ErrorCode = -1
this.bodyDelayAmount = 0L
this.bodyDelayUnit = TimeUnit.MILLISECONDS
this.headersDelayAmount = 0L
this.headersDelayUnit = TimeUnit.MILLISECONDS
this.pushPromises = mutableListOf()
this.settings = Settings()
this.webSocketListener = null
this.duplexResponseBody = null
}
internal constructor(mockResponse: MockResponse) {
this.inTunnel = mockResponse.inTunnel
this.informationalResponses = mockResponse.informationalResponses.toMutableList()
this.status = mockResponse.status
this.headers = mockResponse.headers.newBuilder()
this.trailers = mockResponse.trailers.newBuilder()
this.body = mockResponse.body
this.throttleBytesPerPeriod = mockResponse.throttleBytesPerPeriod
this.throttlePeriodAmount = mockResponse.throttlePeriodAmount
this.throttlePeriodUnit = mockResponse.throttlePeriodUnit
this.socketPolicy = mockResponse.socketPolicy
this.http2ErrorCode = mockResponse.http2ErrorCode
this.bodyDelayAmount = mockResponse.bodyDelayAmount
this.bodyDelayUnit = mockResponse.bodyDelayUnit
this.headersDelayAmount = mockResponse.headersDelayAmount
this.headersDelayUnit = mockResponse.headersDelayUnit
this.pushPromises = mockResponse.pushPromises.toMutableList()
this.settings = Settings().apply {
merge(mockResponse.settings)
}
this.webSocketListener = mockResponse.webSocketListener
this.duplexResponseBody = mockResponse.duplexResponseBody
}
fun code(code: Int) = apply {
this.code = code
}
/** Sets the status and returns this. */
fun status(status: String) = apply {
this.status = status
}
/**
@ -154,15 +255,15 @@ class MockResponse : Cloneable {
* were added by default.
*/
fun clearHeaders() = apply {
headersBuilder = Headers.Builder()
headers = Headers.Builder()
}
/**
* Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a
* name followed by a colon and a value.
* Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a name followed
* by a colon and a value.
*/
fun addHeader(header: String) = apply {
headersBuilder.add(header)
headers.add(header)
}
/**
@ -170,7 +271,7 @@ class MockResponse : Cloneable {
* same name.
*/
fun addHeader(name: String, value: Any) = apply {
headersBuilder.add(name, value.toString())
headers.add(name, value.toString())
}
/**
@ -179,12 +280,10 @@ class MockResponse : Cloneable {
* value.
*/
fun addHeaderLenient(name: String, value: Any) = apply {
addHeaderLenient(headersBuilder, name, value.toString())
addHeaderLenient(headers, name, value.toString())
}
/**
* Removes all headers named [name], then adds a new header with the name and value.
*/
/** Removes all headers named [name], then adds a new header with the name and value. */
fun setHeader(name: String, value: Any) = apply {
removeHeader(name)
addHeader(name, value)
@ -192,30 +291,27 @@ class MockResponse : Cloneable {
/** Removes all headers named [name]. */
fun removeHeader(name: String) = apply {
headersBuilder.removeAll(name)
headers.removeAll(name)
}
/** Returns a copy of the raw HTTP payload. */
fun getBody(): Buffer? = body?.clone()
fun setBody(body: Buffer) = apply {
fun body(body: Buffer) = apply {
setHeader("Content-Length", body.size)
this.body = body.clone() // Defensive copy.
}
/** Sets the response body to the UTF-8 encoded bytes of [body]. */
fun setBody(body: String): MockResponse = setBody(Buffer().writeUtf8(body))
fun body(body: String): Builder = body(Buffer().writeUtf8(body))
fun setBody(duplexResponseBody: DuplexResponseBody) = apply {
fun body(duplexResponseBody: DuplexResponseBody) = apply {
this.duplexResponseBody = duplexResponseBody
}
/**
* Sets the response body to [body], chunked every [maxChunkSize] bytes.
*/
fun setChunkedBody(body: Buffer, maxChunkSize: Int) = apply {
fun chunkedBody(body: Buffer, maxChunkSize: Int) = apply {
removeHeader("Content-Length")
headersBuilder.add(CHUNKED_BODY_HEADER)
headers.add(CHUNKED_BODY_HEADER)
val bytesOut = Buffer()
while (!body.exhausted()) {
@ -233,74 +329,26 @@ class MockResponse : Cloneable {
* Sets the response body to the UTF-8 encoded bytes of [body],
* chunked every [maxChunkSize] bytes.
*/
fun setChunkedBody(body: String, maxChunkSize: Int): MockResponse =
setChunkedBody(Buffer().writeUtf8(body), maxChunkSize)
fun chunkedBody(body: String, maxChunkSize: Int): Builder =
chunkedBody(Buffer().writeUtf8(body), maxChunkSize)
@JvmName("-deprecated_getHeaders")
@Deprecated(
message = "moved to var",
replaceWith = ReplaceWith(expression = "headers"),
level = DeprecationLevel.ERROR)
fun getHeaders(): Headers = headers
/** Sets the headers and returns this. */
fun headers(headers: Headers) = apply {
this.headers = headers.newBuilder()
}
/**
* Sets the headers and returns this.
*
* This was deprecated in OkHttp 4.0 in favor of the [headers] val. In OkHttp 4.3 it is
* un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
* deprecated).
*/
fun setHeaders(headers: Headers) = apply { this.headers = headers }
/** Sets the trailers and returns this. */
fun trailers(trailers: Headers) = apply {
this.trailers = trailers.newBuilder()
}
@JvmName("-deprecated_getTrailers")
@Deprecated(
message = "moved to var",
replaceWith = ReplaceWith(expression = "trailers"),
level = DeprecationLevel.ERROR)
fun getTrailers(): Headers = trailers
/**
* Sets the trailers and returns this.
*
* This was deprecated in OkHttp 4.0 in favor of the [trailers] val. In OkHttp 4.3 it is
* un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
* deprecated).
*/
fun setTrailers(trailers: Headers) = apply { this.trailers = trailers }
@JvmName("-deprecated_getSocketPolicy")
@Deprecated(
message = "moved to var",
replaceWith = ReplaceWith(expression = "socketPolicy"),
level = DeprecationLevel.ERROR)
fun getSocketPolicy(): SocketPolicy = socketPolicy
/**
* Sets the socket policy and returns this.
*
* This was deprecated in OkHttp 4.0 in favor of the [socketPolicy] val. In OkHttp 4.3 it is
* un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
* deprecated).
*/
fun setSocketPolicy(socketPolicy: SocketPolicy) = apply {
/** Sets the socket policy and returns this. */
fun socketPolicy(socketPolicy: SocketPolicy) = apply {
this.socketPolicy = socketPolicy
}
@JvmName("-deprecated_getHttp2ErrorCode")
@Deprecated(
message = "moved to var",
replaceWith = ReplaceWith(expression = "http2ErrorCode"),
level = DeprecationLevel.ERROR)
fun getHttp2ErrorCode(): Int = http2ErrorCode
/**
* Sets the HTTP/2 error code and returns this.
*
* This was deprecated in OkHttp 4.0 in favor of the [http2ErrorCode] val. In OkHttp 4.3 it is
* un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
* deprecated).
*/
fun setHttp2ErrorCode(http2ErrorCode: Int) = apply {
/** Sets the HTTP/2 error code and returns this. */
fun http2ErrorCode(http2ErrorCode: Int) = apply {
this.http2ErrorCode = http2ErrorCode
}
@ -314,50 +362,42 @@ class MockResponse : Cloneable {
throttlePeriodUnit = unit
}
fun getThrottlePeriod(unit: TimeUnit): Long =
unit.convert(throttlePeriodAmount, throttlePeriodUnit)
/**
* Set the delayed time of the response body to [delay]. This applies to the response body
* only; response headers are not affected.
*/
fun setBodyDelay(delay: Long, unit: TimeUnit) = apply {
fun bodyDelay(delay: Long, unit: TimeUnit) = apply {
bodyDelayAmount = delay
bodyDelayUnit = unit
}
fun getBodyDelay(unit: TimeUnit): Long =
unit.convert(bodyDelayAmount, bodyDelayUnit)
fun setHeadersDelay(delay: Long, unit: TimeUnit) = apply {
fun headersDelay(delay: Long, unit: TimeUnit) = apply {
headersDelayAmount = delay
headersDelayUnit = unit
}
fun getHeadersDelay(unit: TimeUnit): Long =
unit.convert(headersDelayAmount, headersDelayUnit)
/**
* When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this attaches a
* pushed stream to this response.
*/
fun withPush(promise: PushPromise) = apply {
promises.add(promise)
fun addPush(promise: PushPromise) = apply {
this.pushPromises += promise
}
/**
* When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this pushes
* [settings] before writing the response.
*/
fun withSettings(settings: Settings) = apply {
this.settings = settings
fun settings(settings: Settings) = apply {
this.settings.clear()
this.settings.merge(settings)
}
/**
* Attempts to perform a web socket upgrade on the connection.
* This will overwrite any previously set status or body.
*/
fun withWebSocketUpgrade(listener: WebSocketListener) = apply {
fun webSocketUpgrade(listener: WebSocketListener) = apply {
status = "HTTP/1.1 101 Switching Protocols"
setHeader("Connection", "Upgrade")
setHeader("Upgrade", "websocket")
@ -379,7 +419,7 @@ class MockResponse : Cloneable {
/**
* Adds an HTTP 1xx response to precede this response. Note that this response's
* [headers delay][setHeadersDelay] applies after this response is transmitted. Set a
* [headers delay][headersDelay] applies after this response is transmitted. Set a
* headers delay on that response to delay its transmission.
*/
fun addInformationalResponse(response: MockResponse) = apply {
@ -387,13 +427,13 @@ class MockResponse : Cloneable {
}
fun add100Continue() = apply {
addInformationalResponse(
MockResponse()
.setResponseCode(100)
)
addInformationalResponse(MockResponse(code = 100))
}
override fun toString(): String = status
public override fun clone(): Builder = build().newBuilder()
fun build(): MockResponse = MockResponse(this)
}
companion object {
private const val CHUNKED_BODY_HEADER = "Transfer-encoding: chunked"

33
mockwebserver/src/main/kotlin/mockwebserver3/MockWebServer.kt
View File

@ -357,7 +357,7 @@ class MockWebServer : Closeable {
* replaced with [setDispatcher][dispatcher].
*/
fun enqueue(response: MockResponse) =
(dispatcher as QueueDispatcher).enqueueResponse(response.clone())
(dispatcher as QueueDispatcher).enqueueResponse(response)
/**
* Starts the server on the loopback interface for the given port.
@ -795,9 +795,10 @@ class MockWebServer : Closeable {
response: MockResponse
) {
val key = request.getHeader("Sec-WebSocket-Key")
response.setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
writeHttpResponse(socket, sink, response)
val webSocketResponse = response.newBuilder()
.setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
.build()
writeHttpResponse(socket, sink, webSocketResponse)
// Adapt the request and response into our Request and Response domain model.
val scheme = if (request.tlsVersion != null) "https" else "http"
@ -807,9 +808,9 @@ class MockWebServer : Closeable {
.headers(request.headers)
.build()
val fancyResponse = Response.Builder()
.code(response.code)
.message(response.message)
.headers(response.headers)
.code(webSocketResponse.code)
.message(webSocketResponse.message)
.headers(webSocketResponse.headers)
.request(fancyRequest)
.protocol(Protocol.HTTP_1_1)
.build()
@ -821,13 +822,13 @@ class MockWebServer : Closeable {
val webSocket = RealWebSocket(
taskRunner = taskRunner,
originalRequest = fancyRequest,
listener = response.webSocketListener!!,
listener = webSocketResponse.webSocketListener!!,
random = SecureRandom(),
pingIntervalMillis = 0,
extensions = WebSocketExtensions.parse(response.headers),
extensions = WebSocketExtensions.parse(webSocketResponse.headers),
minimumDeflateSize = 0L // Compress all messages if compression is enabled.
)
response.webSocketListener!!.onOpen(webSocket, fancyResponse)
webSocketResponse.webSocketListener!!.onOpen(webSocket, fancyResponse)
val name = "MockWebServer WebSocket ${request.path!!}"
webSocket.initReaderAndWriter(name, streams)
try {
@ -850,7 +851,7 @@ class MockWebServer : Closeable {
writeHeaders(sink, response.headers)
val body = response.getBody() ?: return
val body = response.body ?: return
sleepIfDelayed(response.getBodyDelay(TimeUnit.MILLISECONDS))
throttledTransfer(response, socket, body, sink, body.size, false)
@ -1116,7 +1117,7 @@ class MockWebServer : Closeable {
val bodyDelayMs = response.getBodyDelay(TimeUnit.MILLISECONDS)
val trailers = response.trailers
val body = response.getBody()
val body = response.body
val outFinished = (body == null &&
response.pushPromises.isEmpty() &&
!response.isDuplex)
@ -1173,7 +1174,7 @@ class MockWebServer : Closeable {
socket = socket
)
)
val hasBody = pushPromise.response.getBody() != null
val hasBody = pushPromise.response.body != null
val pushedStream = stream.connection.pushStream(stream.id, pushedHeaders, hasBody)
writeResponse(pushedStream, request, pushPromise.response)
}
@ -1184,10 +1185,10 @@ class MockWebServer : Closeable {
init {
MwsDuplexAccess.instance = object : MwsDuplexAccess() {
override fun setBody(
mockResponse: MockResponse,
duplexResponseBody: DuplexResponseBody
mockResponseBuilder: MockResponse.Builder,
duplexResponseBody: DuplexResponseBody,
) {
mockResponse.setBody(duplexResponseBody)
mockResponseBuilder.body(duplexResponseBody)
}
}
}

8
mockwebserver/src/main/kotlin/mockwebserver3/QueueDispatcher.kt
View File

@ -34,7 +34,7 @@ open class QueueDispatcher : Dispatcher() {
val requestLine = request.requestLine
if (requestLine == "GET /favicon.ico HTTP/1.1") {
logger.info("served $requestLine")
return MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
return MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
}
if (failFastResponse != null && responseQueue.peek() == null) {
@ -69,7 +69,7 @@ open class QueueDispatcher : Dispatcher() {
open fun setFailFast(failFast: Boolean) {
val failFastResponse = if (failFast) {
MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
} else {
null
}
@ -85,9 +85,7 @@ open class QueueDispatcher : Dispatcher() {
* Enqueued on shutdown to release threads waiting on [dispatch]. Note that this response
* isn't transmitted because the connection is closed before this response is returned.
*/
private val DEAD_LETTER = MockResponse().apply {
this.status = "HTTP/1.1 $HTTP_UNAVAILABLE shutting down"
}
private val DEAD_LETTER = MockResponse(code = HTTP_UNAVAILABLE)
private val logger = Logger.getLogger(QueueDispatcher::class.java.name)
}

5
mockwebserver/src/main/kotlin/okhttp3/internal/duplex/MwsDuplexAccess.kt
View File

@ -24,7 +24,10 @@ import mockwebserver3.internal.duplex.DuplexResponseBody
*/
abstract class MwsDuplexAccess {
abstract fun setBody(mockResponse: MockResponse, duplexResponseBody: DuplexResponseBody)
abstract fun setBody(
mockResponseBuilder: MockResponse.Builder,
duplexResponseBody: DuplexResponseBody,
)
companion object {
@JvmField var instance: MwsDuplexAccess? = null

150
mockwebserver/src/test/java/mockwebserver3/MockWebServerTest.java
View File

@ -51,7 +51,6 @@ import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.extension.RegisterExtension;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Arrays.asList;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
@ -83,9 +82,9 @@ public final class MockWebServerTest {
}
@Test public void defaultMockResponse() {
MockResponse response = new MockResponse();
assertThat(headersToList(response)).containsExactly("Content-Length: 0");
assertThat(response.getStatus()).isEqualTo("HTTP/1.1 200 OK");
MockResponse.Builder builder = new MockResponse.Builder();
assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
assertThat(builder.getStatus()).isEqualTo("HTTP/1.1 200 OK");
}
@Test public void setResponseMockReason() {
@ -99,56 +98,57 @@ public final class MockWebServerTest {
"Mock Response"
};
for (int i = 0; i < 600; i++) {
MockResponse response = new MockResponse().setResponseCode(i);
MockResponse.Builder builder = new MockResponse.Builder().code(i);
String expectedReason = reasons[i / 100];
assertThat(response.getStatus()).isEqualTo(("HTTP/1.1 " + i + " " + expectedReason));
assertThat(headersToList(response)).containsExactly("Content-Length: 0");
assertThat(builder.getStatus()).isEqualTo(("HTTP/1.1 " + i + " " + expectedReason));
assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
}
}
@Test public void setStatusControlsWholeStatusLine() {
MockResponse response = new MockResponse().setStatus("HTTP/1.1 202 That'll do pig");
assertThat(headersToList(response)).containsExactly("Content-Length: 0");
assertThat(response.getStatus()).isEqualTo("HTTP/1.1 202 That'll do pig");
MockResponse.Builder builder = new MockResponse.Builder().status("HTTP/1.1 202 That'll do pig");
assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
assertThat(builder.getStatus()).isEqualTo("HTTP/1.1 202 That'll do pig");
}
@Test public void setBodyAdjustsHeaders() throws IOException {
MockResponse response = new MockResponse().setBody("ABC");
assertThat(headersToList(response)).containsExactly("Content-Length: 3");
MockResponse.Builder builder = new MockResponse.Builder().body("ABC");
assertThat(headersToList(builder)).containsExactly("Content-Length: 3");
MockResponse response = builder.build();
assertThat(response.getBody().readUtf8()).isEqualTo("ABC");
}
@Test public void mockResponseAddHeader() {
MockResponse response = new MockResponse()
MockResponse.Builder builder = new MockResponse.Builder()
.clearHeaders()
.addHeader("Cookie: s=square")
.addHeader("Cookie", "a=android");
assertThat(headersToList(response)).containsExactly("Cookie: s=square", "Cookie: a=android");
assertThat(headersToList(builder)).containsExactly("Cookie: s=square", "Cookie: a=android");
}
@Test public void mockResponseSetHeader() {
MockResponse response = new MockResponse()
MockResponse.Builder builder = new MockResponse.Builder()
.clearHeaders()
.addHeader("Cookie: s=square")
.addHeader("Cookie: a=android")
.addHeader("Cookies: delicious");
response.setHeader("cookie", "r=robot");
assertThat(headersToList(response)).containsExactly("Cookies: delicious", "cookie: r=robot");
builder.setHeader("cookie", "r=robot");
assertThat(headersToList(builder)).containsExactly("Cookies: delicious", "cookie: r=robot");
}
@Test public void mockResponseSetHeaders() {
MockResponse response = new MockResponse()
MockResponse.Builder builder = new MockResponse.Builder()
.clearHeaders()
.addHeader("Cookie: s=square")
.addHeader("Cookies: delicious");
response.setHeaders(new Headers.Builder().add("Cookie", "a=android").build());
builder.headers(new Headers.Builder().add("Cookie", "a=android").build());
assertThat(headersToList(response)).containsExactly("Cookie: a=android");
assertThat(headersToList(builder)).containsExactly("Cookie: a=android");
}
@Test public void regularResponse() throws Exception {
server.enqueue(new MockResponse().setBody("hello world"));
server.enqueue(new MockResponse.Builder().body("hello world").build());
URL url = server.url("/").url();
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@ -167,11 +167,14 @@ public final class MockWebServerTest {
}
@Test public void redirect() throws Exception {
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: " + server.url("/new-path"))
.setBody("This page has moved!"));
server.enqueue(new MockResponse().setBody("This is the new location!"));
.body("This page has moved!")
.build());
server.enqueue(new MockResponse.Builder()
.body("This is the new location!")
.build());
URLConnection connection = server.url("/").url().openConnection();
InputStream in = connection.getInputStream();
@ -194,7 +197,9 @@ public final class MockWebServerTest {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
}
server.enqueue(new MockResponse().setBody("enqueued in the background"));
server.enqueue(new MockResponse.Builder()
.body("enqueued in the background")
.build());
}).start();
URLConnection connection = server.url("/").url().openConnection();
@ -204,10 +209,11 @@ public final class MockWebServerTest {
}
@Test public void nonHexadecimalChunkSize() throws Exception {
server.enqueue(new MockResponse()
.setBody("G\r\nxxxxxxxxxxxxxxxx\r\n0\r\n\r\n")
server.enqueue(new MockResponse.Builder()
.body("G\r\nxxxxxxxxxxxxxxxx\r\n0\r\n\r\n")
.clearHeaders()
.addHeader("Transfer-encoding: chunked"));
.addHeader("Transfer-encoding: chunked")
.build());
URLConnection connection = server.url("/").url().openConnection();
InputStream in = connection.getInputStream();
@ -219,11 +225,14 @@ public final class MockWebServerTest {
}
@Test public void responseTimeout() throws Exception {
server.enqueue(new MockResponse()
.setBody("ABC")
server.enqueue(new MockResponse.Builder()
.body("ABC")
.clearHeaders()
.addHeader("Content-Length: 4"));
server.enqueue(new MockResponse().setBody("DEF"));
.addHeader("Content-Length: 4")
.build());
server.enqueue(new MockResponse.Builder()
.body("DEF")
.build());
URLConnection urlConnection = server.url("/").url().openConnection();
urlConnection.setReadTimeout(1000);
@ -250,7 +259,9 @@ public final class MockWebServerTest {
@Disabled("Not actually failing where expected")
@Test public void disconnectAtStart() throws Exception {
server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.DISCONNECT_AT_START)
.build());
server.enqueue(new MockResponse()); // The jdk's HttpUrlConnection is a bastard.
server.enqueue(new MockResponse());
try {
@ -262,9 +273,13 @@ public final class MockWebServerTest {
}
@Test public void clearDispatcherQueue() throws Exception {
server.enqueue(new MockResponse().setBody("A"));
server.enqueue(new MockResponse.Builder()
.body("A")
.build());
((QueueDispatcher) server.getDispatcher()).clear();
server.enqueue(new MockResponse().setBody("B"));
server.enqueue(new MockResponse.Builder()
.body("B")
.build());
InputStream in = server.url("/a").url().openConnection().getInputStream();
assertThat(in.read()).isEqualTo('B');
@ -277,8 +292,9 @@ public final class MockWebServerTest {
@Test public void throttleRequest() throws Exception {
TestUtil.assumeNotWindows();
server.enqueue(new MockResponse()
.throttleBody(3, 500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.throttleBody(3, 500, TimeUnit.MILLISECONDS)
.build());
long startNanos = System.nanoTime();
URLConnection connection = server.url("/").url().openConnection();
@ -298,9 +314,10 @@ public final class MockWebServerTest {
@Test public void throttleResponse() throws Exception {
TestUtil.assumeNotWindows();
server.enqueue(new MockResponse()
.setBody("ABCDEF")
.throttleBody(3, 500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.body("ABCDEF")
.throttleBody(3, 500, TimeUnit.MILLISECONDS)
.build());
long startNanos = System.nanoTime();
URLConnection connection = server.url("/").url().openConnection();
@ -321,9 +338,10 @@ public final class MockWebServerTest {
@Test public void delayResponse() throws IOException {
TestUtil.assumeNotWindows();
server.enqueue(new MockResponse()
.setBody("ABCDEF")
.setBodyDelay(1, SECONDS));
server.enqueue(new MockResponse.Builder()
.body("ABCDEF")
.bodyDelay(1, SECONDS)
.build());
long startNanos = System.nanoTime();
URLConnection connection = server.url("/").url().openConnection();
@ -337,7 +355,9 @@ public final class MockWebServerTest {
}
@Test public void disconnectRequestHalfway() throws Exception {
server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
.build());
// Limit the size of the request body that the server holds in memory to an arbitrary
// 3.5 MBytes so this test can pass on devices with little memory.
server.setBodyLimit(7 * 512 * 1024);
@ -368,9 +388,10 @@ public final class MockWebServerTest {
}
@Test public void disconnectResponseHalfway() throws IOException {
server.enqueue(new MockResponse()
.setBody("ab")
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
server.enqueue(new MockResponse.Builder()
.body("ab")
.socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
.build());
URLConnection connection = server.url("/").url().openConnection();
assertThat(connection.getContentLength()).isEqualTo(2);
@ -386,8 +407,8 @@ public final class MockWebServerTest {
}
}
private List<String> headersToList(MockResponse response) {
Headers headers = response.getHeaders();
private List<String> headersToList(MockResponse.Builder response) {
Headers headers = response.build().getHeaders();
int size = headers.size();
List<String> headerList = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
@ -445,7 +466,9 @@ public final class MockWebServerTest {
}
@Test public void requestUrlReconstructed() throws Exception {
server.enqueue(new MockResponse().setBody("hello world"));
server.enqueue(new MockResponse.Builder()
.body("hello world")
.build());
URL url = server.url("/a/deep/path?key=foo%20bar").url();
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@ -467,7 +490,9 @@ public final class MockWebServerTest {
}
@Test public void shutdownServerAfterRequest() throws Exception {
server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.SHUTDOWN_SERVER_AFTER_RESPONSE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.SHUTDOWN_SERVER_AFTER_RESPONSE)
.build());
URL url = server.url("/").url();
@ -485,7 +510,9 @@ public final class MockWebServerTest {
}
@Test public void http100Continue() throws Exception {
server.enqueue(new MockResponse().setBody("response"));
server.enqueue(new MockResponse.Builder()
.body("response")
.build());
URL url = server.url("/").url();
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@ -502,10 +529,11 @@ public final class MockWebServerTest {
}
@Test public void multiple1xxResponses() throws Exception {
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.add100Continue()
.add100Continue()
.setBody("response"));
.body("response")
.build());
URL url = server.url("/").url();
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@ -553,7 +581,9 @@ public final class MockWebServerTest {
@Test public void https() throws Exception {
HandshakeCertificates handshakeCertificates = localhost();
server.useHttps(handshakeCertificates.sslSocketFactory());
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
HttpUrl url = server.url("/");
HttpsURLConnection connection = (HttpsURLConnection) url.url().openConnection();
@ -595,7 +625,9 @@ public final class MockWebServerTest {
.build();
server.useHttps(serverHandshakeCertificates.sslSocketFactory());
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
server.requestClientAuth();
HeldCertificate clientCertificate = new HeldCertificate.Builder()
@ -628,7 +660,9 @@ public final class MockWebServerTest {
}
@Test public void proxiedRequestGetsCorrectRequestUrl() throws Exception {
server.enqueue(new MockResponse().setBody("Result"));
server.enqueue(new MockResponse.Builder()
.body("Result")
.build());
OkHttpClient proxiedClient = new OkHttpClient.Builder()
.proxy(server.toProxyAddress())

24
okhttp-coroutines/src/jvmTest/kotlin/okhttp3/SuspendCallTest.kt
View File

@ -39,7 +39,6 @@ import org.junit.jupiter.api.fail
import java.io.IOException
import java.util.concurrent.TimeUnit
import kotlin.time.Duration.Companion.seconds
import kotlin.time.ExperimentalTime
import org.junit.jupiter.api.BeforeEach
@ExtendWith(MockWebServerExtension::class)
@ -61,7 +60,7 @@ class SuspendCallTest {
@Test
fun suspendCall() {
runTest {
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse(body = "abc"))
val call = client.newCall(request)
@ -77,9 +76,10 @@ class SuspendCallTest {
fun timeoutCall() {
runTest {
server.enqueue(
MockResponse()
.setBodyDelay(5, TimeUnit.SECONDS)
.setBody("abc")
MockResponse.Builder()
.bodyDelay(5, TimeUnit.SECONDS)
.body("abc")
.build()
)
val call = client.newCall(request)
@ -105,9 +105,10 @@ class SuspendCallTest {
fun cancelledCall() {
runTest {
server.enqueue(
MockResponse()
.setBodyDelay(5, TimeUnit.SECONDS)
.setBody("abc")
MockResponse.Builder()
.bodyDelay(5, TimeUnit.SECONDS)
.body("abc")
.build()
)
val call = client.newCall(request)
@ -132,9 +133,10 @@ class SuspendCallTest {
fun failedCall() {
runTest {
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST)
.setBody("abc")
MockResponse(
body = "abc",
socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST,
)
)
val call = client.newCall(request)

21
okhttp-dnsoverhttps/src/test/java/okhttp3/dnsoverhttps/DnsOverHttpsTest.java
View File

@ -178,7 +178,10 @@ public class DnsOverHttpsTest {
server.enqueue(dnsResponse(
"0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
+ "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
+ "0010000003b00049df00112").setHeader("cache-control", "private, max-age=298"));
+ "0010000003b00049df00112")
.newBuilder()
.setHeader("cache-control", "private, max-age=298")
.build());
List<InetAddress> result = cachedDns.lookup("google.com");
@ -201,7 +204,10 @@ public class DnsOverHttpsTest {
server.enqueue(dnsResponse(
"0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
+ "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
+ "0010000003b00049df00112").setHeader("cache-control", "max-age=1"));
+ "0010000003b00049df00112")
.newBuilder()
.setHeader("cache-control", "max-age=1")
.build());
List<InetAddress> result = cachedDns.lookup("google.com");
@ -217,7 +223,10 @@ public class DnsOverHttpsTest {
server.enqueue(dnsResponse(
"0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
+ "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
+ "0010000003b00049df00112").setHeader("cache-control", "max-age=1"));
+ "0010000003b00049df00112")
.newBuilder()
.setHeader("cache-control", "max-age=1")
.build());
result = cachedDns.lookup("google.com");
assertThat(result).isEqualTo(singletonList(address("157.240.1.18")));
@ -229,9 +238,11 @@ public class DnsOverHttpsTest {
}
private MockResponse dnsResponse(String s) {
return new MockResponse().setBody(new Buffer().write(ByteString.decodeHex(s)))
return new MockResponse.Builder()
.body(new Buffer().write(ByteString.decodeHex(s)))
.addHeader("content-type", "application/dns-message")
.addHeader("content-length", s.length() / 2);
.addHeader("content-length", s.length() / 2)
.build();
}
private DnsOverHttps buildLocalhost(OkHttpClient bootstrapClient, boolean includeIPv6) {

91
okhttp-logging-interceptor/src/test/java/okhttp3/logging/HttpLoggingInterceptorTest.java
View File

@ -167,9 +167,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void basicResponseBody() throws IOException {
setLevel(Level.BASIC);
server.enqueue(new MockResponse()
.setBody("Hello!")
.setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.body("Hello!")
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -187,9 +188,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void basicChunkedResponseBody() throws IOException {
setLevel(Level.BASIC);
server.enqueue(new MockResponse()
.setChunkedBody("Hello!", 2)
.setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.chunkedBody("Hello!", 2)
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -378,9 +380,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void headersResponseBody() throws IOException {
setLevel(Level.HEADERS);
server.enqueue(new MockResponse()
.setBody("Hello!")
.setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.body("Hello!")
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -446,8 +449,9 @@ public final class HttpLoggingInterceptorTest {
}
private void bodyGetNoBody(int code) throws IOException {
server.enqueue(new MockResponse()
.setStatus("HTTP/1.1 " + code + " No Content"));
server.enqueue(new MockResponse.Builder()
.status("HTTP/1.1 " + code + " No Content")
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -512,9 +516,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyResponseBody() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
.setBody("Hello!")
.setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.body("Hello!")
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -548,9 +553,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyResponseBodyChunked() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
.setChunkedBody("Hello!", 2)
.setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.chunkedBody("Hello!", 2)
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -584,9 +590,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyRequestGzipEncoded() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.setHeader("Content-Type", PLAIN)
.setBody(new Buffer().writeUtf8("Uncompressed")));
.body(new Buffer().writeUtf8("Uncompressed"))
.build());
Response response = client.newCall(request()
.addHeader("Content-Encoding", "gzip")
@ -620,11 +627,12 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyResponseGzipEncoded() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.setHeader("Content-Encoding", "gzip")
.setHeader("Content-Type", PLAIN)
.setBody(new Buffer().write(ByteString.decodeBase64(
"H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA="))));
.body(new Buffer().write(ByteString.decodeBase64(
"H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA=")))
.build());
Response response = client.newCall(request().build()).execute();
ResponseBody responseBody = response.body();
@ -662,12 +670,13 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyResponseUnknownEncoded() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
// It's invalid to return this if not requested, but the server might anyway
.setHeader("Content-Encoding", "br")
.setHeader("Content-Type", PLAIN)
.setBody(new Buffer().write(ByteString.decodeBase64(
"iwmASGVsbG8sIEhlbGxvLCBIZWxsbwoD"))));
.body(new Buffer().write(ByteString.decodeBase64(
"iwmASGVsbG8sIEhlbGxvLCBIZWxsbwoD")))
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -699,9 +708,9 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyResponseIsStreaming() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.setHeader("Content-Type", "text/event-stream")
.setChunkedBody(""
.chunkedBody(""
+ "event: add\n"
+ "data: 73857293\n"
+ "\n"
@ -711,6 +720,7 @@ public final class HttpLoggingInterceptorTest {
+ "event: add\n"
+ "data: 113411\n"
+ "\n", 8)
.build()
);
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -741,9 +751,10 @@ public final class HttpLoggingInterceptorTest {
@Test public void bodyGetMalformedCharset() throws IOException {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.setHeader("Content-Type", "text/html; charset=0")
.setBody("Body with unknown charset"));
.body("Body with unknown charset")
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -785,9 +796,10 @@ public final class HttpLoggingInterceptorTest {
buffer.writeUtf8CodePoint(0x0a);
buffer.writeUtf8CodePoint(0x1a);
buffer.writeUtf8CodePoint(0x0a);
server.enqueue(new MockResponse()
.setBody(buffer)
.setHeader("Content-Type", "image/png; charset=utf-8"));
server.enqueue(new MockResponse.Builder()
.body(buffer)
.setHeader("Content-Type", "image/png; charset=utf-8")
.build());
Response response = client.newCall(request().build()).execute();
response.body().close();
@ -874,8 +886,9 @@ public final class HttpLoggingInterceptorTest {
.addInterceptor(applicationInterceptor)
.build();
server.enqueue(
new MockResponse().addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value"));
server.enqueue(new MockResponse.Builder()
.addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value")
.build());
Response response =
client
.newCall(
@ -924,8 +937,9 @@ public final class HttpLoggingInterceptorTest {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
.setBody("Hello response!"));
server.enqueue(new MockResponse.Builder()
.body("Hello response!")
.build());
RequestBody asyncRequestBody = new RequestBody() {
@Override public @Nullable MediaType contentType() {
@ -966,8 +980,9 @@ public final class HttpLoggingInterceptorTest {
setLevel(Level.BODY);
server.enqueue(new MockResponse()
.setBody("Hello response!"));
server.enqueue(new MockResponse.Builder()
.body("Hello response!")
.build());
RequestBody asyncRequestBody = new RequestBody() {
@Override public @Nullable MediaType contentType() {

9
okhttp-logging-interceptor/src/test/java/okhttp3/logging/LoggingEventListenerTest.java
View File

@ -77,7 +77,10 @@ public final class LoggingEventListenerTest {
public void get() throws Exception {
TestUtil.assumeNotWindows();
server.enqueue(new MockResponse().setBody("Hello!").setHeader("Content-Type", PLAIN));
server.enqueue(new MockResponse.Builder()
.body("Hello!")
.setHeader("Content-Type", PLAIN)
.build());
Response response = client.newCall(request().build()).execute();
assertThat(response.body()).isNotNull();
response.body().bytes();
@ -223,7 +226,9 @@ public final class LoggingEventListenerTest {
server.useHttps(handshakeCertificates.sslSocketFactory());
server.setProtocols(asList(HTTP_2, HTTP_1_1));
server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
.build());
url = server.url("/");
try {

52
okhttp-sse/src/test/java/okhttp3/sse/internal/EventSourceHttpTest.java
View File

@ -56,9 +56,11 @@ public final class EventSourceHttpTest {
}
@Test public void event() {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
EventSource source = newEventSource();
@ -70,9 +72,11 @@ public final class EventSourceHttpTest {
}
@Test public void cancelInEventShortCircuits() throws IOException {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
listener.enqueueCancel(); // Will cancel in onOpen().
newEventSource();
@ -81,18 +85,24 @@ public final class EventSourceHttpTest {
}
@Test public void badContentType() {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/plain"));
+ "\n").setHeader("content-type", "text/plain")
.build());
newEventSource();
listener.assertFailure("Invalid content-type: text/plain");
}
@Test public void badResponseCode() {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream").setResponseCode(401));
+ "\n")
.setHeader("content-type", "text/event-stream")
.code(401)
.build());
newEventSource();
listener.assertFailure(null);
@ -103,10 +113,11 @@ public final class EventSourceHttpTest {
.callTimeout(250, TimeUnit.MILLISECONDS)
.build();
server.enqueue(new MockResponse()
.setBodyDelay(500, TimeUnit.MILLISECONDS)
server.enqueue(new MockResponse.Builder()
.bodyDelay(500, TimeUnit.MILLISECONDS)
.setHeader("content-type", "text/event-stream")
.setBody("data: hey\n\n"));
.body("data: hey\n\n")
.build());
EventSource source = newEventSource();
@ -122,19 +133,22 @@ public final class EventSourceHttpTest {
.callTimeout(250, TimeUnit.MILLISECONDS)
.build();
server.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS)
server.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.setHeader("content-type", "text/event-stream")
.setBody("data: hey\n\n"));
.body("data: hey\n\n")
.build());
newEventSource();
listener.assertFailure("timeout");
}
@Test public void retainsAccept() throws InterruptedException {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
EventSource source = newEventSource("text/plain");
@ -146,9 +160,11 @@ public final class EventSourceHttpTest {
}
@Test public void setsMissingAccept() throws InterruptedException {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
EventSource source = newEventSource();

12
okhttp-sse/src/test/java/okhttp3/sse/internal/EventSourcesHttpTest.java
View File

@ -52,9 +52,11 @@ public final class EventSourcesHttpTest {
}
@Test public void processResponse() throws IOException {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -68,9 +70,11 @@ public final class EventSourcesHttpTest {
}
@Test public void cancelShortCircuits() throws IOException {
server.enqueue(new MockResponse().setBody(""
server.enqueue(new MockResponse.Builder()
.body(""
+ "data: hey\n"
+ "\n").setHeader("content-type", "text/event-stream"));
+ "\n").setHeader("content-type", "text/event-stream")
.build());
listener.enqueueCancel(); // Will cancel in onOpen().
Request request = new Request.Builder()

45
okhttp/src/jvmTest/java/okhttp3/CacheCorruptionTest.kt
View File

@ -15,8 +15,19 @@
*/
package okhttp3
import java.net.CookieManager
import java.net.ResponseCache
import java.text.DateFormat
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import java.util.TimeZone
import java.util.concurrent.TimeUnit
import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLSession
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.buildCache
import okhttp3.okio.LoggingFilesystem
import okhttp3.testing.PlatformRule
@ -28,16 +39,6 @@ import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension
import java.net.CookieManager
import java.net.ResponseCache
import java.text.DateFormat
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import java.util.TimeZone
import java.util.concurrent.TimeUnit
import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLSession
class CacheCorruptionTest {
var fileSystem = FakeFileSystem()
@ -145,16 +146,22 @@ class CacheCorruptionTest {
private fun testCorruptingCache(corruptor: () -> Unit): Response {
server.useHttps(handshakeCertificates.sslSocketFactory())
server.enqueue(
MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setBody("ABC.1")
MockResponse(
headers = headersOf(
"Last-Modified", formatDate(-1, TimeUnit.HOURS)!!,
"Expires", formatDate(1, TimeUnit.HOURS)!!,
),
body = "ABC.1",
)
)
server.enqueue(
MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setBody("ABC.2")
MockResponse(
headers = headersOf(
"Last-Modified", formatDate(-1, TimeUnit.HOURS)!!,
"Expires", formatDate(1, TimeUnit.HOURS)!!,
),
body = "ABC.2",
)
)
client = client.newBuilder()
.sslSocketFactory(
@ -162,7 +169,7 @@ class CacheCorruptionTest {
)
.hostnameVerifier(NULL_HOSTNAME_VERIFIER)
.build()
val request: Request = Request(server.url("/"))
val request = Request(server.url("/"))
val response1: Response = client.newCall(request).execute()
val bodySource = response1.body.source()
assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

1190
okhttp/src/jvmTest/java/okhttp3/CacheTest.java
View File

File diff suppressed because it is too large Load Diff

4
okhttp/src/jvmTest/java/okhttp3/CallHandshakeTest.kt
View File

@ -15,6 +15,7 @@
*/
package okhttp3
import javax.net.ssl.SSLSocket
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import okhttp3.CipherSuite.Companion.TLS_AES_128_GCM_SHA256
@ -35,7 +36,6 @@ import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension
import javax.net.ssl.SSLSocket
class CallHandshakeTest {
private lateinit var client: OkHttpClient
@ -62,7 +62,7 @@ class CallHandshakeTest {
fun setup(server: MockWebServer) {
this.server = server
server.enqueue(MockResponse().setResponseCode(200))
server.enqueue(MockResponse())
client = clientTestRule.newClientBuilder()
.sslSocketFactory(

39
okhttp/src/jvmTest/java/okhttp3/CallKotlinTest.kt
View File

@ -63,8 +63,8 @@ class CallKotlinTest {
@Test
fun legalToExecuteTwiceCloning() {
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse().setBody("def"))
server.enqueue(MockResponse(body = "abc"))
server.enqueue(MockResponse(body = "def"))
val request = Request(server.url("/"))
@ -83,7 +83,7 @@ class CallKotlinTest {
fun testMockWebserverRequest() {
enableTls()
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse(body = "abc"))
val request = Request.Builder().url(server.url("/")).build()
@ -130,15 +130,9 @@ class CallKotlinTest {
}
}
server.enqueue(MockResponse().apply {
setResponseCode(201)
})
server.enqueue(MockResponse().apply {
setResponseCode(204)
})
server.enqueue(MockResponse().apply {
setResponseCode(204)
})
server.enqueue(MockResponse(code = 201))
server.enqueue(MockResponse(code = 204))
server.enqueue(MockResponse(code = 204))
val endpointUrl = server.url("/endpoint")
@ -192,9 +186,13 @@ class CallKotlinTest {
})
.build()
server.enqueue(MockResponse().setBody("a")
.setSocketPolicy(SocketPolicy.SHUTDOWN_OUTPUT_AT_END))
server.enqueue(MockResponse().setBody("b"))
server.enqueue(
MockResponse(
body = "a",
socketPolicy = SocketPolicy.SHUTDOWN_OUTPUT_AT_END
)
)
server.enqueue(MockResponse(body = "b"))
val requestA = Request(server.url("/"))
val responseA = client.newCall(requestA).execute()
@ -243,8 +241,8 @@ class CallKotlinTest {
/** Confirm suppressed exceptions that occur after connecting are returned. */
@Test fun httpExceptionsAreReturnedAsSuppressed() {
server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START))
server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START))
server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AT_START))
server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AT_START))
client = client.newBuilder()
.dns(DoubleInetAddressDns()) // Two routes so we get two failures.
@ -266,9 +264,10 @@ class CallKotlinTest {
@Test
fun responseRequestIsLastRedirect() {
server.enqueue(
MockResponse()
.setResponseCode(302)
.addHeader("Location: /b")
MockResponse(
code = 302,
headers = headersOf("Location", "/b"),
)
)
server.enqueue(MockResponse())

1582
okhttp/src/jvmTest/java/okhttp3/CallTest.kt
View File

File diff suppressed because it is too large Load Diff

50
okhttp/src/jvmTest/java/okhttp3/ConnectionCoalescingTest.java
View File

@ -276,11 +276,13 @@ public final class ConnectionCoalescingTest {
}
@Test public void skipsOnRedirectWhenDnsDontMatch() throws Exception {
server.enqueue(new MockResponse()
.setResponseCode(301)
.addHeader("Location", url.newBuilder().host("differentdns.com").build()));
server.enqueue(new MockResponse()
.setBody("unexpected call"));
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", url.newBuilder().host("differentdns.com").build())
.build());
server.enqueue(new MockResponse.Builder()
.body("unexpected call")
.build());
try {
Response response = execute(url);
@ -307,9 +309,10 @@ public final class ConnectionCoalescingTest {
}
@Test public void skipsOnRedirectWhenNotSubjectAltName() throws Exception {
server.enqueue(new MockResponse()
.setResponseCode(301)
.addHeader("Location", url.newBuilder().host("nonsan.com").build()));
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", url.newBuilder().host("nonsan.com").build())
.build());
server.enqueue(new MockResponse());
try {
@ -365,9 +368,10 @@ public final class ConnectionCoalescingTest {
.build();
client = client.newBuilder().certificatePinner(pinner).build();
server.enqueue(new MockResponse()
.setResponseCode(301)
.addHeader("Location", url.newBuilder().host("san.com").build()));
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", url.newBuilder().host("san.com").build())
.build());
server.enqueue(new MockResponse());
try {
@ -401,9 +405,10 @@ public final class ConnectionCoalescingTest {
HostnameVerifier verifier = (name, session) -> true;
client = client.newBuilder().hostnameVerifier(verifier).build();
server.enqueue(new MockResponse()
.setResponseCode(301)
.addHeader("Location", url.newBuilder().host("san.com").build()));
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", url.newBuilder().host("san.com").build())
.build());
server.enqueue(new MockResponse());
assert200Http2Response(execute(url), "san.com");
@ -475,13 +480,16 @@ public final class ConnectionCoalescingTest {
}
@Test public void misdirectedRequestResponseCode() throws Exception {
server.enqueue(new MockResponse()
.setBody("seed connection"));
server.enqueue(new MockResponse()
.setResponseCode(421)
.setBody("misdirected!"));
server.enqueue(new MockResponse()
.setBody("after misdirect"));
server.enqueue(new MockResponse.Builder()
.body("seed connection")
.build());
server.enqueue(new MockResponse.Builder()
.code(421)
.body("misdirected!")
.build());
server.enqueue(new MockResponse.Builder()
.body("after misdirect")
.build());
// Seed the connection pool.
assert200Http2Response(execute(url), server.getHostName());

138
okhttp/src/jvmTest/java/okhttp3/ConnectionReuseTest.kt
View File

@ -20,6 +20,7 @@ import javax.net.ssl.SSLException
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy
import okhttp3.Headers.Companion.headersOf
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.ResponseBody.Companion.toResponseBody
@ -48,39 +49,44 @@ class ConnectionReuseTest {
private val handshakeCertificates: HandshakeCertificates = localhost()
private var client: OkHttpClient = clientTestRule.newClient()
@BeforeEach fun setUp(server: MockWebServer) {
@BeforeEach
fun setUp(server: MockWebServer) {
this.server = server
}
@Test fun connectionsAreReused() {
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
@Test
fun connectionsAreReused() {
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
assertConnectionReused(request, request)
}
@Test fun connectionsAreReusedForPosts() {
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
@Test
fun connectionsAreReusedForPosts() {
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val request = Request(
url = server.url("/"),
body ="request body".toRequestBody("text/plain".toMediaType()),
body = "request body".toRequestBody("text/plain".toMediaType()),
)
assertConnectionReused(request, request)
}
@Test fun connectionsAreReusedWithHttp2() {
@Test
fun connectionsAreReusedWithHttp2() {
platform.assumeNotBouncyCastle()
enableHttp2()
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
assertConnectionReused(request, request)
}
@Test fun connectionsAreNotReusedWithRequestConnectionClose() {
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
@Test
fun connectionsAreNotReusedWithRequestConnectionClose() {
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val requestA = Request.Builder()
.url(server.url("/"))
.header("Connection", "close")
@ -89,51 +95,58 @@ class ConnectionReuseTest {
assertConnectionNotReused(requestA, requestB)
}
@Test fun connectionsAreNotReusedWithResponseConnectionClose() {
@Test
fun connectionsAreNotReusedWithResponseConnectionClose() {
server.enqueue(
MockResponse()
.addHeader("Connection", "close")
.setBody("a")
MockResponse(
headers = headersOf("Connection", "close"),
body = "a",
)
server.enqueue(MockResponse().setBody("b"))
)
server.enqueue(MockResponse(body = "b"))
val requestA = Request(server.url("/"))
val requestB = Request(server.url("/"))
assertConnectionNotReused(requestA, requestB)
}
@Test fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
@Test
fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
server.enqueue(
MockResponse()
.setBody("a")
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
MockResponse.Builder()
.body("a")
.clearHeaders()
.socketPolicy(SocketPolicy.DISCONNECT_AT_END)
.build()
)
server.enqueue(MockResponse().setBody("b"))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
assertConnectionNotReused(request, request)
}
@Test fun connectionsAreNotReusedIfPoolIsSizeZero() {
@Test
fun connectionsAreNotReusedIfPoolIsSizeZero() {
client = client.newBuilder()
.connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
.build()
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
assertConnectionNotReused(request, request)
}
@Test fun connectionsReusedWithRedirectEvenIfPoolIsSizeZero() {
@Test
fun connectionsReusedWithRedirectEvenIfPoolIsSizeZero() {
client = client.newBuilder()
.connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
.build()
server.enqueue(
MockResponse()
.setResponseCode(301)
.addHeader("Location: /b")
.setBody("a")
MockResponse(
code = 301,
headers = headersOf("Location", "/b"),
body = "a"
)
server.enqueue(MockResponse().setBody("b"))
)
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
val response = client.newCall(request).execute()
assertThat(response.body.string()).isEqualTo("b")
@ -141,18 +154,19 @@ class ConnectionReuseTest {
assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
}
@Test fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
@Test
fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
client = client.newBuilder()
.connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
.build()
server.enqueue(
MockResponse()
.setResponseCode(301)
MockResponse.Builder()
.code(301)
.addHeader("Location: /b")
.setBodyDelay(1, TimeUnit.SECONDS)
.setBody("a")
)
server.enqueue(MockResponse().setBody("b"))
.bodyDelay(1, TimeUnit.SECONDS)
.body("a")
.build())
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
val response = client.newCall(request).execute()
assertThat(response.body.string()).isEqualTo("b")
@ -160,10 +174,11 @@ class ConnectionReuseTest {
assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
}
@Test fun silentRetryWhenIdempotentRequestFailsOnReusedConnection() {
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
server.enqueue(MockResponse().setBody("b"))
@Test
fun silentRetryWhenIdempotentRequestFailsOnReusedConnection() {
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
val responseA = client.newCall(request).execute()
assertThat(responseA.body.string()).isEqualTo("a")
@ -174,11 +189,12 @@ class ConnectionReuseTest {
assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
}
@Test fun http2ConnectionsAreSharedBeforeResponseIsConsumed() {
@Test
fun http2ConnectionsAreSharedBeforeResponseIsConsumed() {
platform.assumeNotBouncyCastle()
enableHttp2()
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
val request = Request(server.url("/"))
val response1 = client.newCall(request).execute()
val response2 = client.newCall(request).execute()
@ -188,9 +204,10 @@ class ConnectionReuseTest {
assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
}
@Test fun connectionsAreEvicted() {
server.enqueue(MockResponse().setBody("a"))
server.enqueue(MockResponse().setBody("b"))
@Test
fun connectionsAreEvicted() {
server.enqueue(MockResponse(body = "a"))
server.enqueue(MockResponse(body = "b"))
client = client.newBuilder()
.connectionPool(ConnectionPool(5, 250, TimeUnit.MILLISECONDS))
.build()
@ -206,7 +223,8 @@ class ConnectionReuseTest {
assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
}
@Test fun connectionsAreNotReusedIfSslSocketFactoryChanges() {
@Test
fun connectionsAreNotReusedIfSslSocketFactoryChanges() {
platform.assumeNotBouncyCastle()
enableHttps()
server.enqueue(MockResponse())
@ -231,7 +249,8 @@ class ConnectionReuseTest {
}
}
@Test fun connectionsAreNotReusedIfHostnameVerifierChanges() {
@Test
fun connectionsAreNotReusedIfHostnameVerifierChanges() {
platform.assumeNotBouncyCastle()
enableHttps()
server.enqueue(MockResponse())
@ -261,7 +280,8 @@ class ConnectionReuseTest {
*
* https://github.com/square/okhttp/issues/2409
*/
@Test fun connectionsAreNotReusedIfNetworkInterceptorInterferes() {
@Test
fun connectionsAreNotReusedIfNetworkInterceptorInterferes() {
val responsesNotClosed: MutableList<Response?> = ArrayList()
client =
client.newBuilder()
@ -280,14 +300,14 @@ class ConnectionReuseTest {
})
.build()
server.enqueue(
MockResponse()
.setResponseCode(301)
.addHeader("Location: /b")
.setBody("/a has moved!")
MockResponse(
code = 301,
headers = headersOf("Location", "/b"),
body = "/a has moved!",
)
)
server.enqueue(
MockResponse()
.setBody("/b is here")
MockResponse(body = "/b is here")
)
val request = Request(server.url("/"))
val call = client.newCall(request)

32
okhttp/src/jvmTest/java/okhttp3/CookiesTest.java
View File

@ -62,11 +62,13 @@ public class CookiesTest {
.build();
HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
server.enqueue(new MockResponse().addHeader("Set-Cookie: a=android; "
server.enqueue(new MockResponse.Builder()
.addHeader("Set-Cookie: a=android; "
+ "expires=Fri, 31-Dec-9999 23:59:59 GMT; "
+ "path=/path; "
+ "domain=" + urlWithIpAddress.host() + "; "
+ "secure"));
+ "secure")
.build());
get(urlWithIpAddress);
List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@ -90,13 +92,15 @@ public class CookiesTest {
.build();
HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
server.enqueue(new MockResponse().addHeader("Set-Cookie: a=android; "
server.enqueue(new MockResponse.Builder()
.addHeader("Set-Cookie: a=android; "
+ "Comment=this cookie is delicious; "
+ "Domain=" + urlWithIpAddress.host() + "; "
+ "Max-Age=60; "
+ "Path=/path; "
+ "Secure; "
+ "Version=1"));
+ "Version=1")
.build());
get(urlWithIpAddress);
List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@ -119,7 +123,8 @@ public class CookiesTest {
.build();
HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
server.enqueue(new MockResponse().addHeader("Set-Cookie: a=\"android\"; "
server.enqueue(new MockResponse.Builder()
.addHeader("Set-Cookie: a=\"android\"; "
+ "Comment=\"this cookie is delicious\"; "
+ "CommentURL=\"http://google.com/\"; "
+ "Discard; "
@ -128,7 +133,8 @@ public class CookiesTest {
+ "Path=\"/path\"; "
+ "Port=\"80,443," + server.getPort() + "\"; "
+ "Secure; "
+ "Version=\"1\""));
+ "Version=\"1\"")
.build());
get(urlWithIpAddress);
List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@ -191,9 +197,10 @@ public class CookiesTest {
}
@Test public void receiveAndSendMultipleCookies() throws Exception {
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.addHeader("Set-Cookie", "a=android")
.addHeader("Set-Cookie", "b=banana"));
.addHeader("Set-Cookie", "b=banana")
.build());
server.enqueue(new MockResponse());
CookieManager cookieManager = new CookieManager(null, ACCEPT_ORIGINAL_SERVER);
@ -212,14 +219,15 @@ public class CookiesTest {
@Test public void testRedirectsDoNotIncludeTooManyCookies() throws Exception {
MockWebServer redirectTarget = new MockWebServer();
redirectTarget.enqueue(new MockResponse().setBody("A"));
redirectTarget.enqueue(new MockResponse.Builder().body("A").build());
redirectTarget.start();
HttpUrl redirectTargetUrl = urlWithIpAddress(redirectTarget, "/");
MockWebServer redirectSource = new MockWebServer();
redirectSource.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: " + redirectTargetUrl));
redirectSource.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: " + redirectTargetUrl)
.build());
redirectSource.start();
HttpUrl redirectSourceUrl = urlWithIpAddress(redirectSource, "/");

71
okhttp/src/jvmTest/java/okhttp3/DuplexTest.java
View File

@ -43,7 +43,6 @@ import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.extension.RegisterExtension;
import static java.util.Arrays.asList;
import static okhttp3.tls.internal.TlsUtil.localhost;
import static org.assertj.core.api.Assertions.assertThat;
@ -91,7 +90,7 @@ public final class DuplexTest {
@Test public void trueDuplexClientWritesFirst() throws Exception {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.receiveRequest("request A\n")
@ -134,7 +133,7 @@ public final class DuplexTest {
@Test public void trueDuplexServerWritesFirst() throws Exception {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.sendResponse("response A\n")
@ -177,11 +176,11 @@ public final class DuplexTest {
@Test public void clientReadsHeadersDataTrailers() throws Exception {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders()
.addHeader("h1", "v1")
.addHeader("h2", "v2")
.setTrailers(Headers.of("trailers", "boom")),
.trailers(Headers.of("trailers", "boom")),
new MockDuplexResponseBody()
.sendResponse("ok")
.exhaustResponse());
@ -207,7 +206,7 @@ public final class DuplexTest {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders()
.addHeader("h1", "v1")
.addHeader("h2", "v2"),
@ -236,7 +235,7 @@ public final class DuplexTest {
@Test public void requestBodyEndsAfterResponseBody() throws Exception {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.exhaustResponse()
@ -271,7 +270,7 @@ public final class DuplexTest {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders()
.add100Continue(),
new MockDuplexResponseBody()
@ -327,16 +326,17 @@ public final class DuplexTest {
.build();
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders()
.setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
.code(HttpURLConnection.HTTP_MOVED_PERM)
.addHeader("Location: /b"),
new MockDuplexResponseBody()
.sendResponse("/a has moved!\n", duplexResponseSent)
.requestIOException()
.exhaustResponse());
server.enqueue(new MockResponse()
.setBody("this is /b"));
server.enqueue(new MockResponse.Builder()
.body("this is /b")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -381,15 +381,15 @@ public final class DuplexTest {
.build();
MockDuplexResponseBody mockResponseBody1 = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders()
.setResponseCode(HttpURLConnection.HTTP_UNAUTHORIZED),
.code(HttpURLConnection.HTTP_UNAUTHORIZED),
new MockDuplexResponseBody()
.sendResponse("please authenticate!\n")
.requestIOException()
.exhaustResponse());
MockDuplexResponseBody mockResponseBody2 = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.sendResponse("response body\n")
@ -431,8 +431,9 @@ public final class DuplexTest {
@Test public void fullCallTimeoutAppliesToSetup() throws Exception {
enableProtocol(Protocol.HTTP_2);
server.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -454,7 +455,7 @@ public final class DuplexTest {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.sendResponse("response A\n")
@ -490,7 +491,7 @@ public final class DuplexTest {
@Test public void duplexWithRewriteInterceptors() throws Exception {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.receiveRequest("REQUEST A\n")
@ -541,7 +542,7 @@ public final class DuplexTest {
enableProtocol(Protocol.HTTP_2);
MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
new MockResponse()
new MockResponse.Builder()
.clearHeaders(),
new MockDuplexResponseBody()
.sendResponse("success!")
@ -588,8 +589,9 @@ public final class DuplexTest {
@Test public void headersReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() throws Exception {
enableProtocol(Protocol.HTTP_2);
server.enqueue(new MockResponse()
.setHeadersDelay(1500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(1500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -613,9 +615,10 @@ public final class DuplexTest {
@Test public void bodyReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() throws Exception {
enableProtocol(Protocol.HTTP_2);
server.enqueue(new MockResponse()
.setBodyDelay(1500, TimeUnit.MILLISECONDS)
.setBody("this should never be received"));
server.enqueue(new MockResponse.Builder()
.bodyDelay(1500, TimeUnit.MILLISECONDS)
.body("this should never be received")
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -643,8 +646,9 @@ public final class DuplexTest {
@Test public void headersReadTimeoutDoesNotStartUntilLastRequestBodyByteNoFire() throws Exception {
enableProtocol(Protocol.HTTP_2);
server.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -667,9 +671,10 @@ public final class DuplexTest {
@Test public void bodyReadTimeoutDoesNotStartUntilLastRequestBodyByteNoFire() throws Exception {
enableProtocol(Protocol.HTTP_2);
server.enqueue(new MockResponse()
.setBodyDelay(500, TimeUnit.MILLISECONDS)
.setBody("success"));
server.enqueue(new MockResponse.Builder()
.bodyDelay(500, TimeUnit.MILLISECONDS)
.body("success")
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -686,9 +691,9 @@ public final class DuplexTest {
}
private MockDuplexResponseBody enqueueResponseWithBody(
MockResponse response, MockDuplexResponseBody body) {
MwsDuplexAccess.instance.setBody(response, body);
server.enqueue(response);
MockResponse.Builder builder, MockDuplexResponseBody body) {
MwsDuplexAccess.instance.setBody(builder, body);
server.enqueue(builder.build());
return body;
}

243
okhttp/src/jvmTest/java/okhttp3/EventListenerTest.java
View File

@ -120,8 +120,9 @@ public final class EventListenerTest {
}
@Test public void successfulCallEventSequence() throws IOException {
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -139,8 +140,9 @@ public final class EventListenerTest {
}
@Test public void successfulCallEventSequenceForIpAddress() throws IOException {
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
String ipAddress = InetAddress.getLoopbackAddress().getHostAddress();
@ -160,8 +162,9 @@ public final class EventListenerTest {
}
@Test public void successfulCallEventSequenceForEnqueue() throws Exception {
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -191,8 +194,9 @@ public final class EventListenerTest {
}
@Test public void failedCallEventSequence() {
server.enqueue(new MockResponse()
.setHeadersDelay(2, TimeUnit.SECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(2, TimeUnit.SECONDS)
.build());
client = client.newBuilder()
.readTimeout(Duration.ofMillis(250))
@ -215,9 +219,11 @@ public final class EventListenerTest {
}
@Test public void failedDribbledCallEventSequence() throws IOException {
server.enqueue(new MockResponse().setBody("0123456789")
server.enqueue(new MockResponse.Builder()
.body("0123456789")
.throttleBody(2, 100, TimeUnit.MILLISECONDS)
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
.socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
.build());
client = client.newBuilder()
.protocols(Collections.singletonList(Protocol.HTTP_1_1))
@ -262,8 +268,9 @@ public final class EventListenerTest {
}
@Test public void cancelAsyncCall() throws IOException {
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -282,8 +289,9 @@ public final class EventListenerTest {
}
@Test public void multipleCancelsEmitsOnlyOneEvent() throws IOException {
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -409,8 +417,9 @@ public final class EventListenerTest {
@Test public void successfulEmptyHttpsCallEventSequence() throws IOException {
enableTlsWithTunnel();
server.setProtocols(asList(Protocol.HTTP_1_1));
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
assertSuccessfulEventOrder(anyResponse);
@ -421,8 +430,10 @@ public final class EventListenerTest {
@Test public void successfulChunkedHttpsCallEventSequence() throws IOException {
enableTlsWithTunnel();
server.setProtocols(asList(Protocol.HTTP_1_1));
server.enqueue(
new MockResponse().setBodyDelay(100, TimeUnit.MILLISECONDS).setChunkedBody("Hello!", 2));
server.enqueue(new MockResponse.Builder()
.bodyDelay(100, TimeUnit.MILLISECONDS)
.chunkedBody("Hello!", 2)
.build());
assertSuccessfulEventOrder(anyResponse);
@ -433,8 +444,10 @@ public final class EventListenerTest {
@Test public void successfulChunkedH2CallEventSequence() throws IOException {
enableTlsWithTunnel();
server.setProtocols(asList(Protocol.HTTP_2, Protocol.HTTP_1_1));
server.enqueue(
new MockResponse().setBodyDelay(100, TimeUnit.MILLISECONDS).setChunkedBody("Hello!", 2));
server.enqueue(new MockResponse.Builder()
.bodyDelay(100, TimeUnit.MILLISECONDS)
.chunkedBody("Hello!", 2)
.build());
assertSuccessfulEventOrder(matchesProtocol(Protocol.HTTP_2));
@ -489,9 +502,10 @@ public final class EventListenerTest {
}
@Test public void multipleDnsLookupsForSingleCall() throws IOException {
server.enqueue(new MockResponse()
.setResponseCode(301)
.setHeader("Location", "http://www.fakeurl:" + server.getPort()));
server.enqueue(new MockResponse.Builder()
.code(301)
.setHeader("Location", "http://www.fakeurl:" + server.getPort())
.build());
server.enqueue(new MockResponse());
FakeDns dns = new FakeDns();
@ -583,8 +597,9 @@ public final class EventListenerTest {
@Test public void failedConnect() throws UnknownHostException {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -612,8 +627,9 @@ public final class EventListenerTest {
@Test public void multipleConnectsForSingleCall() throws IOException {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
.build());
server.enqueue(new MockResponse());
client = client.newBuilder()
@ -695,13 +711,15 @@ public final class EventListenerTest {
@Test public void authenticatingTunnelProxyConnect() throws IOException {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.inTunnel()
.setResponseCode(407)
.code(407)
.addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
.addHeader("Connection: close"));
server.enqueue(new MockResponse()
.inTunnel());
.addHeader("Connection: close")
.build());
server.enqueue(new MockResponse.Builder()
.inTunnel()
.build());
server.enqueue(new MockResponse());
client = client.newBuilder()
@ -746,8 +764,9 @@ public final class EventListenerTest {
@Test public void failedSecureConnect() {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -768,8 +787,9 @@ public final class EventListenerTest {
@Test public void secureConnectWithTunnel() throws IOException {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
.inTunnel());
server.enqueue(new MockResponse.Builder()
.inTunnel()
.build());
server.enqueue(new MockResponse());
client = client.newBuilder()
@ -793,8 +813,9 @@ public final class EventListenerTest {
@Test public void multipleSecureConnectsForSingleCall() throws IOException {
enableTlsWithTunnel();
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
.build());
server.enqueue(new MockResponse());
client = client.newBuilder()
@ -862,11 +883,13 @@ public final class EventListenerTest {
}
@Test public void noConnectionFoundOnFollowUp() throws IOException {
server.enqueue(new MockResponse()
.setResponseCode(301)
.addHeader("Location", "/foo"));
server.enqueue(new MockResponse()
.setBody("ABC"));
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", "/foo")
.build());
server.enqueue(new MockResponse.Builder()
.body("ABC")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -908,12 +931,14 @@ public final class EventListenerTest {
}
@Test public void multipleConnectionsFoundForSingleCall() throws IOException {
server.enqueue(new MockResponse()
.setResponseCode(301)
server.enqueue(new MockResponse.Builder()
.code(301)
.addHeader("Location", "/foo")
.addHeader("Connection", "Close"));
server.enqueue(new MockResponse()
.setBody("ABC"));
.addHeader("Connection", "Close")
.build());
server.enqueue(new MockResponse.Builder()
.body("ABC")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -946,9 +971,10 @@ public final class EventListenerTest {
private void responseBodyFail(Protocol expectedProtocol) throws IOException {
// Use a 2 MiB body so the disconnect won't happen until the client has read some data.
int responseBodySize = 2 * 1024 * 1024; // 2 MiB
server.enqueue(new MockResponse()
.setBody(new Buffer().write(new byte[responseBodySize]))
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
server.enqueue(new MockResponse.Builder()
.body(new Buffer().write(new byte[responseBodySize]))
.socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -970,10 +996,11 @@ public final class EventListenerTest {
}
@Test public void emptyResponseBody() throws IOException {
server.enqueue(new MockResponse()
.setBody("")
.setBodyDelay(1, TimeUnit.SECONDS)
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
server.enqueue(new MockResponse.Builder()
.body("")
.bodyDelay(1, TimeUnit.SECONDS)
.socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -989,9 +1016,10 @@ public final class EventListenerTest {
}
@Test public void emptyResponseBodyConnectionClose() throws IOException {
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.addHeader("Connection", "close")
.setBody(""));
.body("")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1007,10 +1035,11 @@ public final class EventListenerTest {
}
@Test public void responseBodyClosedClosedWithoutReadingAllData() throws IOException {
server.enqueue(new MockResponse()
.setBody("abc")
.setBodyDelay(1, TimeUnit.SECONDS)
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
server.enqueue(new MockResponse.Builder()
.body("abc")
.bodyDelay(1, TimeUnit.SECONDS)
.socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1046,8 +1075,9 @@ public final class EventListenerTest {
}
private void requestBodyFail(@Nullable Protocol expectedProtocol) {
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
.build());
NonCompletingRequestBody request = new NonCompletingRequestBody();
Call call = client.newCall(new Request.Builder()
@ -1127,8 +1157,9 @@ public final class EventListenerTest {
}
};
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1188,7 +1219,9 @@ public final class EventListenerTest {
}
@Test public void successfulCallEventSequenceWithListener() throws IOException {
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
client = client.newBuilder()
.addNetworkInterceptor(new HttpLoggingInterceptor()
@ -1211,9 +1244,10 @@ public final class EventListenerTest {
private void requestBodySuccess(RequestBody body, Matcher<Long> requestBodyBytes,
Matcher<Long> responseHeaderLength) throws IOException {
server.enqueue(new MockResponse()
.setResponseCode(200)
.setBody("World!"));
server.enqueue(new MockResponse.Builder()
.code(200)
.body("World!")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1307,11 +1341,12 @@ public final class EventListenerTest {
.build());
// Create a response with artificial delays.
server.enqueue(new MockResponse()
.setHeadersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
.setBodyDelay(responseBodyStartDelay, TimeUnit.MILLISECONDS)
server.enqueue(new MockResponse.Builder()
.headersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
.bodyDelay(responseBodyStartDelay, TimeUnit.MILLISECONDS)
.throttleBody(5, responseBodyEndDelay, TimeUnit.MILLISECONDS)
.setBody("fghijk"));
.body("fghijk")
.build());
// Make the call.
try (Response response = call.execute()) {
@ -1343,9 +1378,10 @@ public final class EventListenerTest {
}
@Test public void redirectUsingSameConnectionEventSequence() throws IOException {
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: /foo"));
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: /foo")
.build());
server.enqueue(new MockResponse());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
@ -1364,9 +1400,10 @@ public final class EventListenerTest {
public void redirectUsingNewConnectionEventSequence() throws IOException {
MockWebServer otherServer = new MockWebServer();
server.enqueue(
new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: " + otherServer.url("/foo")));
new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: " + otherServer.url("/foo"))
.build());
otherServer.enqueue(new MockResponse());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
@ -1384,8 +1421,8 @@ public final class EventListenerTest {
}
@Test public void applicationInterceptorProceedsMultipleTimes() throws Exception {
server.enqueue(new MockResponse().setBody("a"));
server.enqueue(new MockResponse().setBody("b"));
server.enqueue(new MockResponse.Builder().body("a").build());
server.enqueue(new MockResponse.Builder().body("b").build());
client = client.newBuilder()
.addInterceptor(chain -> {
@ -1432,8 +1469,9 @@ public final class EventListenerTest {
/** Response headers start, then the entire request body, then response headers end. */
@Test public void expectContinueStartsResponseHeadersEarly() throws Exception {
server.enqueue(new MockResponse()
.add100Continue());
server.enqueue(new MockResponse.Builder()
.add100Continue()
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -1453,9 +1491,10 @@ public final class EventListenerTest {
@Test public void timeToFirstByteGapBetweenResponseHeaderStartAndEnd() throws IOException {
long responseHeadersStartDelay = 250L;
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.add100Continue()
.setHeadersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS));
.headersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -1477,8 +1516,9 @@ public final class EventListenerTest {
@Test public void cacheMiss() throws IOException {
enableCache();
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1498,11 +1538,13 @@ public final class EventListenerTest {
@Test public void conditionalCache() throws IOException {
enableCache();
server.enqueue(new MockResponse()
.addHeader("ETag: v1")
.setBody("abc"));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.enqueue(new MockResponse.Builder()
.addHeader("ETag", "v1")
.body("abc")
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_NOT_MODIFIED)
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1530,13 +1572,15 @@ public final class EventListenerTest {
@Test public void conditionalCacheMiss() throws IOException {
enableCache();
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.addHeader("ETag: v1")
.setBody("abc"));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_OK)
.body("abc")
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_OK)
.addHeader("ETag: v2")
.setBody("abd"));
.body("abd")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))
@ -1578,7 +1622,10 @@ public final class EventListenerTest {
@Test public void cacheHit() throws IOException {
enableCache();
server.enqueue(new MockResponse().setBody("abc").addHeader("cache-control: public, max-age=300"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.addHeader("cache-control: public, max-age=300")
.build());
Call call = client.newCall(new Request.Builder()
.url(server.url("/"))

37
okhttp/src/jvmTest/java/okhttp3/FastFallbackTest.kt
View File

@ -114,12 +114,10 @@ class FastFallbackTest {
localhostIpv6,
)
serverIpv4.enqueue(
MockResponse()
.setBody("unexpected call to IPv4")
MockResponse(body = "unexpected call to IPv4")
)
serverIpv6.enqueue(
MockResponse()
.setBody("hello from IPv6")
MockResponse(body = "hello from IPv6")
)
val call = client.newCall(Request(url))
@ -139,12 +137,10 @@ class FastFallbackTest {
localhostIpv4,
)
serverIpv4.enqueue(
MockResponse()
.setBody("unexpected call to IPv4")
MockResponse(body = "unexpected call to IPv4")
)
serverIpv6.enqueue(
MockResponse()
.setBody("hello from IPv6")
MockResponse(body = "hello from IPv6")
)
val call = client.newCall(Request(url))
@ -160,8 +156,7 @@ class FastFallbackTest {
fun reachesIpv4WhenIpv6IsDown() {
serverIpv6.shutdown()
serverIpv4.enqueue(
MockResponse()
.setBody("hello from IPv4")
MockResponse(body = "hello from IPv4")
)
val call = client.newCall(Request(url))
@ -178,8 +173,7 @@ class FastFallbackTest {
fun reachesIpv6WhenIpv4IsDown() {
serverIpv4.shutdown()
serverIpv6.enqueue(
MockResponse()
.setBody("hello from IPv6")
MockResponse(body = "hello from IPv6")
)
val call = client.newCall(Request(url))
@ -216,8 +210,7 @@ class FastFallbackTest {
)
serverIpv6.shutdown()
serverIpv4.enqueue(
MockResponse()
.setBody("hello from IPv4")
MockResponse(body = "hello from IPv4")
)
val call = client.newCall(Request(url))
@ -237,8 +230,7 @@ class FastFallbackTest {
)
serverIpv4.shutdown()
serverIpv6.enqueue(
MockResponse()
.setBody("hello from IPv6")
MockResponse(body = "hello from IPv6")
)
client = client.newBuilder()
@ -300,17 +292,16 @@ class FastFallbackTest {
// Set up a same-connection retry.
serverIpv4.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
serverIpv4.enqueue(
MockResponse()
.setBody("this was the 2nd request on IPv4")
MockResponse(body = "this was the 2nd request on IPv4")
)
serverIpv6.enqueue(
MockResponse()
.setBody("unexpected call to IPv6")
MockResponse(body = "unexpected call to IPv6")
)
// Confirm the retry succeeds on the same connection.

53
okhttp/src/jvmTest/java/okhttp3/InterceptorTest.java
View File

@ -86,7 +86,9 @@ public final class InterceptorTest {
}
@Test public void networkInterceptorsCannotShortCircuitResponses() throws Exception {
server.enqueue(new MockResponse().setResponseCode(500));
server.enqueue(new MockResponse.Builder()
.code(500)
.build());
Interceptor interceptor = chain -> new Response.Builder()
.request(chain.request())
@ -138,7 +140,9 @@ public final class InterceptorTest {
}
@Test public void networkInterceptorsCannotChangeServerAddress() throws Exception {
server.enqueue(new MockResponse().setResponseCode(500));
server.enqueue(new MockResponse.Builder()
.code(500)
.build());
Interceptor interceptor = chain -> {
Address address = chain.connection().route().address();
@ -184,9 +188,10 @@ public final class InterceptorTest {
}
@Test public void networkInterceptorsObserveNetworkHeaders() throws Exception {
server.enqueue(new MockResponse()
.setBody(gzip("abcabcabc"))
.addHeader("Content-Encoding: gzip"));
server.enqueue(new MockResponse.Builder()
.body(gzip("abcabcabc"))
.addHeader("Content-Encoding: gzip")
.build());
Interceptor interceptor = chain -> {
// The network request has everything: User-Agent, Host, Accept-Encoding.
@ -292,9 +297,10 @@ public final class InterceptorTest {
}
private void rewriteResponseFromServer(boolean network) throws Exception {
server.enqueue(new MockResponse()
server.enqueue(new MockResponse.Builder()
.addHeader("Original-Header: foo")
.setBody("abc"));
.body("abc")
.build());
addInterceptor(network, chain -> {
Response originalResponse = chain.proceed(chain.request());
@ -385,8 +391,8 @@ public final class InterceptorTest {
}
@Test public void applicationInterceptorsCanMakeMultipleRequestsToServer() throws Exception {
server.enqueue(new MockResponse().setBody("a"));
server.enqueue(new MockResponse().setBody("b"));
server.enqueue(new MockResponse.Builder().body("a").build());
server.enqueue(new MockResponse.Builder().body("b").build());
client = client.newBuilder()
.addInterceptor(chain -> {
@ -406,8 +412,8 @@ public final class InterceptorTest {
/** Make sure interceptors can interact with the OkHttp client. */
@Test public void interceptorMakesAnUnrelatedRequest() throws Exception {
server.enqueue(new MockResponse().setBody("a")); // Fetched by interceptor.
server.enqueue(new MockResponse().setBody("b")); // Fetched directly.
server.enqueue(new MockResponse.Builder().body("a").build()); // Fetched by interceptor.
server.enqueue(new MockResponse.Builder().body("b").build()); // Fetched directly.
client = client.newBuilder()
.addInterceptor(chain -> {
@ -432,8 +438,8 @@ public final class InterceptorTest {
/** Make sure interceptors can interact with the OkHttp client asynchronously. */
@Test public void interceptorMakesAnUnrelatedAsyncRequest() throws Exception {
server.enqueue(new MockResponse().setBody("a")); // Fetched by interceptor.
server.enqueue(new MockResponse().setBody("b")); // Fetched directly.
server.enqueue(new MockResponse.Builder().body("a").build()); // Fetched by interceptor.
server.enqueue(new MockResponse.Builder().body("b").build()); // Fetched directly.
client = client.newBuilder()
.addInterceptor(chain -> {
@ -612,9 +618,10 @@ public final class InterceptorTest {
}
@Test public void networkInterceptorReturnsConnectionOnEmptyBody() throws Exception {
server.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
.addHeader("Connection", "Close"));
server.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.DISCONNECT_AT_END)
.addHeader("Connection", "Close")
.build());
Interceptor interceptor = chain -> {
Response response = chain.proceed(chain.request());
@ -700,9 +707,10 @@ public final class InterceptorTest {
.addInterceptor(interceptor2)
.build();
server.enqueue(new MockResponse()
.setBody("abc")
.throttleBody(1, 1, TimeUnit.SECONDS));
server.enqueue(new MockResponse.Builder()
.body("abc")
.throttleBody(1, 1, TimeUnit.SECONDS)
.build());
Request request1 = new Request.Builder()
.url(server.url("/"))
@ -780,9 +788,10 @@ public final class InterceptorTest {
.addInterceptor(interceptor2)
.build();
server.enqueue(new MockResponse()
.setBody("abc")
.throttleBody(1, 1, TimeUnit.SECONDS));
server.enqueue(new MockResponse.Builder()
.body("abc")
.throttleBody(1, 1, TimeUnit.SECONDS)
.build());
byte[] data = new byte[2 * 1024 * 1024]; // 2 MiB.
Request request1 = new Request.Builder()

2
okhttp/src/jvmTest/java/okhttp3/JSSETest.kt
View File

@ -62,7 +62,7 @@ class JSSETest {
enableTls()
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse(body = "abc"))
val request = Request(server.url("/"))

28
okhttp/src/jvmTest/java/okhttp3/KotlinSourceModernTest.kt
View File

@ -46,12 +46,6 @@ import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.X509KeyManager
import javax.net.ssl.X509TrustManager
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.PushPromise
import mockwebserver3.QueueDispatcher
import mockwebserver3.RecordedRequest
import mockwebserver3.SocketPolicy
import okhttp3.Handshake.Companion.handshake
import okhttp3.Headers.Companion.headersOf
import okhttp3.Headers.Companion.toHeaders
@ -68,6 +62,12 @@ import okhttp3.internal.proxy.NullProxySelector
import okhttp3.internal.tls.OkHostnameVerifier
import okhttp3.logging.HttpLoggingInterceptor
import okhttp3.logging.LoggingEventListener
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import okhttp3.mockwebserver.PushPromise
import okhttp3.mockwebserver.QueueDispatcher
import okhttp3.mockwebserver.RecordedRequest
import okhttp3.mockwebserver.SocketPolicy
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.HeldCertificate
import okhttp3.tls.internal.TlsUtil.localhost
@ -337,7 +337,7 @@ class KotlinSourceModernTest {
@Test
fun dispatcherFromMockWebServer() {
val dispatcher = object : mockwebserver3.Dispatcher() {
val dispatcher = object : okhttp3.mockwebserver.Dispatcher() {
override fun dispatch(request: RecordedRequest): MockResponse = TODO()
override fun peek(): MockResponse = TODO()
override fun shutdown() = TODO()
@ -737,7 +737,7 @@ class KotlinSourceModernTest {
mockWebServer.protocolNegotiationEnabled = false
mockWebServer.protocols = listOf()
val protocols: List<Protocol> = mockWebServer.protocols
mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory)
mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory, false)
mockWebServer.noClientAuth()
mockWebServer.requestClientAuth()
mockWebServer.requireClientAuth()
@ -749,7 +749,7 @@ class KotlinSourceModernTest {
mockWebServer.start(0)
mockWebServer.start(InetAddress.getLocalHost(), 0)
mockWebServer.shutdown()
var dispatcher: mockwebserver3.Dispatcher = mockWebServer.dispatcher
var dispatcher: okhttp3.mockwebserver.Dispatcher = mockWebServer.dispatcher
dispatcher = mockWebServer.dispatcher
mockWebServer.dispatcher = QueueDispatcher()
mockWebServer.dispatcher = QueueDispatcher()
@ -909,15 +909,7 @@ class KotlinSourceModernTest {
@Test
fun queueDispatcher() {
var queueDispatcher: QueueDispatcher = object : QueueDispatcher() {
override fun dispatch(request: RecordedRequest): MockResponse = TODO()
override fun peek(): MockResponse = TODO()
override fun enqueueResponse(response: MockResponse) = TODO()
override fun shutdown() = TODO()
override fun setFailFast(failFast: Boolean) = TODO()
override fun setFailFast(failFastResponse: MockResponse?) = TODO()
}
queueDispatcher = QueueDispatcher()
val queueDispatcher = QueueDispatcher()
var mockResponse: MockResponse = queueDispatcher.dispatch(
RecordedRequest("", headersOf(), listOf(), 0L, Buffer(), 0, Socket()))
mockResponse = queueDispatcher.peek()

2
okhttp/src/jvmTest/java/okhttp3/OkHttpClientTest.kt
View File

@ -217,7 +217,7 @@ class OkHttpClientTest {
}
@Test fun nullDefaultProxySelector() {
server!!.enqueue(MockResponse().setBody("abc"))
server!!.enqueue(MockResponse(body = "abc"))
ProxySelector.setDefault(null)
val client = clientTestRule.newClient()
val request = Request(server!!.url("/"))

2
okhttp/src/jvmTest/java/okhttp3/OpenJSSETest.kt
View File

@ -52,7 +52,7 @@ class OpenJSSETest {
fun testTlsv13Works() {
enableTls()
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse(body = "abc"))
val request = Request(server.url("/"))

9
okhttp/src/jvmTest/java/okhttp3/RouteFailureTest.kt
View File

@ -52,10 +52,11 @@ class RouteFailureTest {
val ipv4 = InetAddress.getByName("203.0.113.1")
val ipv6 = InetAddress.getByName("2001:db8:ffff:ffff:ffff:ffff:ffff:1")
val refusedStream = MockResponse()
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
val bodyResponse = MockResponse().setBody("body")
val refusedStream = MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
val bodyResponse = MockResponse(body = "body")
@BeforeEach
fun setUp(

77
okhttp/src/jvmTest/java/okhttp3/ServerTruncatesRequestTest.kt
View File

@ -32,15 +32,19 @@ import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.api.assertThrows
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.api.fail
@Timeout(30)
@Tag("Slowish")
class ServerTruncatesRequestTest {
@RegisterExtension @JvmField val platform = PlatformRule()
@RegisterExtension @JvmField var clientTestRule = OkHttpClientTestRule()
@RegisterExtension
@JvmField
val platform = PlatformRule()
@RegisterExtension
@JvmField
var clientTestRule = OkHttpClientTestRule()
private val listener = RecordingEventListener()
private val handshakeCertificates = localhost()
@ -59,20 +63,25 @@ class ServerTruncatesRequestTest {
platform.assumeNotBouncyCastle()
}
@Test fun serverTruncatesRequestOnLongPostHttp1() {
@Test
fun serverTruncatesRequestOnLongPostHttp1() {
serverTruncatesRequestOnLongPost(https = false)
}
@Test fun serverTruncatesRequestOnLongPostHttp2() {
@Test
fun serverTruncatesRequestOnLongPostHttp2() {
enableProtocol(Protocol.HTTP_2)
serverTruncatesRequestOnLongPost(https = true)
}
private fun serverTruncatesRequestOnLongPost(https: Boolean) {
server.enqueue(MockResponse()
.setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
.setBody("abc")
.apply { this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode })
server.enqueue(
MockResponse(
body = "abc",
socketPolicy = SocketPolicy.DO_NOT_READ_REQUEST_BODY,
http2ErrorCode = ErrorCode.NO_ERROR.httpCode,
)
)
val call = client.newCall(
Request(
@ -120,13 +129,17 @@ class ServerTruncatesRequestTest {
* If the server returns a full response, it doesn't really matter if the HTTP/2 stream is reset.
* Attempts to write the request body fails fast.
*/
@Test fun serverTruncatesRequestHttp2OnDuplexRequest() {
@Test
fun serverTruncatesRequestHttp2OnDuplexRequest() {
enableProtocol(Protocol.HTTP_2)
server.enqueue(MockResponse()
.setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
.setBody("abc")
.apply { this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode })
server.enqueue(
MockResponse(
body = "abc",
socketPolicy = SocketPolicy.DO_NOT_READ_REQUEST_BODY,
http2ErrorCode = ErrorCode.NO_ERROR.httpCode,
)
)
val requestBody = AsyncRequestBody()
@ -156,31 +169,31 @@ class ServerTruncatesRequestTest {
makeSimpleCall()
}
@Test fun serverTruncatesRequestButTrailersCanStillBeReadHttp1() {
@Test
fun serverTruncatesRequestButTrailersCanStillBeReadHttp1() {
serverTruncatesRequestButTrailersCanStillBeRead(http2 = false)
}
@Test fun serverTruncatesRequestButTrailersCanStillBeReadHttp2() {
@Test
fun serverTruncatesRequestButTrailersCanStillBeReadHttp2() {
enableProtocol(Protocol.HTTP_2)
serverTruncatesRequestButTrailersCanStillBeRead(http2 = true)
}
private fun serverTruncatesRequestButTrailersCanStillBeRead(http2: Boolean) {
val mockResponse = MockResponse()
.setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
.apply {
this.trailers = headersOf("caboose", "xyz")
this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode
}
val mockResponse = MockResponse.Builder()
.socketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
.trailers(headersOf("caboose", "xyz"))
.http2ErrorCode(ErrorCode.NO_ERROR.httpCode)
// Trailers always work for HTTP/2, but only for chunked bodies in HTTP/1.
if (http2) {
mockResponse.setBody("abc")
mockResponse.body("abc")
} else {
mockResponse.setChunkedBody("abc", 1)
mockResponse.chunkedBody("abc", 1)
}
server.enqueue(mockResponse)
server.enqueue(mockResponse.build())
val call = client.newCall(
Request(
@ -196,11 +209,12 @@ class ServerTruncatesRequestTest {
}
@Disabled("Follow up with fix in https://github.com/square/okhttp/issues/6853")
@Test fun serverDisconnectsBeforeSecondRequestHttp1() {
@Test
fun serverDisconnectsBeforeSecondRequestHttp1() {
enableProtocol(Protocol.HTTP_1_1)
server.enqueue(MockResponse().setResponseCode(200).setBody("Req1"))
server.enqueue(MockResponse().setResponseCode(200).setBody("Req2"))
server.enqueue(MockResponse(code = 200, body = "Req1"))
server.enqueue(MockResponse(code = 200, body = "Req2"))
val eventListener = object : EventListener() {
var socket: SSLSocket? = null
@ -235,8 +249,9 @@ class ServerTruncatesRequestTest {
}
}
@Test fun noAttemptToReadResponseIfLoadingRequestBodyIsSourceOfFailure() {
server.enqueue(MockResponse().setBody("abc"))
@Test
fun noAttemptToReadResponseIfLoadingRequestBodyIsSourceOfFailure() {
server.enqueue(MockResponse(body = "abc"))
val requestBody = object : RequestBody() {
override fun contentType(): MediaType? = null
@ -271,7 +286,7 @@ class ServerTruncatesRequestTest {
}
private fun makeSimpleCall() {
server.enqueue(MockResponse().setBody("healthy"))
server.enqueue(MockResponse(body = "healthy"))
val callB = client.newCall(Request(server.url("/")))
callB.execute().use { response ->
assertThat(response.body.string()).isEqualTo("healthy")

4
okhttp/src/jvmTest/java/okhttp3/SessionReuseTest.kt
View File

@ -99,8 +99,8 @@ class SessionReuseTest {
.sslSocketFactory(sslSocketFactory, handshakeCertificates.trustManager)
.build()
server.enqueue(MockResponse().setBody("abc1"))
server.enqueue(MockResponse().setBody("abc2"))
server.enqueue(MockResponse(body = "abc1"))
server.enqueue(MockResponse(body = "abc2"))
val request = Request(server.url("/"))

2
okhttp/src/jvmTest/java/okhttp3/SocketChannelTest.kt
View File

@ -151,7 +151,7 @@ class SocketChannelTest {
}
.build()
server.enqueue(MockResponse().setBody("abc"))
server.enqueue(MockResponse(body = "abc"))
@Suppress("HttpUrlsUsage") val url =
if (socketMode is TlsInstance)

8
okhttp/src/jvmTest/java/okhttp3/SocksProxyTest.java
View File

@ -49,8 +49,8 @@ public final class SocksProxyTest {
}
@Test public void proxy() throws Exception {
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse().setBody("def"));
server.enqueue(new MockResponse.Builder().body("abc").build());
server.enqueue(new MockResponse.Builder().body("def").build());
OkHttpClient client = clientTestRule.newClientBuilder()
.proxy(socksProxy.proxy())
@ -69,7 +69,7 @@ public final class SocksProxyTest {
}
@Test public void proxySelector() throws Exception {
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder().body("abc").build());
ProxySelector proxySelector = new ProxySelector() {
@Override public List<Proxy> select(URI uri) {
@ -94,7 +94,7 @@ public final class SocksProxyTest {
@Test public void checkRemoteDNSResolve() throws Exception {
// This testcase will fail if the target is resolved locally instead of through the proxy.
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder().body("abc").build());
OkHttpClient client = clientTestRule.newClientBuilder()
.proxy(socksProxy.proxy())

1001
okhttp/src/jvmTest/java/okhttp3/URLConnectionTest.kt
View File

File diff suppressed because it is too large Load Diff

74
okhttp/src/jvmTest/java/okhttp3/WholeOperationTimeoutTest.java
View File

@ -122,8 +122,9 @@ public final class WholeOperationTimeoutTest {
}
@Test public void timeoutProcessing() throws Exception {
server.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -141,8 +142,9 @@ public final class WholeOperationTimeoutTest {
}
@Test public void timeoutProcessingWithEnqueue() throws Exception {
server.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -171,8 +173,9 @@ public final class WholeOperationTimeoutTest {
}
@Test public void timeoutReadingResponse() throws Exception {
server.enqueue(new MockResponse()
.setBody(BIG_ENOUGH_BODY));
server.enqueue(new MockResponse.Builder()
.body(BIG_ENOUGH_BODY)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -192,8 +195,9 @@ public final class WholeOperationTimeoutTest {
}
@Test public void timeoutReadingResponseWithEnqueue() throws Exception {
server.enqueue(new MockResponse()
.setBody(BIG_ENOUGH_BODY));
server.enqueue(new MockResponse.Builder()
.body(BIG_ENOUGH_BODY)
.build());
Request request = new Request.Builder()
.url(server.url("/"))
@ -232,26 +236,31 @@ public final class WholeOperationTimeoutTest {
}
@Test public void singleTimeoutForAllFollowUpRequests() throws Exception {
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", "/b")
.setHeadersDelay(100, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.headersDelay(100, TimeUnit.MILLISECONDS)
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", "/c")
.setHeadersDelay(100, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.headersDelay(100, TimeUnit.MILLISECONDS)
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", "/d")
.setHeadersDelay(100, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.headersDelay(100, TimeUnit.MILLISECONDS)
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", "/e")
.setHeadersDelay(100, TimeUnit.MILLISECONDS));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.headersDelay(100, TimeUnit.MILLISECONDS)
.build());
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", "/f")
.setHeadersDelay(100, TimeUnit.MILLISECONDS));
.headersDelay(100, TimeUnit.MILLISECONDS)
.build());
server.enqueue(new MockResponse());
Request request = new Request.Builder()
@ -273,12 +282,14 @@ public final class WholeOperationTimeoutTest {
public void timeoutFollowingRedirectOnNewConnection() throws Exception {
MockWebServer otherServer = new MockWebServer();
server.enqueue(
new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", otherServer.url("/")));
server.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_MOVED_TEMP)
.setHeader("Location", otherServer.url("/"))
.build());
otherServer.enqueue(new MockResponse().setHeadersDelay(500, TimeUnit.MILLISECONDS));
otherServer.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
Request request = new Request.Builder().url(server.url("/")).build();
@ -297,9 +308,10 @@ public final class WholeOperationTimeoutTest {
@Test public void noTimeout() throws Exception {
// Flaky https://github.com/square/okhttp/issues/5304
server.enqueue(new MockResponse()
.setHeadersDelay(250, TimeUnit.MILLISECONDS)
.setBody(BIG_ENOUGH_BODY));
server.enqueue(new MockResponse.Builder()
.headersDelay(250, TimeUnit.MILLISECONDS)
.body(BIG_ENOUGH_BODY)
.build());
Request request = new Request.Builder()
.url(server.url("/"))

23
okhttp/src/jvmTest/java/okhttp3/internal/http/CancelTest.kt
View File

@ -180,13 +180,14 @@ class CancelTest {
setUp(mode)
val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
server.enqueue(
MockResponse()
.setBody(
MockResponse.Builder()
.body(
Buffer()
.write(ByteArray(responseBodySize))
)
.throttleBody(64 * 1024, 125, MILLISECONDS)
) // 500 Kbps
.throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
.build()
)
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
cancelLater(call, 500)
@ -209,17 +210,15 @@ class CancelTest {
setUp(mode)
val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
server.enqueue(
MockResponse()
.setBody(
MockResponse.Builder()
.body(
Buffer()
.write(ByteArray(responseBodySize))
)
.throttleBody(64 * 1024, 125, MILLISECONDS)
) // 500 Kbps
server.enqueue(MockResponse().apply {
setResponseCode(200)
setBody(".")
})
.throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
.build()
)
server.enqueue(MockResponse(body = "."))
val call = client.newCall(Request.Builder().url(server.url("/")).build())
val response = call.execute()

505
okhttp/src/jvmTest/java/okhttp3/internal/http2/HttpOverHttp2Test.kt
View File

@ -156,11 +156,7 @@ class HttpOverHttp2Test {
@ArgumentsSource(ProtocolParamProvider::class)
fun get(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody("ABCDE")
.setStatus("HTTP/1.1 200 Sweet")
)
server.enqueue(MockResponse(body = "ABCDE"))
val call = client.newCall(Request(server.url("/foo")))
val response = call.execute()
assertThat(response.body.string()).isEqualTo("ABCDE")
@ -176,9 +172,10 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun get204Response(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
val responseWithoutBody = MockResponse()
responseWithoutBody.status = "HTTP/1.1 204"
responseWithoutBody.removeHeader("Content-Length")
val responseWithoutBody = MockResponse.Builder()
.status("HTTP/1.1 204")
.removeHeader("Content-Length")
.build()
server.enqueue(responseWithoutBody)
val call = client.newCall(Request(server.url("/foo")))
val response = call.execute()
@ -197,8 +194,10 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun head(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
val mockResponse = MockResponse().setHeader("Content-Length", 5)
mockResponse.status = "HTTP/1.1 200"
val mockResponse = MockResponse.Builder()
.setHeader("Content-Length", 5)
.status("HTTP/1.1 200")
.build()
server.enqueue(mockResponse)
val call = client.newCall(
Request.Builder()
@ -232,7 +231,7 @@ class HttpOverHttp2Test {
fun noDefaultContentLengthOnStreamingPost(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
val postBytes = "FGHIJ".toByteArray()
server.enqueue(MockResponse().setBody("ABCDE"))
server.enqueue(MockResponse(body = "ABCDE"))
val call = client.newCall(
Request(
url = server.url("/foo"),
@ -257,7 +256,7 @@ class HttpOverHttp2Test {
fun userSuppliedContentLengthHeader(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
val postBytes = "FGHIJ".toByteArray()
server.enqueue(MockResponse().setBody("ABCDE"))
server.enqueue(MockResponse(body = "ABCDE"))
val call = client.newCall(
Request(
url = server.url("/foo"),
@ -288,7 +287,7 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
val postBytes = "FGHIJ".toByteArray()
server.enqueue(MockResponse().setBody("ABCDE"))
server.enqueue(MockResponse(body = "ABCDE"))
val call = client.newCall(
Request(
url = server.url("/foo"),
@ -317,8 +316,8 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun connectionReuse(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(MockResponse().setBody("ABCDEF"))
server.enqueue(MockResponse().setBody("GHIJKL"))
server.enqueue(MockResponse(body = "ABCDEF"))
server.enqueue(MockResponse(body = "GHIJKL"))
val call1 = client.newCall(Request(server.url("/r1")))
val call2 = client.newCall(Request(server.url("/r1")))
val response1 = call1.execute()
@ -337,12 +336,12 @@ class HttpOverHttp2Test {
fun connectionWindowUpdateAfterCanceling(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
MockResponse.Builder()
.body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
.build()
)
server.enqueue(
MockResponse()
.setBody("abc")
MockResponse(body = "abc")
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -375,17 +374,16 @@ class HttpOverHttp2Test {
fun connectionWindowUpdateOnClose(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
MockResponse.Builder()
.body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
.build()
)
server.enqueue(
MockResponse()
.setBody("abc")
MockResponse(body = "abc")
)
// Enqueue an additional response that show if we burnt a good prior response.
server.enqueue(
MockResponse()
.setBody("XXX")
MockResponse(body = "XXX")
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -406,12 +404,12 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)))
MockResponse.Builder()
.body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)))
.build()
)
server.enqueue(
MockResponse()
.setBody("abc")
MockResponse(body = "abc")
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -439,8 +437,8 @@ class HttpOverHttp2Test {
@Disabled
fun synchronousRequest(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(MockResponse().setBody("A"))
server.enqueue(MockResponse().setBody("A"))
server.enqueue(MockResponse(body = "A"))
server.enqueue(MockResponse(body = "A"))
val executor = Executors.newCachedThreadPool()
val countDownLatch = CountDownLatch(2)
executor.execute(AsyncRequest("/r1", countDownLatch))
@ -454,9 +452,10 @@ class HttpOverHttp2Test {
fun gzippedResponseBody(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
MockResponse.Builder()
.addHeader("Content-Encoding: gzip")
.setBody(gzip("ABCABCABC"))
.body(gzip("ABCABCABC"))
.build()
)
val call = client.newCall(Request(server.url("/r1")))
val response = call.execute()
@ -467,14 +466,14 @@ class HttpOverHttp2Test {
fun authenticate(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setResponseCode(HttpURLConnection.HTTP_UNAUTHORIZED)
.addHeader("www-authenticate: Basic realm=\"protected area\"")
.setBody("Please authenticate.")
MockResponse(
code = HttpURLConnection.HTTP_UNAUTHORIZED,
headers = headersOf("www-authenticate", "Basic realm=\"protected area\""),
body = "Please authenticate.",
)
)
server.enqueue(
MockResponse()
.setBody("Successful auth!")
MockResponse(body = "Successful auth!")
)
val credential = basic("username", "password")
client = client.newBuilder()
@ -494,11 +493,13 @@ class HttpOverHttp2Test {
fun redirect(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse().setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
.addHeader("Location: /foo")
.setBody("This page has moved!")
MockResponse(
code = HttpURLConnection.HTTP_MOVED_TEMP,
headers = headersOf("Location", "/foo"),
body = "This page has moved!",
)
server.enqueue(MockResponse().setBody("This is the new location!"))
)
server.enqueue(MockResponse(body = "This is the new location!"))
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
assertThat(response.body.string()).isEqualTo("This is the new location!")
@ -511,7 +512,7 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun readAfterLastByte(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(MockResponse().setBody("ABC"))
server.enqueue(MockResponse(body = "ABC"))
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
val inputStream = response.body.byteStream()
@ -526,8 +527,8 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun readResponseHeaderTimeout(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.NO_RESPONSE))
server.enqueue(MockResponse().setBody("A"))
server.enqueue(MockResponse(socketPolicy = SocketPolicy.NO_RESPONSE))
server.enqueue(MockResponse(body = "A"))
client = client.newBuilder()
.readTimeout(Duration.ofSeconds(1))
.build()
@ -562,8 +563,10 @@ class HttpOverHttp2Test {
val body = CharArray(4096) // 4KiB to read.
Arrays.fill(body, 'y')
server.enqueue(
MockResponse().setBody(String(body))
MockResponse.Builder()
.body(String(body))
.throttleBody(1024, 1, TimeUnit.SECONDS) // Slow connection 1KiB/second.
.build()
)
client = client.newBuilder()
.readTimeout(Duration.ofSeconds(2))
@ -584,13 +587,13 @@ class HttpOverHttp2Test {
setUp(protocol, mockWebServer)
val body = repeat('y', 2048)
server.enqueue(
MockResponse()
.setBody(body)
MockResponse.Builder()
.body(body)
.throttleBody(1024, 1, TimeUnit.SECONDS)
.build()
) // Slow connection 1KiB/second.
server.enqueue(
MockResponse()
.setBody(body)
MockResponse(body = body)
)
client = client.newBuilder()
.readTimeout(Duration.ofMillis(500)) // Half a second to read something.
@ -620,9 +623,10 @@ class HttpOverHttp2Test {
fun connectionTimeout(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody("A")
.setBodyDelay(1, TimeUnit.SECONDS)
MockResponse.Builder()
.body("A")
.bodyDelay(1, TimeUnit.SECONDS)
.build()
)
val client1 = client.newBuilder()
.readTimeout(Duration.ofSeconds(2))
@ -662,9 +666,10 @@ class HttpOverHttp2Test {
.cache(cache)
.build()
server.enqueue(
MockResponse()
.addHeader("cache-control: max-age=60")
.setBody("A")
MockResponse(
headers = headersOf("cache-control", "max-age=60"),
body = "A",
)
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -690,13 +695,13 @@ class HttpOverHttp2Test {
.cache(cache)
.build()
server.enqueue(
MockResponse()
.addHeader("ETag: v1")
.setBody("A")
MockResponse(
headers = headersOf("ETag", "v1"),
body = "A",
)
)
server.enqueue(
MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED)
MockResponse(code = HttpURLConnection.HTTP_NOT_MODIFIED)
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -719,14 +724,16 @@ class HttpOverHttp2Test {
.cache(cache)
.build()
server.enqueue(
MockResponse()
.addHeader("cache-control: max-age=60")
.setBody("ABCD")
MockResponse(
headers = headersOf("cache-control", "max-age=60"),
body = "ABCD",
)
)
server.enqueue(
MockResponse()
.addHeader("cache-control: max-age=60")
.setBody("EFGH")
MockResponse(
headers = headersOf("cache-control", "max-age=60"),
body = "EFGH",
)
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -767,8 +774,7 @@ class HttpOverHttp2Test {
.cookieJar(cookieJar)
.build()
server.enqueue(
MockResponse()
.addHeader("set-cookie: a=b")
MockResponse(headers = headersOf("set-cookie", "a=b"))
)
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
@ -779,14 +785,8 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun cancelWithStreamNotCompleted(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(
MockResponse()
.setBody("def")
)
server.enqueue(MockResponse(body = "abc"))
server.enqueue(MockResponse(body = "def"))
// Disconnect before the stream is created. A connection is still established!
val call1 = client.newCall(Request(server.url("/")))
@ -810,14 +810,12 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
val call = client.newCall(Request(server.url("/")))
try {
call.execute()
@ -836,14 +834,12 @@ class HttpOverHttp2Test {
.dns(DoubleInetAddressDns()) // Two routes!
.build()
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
val request = Request(server.url("/"))
val response = client.newCall(request).execute()
@ -865,19 +861,22 @@ class HttpOverHttp2Test {
.dns(DoubleInetAddressDns()) // Two routes!
.build()
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
val request = Request(server.url("/"))
@ -898,14 +897,12 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
val request = Request(server.url("/"))
// First call fails because it only has one route.
@ -929,23 +926,19 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(
MockResponse()
.setBody("def")
)
server.enqueue(MockResponse(body = "abc"))
server.enqueue(MockResponse(body = "def"))
val request = Request(server.url("/"))
// First call makes a new connection and fails because it is the only route.
@ -979,18 +972,19 @@ class HttpOverHttp2Test {
fun noRecoveryFromTwoRefusedStreams(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setBody("abc")
MockResponse(body = "abc")
)
val call = client.newCall(Request(server.url("/")))
try {
@ -1019,14 +1013,12 @@ class HttpOverHttp2Test {
private fun recoverFromOneHttp2ErrorRequiresNewConnection(errorCode: ErrorCode?) {
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(errorCode!!.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = errorCode!!.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
client = client.newBuilder()
.dns(DoubleInetAddressDns())
.build()
@ -1046,19 +1038,18 @@ class HttpOverHttp2Test {
) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
client = client.newBuilder()
.dns(DoubleInetAddressDns())
.build()
@ -1087,13 +1078,13 @@ class HttpOverHttp2Test {
)
val dispatcher = RespondAfterCancelDispatcher(responseDequeuedLatches, requestCanceledLatches)
dispatcher.enqueueResponse(
MockResponse()
.setBodyDelay(10, TimeUnit.SECONDS)
.setBody("abc")
MockResponse.Builder()
.bodyDelay(10, TimeUnit.SECONDS)
.body("abc")
.build()
)
dispatcher.enqueueResponse(
MockResponse()
.setBody("def")
MockResponse(body = "def")
)
server.dispatcher = dispatcher
client = client.newBuilder()
@ -1123,18 +1114,19 @@ class HttpOverHttp2Test {
)
val dispatcher = RespondAfterCancelDispatcher(responseDequeuedLatches, requestCanceledLatches)
dispatcher.enqueueResponse(
MockResponse()
.setBodyDelay(10, TimeUnit.SECONDS)
.setBody("abc")
MockResponse.Builder()
.bodyDelay(10, TimeUnit.SECONDS)
.body("abc")
.build()
)
dispatcher.enqueueResponse(
MockResponse()
.setBodyDelay(10, TimeUnit.SECONDS)
.setBody("def")
MockResponse.Builder()
.bodyDelay(10, TimeUnit.SECONDS)
.body("def")
.build()
)
dispatcher.enqueueResponse(
MockResponse()
.setBody("ghi")
MockResponse(body = "ghi")
)
server.dispatcher = dispatcher
client = client.newBuilder()
@ -1222,14 +1214,12 @@ class HttpOverHttp2Test {
private fun noRecoveryFromErrorWithRetryDisabled(errorCode: ErrorCode?) {
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(errorCode!!.httpCode)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = errorCode!!.httpCode,
)
server.enqueue(
MockResponse()
.setBody("abc")
)
server.enqueue(MockResponse(body = "abc"))
client = client.newBuilder()
.retryOnConnectionFailure(false)
.build()
@ -1247,28 +1237,21 @@ class HttpOverHttp2Test {
protocol: Protocol, mockWebServer: MockWebServer
) {
setUp(protocol, mockWebServer)
server.enqueue(MockResponse(code = 401))
server.enqueue(
MockResponse()
.setResponseCode(401)
MockResponse(
socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
http2ErrorCode = ErrorCode.INTERNAL_ERROR.httpCode,
)
)
server.enqueue(MockResponse(body = "DEF"))
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
.setHttp2ErrorCode(ErrorCode.INTERNAL_ERROR.httpCode)
MockResponse(
code = 301,
headers = headersOf("Location", "/foo")
)
server.enqueue(
MockResponse()
.setBody("DEF")
)
server.enqueue(
MockResponse()
.setResponseCode(301)
.addHeader("Location", "/foo")
)
server.enqueue(
MockResponse()
.setBody("ABC")
)
server.enqueue(MockResponse(body = "ABC"))
val latch = CountDownLatch(1)
val responses: BlockingQueue<String?> = SynchronousQueue()
val authenticator = okhttp3.Authenticator { route: Route?, response: Response? ->
@ -1321,9 +1304,10 @@ class HttpOverHttp2Test {
fun nonAsciiResponseHeader(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
MockResponse.Builder()
.addHeaderLenient("Alpha", "α")
.addHeaderLenient("β", "Beta")
.build()
)
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
@ -1337,13 +1321,13 @@ class HttpOverHttp2Test {
setUp(protocol, mockWebServer)
val pushPromise = PushPromise(
"GET", "/foo/bar", headersOf("foo", "bar"),
MockResponse().setBody("bar").setStatus("HTTP/1.1 200 Sweet")
MockResponse(body = "bar")
)
server.enqueue(
MockResponse()
.setBody("ABCDE")
.setStatus("HTTP/1.1 200 Sweet")
.withPush(pushPromise)
MockResponse.Builder()
.body("ABCDE")
.addPush(pushPromise)
.build()
)
val call = client.newCall(Request(server.url("/foo")))
val response = call.execute()
@ -1366,13 +1350,13 @@ class HttpOverHttp2Test {
setUp(protocol, mockWebServer)
val pushPromise = PushPromise(
"HEAD", "/foo/bar", headersOf("foo", "bar"),
MockResponse().setStatus("HTTP/1.1 204 Sweet")
MockResponse(code = 204)
)
server.enqueue(
MockResponse()
.setBody("ABCDE")
.setStatus("HTTP/1.1 200 Sweet")
.withPush(pushPromise)
MockResponse.Builder()
.body("ABCDE")
.addPush(pushPromise)
.build()
)
val call = client.newCall(Request(server.url("/foo")))
val response = call.execute()
@ -1395,10 +1379,7 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun noDataFramesSentWithNullRequestBody(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody("ABC")
)
server.enqueue(MockResponse(body = "ABC"))
val call = client.newCall(
Request.Builder()
.url(server.url("/"))
@ -1417,10 +1398,7 @@ class HttpOverHttp2Test {
@ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
fun emptyDataFrameSentWithEmptyBody(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setBody("ABC")
)
server.enqueue(MockResponse(body = "ABC"))
val call = client.newCall(
Request.Builder()
.url(server.url("/"))
@ -1453,9 +1431,10 @@ class HttpOverHttp2Test {
// Delay the response to give 1 ping enough time to be sent and replied to.
server.enqueue(
MockResponse()
.setBodyDelay(750, TimeUnit.MILLISECONDS)
.setBody("ABC")
MockResponse.Builder()
.bodyDelay(750, TimeUnit.MILLISECONDS)
.body("ABC")
.build()
)
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
@ -1491,10 +1470,7 @@ class HttpOverHttp2Test {
.build()
// Set up the server to ignore the socket. It won't respond to pings!
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START)
)
server.enqueue(MockResponse(socketPolicy = SocketPolicy.STALL_SOCKET_AT_START))
// Make a call. It'll fail as soon as our pings detect a problem.
val call = client.newCall(Request(server.url("/")))
@ -1528,15 +1504,11 @@ class HttpOverHttp2Test {
.build()
// Stalling the socket will cause TWO requests to time out!
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START)
)
server.enqueue(MockResponse(socketPolicy = SocketPolicy.STALL_SOCKET_AT_START))
// The 3rd request should be sent to a fresh connection.
server.enqueue(
MockResponse()
.setBody("fresh connection")
MockResponse(body = "fresh connection")
)
// The first call times out.
@ -1573,18 +1545,13 @@ class HttpOverHttp2Test {
.readTimeout(Duration.ofMillis(500))
.build()
server.enqueue(
MockResponse()
.setBodyDelay(1000, TimeUnit.MILLISECONDS)
.setBody("a")
)
server.enqueue(
MockResponse()
.setBody("b")
)
server.enqueue(
MockResponse()
.setBody("c")
MockResponse.Builder()
.bodyDelay(1000, TimeUnit.MILLISECONDS)
.body("a")
.build()
)
server.enqueue(MockResponse(body = "b"))
server.enqueue(MockResponse(body = "c"))
// The first call times out.
val call1 = client.newCall(Request(server.url("/")))
@ -1649,21 +1616,20 @@ class HttpOverHttp2Test {
settings[Settings.MAX_CONCURRENT_STREAMS] = 2
// Read & write a full request to confirm settings are accepted.
server.enqueue(MockResponse().withSettings(settings))
server.enqueue(MockResponse.Builder()
.settings(settings)
.build())
val call = client.newCall(Request(server.url("/")))
val response = call.execute()
assertThat(response.body.string()).isEqualTo("")
server.enqueue(
MockResponse()
.setBody("ABC")
MockResponse(body = "ABC")
)
server.enqueue(
MockResponse()
.setBody("DEF")
MockResponse(body = "DEF")
)
server.enqueue(
MockResponse()
.setBody("GHI")
MockResponse(body = "GHI")
)
val call1 = client.newCall(Request(server.url("/")))
val response1 = call1.execute()
@ -1688,18 +1654,15 @@ class HttpOverHttp2Test {
fun connectionNotReusedAfterShutdown(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
.setBody("ABC")
MockResponse(
body = "ABC",
socketPolicy = SocketPolicy.DISCONNECT_AT_END,
)
server.enqueue(
MockResponse()
.setBody("DEF")
)
server.enqueue(MockResponse(body = "DEF"))
// Enqueue an additional response that show if we burnt a good prior response.
server.enqueue(
MockResponse()
.setBody("XXX")
MockResponse(body = "XXX")
)
val connections: MutableList<RealConnection?> = ArrayList()
val localClient = client.newBuilder().eventListener(object : EventListener() {
@ -1741,14 +1704,12 @@ class HttpOverHttp2Test {
fun connectionShutdownAfterHealthCheck(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
.setBody("ABC")
MockResponse(
body = "ABC",
socketPolicy = SocketPolicy.DISCONNECT_AT_END,
)
server.enqueue(
MockResponse()
.setBody("DEF")
)
server.enqueue(MockResponse(body = "DEF"))
val client2 = client.newBuilder()
.addNetworkInterceptor(object : Interceptor {
var executedCall = false
@ -1783,14 +1744,16 @@ class HttpOverHttp2Test {
fun responseHeadersAfterGoaway(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.setHeadersDelay(1, TimeUnit.SECONDS)
.setBody("ABC")
MockResponse.Builder()
.headersDelay(1, TimeUnit.SECONDS)
.body("ABC")
.build()
)
server.enqueue(
MockResponse()
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
.setBody("DEF")
MockResponse(
body = "DEF",
socketPolicy = SocketPolicy.DISCONNECT_AT_END,
)
)
val latch = CountDownLatch(2)
val errors = ArrayList<IOException?>()
@ -1840,22 +1803,10 @@ class HttpOverHttp2Test {
assumeTrue(protocol === Protocol.HTTP_2)
server.useHttps(handshakeCertificates.sslSocketFactory())
val queueDispatcher = QueueDispatcher()
queueDispatcher.enqueueResponse(
MockResponse()
.inTunnel()
)
queueDispatcher.enqueueResponse(
MockResponse()
.inTunnel()
)
queueDispatcher.enqueueResponse(
MockResponse()
.setBody("call2 response")
)
queueDispatcher.enqueueResponse(
MockResponse()
.setBody("call1 response")
)
queueDispatcher.enqueueResponse(MockResponse(inTunnel = true))
queueDispatcher.enqueueResponse(MockResponse(inTunnel = true))
queueDispatcher.enqueueResponse(MockResponse(body = "call2 response"))
queueDispatcher.enqueueResponse(MockResponse(body = "call1 response"))
// We use a re-entrant dispatcher to initiate one HTTPS connection while the other is in flight.
server.dispatcher = object : Dispatcher() {
@ -2028,15 +1979,8 @@ class HttpOverHttp2Test {
@ArgumentsSource(ProtocolParamProvider::class)
fun http2WithProxy(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.inTunnel()
)
server.enqueue(
MockResponse()
.setBody("ABCDE")
.setStatus("HTTP/1.1 200 Sweet")
)
server.enqueue(MockResponse(inTunnel = true))
server.enqueue(MockResponse(body = "ABCDE"))
val client = client.newBuilder()
.proxy(server.toProxyAddress())
.build()
@ -2070,19 +2014,14 @@ class HttpOverHttp2Test {
fun proxyAuthenticateOnConnect(protocol: Protocol, mockWebServer: MockWebServer) {
setUp(protocol, mockWebServer)
server.enqueue(
MockResponse()
.inTunnel()
.setResponseCode(407)
.addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
MockResponse(
code = 407,
headers = headersOf("Proxy-Authenticate", "Basic realm=\"localhost\""),
inTunnel = true,
)
server.enqueue(
MockResponse()
.inTunnel()
)
server.enqueue(
MockResponse()
.setBody("response body")
)
server.enqueue(MockResponse(inTunnel = true))
server.enqueue(MockResponse(body = "response body"))
val client = client.newBuilder()
.proxy(server.toProxyAddress())
.proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))

38
okhttp/src/jvmTest/java/okhttp3/internal/tls/CertificatePinnerChainValidationTest.java
View File

@ -101,8 +101,9 @@ public final class CertificatePinnerChainValidationTest {
server.useHttps(serverHandshakeCertificates.sslSocketFactory());
// The request should complete successfully.
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call1 = client.newCall(new Request.Builder()
.url(server.url("/"))
.build());
@ -149,9 +150,10 @@ public final class CertificatePinnerChainValidationTest {
server.useHttps(serverHandshakeCertificates.sslSocketFactory());
// The request should complete successfully.
server.enqueue(new MockResponse()
.setBody("abc")
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END));
server.enqueue(new MockResponse.Builder()
.body("abc")
.socketPolicy(SocketPolicy.DISCONNECT_AT_END)
.build());
Call call1 = client.newCall(new Request.Builder()
.url(server.url("/"))
.build());
@ -163,9 +165,10 @@ public final class CertificatePinnerChainValidationTest {
client.connectionPool().evictAll();
// Confirm that a second request also succeeds. This should detect caching problems.
server.enqueue(new MockResponse()
.setBody("def")
.setSocketPolicy(SocketPolicy.DISCONNECT_AT_END));
server.enqueue(new MockResponse.Builder()
.body("def")
.socketPolicy(SocketPolicy.DISCONNECT_AT_END)
.build());
Call call2 = client.newCall(new Request.Builder()
.url(server.url("/"))
.build());
@ -233,9 +236,10 @@ public final class CertificatePinnerChainValidationTest {
compromisedIntermediateCa.certificate(), goodCertificate.certificate());
server.useHttps(socketFactory);
server.enqueue(new MockResponse()
.setBody("abc")
.addHeader("Content-Type: text/plain"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.addHeader("Content-Type: text/plain")
.build());
// Make a request from client to server. It should succeed certificate checks (unfortunately the
// rogue CA is trusted) but it should fail certificate pinning.
@ -312,9 +316,10 @@ public final class CertificatePinnerChainValidationTest {
SSLSocketFactory socketFactory = newServerSocketFactory(rogueCertificate,
goodIntermediateCa.certificate(), compromisedIntermediateCa.certificate());
server.useHttps(socketFactory);
server.enqueue(new MockResponse()
.setBody("abc")
.addHeader("Content-Type: text/plain"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.addHeader("Content-Type: text/plain")
.build());
// Make a request from client to server. It should succeed certificate checks (unfortunately the
// rogue CA is trusted) but it should fail certificate pinning.
@ -595,8 +600,9 @@ public final class CertificatePinnerChainValidationTest {
server.useHttps(serverHandshakeCertificates.sslSocketFactory());
// The request should complete successfully.
server.enqueue(new MockResponse()
.setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call1 = client.newCall(new Request.Builder()
.url(server.url("/"))
.build());

20
okhttp/src/jvmTest/java/okhttp3/internal/tls/ClientAuthTest.java
View File

@ -130,7 +130,9 @@ public final class ClientAuthTest {
server.useHttps(socketFactory);
server.requestClientAuth();
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
Response response = call.execute();
@ -148,7 +150,9 @@ public final class ClientAuthTest {
server.useHttps(socketFactory);
server.requireClientAuth();
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
Response response = call.execute();
@ -166,7 +170,9 @@ public final class ClientAuthTest {
server.useHttps(socketFactory);
server.noClientAuth();
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
Response response = call.execute();
@ -183,7 +189,9 @@ public final class ClientAuthTest {
server.useHttps(socketFactory);
server.requestClientAuth();
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
Response response = call.execute();
@ -282,7 +290,9 @@ public final class ClientAuthTest {
}
@Test public void invalidClientAuthEvents() throws Throwable {
server.enqueue(new MockResponse().setBody("abc"));
server.enqueue(new MockResponse.Builder()
.body("abc")
.build());
clientCert = new HeldCertificate.Builder()
.signedBy(clientIntermediateCa)

197
okhttp/src/jvmTest/java/okhttp3/internal/ws/WebSocketHttpTest.java
View File

@ -106,7 +106,9 @@ public final class WebSocketHttpTest {
}
@Test public void textMessage() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -119,7 +121,9 @@ public final class WebSocketHttpTest {
}
@Test public void binaryMessage() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -132,7 +136,9 @@ public final class WebSocketHttpTest {
}
@Test public void nullStringThrows() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -149,7 +155,9 @@ public final class WebSocketHttpTest {
@Test public void nullByteStringThrows() {
TestUtil.assumeNotWindows();
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -164,7 +172,9 @@ public final class WebSocketHttpTest {
}
@Test public void serverMessage() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -177,7 +187,9 @@ public final class WebSocketHttpTest {
}
@Test public void throwingOnOpenFailsImmediately() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
final RuntimeException e = new RuntimeException();
clientListener.setNextEventDelegate(new WebSocketListener() {
@ -195,7 +207,10 @@ public final class WebSocketHttpTest {
@Disabled("AsyncCall currently lets runtime exceptions propagate.")
@Test public void throwingOnFailLogs() throws Exception {
webServer.enqueue(new MockResponse().setResponseCode(200).setBody("Body"));
webServer.enqueue(new MockResponse.Builder()
.code(200)
.body("Body")
.build());
final RuntimeException e = new RuntimeException("boom");
clientListener.setNextEventDelegate(new WebSocketListener() {
@ -210,7 +225,9 @@ public final class WebSocketHttpTest {
}
@Test public void throwingOnMessageClosesImmediatelyAndFails() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
newWebSocket();
clientListener.assertOpen();
@ -230,7 +247,9 @@ public final class WebSocketHttpTest {
}
@Test public void throwingOnClosingClosesImmediatelyAndFails() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
newWebSocket();
clientListener.assertOpen();
@ -250,7 +269,9 @@ public final class WebSocketHttpTest {
}
@Test public void unplannedCloseHandledByCloseWithoutFailure() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
newWebSocket();
clientListener.assertOpen();
@ -270,7 +291,9 @@ public final class WebSocketHttpTest {
}
@Test public void unplannedCloseHandledWithoutFailure() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
newWebSocket();
WebSocket webSocket = clientListener.assertOpen();
@ -280,7 +303,10 @@ public final class WebSocketHttpTest {
}
@Test public void non101RetainsBody() throws IOException {
webServer.enqueue(new MockResponse().setResponseCode(200).setBody("Body"));
webServer.enqueue(new MockResponse.Builder()
.code(200)
.body("Body")
.build());
newWebSocket();
clientListener.assertFailure(200, "Body", ProtocolException.class,
@ -288,7 +314,9 @@ public final class WebSocketHttpTest {
}
@Test public void notFound() throws IOException {
webServer.enqueue(new MockResponse().setStatus("HTTP/1.1 404 Not Found"));
webServer.enqueue(new MockResponse.Builder()
.status("HTTP/1.1 404 Not Found")
.build());
newWebSocket();
clientListener.assertFailure(404, null, ProtocolException.class,
@ -296,8 +324,12 @@ public final class WebSocketHttpTest {
}
@Test public void clientTimeoutClosesBody() {
webServer.enqueue(new MockResponse().setResponseCode(408));
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.code(408)
.build());
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -313,10 +345,11 @@ public final class WebSocketHttpTest {
}
@Test public void missingConnectionHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Upgrade", "websocket")
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -324,11 +357,12 @@ public final class WebSocketHttpTest {
}
@Test public void wrongConnectionHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Upgrade", "websocket")
.setHeader("Connection", "Downgrade")
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -336,10 +370,11 @@ public final class WebSocketHttpTest {
}
@Test public void missingUpgradeHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Connection", "Upgrade")
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -347,11 +382,12 @@ public final class WebSocketHttpTest {
}
@Test public void wrongUpgradeHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Connection", "Upgrade")
.setHeader("Upgrade", "Pepsi")
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
.setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -359,10 +395,11 @@ public final class WebSocketHttpTest {
}
@Test public void missingMagicHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Connection", "Upgrade")
.setHeader("Upgrade", "websocket"));
.setHeader("Upgrade", "websocket")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -370,11 +407,12 @@ public final class WebSocketHttpTest {
}
@Test public void wrongMagicHeader() throws IOException {
webServer.enqueue(new MockResponse()
.setResponseCode(101)
webServer.enqueue(new MockResponse.Builder()
.code(101)
.setHeader("Connection", "Upgrade")
.setHeader("Upgrade", "websocket")
.setHeader("Sec-WebSocket-Accept", "magic"));
.setHeader("Sec-WebSocket-Accept", "magic")
.build());
newWebSocket();
clientListener.assertFailure(101, null, ProtocolException.class,
@ -406,7 +444,9 @@ public final class WebSocketHttpTest {
})
.build();
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -422,7 +462,9 @@ public final class WebSocketHttpTest {
})
.build();
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -432,7 +474,9 @@ public final class WebSocketHttpTest {
}
@Test public void overflowOutgoingQueue() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -466,7 +510,9 @@ public final class WebSocketHttpTest {
}
@Test public void closeReasonMaximumLength() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
String clientReason = repeat('C', 123);
String serverReason = repeat('S', 123);
@ -486,7 +532,9 @@ public final class WebSocketHttpTest {
}
@Test public void closeReasonTooLong() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
WebSocket server = serverListener.assertOpen();
@ -543,8 +591,9 @@ public final class WebSocketHttpTest {
}
@Test public void readTimeoutAppliesToHttpRequest() {
webServer.enqueue(new MockResponse()
.setSocketPolicy(SocketPolicy.NO_RESPONSE));
webServer.enqueue(new MockResponse.Builder()
.socketPolicy(SocketPolicy.NO_RESPONSE)
.build());
WebSocket webSocket = newWebSocket();
@ -561,9 +610,10 @@ public final class WebSocketHttpTest {
webServer.setDispatcher(new Dispatcher() {
@Override public MockResponse dispatch(RecordedRequest request) {
return upgradeResponse(request)
.setBody(new Buffer().write(ByteString.decodeHex("81"))) // Truncated frame.
.body(new Buffer().write(ByteString.decodeHex("81"))) // Truncated frame.
.removeHeader("Content-Length")
.setSocketPolicy(SocketPolicy.KEEP_OPEN);
.socketPolicy(SocketPolicy.KEEP_OPEN)
.build();
}
});
@ -575,7 +625,9 @@ public final class WebSocketHttpTest {
}
@Test public void readTimeoutDoesNotApplyAcrossFrames() throws Exception {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -595,7 +647,9 @@ public final class WebSocketHttpTest {
.pingInterval(Duration.ofMillis(500))
.build();
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
RealWebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -623,7 +677,9 @@ public final class WebSocketHttpTest {
}
@Test public void clientDoesNotPingServerByDefault() throws Exception {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
RealWebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -656,7 +712,8 @@ public final class WebSocketHttpTest {
// Stall in onOpen to prevent pongs from being sent.
final CountDownLatch latch = new CountDownLatch(1);
webServer.enqueue(new MockResponse().withWebSocketUpgrade(new WebSocketListener() {
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(new WebSocketListener() {
@Override public void onOpen(WebSocket webSocket, Response response) {
try {
latch.await(); // The server can't respond to pings!
@ -664,7 +721,8 @@ public final class WebSocketHttpTest {
throw new AssertionError(e);
}
}
}));
})
.build());
long openAtNanos = System.nanoTime();
newWebSocket();
@ -680,7 +738,9 @@ public final class WebSocketHttpTest {
/** https://github.com/square/okhttp/issues/2788 */
@Test public void clientCancelsIfCloseIsNotAcknowledged() {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
RealWebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -709,7 +769,9 @@ public final class WebSocketHttpTest {
.eventListenerFactory(clientTestRule.wrap(listener))
.build();
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -730,8 +792,9 @@ public final class WebSocketHttpTest {
}
@Test public void callTimeoutAppliesToSetup() throws Exception {
webServer.enqueue(new MockResponse()
.setHeadersDelay(500, TimeUnit.MILLISECONDS));
webServer.enqueue(new MockResponse.Builder()
.headersDelay(500, TimeUnit.MILLISECONDS)
.build());
client = client.newBuilder()
.readTimeout(Duration.ZERO)
@ -748,8 +811,9 @@ public final class WebSocketHttpTest {
.callTimeout(Duration.ofMillis(100))
.build();
webServer.enqueue(new MockResponse()
.withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
WebSocket webSocket = newWebSocket();
clientListener.assertOpen();
@ -774,9 +838,10 @@ public final class WebSocketHttpTest {
.protocols(asList(Protocol.HTTP_1_1))
.build();
webServer.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
.setBody("not found!"));
webServer.enqueue(new MockResponse.Builder()
.code(HttpURLConnection.HTTP_NOT_FOUND)
.body("not found!")
.build());
webServer.enqueue(new MockResponse());
newWebSocket();
@ -835,9 +900,10 @@ public final class WebSocketHttpTest {
}
private void successfulExtensions(String extensionsHeader) throws Exception {
webServer.enqueue(new MockResponse()
webServer.enqueue(new MockResponse.Builder()
.addHeader("Sec-WebSocket-Extensions", extensionsHeader)
.withWebSocketUpgrade(serverListener));
.webSocketUpgrade(serverListener)
.build());
WebSocket client = newWebSocket();
clientListener.assertOpen();
@ -881,9 +947,10 @@ public final class WebSocketHttpTest {
}
private void extensionNegotiationFailure(String extensionsHeader) throws Exception {
webServer.enqueue(new MockResponse()
webServer.enqueue(new MockResponse.Builder()
.addHeader("Sec-WebSocket-Extensions", extensionsHeader)
.withWebSocketUpgrade(serverListener));
.webSocketUpgrade(serverListener)
.build());
newWebSocket();
clientListener.assertOpen();
@ -899,17 +966,19 @@ public final class WebSocketHttpTest {
serverListener.assertExhausted();
}
private MockResponse upgradeResponse(RecordedRequest request) {
private MockResponse.Builder upgradeResponse(RecordedRequest request) {
String key = request.getHeader("Sec-WebSocket-Key");
return new MockResponse()
.setStatus("HTTP/1.1 101 Switching Protocols")
return new MockResponse.Builder()
.status("HTTP/1.1 101 Switching Protocols")
.setHeader("Connection", "Upgrade")
.setHeader("Upgrade", "websocket")
.setHeader("Sec-WebSocket-Accept", WebSocketProtocol.INSTANCE.acceptHeader(key));
}
private void websocketScheme(String scheme) {
webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
webServer.enqueue(new MockResponse.Builder()
.webSocketUpgrade(serverListener)
.build());
Request request = new Request.Builder()
.url(scheme + "://" + webServer.getHostName() + ":" + webServer.getPort() + "/")

5
samples/compare/src/test/kotlin/okhttp3/compare/ApacheHttpClientTest.kt
View File

@ -39,8 +39,9 @@ class ApacheHttpClientTest {
}
@Test fun get(server: MockWebServer) {
server.enqueue(MockResponse()
.setBody("hello, Apache HttpClient 5.x"))
server.enqueue(MockResponse.Builder()
.body("hello, Apache HttpClient 5.x")
.build())
val request = HttpGet(server.url("/").toUri())
request.addHeader("Accept", "text/plain")

5
samples/compare/src/test/kotlin/okhttp3/compare/JavaHttpClientTest.kt
View File

@ -44,8 +44,9 @@ class JavaHttpClientTest {
.followRedirects(NORMAL)
.build()
server.enqueue(MockResponse()
.setBody("hello, Java HTTP Client"))
server.enqueue(MockResponse.Builder()
.body("hello, Java HTTP Client")
.build())
val request = HttpRequest.newBuilder(server.url("/").toUri())
.header("Accept", "text/plain")

3
samples/compare/src/test/kotlin/okhttp3/compare/JettyHttpClientTest.kt
View File

@ -42,8 +42,7 @@ class JettyHttpClientTest {
}
@Test fun get(server: MockWebServer) {
server.enqueue(MockResponse()
.setBody("hello, Jetty HTTP Client"))
server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))
val request = client.newRequest(server.url("/").toUri())
.header("Accept", "text/plain")

3
samples/compare/src/test/kotlin/okhttp3/compare/OkHttpClientTest.kt
View File

@ -35,8 +35,7 @@ class OkHttpClientTest {
@Test fun get(server: MockWebServer) {
platform.assumeNotBouncyCastle()
server.enqueue(MockResponse()
.setBody("hello, OkHttp"))
server.enqueue(MockResponse(body = "hello, OkHttp"))
val client = OkHttpClient()