673 lines
30 KiB
Rust
673 lines
30 KiB
Rust
use anyhow::{anyhow, Result};
|
|
use chrono::{DateTime, Utc};
|
|
use quick_xml::events::{BytesStart, Event};
|
|
use quick_xml::reader::Reader;
|
|
use std::str;
|
|
use serde_json;
|
|
|
|
use crate::models::FileInfo;
|
|
|
|
#[derive(Debug, Default)]
|
|
struct PropFindResponse {
|
|
href: String,
|
|
displayname: String,
|
|
content_length: Option<i64>,
|
|
last_modified: Option<String>,
|
|
content_type: Option<String>,
|
|
etag: Option<String>,
|
|
is_collection: bool,
|
|
creation_date: Option<String>,
|
|
owner: Option<String>,
|
|
group: Option<String>,
|
|
permissions: Option<String>,
|
|
owner_display_name: Option<String>,
|
|
metadata: Option<serde_json::Value>,
|
|
}
|
|
|
|
pub fn parse_propfind_response(xml_text: &str) -> Result<Vec<FileInfo>> {
|
|
let mut reader = Reader::from_str(xml_text);
|
|
reader.config_mut().trim_text(true);
|
|
|
|
let mut files = Vec::new();
|
|
let mut current_response: Option<PropFindResponse> = None;
|
|
let mut current_element = String::new();
|
|
let mut in_response = false;
|
|
let mut in_propstat = false;
|
|
let mut in_prop = false;
|
|
let mut in_resourcetype = false;
|
|
let mut status_ok = false;
|
|
|
|
let mut buf = Vec::new();
|
|
|
|
loop {
|
|
match reader.read_event_into(&mut buf) {
|
|
Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
|
|
let name = get_local_name(&e)?;
|
|
|
|
match name.as_str() {
|
|
"response" => {
|
|
in_response = true;
|
|
current_response = Some(PropFindResponse::default());
|
|
}
|
|
"propstat" => {
|
|
in_propstat = true;
|
|
}
|
|
"prop" => {
|
|
in_prop = true;
|
|
}
|
|
"resourcetype" => {
|
|
in_resourcetype = true;
|
|
}
|
|
"collection" if in_resourcetype => {
|
|
if let Some(ref mut resp) = current_response {
|
|
resp.is_collection = true;
|
|
}
|
|
}
|
|
_ => {
|
|
current_element = name;
|
|
}
|
|
}
|
|
}
|
|
Ok(Event::Text(e)) => {
|
|
let text = e.unescape()?.to_string();
|
|
|
|
if in_response && !text.trim().is_empty() {
|
|
if let Some(ref mut resp) = current_response {
|
|
match current_element.as_str() {
|
|
"href" => {
|
|
resp.href = text.trim().to_string();
|
|
}
|
|
"displayname" => {
|
|
resp.displayname = text.trim().to_string();
|
|
}
|
|
"getcontentlength" => {
|
|
resp.content_length = text.trim().parse().ok();
|
|
}
|
|
"getlastmodified" => {
|
|
resp.last_modified = Some(text.trim().to_string());
|
|
}
|
|
"getcontenttype" => {
|
|
resp.content_type = Some(text.trim().to_string());
|
|
}
|
|
"getetag" => {
|
|
resp.etag = Some(normalize_etag(&text));
|
|
}
|
|
"creationdate" => {
|
|
resp.creation_date = Some(text.trim().to_string());
|
|
}
|
|
"owner" => {
|
|
resp.owner = Some(text.trim().to_string());
|
|
}
|
|
"group" => {
|
|
resp.group = Some(text.trim().to_string());
|
|
}
|
|
"status" if in_propstat => {
|
|
// Check if status is 200 OK
|
|
if text.contains("200") {
|
|
status_ok = true;
|
|
}
|
|
}
|
|
_ => {
|
|
// Store any other properties as generic metadata
|
|
// This handles vendor-specific properties from any WebDAV server
|
|
if !text.trim().is_empty() && in_prop {
|
|
if resp.metadata.is_none() {
|
|
resp.metadata = Some(serde_json::Value::Object(serde_json::Map::new()));
|
|
}
|
|
|
|
if let Some(serde_json::Value::Object(ref mut map)) = resp.metadata {
|
|
// Special handling for known properties
|
|
match current_element.as_str() {
|
|
"permissions" | "oc:permissions" => {
|
|
resp.permissions = Some(text.trim().to_string());
|
|
map.insert("permissions_raw".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"fileid" | "oc:fileid" => {
|
|
map.insert("file_id".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"owner-id" | "oc:owner-id" => {
|
|
map.insert("owner_id".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"owner-display-name" | "oc:owner-display-name" => {
|
|
resp.owner_display_name = Some(text.trim().to_string());
|
|
map.insert("owner_display_name".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"has-preview" | "nc:has-preview" => {
|
|
if let Ok(val) = text.trim().parse::<bool>() {
|
|
map.insert("has_preview".to_string(), serde_json::Value::Bool(val));
|
|
}
|
|
}
|
|
_ => {
|
|
// Store any other property as-is
|
|
map.insert(current_element.clone(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(Event::End(e)) => {
|
|
let name = get_local_name_from_end(&e)?;
|
|
|
|
match name.as_str() {
|
|
"response" => {
|
|
if let Some(resp) = current_response.take() {
|
|
// Only add files (not directories) with valid properties
|
|
if !resp.is_collection && status_ok && !resp.href.is_empty() {
|
|
// Extract filename from href
|
|
let name = if resp.displayname.is_empty() {
|
|
resp.href
|
|
.split('/')
|
|
.last()
|
|
.unwrap_or("")
|
|
.to_string()
|
|
} else {
|
|
resp.displayname.clone()
|
|
};
|
|
|
|
// Decode URL-encoded characters
|
|
let name = urlencoding::decode(&name)
|
|
.unwrap_or_else(|_| std::borrow::Cow::Borrowed(&name))
|
|
.to_string();
|
|
|
|
// Parse creation date
|
|
let created_at = resp.creation_date
|
|
.as_ref()
|
|
.and_then(|d| parse_http_date(d));
|
|
|
|
// Parse permissions (Nextcloud/ownCloud format)
|
|
let permissions_int = resp.permissions
|
|
.as_ref()
|
|
.and_then(|p| {
|
|
// Nextcloud permissions are a string like "RGDNVW"
|
|
// Convert to Unix-style octal permissions
|
|
if p.chars().all(|c| c.is_uppercase()) {
|
|
// This is Nextcloud format
|
|
let mut perms = 0u32;
|
|
if p.contains('R') { perms |= 0o444; } // Read
|
|
if p.contains('W') { perms |= 0o222; } // Write
|
|
if p.contains('D') { perms |= 0o111; } // Delete (execute-like)
|
|
Some(perms)
|
|
} else {
|
|
// Try to parse as numeric
|
|
p.parse().ok()
|
|
}
|
|
});
|
|
|
|
// Use the metadata collected during parsing
|
|
let metadata = resp.metadata;
|
|
|
|
let file_info = FileInfo {
|
|
path: resp.href.clone(),
|
|
name,
|
|
size: resp.content_length.unwrap_or(0),
|
|
mime_type: resp.content_type.unwrap_or_else(|| "application/octet-stream".to_string()),
|
|
last_modified: parse_http_date(&resp.last_modified.unwrap_or_default()),
|
|
etag: resp.etag.unwrap_or_else(|| format!("\"{}\"", uuid::Uuid::new_v4())),
|
|
is_directory: false,
|
|
created_at,
|
|
permissions: permissions_int,
|
|
owner: resp.owner.or(resp.owner_display_name),
|
|
group: resp.group,
|
|
metadata,
|
|
};
|
|
|
|
files.push(file_info);
|
|
}
|
|
}
|
|
in_response = false;
|
|
status_ok = false;
|
|
}
|
|
"propstat" => {
|
|
in_propstat = false;
|
|
}
|
|
"prop" => {
|
|
in_prop = false;
|
|
}
|
|
"resourcetype" => {
|
|
in_resourcetype = false;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
current_element.clear();
|
|
}
|
|
Ok(Event::Eof) => break,
|
|
Err(e) => return Err(anyhow!("XML parsing error: {}", e)),
|
|
_ => {}
|
|
}
|
|
|
|
buf.clear();
|
|
}
|
|
|
|
Ok(files)
|
|
}
|
|
|
|
/// Parse PROPFIND response including both files and directories
|
|
/// This is used for shallow directory scans where we need to track directory structure
|
|
pub fn parse_propfind_response_with_directories(xml_text: &str) -> Result<Vec<FileInfo>> {
|
|
let mut reader = Reader::from_str(xml_text);
|
|
reader.config_mut().trim_text(true);
|
|
|
|
let mut files = Vec::new();
|
|
let mut current_response: Option<PropFindResponse> = None;
|
|
let mut current_element = String::new();
|
|
let mut in_response = false;
|
|
let mut in_propstat = false;
|
|
let mut in_prop = false;
|
|
let mut in_resourcetype = false;
|
|
let mut status_ok = false;
|
|
|
|
let mut buf = Vec::new();
|
|
|
|
loop {
|
|
match reader.read_event_into(&mut buf) {
|
|
Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
|
|
let name = get_local_name(&e)?;
|
|
|
|
match name.as_str() {
|
|
"response" => {
|
|
in_response = true;
|
|
current_response = Some(PropFindResponse::default());
|
|
}
|
|
"propstat" => {
|
|
in_propstat = true;
|
|
}
|
|
"prop" => {
|
|
in_prop = true;
|
|
}
|
|
"resourcetype" => {
|
|
in_resourcetype = true;
|
|
}
|
|
"collection" if in_resourcetype => {
|
|
if let Some(ref mut resp) = current_response {
|
|
resp.is_collection = true;
|
|
}
|
|
}
|
|
_ => {
|
|
current_element = name;
|
|
}
|
|
}
|
|
}
|
|
Ok(Event::Text(e)) => {
|
|
let text = e.unescape()?.to_string();
|
|
|
|
if in_response && !text.trim().is_empty() {
|
|
if let Some(ref mut resp) = current_response {
|
|
match current_element.as_str() {
|
|
"href" => {
|
|
resp.href = text.trim().to_string();
|
|
}
|
|
"displayname" => {
|
|
resp.displayname = text.trim().to_string();
|
|
}
|
|
"getcontentlength" => {
|
|
resp.content_length = text.trim().parse().ok();
|
|
}
|
|
"getlastmodified" => {
|
|
resp.last_modified = Some(text.trim().to_string());
|
|
}
|
|
"getcontenttype" => {
|
|
resp.content_type = Some(text.trim().to_string());
|
|
}
|
|
"getetag" => {
|
|
resp.etag = Some(normalize_etag(&text));
|
|
}
|
|
"creationdate" => {
|
|
resp.creation_date = Some(text.trim().to_string());
|
|
}
|
|
"owner" => {
|
|
resp.owner = Some(text.trim().to_string());
|
|
}
|
|
"group" => {
|
|
resp.group = Some(text.trim().to_string());
|
|
}
|
|
"status" if in_propstat => {
|
|
// Check if status is 200 OK
|
|
if text.contains("200") {
|
|
status_ok = true;
|
|
}
|
|
}
|
|
_ => {
|
|
// Store any other properties as generic metadata
|
|
if !text.trim().is_empty() && in_prop {
|
|
if resp.metadata.is_none() {
|
|
resp.metadata = Some(serde_json::Value::Object(serde_json::Map::new()));
|
|
}
|
|
|
|
if let Some(serde_json::Value::Object(ref mut map)) = resp.metadata {
|
|
match current_element.as_str() {
|
|
"permissions" | "oc:permissions" => {
|
|
resp.permissions = Some(text.trim().to_string());
|
|
map.insert("permissions_raw".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"fileid" | "oc:fileid" => {
|
|
map.insert("file_id".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"owner-id" | "oc:owner-id" => {
|
|
map.insert("owner_id".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"owner-display-name" | "oc:owner-display-name" => {
|
|
resp.owner_display_name = Some(text.trim().to_string());
|
|
map.insert("owner_display_name".to_string(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
"has-preview" | "nc:has-preview" => {
|
|
if let Ok(val) = text.trim().parse::<bool>() {
|
|
map.insert("has_preview".to_string(), serde_json::Value::Bool(val));
|
|
}
|
|
}
|
|
_ => {
|
|
map.insert(current_element.clone(), serde_json::Value::String(text.trim().to_string()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(Event::End(e)) => {
|
|
let name = get_local_name_from_end(&e)?;
|
|
|
|
match name.as_str() {
|
|
"response" => {
|
|
if let Some(resp) = current_response.take() {
|
|
// Include both files AND directories with valid properties
|
|
if status_ok && !resp.href.is_empty() {
|
|
// Extract name from href
|
|
let name = if resp.displayname.is_empty() {
|
|
resp.href
|
|
.split('/')
|
|
.filter(|s| !s.is_empty())
|
|
.last()
|
|
.unwrap_or("")
|
|
.to_string()
|
|
} else {
|
|
resp.displayname.clone()
|
|
};
|
|
|
|
// Decode URL-encoded characters
|
|
let name = urlencoding::decode(&name)
|
|
.unwrap_or_else(|_| std::borrow::Cow::Borrowed(&name))
|
|
.to_string();
|
|
|
|
// Parse creation date
|
|
let created_at = resp.creation_date
|
|
.as_ref()
|
|
.and_then(|d| parse_http_date(d));
|
|
|
|
// Parse permissions
|
|
let permissions_int = resp.permissions
|
|
.as_ref()
|
|
.and_then(|p| {
|
|
if p.chars().all(|c| c.is_uppercase()) {
|
|
let mut perms = 0u32;
|
|
if p.contains('R') { perms |= 0o444; }
|
|
if p.contains('W') { perms |= 0o222; }
|
|
if p.contains('D') { perms |= 0o111; }
|
|
Some(perms)
|
|
} else {
|
|
p.parse().ok()
|
|
}
|
|
});
|
|
|
|
let file_info = FileInfo {
|
|
path: resp.href.clone(),
|
|
name,
|
|
size: resp.content_length.unwrap_or(0),
|
|
mime_type: if resp.is_collection {
|
|
"".to_string()
|
|
} else {
|
|
resp.content_type.unwrap_or_else(|| "application/octet-stream".to_string())
|
|
},
|
|
last_modified: parse_http_date(&resp.last_modified.unwrap_or_default()),
|
|
etag: resp.etag.unwrap_or_else(|| format!("\"{}\"", uuid::Uuid::new_v4())),
|
|
is_directory: resp.is_collection,
|
|
created_at,
|
|
permissions: permissions_int,
|
|
owner: resp.owner.or(resp.owner_display_name),
|
|
group: resp.group,
|
|
metadata: resp.metadata,
|
|
};
|
|
|
|
files.push(file_info);
|
|
}
|
|
}
|
|
in_response = false;
|
|
status_ok = false;
|
|
}
|
|
"propstat" => {
|
|
in_propstat = false;
|
|
}
|
|
"prop" => {
|
|
in_prop = false;
|
|
}
|
|
"resourcetype" => {
|
|
in_resourcetype = false;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
current_element.clear();
|
|
}
|
|
Ok(Event::Eof) => break,
|
|
Err(e) => return Err(anyhow!("XML parsing error: {}", e)),
|
|
_ => {}
|
|
}
|
|
|
|
buf.clear();
|
|
}
|
|
|
|
Ok(files)
|
|
}
|
|
|
|
fn get_local_name(e: &BytesStart) -> Result<String> {
|
|
let qname = e.name();
|
|
let local = qname.local_name();
|
|
let name = str::from_utf8(local.as_ref())
|
|
.map_err(|e| anyhow!("Invalid UTF-8 in element name: {}", e))?;
|
|
Ok(name.to_string())
|
|
}
|
|
|
|
fn get_local_name_from_end(e: &quick_xml::events::BytesEnd) -> Result<String> {
|
|
let qname = e.name();
|
|
let local = qname.local_name();
|
|
let name = str::from_utf8(local.as_ref())
|
|
.map_err(|e| anyhow!("Invalid UTF-8 in element name: {}", e))?;
|
|
Ok(name.to_string())
|
|
}
|
|
|
|
fn parse_http_date(date_str: &str) -> Option<DateTime<Utc>> {
|
|
if date_str.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
// Try to parse RFC 2822 format (used by WebDAV)
|
|
DateTime::parse_from_rfc2822(date_str)
|
|
.ok()
|
|
.map(|dt| dt.with_timezone(&Utc))
|
|
.or_else(|| {
|
|
// Try RFC 3339 as fallback
|
|
DateTime::parse_from_rfc3339(date_str)
|
|
.ok()
|
|
.map(|dt| dt.with_timezone(&Utc))
|
|
})
|
|
.or_else(|| {
|
|
// Try a custom format as last resort
|
|
chrono::NaiveDateTime::parse_from_str(date_str, "%a, %d %b %Y %H:%M:%S GMT")
|
|
.ok()
|
|
.map(|ndt| DateTime::from_naive_utc_and_offset(ndt, Utc))
|
|
})
|
|
}
|
|
|
|
/// Normalize ETag by removing quotes and weak ETag prefix
|
|
/// This ensures consistent ETag comparison across different WebDAV servers
|
|
///
|
|
/// Examples:
|
|
/// - `"abc123"` → `abc123`
|
|
/// - `W/"abc123"` → `abc123`
|
|
/// - `abc123` → `abc123`
|
|
pub fn normalize_etag(etag: &str) -> String {
|
|
etag.trim()
|
|
.trim_start_matches("W/")
|
|
.trim()
|
|
.trim_matches('"')
|
|
.to_string()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_parse_simple_propfind() {
|
|
let xml = r#"<?xml version="1.0"?>
|
|
<d:multistatus xmlns:d="DAV:">
|
|
<d:response>
|
|
<d:href>/webdav/test.pdf</d:href>
|
|
<d:propstat>
|
|
<d:prop>
|
|
<d:displayname>test.pdf</d:displayname>
|
|
<d:getcontentlength>1024</d:getcontentlength>
|
|
<d:getlastmodified>Mon, 01 Jan 2024 12:00:00 GMT</d:getlastmodified>
|
|
<d:getcontenttype>application/pdf</d:getcontenttype>
|
|
<d:getetag>"abc123"</d:getetag>
|
|
<d:resourcetype/>
|
|
</d:prop>
|
|
<d:status>HTTP/1.1 200 OK</d:status>
|
|
</d:propstat>
|
|
</d:response>
|
|
</d:multistatus>"#;
|
|
|
|
let files = parse_propfind_response(xml).unwrap();
|
|
assert_eq!(files.len(), 1);
|
|
|
|
let file = &files[0];
|
|
assert_eq!(file.name, "test.pdf");
|
|
assert_eq!(file.size, 1024);
|
|
assert_eq!(file.mime_type, "application/pdf");
|
|
assert_eq!(file.etag, "abc123");
|
|
assert!(!file.is_directory);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_propfind_with_directory() {
|
|
let xml = r#"<?xml version="1.0"?>
|
|
<d:multistatus xmlns:d="DAV:">
|
|
<d:response>
|
|
<d:href>/webdav/Documents/</d:href>
|
|
<d:propstat>
|
|
<d:prop>
|
|
<d:displayname>Documents</d:displayname>
|
|
<d:resourcetype>
|
|
<d:collection/>
|
|
</d:resourcetype>
|
|
</d:prop>
|
|
<d:status>HTTP/1.1 200 OK</d:status>
|
|
</d:propstat>
|
|
</d:response>
|
|
<d:response>
|
|
<d:href>/webdav/Documents/file.txt</d:href>
|
|
<d:propstat>
|
|
<d:prop>
|
|
<d:displayname>file.txt</d:displayname>
|
|
<d:getcontentlength>256</d:getcontentlength>
|
|
<d:getcontenttype>text/plain</d:getcontenttype>
|
|
<d:resourcetype/>
|
|
</d:prop>
|
|
<d:status>HTTP/1.1 200 OK</d:status>
|
|
</d:propstat>
|
|
</d:response>
|
|
</d:multistatus>"#;
|
|
|
|
let files = parse_propfind_response(xml).unwrap();
|
|
assert_eq!(files.len(), 1); // Only the file, not the directory
|
|
|
|
let file = &files[0];
|
|
assert_eq!(file.name, "file.txt");
|
|
assert_eq!(file.size, 256);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_nextcloud_response() {
|
|
let xml = r#"<?xml version="1.0"?>
|
|
<d:multistatus xmlns:d="DAV:" xmlns:s="http://sabredav.org/ns" xmlns:oc="http://owncloud.org/ns">
|
|
<d:response>
|
|
<d:href>/remote.php/dav/files/admin/Documents/report.pdf</d:href>
|
|
<d:propstat>
|
|
<d:prop>
|
|
<d:displayname>report.pdf</d:displayname>
|
|
<d:getcontentlength>2048000</d:getcontentlength>
|
|
<d:getlastmodified>Mon, 15 Jan 2024 14:30:00 GMT</d:getlastmodified>
|
|
<d:getcontenttype>application/pdf</d:getcontenttype>
|
|
<d:getetag>"pdf123"</d:getetag>
|
|
<d:resourcetype/>
|
|
</d:prop>
|
|
<d:status>HTTP/1.1 200 OK</d:status>
|
|
</d:propstat>
|
|
</d:response>
|
|
</d:multistatus>"#;
|
|
|
|
let files = parse_propfind_response(xml).unwrap();
|
|
assert_eq!(files.len(), 1);
|
|
|
|
let file = &files[0];
|
|
assert_eq!(file.name, "report.pdf");
|
|
assert_eq!(file.path, "/remote.php/dav/files/admin/Documents/report.pdf");
|
|
assert_eq!(file.size, 2048000);
|
|
assert_eq!(file.etag, "pdf123"); // ETag should be normalized (quotes removed)
|
|
assert!(file.last_modified.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_url_encoded_filenames() {
|
|
let xml = r#"<?xml version="1.0"?>
|
|
<d:multistatus xmlns:d="DAV:">
|
|
<d:response>
|
|
<d:href>/webdav/File%20with%20spaces.pdf</d:href>
|
|
<d:propstat>
|
|
<d:prop>
|
|
<d:displayname>File with spaces.pdf</d:displayname>
|
|
<d:getcontentlength>1024</d:getcontentlength>
|
|
<d:getcontenttype>application/pdf</d:getcontenttype>
|
|
<d:resourcetype/>
|
|
</d:prop>
|
|
<d:status>HTTP/1.1 200 OK</d:status>
|
|
</d:propstat>
|
|
</d:response>
|
|
</d:multistatus>"#;
|
|
|
|
let files = parse_propfind_response(xml).unwrap();
|
|
assert_eq!(files.len(), 1);
|
|
|
|
let file = &files[0];
|
|
assert_eq!(file.name, "File with spaces.pdf");
|
|
}
|
|
|
|
#[test]
|
|
fn test_empty_response() {
|
|
let xml = r#"<?xml version="1.0"?>
|
|
<d:multistatus xmlns:d="DAV:">
|
|
</d:multistatus>"#;
|
|
|
|
let files = parse_propfind_response(xml).unwrap();
|
|
assert_eq!(files.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_normalize_etag() {
|
|
// Test various ETag formats that WebDAV servers might return
|
|
assert_eq!(normalize_etag("abc123"), "abc123");
|
|
assert_eq!(normalize_etag("\"abc123\""), "abc123");
|
|
assert_eq!(normalize_etag("W/\"abc123\""), "abc123");
|
|
assert_eq!(normalize_etag(" \"abc123\" "), "abc123");
|
|
assert_eq!(normalize_etag("W/\"abc-123-def\""), "abc-123-def");
|
|
assert_eq!(normalize_etag(""), "");
|
|
assert_eq!(normalize_etag("\"\""), "");
|
|
assert_eq!(normalize_etag("W/\"\""), "");
|
|
}
|
|
} |