class Playwright::Request

request is issued to a redirected url.
If request gets a ‘redirect’ response, the request is successfully finished with the ‘requestfinished` event, and a new
with `’requestfinished’‘ event.
NOTE: HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will complete
the [`event: Page.requestFailed`] event is emitted.
If request fails at some point, then instead of `’requestfinished’‘ event (and possibly instead of ’response’ event),
- [‘event: Page.requestFinished`] emitted when the response body is downloaded and the request is complete.
- [`event: Page.response`] emitted when/if the response status and headers are received for the request.
- [`event: Page.request`] emitted when the request is issued by the page.
Whenever the page sends a request for a network resource the following sequence of events are emitted by `Page`:

def all_headers

An object with all the request HTTP headers associated with this request. The header names are lower-cased.
def all_headers
  wrap_impl(@impl.all_headers)
end

def apply_fallback_overrides(overrides)

@nodoc 
def apply_fallback_overrides(overrides)
  wrap_impl(@impl.apply_fallback_overrides(unwrap_impl(overrides)))
end

def event_emitter_proxy 

def event_emitter_proxy
_emitter_proxy ||= EventEmitterProxy.new(self, @impl)

def failure

```
page.on("requestfailed", lambda request: print(request.url + " " + request.failure))
```py

Example of logging of all the failed requests:

**Usage**

The method returns `null` unless this request has failed, as reported by `requestfailed` event.
def failure
  wrap_impl(@impl.failure)
end

def frame

Here is an example that handles all the cases:

- When navigation request is issued before the corresponding frame is created. You can use [`method: Request.isNavigationRequest`] to check that.
- When request originates in the Service Worker. You can use `request.serviceWorker()` to check that.
Note that in some cases the frame is not available, and this method will throw.

**Details**

```
frame_url = request.frame.url
```py

**Usage**

Returns the `Frame` that initiated this request.
def frame
  wrap_impl(@impl.frame)
end

def header_value(name)

Returns the value of the header matching the name. The name is case insensitive.
def header_value(name)
  wrap_impl(@impl.header_value(unwrap_impl(name)))
end

def header_values(name)

@nodoc 
def header_values(name)
  wrap_impl(@impl.header_values(unwrap_impl(name)))
end

def headers

You can use [`method: Request.allHeaders`] for complete list of headers that include `cookie` information.
Note that this method does not return security-related headers, including cookie-related ones.
An object with the request HTTP headers. The header names are lower-cased.
def headers
  wrap_impl(@impl.headers)
end

def headers_array

Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple times.
An array with all the request HTTP headers associated with this request. Unlike [`method: Request.allHeaders`], header names are NOT lower-cased.
def headers_array
  wrap_impl(@impl.headers_array)
end

def method

Request's method (GET, POST, etc.)
def method
  wrap_impl(@impl.method)
end

def navigation_request?

do not have [`method: Request.frame`] available.
Some navigation requests are issued before the corresponding frame is created, and therefore

Whether this request is driving frame's navigation.
def navigation_request?
  wrap_impl(@impl.navigation_request?)
end

def off(event, callback)

@nodoc
-- inherited from EventEmitter -- 
def off(event, callback)
  event_emitter_proxy.off(event, callback)
end

def on(event, callback)

@nodoc
-- inherited from EventEmitter -- 
def on(event, callback)
  event_emitter_proxy.on(event, callback)
end

def once(event, callback)

@nodoc
-- inherited from EventEmitter -- 
def once(event, callback)
  event_emitter_proxy.once(event, callback)
end

def post_data

Request's post body, if any.
def post_data
  wrap_impl(@impl.post_data)
end

def post_data_buffer

Request's post body in a binary form, if any.
def post_data_buffer
  wrap_impl(@impl.post_data_buffer)
end

def post_data_json

Otherwise it will be parsed as JSON.
When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned.

Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.
def post_data_json
  wrap_impl(@impl.post_data_json)
end

def redirected_from

```
print(response.request.redirected_from) # None
response = page.goto("https://google.com")
```python sync

If the website `https://google.com` has no redirects:

```
print(response.request.redirected_from.url) # "http://example.com"
response = page.goto("http://example.com")
```python sync

For example, if the website `http://example.com` redirects to `https://example.com`:

**Usage**

construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
`redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
When the server responds with a redirect, Playwright creates a new `Request` object. The two requests are connected by

Request that was redirected by the server to this one, if any.
def redirected_from
  wrap_impl(@impl.redirected_from)
end

def redirected_to

```
assert request.redirected_from.redirected_to == request
```py

This method is the opposite of [`method: Request.redirectedFrom`]:

**Usage**

New request issued by the browser if the server responded with redirect.
def redirected_to
  wrap_impl(@impl.redirected_to)
end

def resource_type

`websocket`, `manifest`, `other`.
following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`,
Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the
def resource_type
  wrap_impl(@impl.resource_type)
end

def response

Returns the matching `Response` object, or `null` if the response was not received due to error.
def response
  wrap_impl(@impl.response)
end

def sizes

Returns resource size information for given request.
def sizes
  wrap_impl(@impl.sizes)
end

def timing

```
print(request.timing)
request = request_info.value
page.goto("http://example.com")
with page.expect_event("requestfinished") as request_info:
```python sync

**Usage**

[Resource Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming).
`responseEnd` becomes available when request finishes. Find more information at
Returns resource timing information for given request. Most of the timing values become available upon the response,
def timing
  wrap_impl(@impl.timing)
end

def url

URL of the request.
def url
  wrap_impl(@impl.url)
end