In REST Assured, what does given().request(Method, path) do that get() and post() cannot?

`get(...)`, `post(...)`, `put(...)` and their siblings are convenience methods on top of a single generic sender. That sender is `request(...)`, and it is what you reach for when the HTTP verb has to be a **value** rather than a method name. ## Two things the named verbs cannot do - **Take the verb as data.** `request(Method.GET, "/plots")` and `request(Method.PATCH, "/plots/17")` differ only in an argument, so a parameterised test can drive the same chain across several verbs from a data source. - **Send a verb with no constant.** The `String` overloads — `request("REPORT", "/plots")` — send whatever verb you name. The `Method` enum's own documentation says as much: any verb is supported when you go through `request`. ## The eight Method constants `io.restassured.http.Method` declares exactly eight values, and no more: - `GET`, `PUT`, `POST`, `DELETE` - `HEAD`, `TRACE`, `OPTIONS`, `PATCH` Each has a matching named verb method on the DSL, so `request(Method.HEAD, "/plots")` and `head("/plots")` are equivalent. If you need something outside this set — a WebDAV verb, or a bespoke one a service defines — the enum is a dead end and the `String` overload is the answer. It is a plain Java enum, so it cannot be extended at runtime and there is no registration hook to add a ninth constant. That is not a limitation in practice, because the `String` forms exist precisely to cover everything the enum does not. ## The overload set `request` comes in eight forms, four for the enum and four mirroring them for a raw `String`: | Form | What the target is | |---|---| | `request(Method)` / `request(String)` | base URI plus base path, with an empty path | | `request(Method, String path, Object... pathParams)` and its `String` twin | the usual assembly: base URI, base path, then this path | | `request(Method, URI)` / `request(String, URI)` | the URI itself — fully qualified, so the defaults are bypassed | | `request(Method, URL)` / `request(String, URL)` | the URL itself — same bypass | ## Where the call lands This is the part worth being precise about, because `request(...)` is not a different addressing mechanism: - The `String path` overloads resolve **exactly** as `get(...)` does — base URI, then base path, then the path — with slashes normalised at each seam. - The no-path forms pass an empty path internally, so `given().baseUri("https://rota.allotment-water.test").basePath("/api/v2/plots").request(Method.GET)` sends a GET to `https://rota.allotment-water.test/api/v2/plots`. That is a genuinely useful shape when the base path already names the resource. - The `URI` and `URL` overloads are fully qualified by construction, so they discard the base URI and base path the same way an absolute string in `get(...)` does. - Everything else on the chain — the port rule, headers, auth, filters — behaves identically. Only the way the verb is named has changed. ## When to reach for it - **Data-driven verb coverage.** Asserting that the allotment water-rota API answers `405` for every verb it does not implement on `/plots/17/slots` is one loop over `Method.values()` and one `request(method, path)` call, instead of eight near-identical tests. - **A verb the enum does not carry.** Use the `String` form and name the verb directly. - **A helper that wraps sending.** A shared method taking `(Method method, String path)` keeps one place responsible for logging, auth and base defaults. ## The cost side Routing everything through `request(...)` has a readability price that is easy to underestimate. A file of named verbs can be skimmed for what it does — the `post` calls are the writes, the `get` calls are the reads — and that scanning disappears the moment the verb becomes an argument. A generic sender also pushes the verb one level away from the assertion it belongs with, so a reviewer has to follow a parameter to know what was tested. So for an ordinary hand-written test, prefer the named verb: `get("/plots/17/slots")` reads better than `request(Method.GET, "/plots/17/slots")`. `request(...)` earns its place in exactly two situations — when the verb stops being a constant in the source and becomes a parameter, and when the verb has no constant to be. Those are real cases, and it is worth knowing the method is there for them, but they are the minority of calls in most suites.