Response handling examples

In this topic, we'll examine a couple of HTTP response handling examples. To try examples yourself, explore the auth-requests and test-responses requests collections.

Checking response headers, body, and content type

In this example, we'll create several tests to verify the following:

The request is executed successfully, that is, the response status is 200.
Headers are received within the response body.
The response's content type is application/json.

To create a test, we call the test method of the client object. Inside the test, we can assert a specific condition by calling the assert method of the client object and refer to various properties of the response object to validate them.

            ### Check response status, headers, and content-type
            GET https://httpbin.org/get

            > {%
                client.test("Request executed successfully", function() {
                    client.assert(response.status === 200, "Response status is not 200");
                });

                client.test("Headers option exists", function() {
                    client.assert(response.body.hasOwnProperty("headers"), "Cannot find 'headers' option in response");
                });

                client.test("Response content-type is json", function() {
                    var type = response.contentType.mimeType;
                    client.assert(type === "application/json", "Expected 'application/json' but received '" + type + "'");
                });
            %}
        

Working with environment variables

In this example, we'll capture a value from the received response into an environment variable, which can be then used in subsequent requests.

The first request involves a response handler script, which saves an authentication token from the received response body into the auth_token variable under client.global. To achieve this, we use the client.global.set(VariableName, VariableValue) construction. As the VariableValue argument, we use the value of the json.token field from the response body returned by the server (by httpbin.org in our example). This value is then assigned to the "auth_token" variable.

            POST https://httpbin.org/post
            Content-Type: application/json

            {
                "token": "my-secret-token"
            }

            //Saving a variable
            > {%
                client.global.set("auth_token", response.body.json.token);
            %}
        

After the request is executed, the auth_token variable can be accessed from both subsequent requests as {{auth_token}} and response handler scripts by means of the client.global.get("auth_token") construction.

            //Accessing a variable
            GET https://httpbin.org/headers
            Authorization: Bearer {{auth_token}}
        

To obtain a value from a response header, use the valueOf method of the headers object. If several headers with the same name are received (which is a common case for the Set-Cookie header), use the valuesOf method instead. This will return an array of all response header values.

            POST https://httpbin.org/cookies

            //Saving a cookie from the first Set-Cookie header
            > {%
                client.global.set("my_cookie", response.headers.valuesOf("Set-Cookie")[0]);
            %}
        

Process each line of an event stream

If you subscribe to an event stream, a server will automatically send events to your client when new data becomes available. This data can be in the form of Server-Sent Events or newline-delimited JSON (NDJSON). In PyCharm, you can use the HTTP Client response.body.onEachLine method to call a function on each line of this event stream.

Suppose you have a server that regularly sends information on the gold price. In this example, let's write a response handler script, which does the following:

Takes each chunk of data (JSON object) received from the server and logs the price value. When you run the request, you can view the logged info in the Response Handler tab of the Services tool window.
Stops processing the received data when the number of events exceeds 10. Note that this does not unsubscribe you from the event stream – you'll keep receiving events as long as the HTTP connection is open (check the Console tab of the Services tool window).
Tests the obtained chunks of data: if the price is less than 45, the test fails. You can view the test results in the Tests tab of the Services tool window.

GET localhost/stocks/subscribe?symbol=GOLD

> {%
var updatesCount = 0;
response.body.onEachLine(
    (symbolUpdate, unsubscribe) => {
        updatesCount++;
        client.log(symbolUpdate.pricePresentation);
        if (updatesCount > 10) {
            unsubscribe();
            return;
        }

        client.test("Price test " + updatesCount, () => {
            client.assert(symbolUpdate.lastPrice >= 45, "Price must be >= 45");
            client.log(symbolUpdate.pricePresentation);
        });
    }
)
%}
        

Last modified: 28 April 2022