use axum_core::{
body,
response::{IntoResponse, Response},
BoxError,
};
use bytes::Bytes;
use futures_core::TryStream;
use futures_util::{stream, TryStreamExt};
use http::{header, HeaderValue, StatusCode};
use std::{io, path::Path};
use tokio::{
fs::File,
io::{AsyncReadExt, AsyncSeekExt},
};
use tokio_util::io::ReaderStream;
mod range;
use self::range::{normalize_range_specs, RangeSpecs, MAX_RANGES};
use super::multipart;
/// Encapsulate the file stream.
///
/// The encapsulated file stream construct requires passing in a stream.
///
/// # Examples
///
/// ```
/// use axum::{
/// http::StatusCode,
/// response::{IntoResponse, Response},
/// routing::get,
/// Router,
/// };
/// use axum_extra::response::file_stream::FileStream;
/// use tokio::fs::File;
/// use tokio_util::io::ReaderStream;
///
/// async fn file_stream() -> Result<Response, (StatusCode, String)> {
/// let file = File::open("test.txt")
/// .await
/// .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;
///
/// let stream = ReaderStream::new(file);
/// let file_stream_resp = FileStream::new(stream).file_name("test.txt");
///
/// Ok(file_stream_resp.into_response())
/// }
///
/// let app = Router::new().route("/file-stream", get(file_stream));
/// # let _: Router = app;
/// ```
#[must_use]
#[derive(Debug)]
pub struct FileStream<S> {
/// stream.
pub stream: S,
/// The file name of the file.
pub file_name: Option<String>,
/// The size of the file.
pub content_size: Option<u64>,
}
impl<S> FileStream<S>
where
S: TryStream + Send + 'static,
S::Ok: Into<Bytes>,
S::Error: Into<BoxError>,
{
/// Create a new [`FileStream`]
pub fn new(stream: S) -> Self {
Self {
stream,
file_name: None,
content_size: None,
}
}
/// Set the file name of the [`FileStream`].
///
/// This adds the attachment `Content-Disposition` header with the given `file_name`.
pub fn file_name(mut self, file_name: impl Into<String>) -> Self {
self.file_name = Some(file_name.into());
self
}
/// Set the size of the file.
pub fn content_size(mut self, len: u64) -> Self {
self.content_size = Some(len);
self
}
/// Return a range response, or `416 Range Not Satisfiable` for invalid offsets.
///
/// range: (start, end, total_size)
///
/// # Examples
///
/// ```
/// use axum::{
/// http::StatusCode,
/// response::IntoResponse,
/// routing::get,
/// Router,
/// };
/// use axum_extra::response::file_stream::FileStream;
/// use tokio::fs::File;
/// use tokio::io::AsyncSeekExt;
/// use tokio_util::io::ReaderStream;
///
/// async fn range_response() -> Result<impl IntoResponse, (StatusCode, String)> {
/// let mut file = File::open("test.txt")
/// .await
/// .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;
/// let mut file_size = file
/// .metadata()
/// .await
/// .map_err(|e| (StatusCode::NOT_FOUND, format!("Get file size: {e}")))?
/// .len();
///
/// file.seek(std::io::SeekFrom::Start(10))
/// .await
/// .map_err(|e| (StatusCode::NOT_FOUND, format!("File seek error: {e}")))?;
/// let stream = ReaderStream::new(file);
///
/// Ok(FileStream::new(stream).into_range_response(10, file_size - 1, file_size))
/// }
///
/// let app = Router::new().route("/file-stream", get(range_response));
/// # let _: Router = app;
/// ```
pub fn into_range_response(self, start: u64, end: u64, total_size: u64) -> Response {
if start > end || end >= total_size {
return response_416(total_size);
}
let mut resp = Response::builder().header(header::CONTENT_TYPE, "application/octet-stream");
resp = resp.status(StatusCode::PARTIAL_CONTENT);
resp = resp.header(header::ACCEPT_RANGES, "bytes");
resp = resp.header(header::CONTENT_LENGTH, end - start + 1);
resp = resp.header(
header::CONTENT_RANGE,
format!("bytes {start}-{end}/{total_size}"),
);
resp.body(body::Body::from_stream(self.stream))
.unwrap_or_else(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("build FileStream response error: {e}"),
)
.into_response()
})
}
/// Attempts to return a response for an HTTP `Range` header directly from the file path.
///
/// # Arguments
///
/// * `file_path` - The path of the file to be streamed
/// * `range` - The value of the `Range` header
///
/// If the header is absent, use [`FileStream::from_path`] to return the full file.
/// Range handling is defined for GET only; callers should ignore this header on other methods.
///
/// # Examples
///
/// ```
/// use axum::{
/// http::{header, HeaderMap, Method, StatusCode},
/// response::IntoResponse,
/// Router,
/// routing::get
/// };
/// use axum_extra::response::file_stream::FileStream;
/// use tokio::fs::File;
/// use tokio_util::io::ReaderStream;
///
/// async fn range_stream(method: Method, headers: HeaderMap) -> impl IntoResponse {
/// let response = match headers.get(header::RANGE).filter(|_| method == Method::GET) {
/// Some(range) => FileStream::<ReaderStream<File>>::try_range_response(
/// "CHANGELOG.md", range,
/// ).await,
/// None => FileStream::from_path("CHANGELOG.md")
/// .await
/// .map(|file| file.into_response()),
/// };
/// response.map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))
/// }
///
/// let app = Router::new().route("/file-stream", get(range_stream));
/// # let _: Router = app;
/// ```
pub async fn try_range_response(
file_path: impl AsRef<Path>,
range: &HeaderValue,
) -> io::Result<Response> {
let path = file_path.as_ref();
let Some((unit, range_values)) = range
.to_str()
.ok()
.and_then(|range| range.trim().split_once('='))
else {
return full_file_response(path).await;
};
if !unit.trim().eq_ignore_ascii_case("bytes") {
return full_file_response(path).await;
}
let file = File::open(path).await?;
let metadata = file.metadata().await?;
let total_size = metadata.len();
if total_size == 0 {
return full_file_response(path).await;
}
let Ok(range_specs) = range_values.parse::<RangeSpecs>() else {
return Ok(response_416(total_size));
};
let ranges = normalize_range_specs(&range_specs, total_size);
let ranges = ranges.as_slice();
if ranges.is_empty() {
return Ok(response_416(total_size));
}
if ranges.len() == 1 {
let (start, end) = ranges[0];
return single_range_response(file, start, end, total_size).await;
}
Ok(multipart_range_response(path, ranges, total_size))
}
}
async fn full_file_response(path: impl AsRef<Path>) -> io::Result<Response> {
Ok(FileStream::<ReaderStream<File>>::from_path(path)
.await?
.into_response())
}
async fn single_range_response(
mut file: File,
start: u64,
end: u64,
total_size: u64,
) -> io::Result<Response> {
file.seek(std::io::SeekFrom::Start(start)).await?;
let stream = ReaderStream::new(file.take(end - start + 1));
Ok(FileStream::new(stream).into_range_response(start, end, total_size))
}
fn multipart_range_response(path: &Path, ranges: &[(u64, u64)], total_size: u64) -> Response {
let boundary = multipart_boundary(total_size, ranges.len());
let content_type = format!("multipart/byteranges; boundary={boundary}");
let parts: [Option<multipart::Part>; MAX_RANGES] = std::array::from_fn(|index| {
let &(start, end) = ranges.get(index)?;
let content_range = format!("bytes {start}-{end}/{total_size}");
let path = path.to_path_buf();
let reader = stream::once(async move {
let mut file = File::open(path).await?;
file.seek(std::io::SeekFrom::Start(start)).await?;
Ok::<_, io::Error>(ReaderStream::new(file.take(end - start + 1)))
})
.try_flatten();
Some(multipart::Part::new(
&boundary,
[
("Content-Type", "application/octet-stream"),
("Content-Range", content_range.as_str()),
],
body::Body::from_stream(reader),
))
});
let multipart = multipart::Multipart::new(&boundary, parts, true);
Response::builder()
.status(StatusCode::PARTIAL_CONTENT)
.header(header::CONTENT_TYPE, content_type)
.header(header::ACCEPT_RANGES, "bytes")
.body(body::Body::new(multipart))
.unwrap_or_else(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("build FileStream response error: {e}"),
)
.into_response()
})
}
fn multipart_boundary(total_size: u64, len: usize) -> String {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |duration| duration.as_nanos());
format!("axum-extra-boundary-{total_size}-{len}-{nanos}")
}
fn response_416(total_size: u64) -> Response {
let mut response = StatusCode::RANGE_NOT_SATISFIABLE.into_response();
if let Ok(content_range) = HeaderValue::try_from(format!("bytes */{total_size}")) {
response
.headers_mut()
.insert(header::CONTENT_RANGE, content_range);
}
response
}
// Split because the general impl requires to specify `S` and this one does not.
impl FileStream<ReaderStream<File>> {
/// Create a [`FileStream`] from a file path.
///
/// # Examples
///
/// ```
/// use axum::{
/// http::StatusCode,
/// response::IntoResponse,
/// Router,
/// routing::get
/// };
/// use axum_extra::response::file_stream::FileStream;
///
/// async fn file_stream() -> impl IntoResponse {
/// FileStream::from_path("test.txt")
/// .await
/// .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))
/// }
///
/// let app = Router::new().route("/file-stream", get(file_stream));
/// # let _: Router = app;
/// ```
pub async fn from_path(path: impl AsRef<Path>) -> io::Result<Self> {
let file = File::open(&path).await?;
let mut content_size = None;
let mut file_name = None;
if let Ok(metadata) = file.metadata().await {
content_size = Some(metadata.len());
}
if let Some(file_name_os) = path.as_ref().file_name() {
if let Some(file_name_str) = file_name_os.to_str() {
file_name = Some(file_name_str.to_owned());
}
}
Ok(Self {
stream: ReaderStream::new(file),
file_name,
content_size,
})
}
}
impl<S> IntoResponse for FileStream<S>
where
S: TryStream + Send + 'static,
S::Ok: Into<Bytes>,
S::Error: Into<BoxError>,
{
fn into_response(self) -> Response {
let mut resp = Response::builder().header(header::CONTENT_TYPE, "application/octet-stream");
if let Some(file_name) = self.file_name {
resp = resp.header(
header::CONTENT_DISPOSITION,
format!(
"attachment; filename=\"{}\"",
super::content_disposition::EscapedQuotedString(&file_name)
),
);
}
if let Some(content_size) = self.content_size {
resp = resp.header(header::CONTENT_LENGTH, content_size);
}
resp.body(body::Body::from_stream(self.stream))
.unwrap_or_else(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("build FileStream response error: {e}"),
)
.into_response()
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use axum::{extract::Request, routing::get, Router};
use body::Body;
use http::{HeaderMap, Method};
use http_body_util::BodyExt;
use std::io::{Cursor, Write};
use tokio_util::io::ReaderStream;
use tower::ServiceExt;
#[tokio::test]
async fn response() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
// Simulating a file stream
let file_content = b"Hello, this is the simulated file content!".to_vec();
let reader = Cursor::new(file_content);
// Response file stream
// Content size and file name are not attached by default
let stream = ReaderStream::new(reader);
FileStream::new(stream).into_response()
}),
);
// Simulating a GET request
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
// Validate Response Status Code
assert_eq!(response.status(), StatusCode::OK);
// Validate Response Headers
assert_eq!(
response.headers().get("content-type").unwrap(),
"application/octet-stream"
);
// Validate Response Body
let body: &[u8] = &response.into_body().collect().await?.to_bytes();
assert_eq!(
std::str::from_utf8(body)?,
"Hello, this is the simulated file content!"
);
Ok(())
}
#[tokio::test]
async fn response_not_set_filename() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
// Simulating a file stream
let file_content = b"Hello, this is the simulated file content!".to_vec();
let size = file_content.len() as u64;
let reader = Cursor::new(file_content);
// Response file stream
let stream = ReaderStream::new(reader);
FileStream::new(stream).content_size(size).into_response()
}),
);
// Simulating a GET request
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
// Validate Response Status Code
assert_eq!(response.status(), StatusCode::OK);
// Validate Response Headers
assert_eq!(
response.headers().get("content-type").unwrap(),
"application/octet-stream"
);
assert_eq!(response.headers().get("content-length").unwrap(), "42");
// Validate Response Body
let body: &[u8] = &response.into_body().collect().await?.to_bytes();
assert_eq!(
std::str::from_utf8(body)?,
"Hello, this is the simulated file content!"
);
Ok(())
}
#[tokio::test]
async fn response_not_set_content_size() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
// Simulating a file stream
let file_content = b"Hello, this is the simulated file content!".to_vec();
let reader = Cursor::new(file_content);
// Response file stream
let stream = ReaderStream::new(reader);
FileStream::new(stream).file_name("test").into_response()
}),
);
// Simulating a GET request
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
// Validate Response Status Code
assert_eq!(response.status(), StatusCode::OK);
// Validate Response Headers
assert_eq!(
response.headers().get("content-type").unwrap(),
"application/octet-stream"
);
assert_eq!(
response.headers().get("content-disposition").unwrap(),
"attachment; filename=\"test\""
);
// Validate Response Body
let body: &[u8] = &response.into_body().collect().await?.to_bytes();
assert_eq!(
std::str::from_utf8(body)?,
"Hello, this is the simulated file content!"
);
Ok(())
}
#[tokio::test]
async fn response_with_content_size_and_filename() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
// Simulating a file stream
let file_content = b"Hello, this is the simulated file content!".to_vec();
let size = file_content.len() as u64;
let reader = Cursor::new(file_content);
// Response file stream
let stream = ReaderStream::new(reader);
FileStream::new(stream)
.file_name("test")
.content_size(size)
.into_response()
}),
);
// Simulating a GET request
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
// Validate Response Status Code
assert_eq!(response.status(), StatusCode::OK);
// Validate Response Headers
assert_eq!(
response.headers().get("content-type").unwrap(),
"application/octet-stream"
);
assert_eq!(
response.headers().get("content-disposition").unwrap(),
"attachment; filename=\"test\""
);
assert_eq!(response.headers().get("content-length").unwrap(), "42");
// Validate Response Body
let body: &[u8] = &response.into_body().collect().await?.to_bytes();
assert_eq!(
std::str::from_utf8(body)?,
"Hello, this is the simulated file content!"
);
Ok(())
}
#[tokio::test]
async fn response_from_path() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/from_path",
get(move || async move {
FileStream::from_path(Path::new("CHANGELOG.md"))
.await
.unwrap()
.into_response()
}),
);
// Simulating a GET request
let response = app
.oneshot(
Request::builder()
.uri("/from_path")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
// Validate Response Status Code
assert_eq!(response.status(), StatusCode::OK);
// Validate Response Headers
assert_eq!(
response.headers().get("content-type").unwrap(),
"application/octet-stream"
);
assert_eq!(
response.headers().get("content-disposition").unwrap(),
"attachment; filename=\"CHANGELOG.md\""
);
let file = File::open("CHANGELOG.md").await.unwrap();
// get file size
let content_length = file.metadata().await.unwrap().len();
assert_eq!(
response
.headers()
.get("content-length")
.unwrap()
.to_str()
.unwrap(),
content_length.to_string()
);
Ok(())
}
#[tokio::test]
async fn response_range_header_single_ranges() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
for (range_header, content_range, expected_body) in [
("bytes=0-0", "bytes 0-0/10", "0"),
("bytes=,0-0", "bytes 0-0/10", "0"),
("bytes=0-0,", "bytes 0-0/10", "0"),
("bytes=4-", "bytes 4-9/10", "456789"),
("bytes=-4", "bytes 6-9/10", "6789"),
("bytes=-999", "bytes 0-9/10", "0123456789"),
("bytes=-18446744073709551615", "bytes 0-9/10", "0123456789"),
("bytes=0-999", "bytes 0-9/10", "0123456789"),
("bytes=0-18446744073709551615", "bytes 0-9/10", "0123456789"),
] {
let response = response_from_range_header(file.path(), range_header).await?;
let headers = response.headers().clone();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(headers.get(header::ACCEPT_RANGES).unwrap(), "bytes");
assert_eq!(headers.get(header::CONTENT_RANGE).unwrap(), content_range);
assert_eq!(
headers.get(header::CONTENT_LENGTH).unwrap(),
&expected_body.len().to_string()
);
assert_eq!(body_text(response).await?, expected_body);
}
Ok(())
}
#[tokio::test]
async fn into_range_response_rejects_invalid_offsets() -> Result<(), Box<dyn std::error::Error>>
{
for (start, end, total_size) in
[(5, 3, 10), (0, 10, 10), (0, 0, 0), (0, u64::MAX, u64::MAX)]
{
let stream = ReaderStream::new(Cursor::new(Vec::<u8>::new()));
let response = FileStream::new(stream).into_range_response(start, end, total_size);
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
assert_eq!(
response.headers().get(header::CONTENT_RANGE).unwrap(),
&format!("bytes */{total_size}")
);
assert_eq!(body_text(response).await?, "");
}
Ok(())
}
#[tokio::test]
async fn response_range_header_unsatisfiable() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
for range in ["bytes=99-100", "bytes=-0", "bytes=9223372036854775808-"] {
let response = response_from_range_header(file.path(), range).await?;
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
assert_eq!(
response.headers().get(header::CONTENT_RANGE).unwrap(),
"bytes */10"
);
assert_eq!(body_text(response).await?, "");
}
Ok(())
}
#[tokio::test]
async fn response_range_header_malformed() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
for range_header in [
"bytes=5-3",
"bytes=abc-def",
"bytes=18446744073709551616-",
"bytes=-18446744073709551616",
"bytes=0-18446744073709551616",
"bytes=-18446744073709551616x",
"bytes=0-18446744073709551616x",
] {
let response = response_from_range_header(file.path(), range_header).await?;
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
assert_eq!(
response.headers().get(header::CONTENT_RANGE).unwrap(),
"bytes */10"
);
}
Ok(())
}
#[tokio::test]
async fn response_range_header_limits_ranges() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
let response =
response_from_range_header(file.path(), "bytes=0-0,1-1,2-2,3-3,4-4,5-5,6-6,7-7,8-8")
.await?;
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
let body = body_text(response).await?;
assert_eq!(body.matches("Content-Range:").count(), MAX_RANGES);
assert!(body.contains("Content-Range: bytes 7-7/10"));
assert!(!body.contains("Content-Range: bytes 8-8/10"));
Ok(())
}
#[tokio::test]
async fn response_range_header_ignored_or_missing() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
for range_header in ["items=0-3", "bytes 0-3"] {
let response = response_from_range_header(file.path(), range_header).await?;
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(body_text(response).await?, "0123456789");
}
let response = FileStream::from_path(file.path()).await?.into_response();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(body_text(response).await?, "0123456789");
Ok(())
}
#[tokio::test]
async fn response_range_header_ignored_on_head() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
let path = file.path().to_owned();
let app = Router::new().route(
"/file",
get(move |method: Method, headers: HeaderMap| {
let path = path.clone();
async move {
let response =
match headers.get(header::RANGE).filter(|_| method == Method::GET) {
Some(range) => {
FileStream::<ReaderStream<File>>::try_range_response(&path, range)
.await
}
None => FileStream::from_path(&path)
.await
.map(|file| file.into_response()),
};
response.unwrap()
}
}),
);
let response = app
.oneshot(
Request::builder()
.method(Method::HEAD)
.uri("/file")
.header(header::RANGE, "bytes=0-0")
.body(Body::empty())?,
)
.await?;
assert_eq!(response.status(), StatusCode::OK);
assert!(response.headers().get(header::CONTENT_RANGE).is_none());
assert_eq!(
response.headers().get(header::CONTENT_LENGTH).unwrap(),
"10"
);
assert_eq!(body_text(response).await?, "");
Ok(())
}
#[tokio::test]
async fn response_range_header_multiple_ranges() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"0123456789")?;
for range_header in ["bytes=0-0,8-9", "bytes=0-0,,8-9"] {
let response = response_from_range_header(file.path(), range_header).await?;
let headers = response.headers().clone();
let content_type = headers
.get(header::CONTENT_TYPE)
.unwrap()
.to_str()?
.to_owned();
let boundary = content_type
.strip_prefix("multipart/byteranges; boundary=")
.unwrap();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(headers.get(header::ACCEPT_RANGES).unwrap(), "bytes");
assert!(headers.get(header::CONTENT_RANGE).is_none());
let body = body_text(response).await?;
assert!(body.contains(&format!(
"--{boundary}\r\nContent-Type: application/octet-stream\r\nContent-Range: bytes 0-0/10\r\n\r\n0\r\n"
)));
assert!(body.contains(&format!(
"--{boundary}\r\nContent-Type: application/octet-stream\r\nContent-Range: bytes 8-9/10\r\n\r\n89\r\n"
)));
assert!(body.ends_with(&format!("--{boundary}--\r\n")));
}
Ok(())
}
#[tokio::test]
async fn filename_escapes_quotes() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
let file_content = b"data".to_vec();
let reader = Cursor::new(file_content);
let stream = ReaderStream::new(reader);
// Filename containing double quotes that could cause parameter injection
FileStream::new(stream)
.file_name("evil\"; filename*=UTF-8''pwned.txt; x=\"")
.into_response()
}),
);
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("content-disposition").unwrap(),
"attachment; filename=\"evil\\\"; filename*=UTF-8''pwned.txt; x=\\\"\""
);
Ok(())
}
#[tokio::test]
async fn filename_escapes_backslashes() -> Result<(), Box<dyn std::error::Error>> {
let app = Router::new().route(
"/file",
get(|| async {
let file_content = b"data".to_vec();
let reader = Cursor::new(file_content);
let stream = ReaderStream::new(reader);
FileStream::new(stream)
.file_name("file\\name.txt")
.into_response()
}),
);
let response = app
.oneshot(Request::builder().uri("/file").body(Body::empty())?)
.await?;
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("content-disposition").unwrap(),
"attachment; filename=\"file\\\\name.txt\""
);
Ok(())
}
#[tokio::test]
async fn response_range_empty_file() -> Result<(), Box<dyn std::error::Error>> {
let file = test_file(b"")?;
for range in ["bytes=0-", "bytes=-1", "bytes=0-0,1-2", "bytes=abc-def"] {
let response = response_from_range_header(file.path(), range).await?;
assert_eq!(response.status(), StatusCode::OK);
assert!(response.headers().get(header::CONTENT_RANGE).is_none());
assert_eq!(response.headers().get(header::CONTENT_LENGTH).unwrap(), "0");
assert_eq!(body_text(response).await?, "");
}
Ok(())
}
fn test_file(contents: &[u8]) -> Result<tempfile::NamedTempFile, Box<dyn std::error::Error>> {
let mut file = tempfile::NamedTempFile::new()?;
file.write_all(contents)?;
Ok(file)
}
async fn response_from_range_header(
path: &Path,
range: &'static str,
) -> Result<Response, Box<dyn std::error::Error>> {
let range = HeaderValue::from_static(range);
Ok(FileStream::<ReaderStream<File>>::try_range_response(path, &range).await?)
}
async fn body_text(response: Response) -> Result<String, Box<dyn std::error::Error>> {
Ok(String::from_utf8(
response.into_body().collect().await?.to_bytes().to_vec(),
)?)
}
}