micropelago/garage
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'Use status code 204 No Content for empty responses' (#403) from tobikris/garage:http-no-content into main

Browse Source 
Reviewed-on: https://git.deuxfleurs.fr/Deuxfleurs/garage/pulls/403
This commit is contained in:
Alex 2022-10-18 14:20:44 +00:00
commit 5670599372
11 changed files with 104 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
doc/drafts/k2v-spec.md
View File

@ -207,7 +207,7 @@ and responses need to be translated.
Query parameters: Query parameters:
| name | default value | meaning | | name | default value | meaning |
| - | - | - | |------------|---------------|----------------------------------|
| `sort_key` | **mandatory** | The sort key of the item to read | | `sort_key` | **mandatory** | The sort key of the item to read |
Returns the item with specified partition key and sort key. Values can be Returns the item with specified partition key and sort key. Values can be
@ -318,7 +318,7 @@ an HTTP 304 NOT MODIFIED is returned.
Query parameters: Query parameters:
| name | default value | meaning | | name | default value | meaning |
| - | - | - | |-------------------|---------------|----------------------------------------------------------------------------|
| `sort_key` | **mandatory** | The sort key of the item to read | | `sort_key` | **mandatory** | The sort key of the item to read |
| `causality_token` | **mandatory** | The causality token of the last known value or set of values | | `causality_token` | **mandatory** | The causality token of the last known value or set of values |
| `timeout` | 300 | The timeout before 304 NOT MODIFIED is returned if the value isn't updated | | `timeout` | 300 | The timeout before 304 NOT MODIFIED is returned if the value isn't updated |
@ -346,7 +346,7 @@ myblobblahblahblah
Example response: Example response:
``` ```
HTTP/1.1 200 OK HTTP/1.1 204 No Content
``` ```
**DeleteItem: `DELETE /<bucket>/<partition key>?sort_key=<sort_key>`** **DeleteItem: `DELETE /<bucket>/<partition key>?sort_key=<sort_key>`**
@ -383,7 +383,7 @@ as these values are asynchronously updated, and thus eventually consistent.
Query parameters: Query parameters:
| name | default value | meaning | | name | default value | meaning |
| - | - | - | |-----------|---------------|----------------------------------------------------------------|
| `prefix` | `null` | Restrict listing to partition keys that start with this prefix | | `prefix` | `null` | Restrict listing to partition keys that start with this prefix |
| `start` | `null` | First partition key to list, in lexicographical order | | `start` | `null` | First partition key to list, in lexicographical order |
| `end` | `null` | Last partition key to list (excluded) | | `end` | `null` | Last partition key to list (excluded) |
@ -512,7 +512,7 @@ POST /my_bucket HTTP/1.1
Example response: Example response:
``` ```
HTTP/1.1 200 OK HTTP/1.1 204 NO CONTENT
``` ```
@ -526,7 +526,7 @@ items to get (to get single items, set `singleItem` to `true`). A search is a
JSON struct with the following fields: JSON struct with the following fields:
| name | default value | meaning | | name | default value | meaning |
| - | - | - | |-----------------|---------------|----------------------------------------------------------------------------------------|
| `partitionKey` | **mandatory** | The partition key in which to search | | `partitionKey` | **mandatory** | The partition key in which to search |
| `prefix` | `null` | Restrict items to list to those whose sort keys start with this prefix | | `prefix` | `null` | Restrict items to list to those whose sort keys start with this prefix |
| `start` | `null` | The sort key of the first item to read | | `start` | `null` | The sort key of the first item to read |
@ -683,7 +683,7 @@ POST /my_bucket?delete HTTP/1.1
Example response: Example response:
``` ```json
HTTP/1.1 200 OK HTTP/1.1 200 OK
[ [

6
src/api/admin/api_server.rs
View File

@ -5,7 +5,7 @@ use async_trait::async_trait;
use futures::future::Future; use futures::future::Future;
use http::header::{ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW}; use http::header::{ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW};
use hyper::{Body, Request, Response}; use hyper::{Body, Request, Response, StatusCode};
use opentelemetry::trace::SpanRef; use opentelemetry::trace::SpanRef;
@ -69,7 +69,7 @@ impl AdminApiServer {
fn handle_options(&self, _req: &Request<Body>) -> Result<Response<Body>, Error> { fn handle_options(&self, _req: &Request<Body>) -> Result<Response<Body>, Error> {
Ok(Response::builder() Ok(Response::builder()
.status(204) .status(StatusCode::NO_CONTENT)
.header(ALLOW, "OPTIONS, GET, POST") .header(ALLOW, "OPTIONS, GET, POST")
.header(ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, GET, POST") .header(ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, GET, POST")
.header(ACCESS_CONTROL_ALLOW_ORIGIN, "*") .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
@ -94,7 +94,7 @@ impl AdminApiServer {
.ok_or_internal_error("Could not serialize metrics")?; .ok_or_internal_error("Could not serialize metrics")?;
Ok(Response::builder() Ok(Response::builder()
.status(200) .status(StatusCode::OK)
.header(http::header::CONTENT_TYPE, encoder.format_type()) .header(http::header::CONTENT_TYPE, encoder.format_type())
.body(Body::from(buffer))?) .body(Body::from(buffer))?)
} }

6
src/api/admin/cluster.rs
View File

@ -151,7 +151,7 @@ pub async fn handle_update_cluster_layout(
garage.system.update_cluster_layout(&layout).await?; garage.system.update_cluster_layout(&layout).await?;
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::OK) .status(StatusCode::NO_CONTENT)
.body(Body::empty())?) .body(Body::empty())?)
} }
@ -166,7 +166,7 @@ pub async fn handle_apply_cluster_layout(
garage.system.update_cluster_layout(&layout).await?; garage.system.update_cluster_layout(&layout).await?;
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::OK) .status(StatusCode::NO_CONTENT)
.body(Body::empty())?) .body(Body::empty())?)
} }
@ -181,7 +181,7 @@ pub async fn handle_revert_cluster_layout(
garage.system.update_cluster_layout(&layout).await?; garage.system.update_cluster_layout(&layout).await?;
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::OK) .status(StatusCode::NO_CONTENT)
.body(Body::empty())?) .body(Body::empty())?)
} }

2
src/api/k2v/batch.rs
View File

@ -42,7 +42,7 @@ pub async fn handle_insert_batch(
garage.k2v.rpc.insert_batch(bucket_id, items2).await?; garage.k2v.rpc.insert_batch(bucket_id, items2).await?;
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::OK) .status(StatusCode::NO_CONTENT)
.body(Body::empty())?) .body(Body::empty())?)
} }

2
src/api/k2v/item.rs
View File

@ -153,7 +153,7 @@ pub async fn handle_insert_item(
.await?; .await?;
Ok(Response::builder() Ok(Response::builder()
.status(StatusCode::OK) .status(StatusCode::NO_CONTENT)
.body(Body::empty())?) .body(Body::empty())?)
} }

22
src/garage/tests/k2v/batch.rs
View File

@ -6,7 +6,7 @@ use assert_json_diff::assert_json_eq;
use serde_json::json; use serde_json::json;
use super::json_body; use super::json_body;
use hyper::Method; use hyper::{Method, StatusCode};
#[tokio::test] #[tokio::test]
async fn test_batch() { async fn test_batch() {
@ -49,7 +49,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
for sk in ["a", "b", "c", "d.1", "d.2", "e"] { for sk in ["a", "b", "c", "d.1", "d.2", "e"] {
let res = ctx let res = ctx
@ -62,7 +62,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -104,7 +104,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
let json_res = json_body(res).await; let json_res = json_body(res).await;
assert_json_eq!( assert_json_eq!(
json_res, json_res,
@ -266,7 +266,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
for sk in ["b", "c", "d.1", "d.2"] { for sk in ["b", "c", "d.1", "d.2"] {
let res = ctx let res = ctx
@ -280,9 +280,9 @@ async fn test_batch() {
.await .await
.unwrap(); .unwrap();
if sk == "b" { if sk == "b" {
assert_eq!(res.status(), 204); assert_eq!(res.status(), StatusCode::NO_CONTENT);
} else { } else {
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
} }
ct.insert( ct.insert(
sk, sk,
@ -317,7 +317,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
let json_res = json_body(res).await; let json_res = json_body(res).await;
assert_json_eq!( assert_json_eq!(
json_res, json_res,
@ -478,7 +478,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
let json_res = json_body(res).await; let json_res = json_body(res).await;
assert_json_eq!( assert_json_eq!(
json_res, json_res,
@ -514,7 +514,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); assert_eq!(res.status(), StatusCode::NO_CONTENT);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -547,7 +547,7 @@ async fn test_batch() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
let json_res = json_body(res).await; let json_res = json_body(res).await;
assert_json_eq!( assert_json_eq!(
json_res, json_res,

20
src/garage/tests/k2v/errorcodes.rs
View File

@ -1,13 +1,13 @@
use crate::common; use crate::common;
use hyper::Method; use hyper::{Method, StatusCode};
#[tokio::test] #[tokio::test]
async fn test_error_codes() { async fn test_error_codes() {
let ctx = common::context(); let ctx = common::context();
let bucket = ctx.create_bucket("test-k2v-error-codes"); let bucket = ctx.create_bucket("test-k2v-error-codes");
// Regular insert should work (code 200) // Regular insert should work (code 204)
let res = ctx let res = ctx
.k2v .k2v
.request .request
@ -19,7 +19,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Insert with trash causality token: invalid request // Insert with trash causality token: invalid request
let res = ctx let res = ctx
@ -34,7 +34,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Search without partition key: invalid request // Search without partition key: invalid request
let res = ctx let res = ctx
@ -52,7 +52,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Search with start that is not in prefix: invalid request // Search with start that is not in prefix: invalid request
let res = ctx let res = ctx
@ -70,7 +70,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Search with invalid json: 400 // Search with invalid json: 400
let res = ctx let res = ctx
@ -88,7 +88,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Batch insert with invalid causality token: 400 // Batch insert with invalid causality token: 400
let res = ctx let res = ctx
@ -105,7 +105,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Batch insert with invalid data: 400 // Batch insert with invalid data: 400
let res = ctx let res = ctx
@ -122,7 +122,7 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
// Poll with invalid causality token: 400 // Poll with invalid causality token: 400
let res = ctx let res = ctx
@ -137,5 +137,5 @@ async fn test_error_codes() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 400); assert_eq!(res.status(), StatusCode::BAD_REQUEST);
} }

58
src/garage/tests/k2v/item.rs
View File

@ -6,7 +6,7 @@ use assert_json_diff::assert_json_eq;
use serde_json::json; use serde_json::json;
use super::json_body; use super::json_body;
use hyper::Method; use hyper::{Method, StatusCode};
#[tokio::test] #[tokio::test]
async fn test_items_and_indices() { async fn test_items_and_indices() {
@ -56,7 +56,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Get value back // Get value back
let res = ctx let res = ctx
@ -69,7 +69,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -132,7 +132,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Get value back // Get value back
let res = ctx let res = ctx
@ -145,7 +145,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -201,7 +201,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Get value back // Get value back
let res = ctx let res = ctx
@ -214,7 +214,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -271,7 +271,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
let ct = res let ct = res
.headers() .headers()
.get("x-garage-causality-token") .get("x-garage-causality-token")
@ -292,7 +292,7 @@ async fn test_items_and_indices() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// ReadIndex -- now there should be some stuff // ReadIndex -- now there should be some stuff
tokio::time::sleep(Duration::from_secs(1)).await; tokio::time::sleep(Duration::from_secs(1)).await;
@ -364,7 +364,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// f0: either // f0: either
let res = ctx let res = ctx
@ -377,7 +377,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -405,7 +405,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -424,7 +424,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream" "application/octet-stream"
@ -446,7 +446,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -466,7 +466,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// f0: either // f0: either
let res = ctx let res = ctx
@ -479,7 +479,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -503,7 +503,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -528,7 +528,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 409); // CONFLICT assert_eq!(res.status(), StatusCode::CONFLICT); // CONFLICT
// f3: json // f3: json
let res = ctx let res = ctx
@ -541,7 +541,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -568,7 +568,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// f0: either // f0: either
let res = ctx let res = ctx
@ -581,7 +581,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -599,7 +599,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -625,7 +625,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 409); // CONFLICT assert_eq!(res.status(), StatusCode::CONFLICT); // CONFLICT
// f3: json // f3: json
let res = ctx let res = ctx
@ -638,7 +638,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -658,7 +658,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// f0: either // f0: either
let res = ctx let res = ctx
@ -671,7 +671,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); // NO CONTENT assert_eq!(res.status(), StatusCode::NO_CONTENT); // NO CONTENT
// f1: not specified // f1: not specified
let res = ctx let res = ctx
@ -683,7 +683,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"
@ -702,7 +702,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 204); // NO CONTENT assert_eq!(res.status(), StatusCode::NO_CONTENT); // NO CONTENT
// f3: json // f3: json
let res = ctx let res = ctx
@ -715,7 +715,7 @@ async fn test_item_return_format() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::OK);
assert_eq!( assert_eq!(
res.headers().get("content-type").unwrap().to_str().unwrap(), res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/json" "application/json"

10
src/garage/tests/k2v/poll.rs
View File

@ -1,4 +1,4 @@
use hyper::Method; use hyper::{Method, StatusCode};
use std::time::Duration; use std::time::Duration;
use crate::common; use crate::common;
@ -20,7 +20,7 @@ async fn test_poll() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Retrieve initial value to get its causality token // Retrieve initial value to get its causality token
let res2 = ctx let res2 = ctx
@ -33,7 +33,7 @@ async fn test_poll() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res2.status(), 200); assert_eq!(res2.status(), StatusCode::OK);
let ct = res2 let ct = res2
.headers() .headers()
.get("x-garage-causality-token") .get("x-garage-causality-token")
@ -80,7 +80,7 @@ async fn test_poll() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
// Check poll finishes with correct value // Check poll finishes with correct value
let poll_res = tokio::select! { let poll_res = tokio::select! {
@ -88,7 +88,7 @@ async fn test_poll() {
res = poll => res.unwrap().unwrap(), res = poll => res.unwrap().unwrap(),
}; };
assert_eq!(poll_res.status(), 200); assert_eq!(poll_res.status(), StatusCode::OK);
let poll_res_body = hyper::body::to_bytes(poll_res.into_body()) let poll_res_body = hyper::body::to_bytes(poll_res.into_body())
.await .await

6
src/garage/tests/k2v/simple.rs
View File

@ -1,6 +1,6 @@
use crate::common; use crate::common;
use hyper::Method; use hyper::{Method, StatusCode};
#[tokio::test] #[tokio::test]
async fn test_simple() { async fn test_simple() {
@ -18,7 +18,7 @@ async fn test_simple() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res.status(), 200); assert_eq!(res.status(), StatusCode::NO_CONTENT);
let res2 = ctx let res2 = ctx
.k2v .k2v
@ -30,7 +30,7 @@ async fn test_simple() {
.send() .send()
.await .await
.unwrap(); .unwrap();
assert_eq!(res2.status(), 200); assert_eq!(res2.status(), StatusCode::OK);
let res2_body = hyper::body::to_bytes(res2.into_body()) let res2_body = hyper::body::to_bytes(res2.into_body())
.await .await

20
src/garage/tests/s3/website.rs
View File

@ -4,7 +4,7 @@ use aws_sdk_s3::{
model::{CorsConfiguration, CorsRule, ErrorDocument, IndexDocument, WebsiteConfiguration}, model::{CorsConfiguration, CorsRule, ErrorDocument, IndexDocument, WebsiteConfiguration},
types::ByteStream, types::ByteStream,
}; };
use http::Request; use http::{Request, StatusCode};
use hyper::{ use hyper::{
body::{to_bytes, Body}, body::{to_bytes, Body},
Client, Client,
@ -43,7 +43,7 @@ async fn test_website() {
let mut resp = client.request(req()).await.unwrap(); let mut resp = client.request(req()).await.unwrap();
assert_eq!(resp.status(), 404); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!( assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref() BODY.as_ref()
@ -56,7 +56,7 @@ async fn test_website() {
.expect_success_status("Could not allow website on bucket"); .expect_success_status("Could not allow website on bucket");
resp = client.request(req()).await.unwrap(); resp = client.request(req()).await.unwrap();
assert_eq!(resp.status(), 200); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref() BODY.as_ref()
@ -69,7 +69,7 @@ async fn test_website() {
.expect_success_status("Could not deny website on bucket"); .expect_success_status("Could not deny website on bucket");
resp = client.request(req()).await.unwrap(); resp = client.request(req()).await.unwrap();
assert_eq!(resp.status(), 404); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!( assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref() BODY.as_ref()
@ -175,7 +175,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 200); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get("access-control-allow-origin").unwrap(), resp.headers().get("access-control-allow-origin").unwrap(),
"*" "*"
@ -200,7 +200,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 404); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_eq!( assert_eq!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY_ERR.as_ref() BODY_ERR.as_ref()
@ -220,7 +220,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 200); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get("access-control-allow-origin").unwrap(), resp.headers().get("access-control-allow-origin").unwrap(),
"*" "*"
@ -244,7 +244,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 403); assert_eq!(resp.status(), StatusCode::FORBIDDEN);
assert_ne!( assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref() BODY.as_ref()
@ -285,7 +285,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 403); assert_eq!(resp.status(), StatusCode::FORBIDDEN);
assert_ne!( assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref() BODY.as_ref()
@ -311,7 +311,7 @@ async fn test_website_s3_api() {
let mut resp = client.request(req).await.unwrap(); let mut resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), 404); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!( assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(), to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY_ERR.as_ref() BODY_ERR.as_ref()