sdgoij/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-01-17 01:30:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: resolve all Clippy warnings across codebase - Fixed field reassignment warnings in ecstore/src/file_meta.rs by using struct initialization instead of default + field assignment - Fixed overly complex boolean expression in ecstore/src/utils/os/mod.rs by removing meaningless assertion - Replaced manual Default implementation with derive in crates/zip/src/lib.rs - Updated io::Error usage to use io::Error::other() instead of deprecated pattern - Removed useless assertions and clone-on-copy warnings - Fixed unwrap usage by replacing with expect() providing meaningful error messages - Fixed useless vec usage by using array repeat instead - All code now passes comprehensive Clippy check with --all-targets --all-features -- -D warnings

Browse Source
This commit is contained in:
安正超
2025-05-28 11:00:07 +08:00
parent 249a46bc8e
commit 9ec22255e0
37 changed files with 309 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.cursorrules
View File

@@ -402,6 +402,7 @@ These rules should serve as guiding principles when developing the RustFS projec
- Ensure each change provides sufficient test cases to guarantee code correctness
- Do not arbitrarily modify numbers and constants in test cases, carefully analyze their meaning to ensure test case correctness
- When writing or modifying tests, check existing test cases to ensure they have scientific naming and rigorous logic testing, if not compliant, modify test cases to ensure scientific and rigorous testing
- **Before committing any changes, run `cargo clippy --all-targets --all-features -- -D warnings` to ensure all code passes Clippy checks**
- After each development completion, first git add . then git commit -m "feat: feature description" or "fix: issue description", ensure compliance with [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
- **Keep commit messages concise and under 72 characters** for the title line, use body for detailed explanations if needed
- After each development completion, first git push to remote repository

7
cli/rustfs-gui/src/utils/config.rs
View File

@@ -198,15 +198,16 @@ impl RustFSConfig {
Ok(())
}
/// delete the stored configuration
/// Clear the stored configuration from the system keyring
///
/// # Errors
/// * If the configuration cannot be deleted from the keyring
/// # Returns
/// Returns `Ok(())` if the configuration was successfully cleared, or an error if the operation failed.
///
/// # Example
/// ```
/// RustFSConfig::clear().unwrap();
/// ```
#[allow(dead_code)]
pub fn clear() -> Result<(), Box<dyn Error>> {
let entry = Entry::new(Self::SERVICE_NAME, Self::SERVICE_KEY)?;
entry.delete_credential()?;

2
cli/rustfs-gui/src/utils/helper.rs
View File

@@ -758,7 +758,6 @@ mod tests {
// Test that show_error function exists and can be called
// We can't actually test the dialog in a test environment
// so we just verify the function signature
assert!(true); // Function exists and compiles
}
#[test]
@@ -766,7 +765,6 @@ mod tests {
// Test that show_info function exists and can be called
// We can't actually test the dialog in a test environment
// so we just verify the function signature
assert!(true); // Function exists and compiles
}
#[test]

6
common/common/src/error.rs
View File

@@ -279,8 +279,10 @@ mod tests {
let result: Result<(), Error> = Err(error);
assert!(result.is_err());
let err = result.unwrap_err();
assert!(err.is::<io::Error>());
// Test the error from the result
if let Err(err) = result {
assert!(err.is::<io::Error>());
}
}
#[test]

32
common/common/src/last_minute.rs
View File

@@ -245,8 +245,10 @@ mod tests {
#[test]
fn test_last_minute_latency_clone() {
let mut latency = LastMinuteLatency::default();
latency.last_sec = 12345;
let mut latency = LastMinuteLatency {
last_sec: 12345,
..Default::default()
};
latency.totals[0].total = 100;
let cloned = latency.clone();
@@ -257,8 +259,10 @@ mod tests {
#[test]
fn test_forward_to_same_time() {
let mut latency = LastMinuteLatency::default();
latency.last_sec = 100;
let mut latency = LastMinuteLatency {
last_sec: 100,
..Default::default()
};
// Forward to same time should not change anything
latency.forward_to(100);
@@ -271,8 +275,10 @@ mod tests {
#[test]
fn test_forward_to_large_gap() {
let mut latency = LastMinuteLatency::default();
latency.last_sec = 100;
let mut latency = LastMinuteLatency {
last_sec: 100,
..Default::default()
};
latency.totals[0].total = 999; // Set some data
// Forward by more than 60 seconds should reset all totals
@@ -289,8 +295,10 @@ mod tests {
#[test]
fn test_forward_to_small_gap() {
let mut latency = LastMinuteLatency::default();
latency.last_sec = 100;
let mut latency = LastMinuteLatency {
last_sec: 100,
..Default::default()
};
latency.totals[1].total = 999; // Set some data at index 1
// Forward by 2 seconds
@@ -446,7 +454,7 @@ mod tests {
#[test]
fn test_window_index_calculation() {
// Test that window index calculation works correctly
let mut latency = LastMinuteLatency::default();
let _latency = LastMinuteLatency::default();
let acc_elem = AccElem {
total: 1,
@@ -476,10 +484,12 @@ mod tests {
#[test]
fn test_edge_case_boundary_conditions() {
let mut latency = LastMinuteLatency::default();
let mut latency = LastMinuteLatency {
last_sec: 59,
..Default::default()
};
// Test boundary at 60 seconds
latency.last_sec = 59;
latency.forward_to(119); // Exactly 60 seconds later
// Should reset all totals

28
common/lock/src/drwmutex.rs
View File

@@ -696,12 +696,12 @@ mod tests {
};
// Test get_lock (result depends on local locker state)
let result = mutex.get_lock(&id, &source, &opts).await;
let _result = mutex.get_lock(&id, &source, &opts).await;
// Just ensure the method doesn't panic and returns a boolean
assert!(result == true || result == false);
// assert!(result || !result); // This is always true, so removed
// If lock was acquired, test unlock
if result {
if _result {
assert!(mutex.is_locked(), "Mutex should be in locked state");
mutex.un_lock().await;
assert!(!mutex.is_locked(), "Mutex should be unlocked after un_lock");
@@ -722,12 +722,12 @@ mod tests {
};
// Test get_r_lock (result depends on local locker state)
let result = mutex.get_r_lock(&id, &source, &opts).await;
let _result = mutex.get_r_lock(&id, &source, &opts).await;
// Just ensure the method doesn't panic and returns a boolean
assert!(result == true || result == false);
// assert!(result || !result); // This is always true, so removed
// If read lock was acquired, test runlock
if result {
if _result {
assert!(mutex.is_r_locked(), "Mutex should be in read locked state");
mutex.un_r_lock().await;
assert!(!mutex.is_r_locked(), "Mutex should be unlocked after un_r_lock");
@@ -752,10 +752,10 @@ mod tests {
// quorum = 3 - 1 = 2
// Since it's a write lock and quorum != tolerance, quorum stays 2
// The result depends on the actual locker implementation
let result = mutex.get_lock(&id, &source, &opts).await;
let _result = mutex.get_lock(&id, &source, &opts).await;
// We don't assert success/failure here since it depends on the local locker state
// Just ensure the method doesn't panic and returns a boolean
assert!(result == true || result == false);
// assert!(result || !result); // This is always true, so removed
}
#[tokio::test]
@@ -795,10 +795,10 @@ mod tests {
retry_interval: Duration::from_millis(10),
};
let result = mutex.get_lock(&id, &source, &opts).await;
let _result = mutex.get_lock(&id, &source, &opts).await;
// The result depends on the actual locker implementation
// Just ensure the method doesn't panic and returns a boolean
assert!(result == true || result == false);
// assert!(result || !result); // This is always true, so removed
}
#[tokio::test]
@@ -1049,8 +1049,8 @@ mod tests {
// tolerance = 0 / 2 = 0
// quorum = 0 - 0 = 0
// This should fail because we can't achieve any quorum
let result = mutex.get_lock(&id, &source, &opts).await;
assert!(!result, "Should fail with zero lockers");
let _result = mutex.get_lock(&id, &source, &opts).await;
assert!(!_result, "Should fail with zero lockers");
}
#[test]
@@ -1125,8 +1125,8 @@ mod tests {
let mut some_locks = vec!["uid1".to_string(), "uid2".to_string()];
let result = mutex.release_all(1, &mut some_locks, false).await;
// This should attempt to release the locks and may succeed or fail
// depending on the local locker state
assert!(result || !result); // Just ensure it doesn't panic
// depending on the local locker state - just ensure it doesn't panic
let _ = result; // Suppress unused variable warning
}
#[test]

29
crates/config/src/constants/app.rs
View File

@@ -98,11 +98,9 @@ mod tests {
fn test_app_basic_constants() {
// Test application basic constants
assert_eq!(APP_NAME, "RustFs");
assert!(!APP_NAME.is_empty(), "App name should not be empty");
assert!(!APP_NAME.contains(' '), "App name should not contain spaces");
assert_eq!(VERSION, "0.0.1");
assert!(!VERSION.is_empty(), "Version should not be empty");
assert_eq!(SERVICE_VERSION, "0.0.1");
assert_eq!(VERSION, SERVICE_VERSION, "Version and service version should be consistent");
@@ -117,13 +115,9 @@ mod tests {
"Log level should be a valid tracing level"
);
assert_eq!(USE_STDOUT, false);
assert_eq!(SAMPLE_RATIO, 1.0);
assert!(SAMPLE_RATIO >= 0.0 && SAMPLE_RATIO <= 1.0, "Sample ratio should be between 0.0 and 1.0");
assert_eq!(METER_INTERVAL, 30);
assert!(METER_INTERVAL > 0, "Meter interval should be positive");
}
#[test]
@@ -140,23 +134,17 @@ mod tests {
fn test_connection_constants() {
// Test connection related constants
assert_eq!(MAX_CONNECTIONS, 100);
assert!(MAX_CONNECTIONS > 0, "Max connections should be positive");
assert!(MAX_CONNECTIONS <= 10000, "Max connections should be reasonable");
assert_eq!(DEFAULT_TIMEOUT_MS, 3000);
assert!(DEFAULT_TIMEOUT_MS > 0, "Timeout should be positive");
assert!(DEFAULT_TIMEOUT_MS >= 1000, "Timeout should be at least 1 second");
}
#[test]
fn test_security_constants() {
// Test security related constants
assert_eq!(DEFAULT_ACCESS_KEY, "rustfsadmin");
assert!(!DEFAULT_ACCESS_KEY.is_empty(), "Access key should not be empty");
assert!(DEFAULT_ACCESS_KEY.len() >= 8, "Access key should be at least 8 characters");
assert_eq!(DEFAULT_SECRET_KEY, "rustfsadmin");
assert!(!DEFAULT_SECRET_KEY.is_empty(), "Secret key should not be empty");
assert!(DEFAULT_SECRET_KEY.len() >= 8, "Secret key should be at least 8 characters");
// In production environment, access key and secret key should be different
@@ -169,7 +157,6 @@ mod tests {
// Test file path related constants
assert_eq!(DEFAULT_OBS_CONFIG, "./deploy/config/obs.toml");
assert!(DEFAULT_OBS_CONFIG.ends_with(".toml"), "Config file should be TOML format");
assert!(!DEFAULT_OBS_CONFIG.is_empty(), "Config path should not be empty");
assert_eq!(RUSTFS_TLS_KEY, "rustfs_key.pem");
assert!(RUSTFS_TLS_KEY.ends_with(".pem"), "TLS key should be PEM format");
@@ -182,12 +169,8 @@ mod tests {
fn test_port_constants() {
// Test port related constants
assert_eq!(DEFAULT_PORT, 9000);
assert!(DEFAULT_PORT > 1024, "Default port should be above reserved range");
// u16 type automatically ensures port is in valid range (0-65535)
assert_eq!(DEFAULT_CONSOLE_PORT, 9002);
assert!(DEFAULT_CONSOLE_PORT > 1024, "Console port should be above reserved range");
// u16 type automatically ensures port is in valid range (0-65535)
assert_ne!(DEFAULT_PORT, DEFAULT_CONSOLE_PORT, "Main port and console port should be different");
}
@@ -256,12 +239,14 @@ mod tests {
assert!(SAMPLE_RATIO.is_finite(), "Sample ratio should be finite");
assert!(!SAMPLE_RATIO.is_nan(), "Sample ratio should not be NaN");
assert!(METER_INTERVAL < u64::MAX, "Meter interval should be reasonable");
assert!(MAX_CONNECTIONS < usize::MAX, "Max connections should be reasonable");
assert!(DEFAULT_TIMEOUT_MS < u64::MAX, "Timeout should be reasonable");
// All these are const values, so range checks are redundant
// assert!(METER_INTERVAL < u64::MAX, "Meter interval should be reasonable");
// assert!(MAX_CONNECTIONS < usize::MAX, "Max connections should be reasonable");
// assert!(DEFAULT_TIMEOUT_MS < u64::MAX, "Timeout should be reasonable");
assert!(DEFAULT_PORT != 0, "Default port should not be zero");
assert!(DEFAULT_CONSOLE_PORT != 0, "Console port should not be zero");
// These are const non-zero values, so zero checks are redundant
// assert!(DEFAULT_PORT != 0, "Default port should not be zero");
// assert!(DEFAULT_CONSOLE_PORT != 0, "Console port should not be zero");
}
#[test]

3
crates/config/src/event/config.rs
View File

@@ -317,7 +317,8 @@ mod tests {
fn test_default_config_file_constant() {
// Test that the constant is properly defined
assert_eq!(DEFAULT_CONFIG_FILE, "event");
assert!(!DEFAULT_CONFIG_FILE.is_empty(), "Config file name should not be empty");
// DEFAULT_CONFIG_FILE is a const, so is_empty() check is redundant
// assert!(!DEFAULT_CONFIG_FILE.is_empty(), "Config file name should not be empty");
assert!(!DEFAULT_CONFIG_FILE.contains('/'), "Config file name should not contain path separators");
assert!(!DEFAULT_CONFIG_FILE.contains('\\'), "Config file name should not contain Windows path separators");
}

7
crates/config/src/observability/config.rs
View File

@@ -76,12 +76,13 @@ mod tests {
let config = ObservabilityConfig::new();
// Test OTEL default values
if let Some(use_stdout) = config.otel.use_stdout {
assert!(use_stdout == true || use_stdout == false, "use_stdout should be a valid boolean");
if let Some(_use_stdout) = config.otel.use_stdout {
// Test boolean values - any boolean value is valid
// assert!(use_stdout || !use_stdout, "use_stdout should be a valid boolean");
}
if let Some(sample_ratio) = config.otel.sample_ratio {
assert!(sample_ratio >= 0.0 && sample_ratio <= 1.0, "Sample ratio should be between 0.0 and 1.0");
assert!((0.0..=1.0).contains(&sample_ratio), "Sample ratio should be between 0.0 and 1.0");
}
if let Some(meter_interval) = config.otel.meter_interval {

8
crates/event-notifier/src/error.rs
View File

@@ -343,7 +343,7 @@ mod tests {
#[test]
fn test_error_downcast() {
// 测试错误的向下转型
let io_error = io::Error::new(io::ErrorKind::Other, "test error");
let io_error = io::Error::other("test error");
let converted: Error = io_error.into();
// 验证可以获取源错误
@@ -358,7 +358,7 @@ mod tests {
#[test]
fn test_error_chain_depth() {
// 测试错误链的深度
let root_cause = io::Error::new(io::ErrorKind::Other, "root cause");
let root_cause = io::Error::other("root cause");
let converted: Error = root_cause.into();
let mut depth = 0;
@@ -411,8 +411,8 @@ mod tests {
// Debug 输出通常包含更多信息，但不是绝对的
// 这里我们只验证两者都有内容即可
assert!(debug_str.len() > 0);
assert!(display_str.len() > 0);
assert!(!debug_str.is_empty());
assert!(!display_str.is_empty());
}
}
}

2
crates/utils/src/certs.rs
View File

@@ -43,7 +43,7 @@ pub fn load_private_key(filename: &str) -> io::Result<PrivateKeyDer<'static>> {
/// error function
pub fn certs_error(err: String) -> Error {
Error::new(io::ErrorKind::Other, err)
Error::other(err)
}
/// Load all certificates and private keys in the directory

14
crates/zip/src/lib.rs
View File

@@ -21,20 +21,15 @@ pub enum CompressionFormat {
Unknown,
}
#[derive(Debug, PartialEq, Clone, Copy)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CompressionLevel {
Fastest,
Best,
#[default]
Default,
Level(u32),
}
impl Default for CompressionLevel {
fn default() -> Self {
CompressionLevel::Default
}
}
impl CompressionFormat {
/// Identify compression format from file extension
pub fn from_extension(ext: &str) -> Self {
@@ -679,7 +674,7 @@ mod tests {
async move {
if invocation_number == 0 {
// First invocation returns an error
Err(io::Error::new(io::ErrorKind::Other, "Simulated callback error"))
Err(io::Error::other("Simulated callback error"))
} else {
Ok(())
}
@@ -765,8 +760,7 @@ mod tests {
}
}
// 如果能执行到这里，说明性能是可接受的
assert!(true, "Extension parsing performance test completed");
// Extension parsing performance test completed
}
#[test]

30
crypto/src/encdec/id.rs
View File

@@ -89,7 +89,7 @@ mod tests {
fn test_id_clone_and_copy() {
// Test Clone and Copy traits
let original = ID::Argon2idAESGCM;
let cloned = original.clone();
let cloned = original;
let copied = original;
assert!(matches!(cloned, ID::Argon2idAESGCM));
@@ -106,13 +106,13 @@ mod tests {
let result = id.get_key(password, salt);
assert!(result.is_ok());
let key = result.unwrap();
let key = result.expect("PBKDF2 key generation should succeed");
assert_eq!(key.len(), 32);
// Verify deterministic behavior - same inputs should produce same output
let result2 = id.get_key(password, salt);
assert!(result2.is_ok());
assert_eq!(key, result2.unwrap());
assert_eq!(key, result2.expect("PBKDF2 key generation should succeed"));
}
#[test]
@@ -125,13 +125,13 @@ mod tests {
let result = id.get_key(password, salt);
assert!(result.is_ok());
let key = result.unwrap();
let key = result.expect("Argon2id key generation should succeed");
assert_eq!(key.len(), 32);
// Verify deterministic behavior
let result2 = id.get_key(password, salt);
assert!(result2.is_ok());
assert_eq!(key, result2.unwrap());
assert_eq!(key, result2.expect("Argon2id key generation should succeed"));
}
#[test]
@@ -144,7 +144,7 @@ mod tests {
let result = id.get_key(password, salt);
assert!(result.is_ok());
let key = result.unwrap();
let key = result.expect("Argon2id ChaCha20Poly1305 key generation should succeed");
assert_eq!(key.len(), 32);
}
@@ -154,8 +154,8 @@ mod tests {
let id = ID::Pbkdf2AESGCM;
let salt = b"same_salt_for_all";
let key1 = id.get_key(b"password1", salt).unwrap();
let key2 = id.get_key(b"password2", salt).unwrap();
let key1 = id.get_key(b"password1", salt).expect("Key generation with password1 should succeed");
let key2 = id.get_key(b"password2", salt).expect("Key generation with password2 should succeed");
assert_ne!(key1, key2);
}
@@ -166,8 +166,8 @@ mod tests {
let id = ID::Pbkdf2AESGCM;
let password = b"same_password";
let key1 = id.get_key(password, b"salt1_16_bytes__").unwrap();
let key2 = id.get_key(password, b"salt2_16_bytes__").unwrap();
let key1 = id.get_key(password, b"salt1_16_bytes__").expect("Key generation with salt1 should succeed");
let key2 = id.get_key(password, b"salt2_16_bytes__").expect("Key generation with salt2 should succeed");
assert_ne!(key1, key2);
}
@@ -199,7 +199,7 @@ mod tests {
let result = algorithm.get_key(password, salt);
assert!(result.is_ok(), "Algorithm {:?} should generate valid key", algorithm);
let key = result.unwrap();
let key = result.expect("Key generation should succeed for all algorithms");
assert_eq!(key.len(), 32, "Key length should be 32 bytes for {:?}", algorithm);
// Verify key is not all zeros (very unlikely with proper implementation)
@@ -214,7 +214,7 @@ mod tests {
for original in &original_ids {
let as_u8 = *original as u8;
let converted_back = ID::try_from(as_u8).unwrap();
let converted_back = ID::try_from(as_u8).expect("Round-trip conversion should succeed");
assert!(matches!(
(original, converted_back),
@@ -231,9 +231,9 @@ mod tests {
let password = b"consistent_password";
let salt = b"consistent_salt_";
let key_argon2_aes = ID::Argon2idAESGCM.get_key(password, salt).unwrap();
let key_argon2_chacha = ID::Argon2idChaCHa20Poly1305.get_key(password, salt).unwrap();
let key_pbkdf2 = ID::Pbkdf2AESGCM.get_key(password, salt).unwrap();
let key_argon2_aes = ID::Argon2idAESGCM.get_key(password, salt).expect("Argon2id AES key generation should succeed");
let key_argon2_chacha = ID::Argon2idChaCHa20Poly1305.get_key(password, salt).expect("Argon2id ChaCha key generation should succeed");
let key_pbkdf2 = ID::Pbkdf2AESGCM.get_key(password, salt).expect("PBKDF2 key generation should succeed");
// Different algorithms should produce different keys
assert_ne!(key_argon2_aes, key_pbkdf2);

2
crypto/src/encdec/tests.rs
View File

@@ -78,7 +78,7 @@ fn test_encrypt_decrypt_binary_data() -> Result<(), crate::Error> {
vec![0x00; 100], // All zeros
vec![0xFF; 100], // All ones
(0..=255u8).cycle().take(1000).collect::<Vec<u8>>(), // Sequential pattern
vec![0xAA, 0x55].repeat(500), // Alternating pattern
[0xAA, 0x55].repeat(500), // Alternating pattern
];
for pattern in &binary_patterns {

4
crypto/src/jwt/tests.rs
View File

@@ -143,10 +143,10 @@ fn test_jwt_with_different_secret_lengths() {
for secret in &secrets {
let jwt_token = encode(secret, &claims)
.expect(&format!("Failed to encode JWT with secret length {}", secret.len()));
.unwrap_or_else(|_| panic!("Failed to encode JWT with secret length {}", secret.len()));
let decoded = decode(&jwt_token, secret)
.expect(&format!("Failed to decode JWT with secret length {}", secret.len()));
.unwrap_or_else(|_| panic!("Failed to decode JWT with secret length {}", secret.len()));
assert_eq!(decoded.claims, claims);
}

2
ecstore/src/bucket/metadata.rs
View File

@@ -288,7 +288,7 @@ impl BucketMetadata {
}
pub fn set_created(&mut self, created: Option<OffsetDateTime>) {
self.created = { created.unwrap_or_else(|| OffsetDateTime::now_utc()) }
self.created = created.unwrap_or_else(OffsetDateTime::now_utc)
}
pub async fn save(&mut self) -> Result<()> {

4
ecstore/src/config/com.rs
View File

@@ -1,5 +1,5 @@
use super::error::{is_err_config_not_found, ConfigError};
use super::{storageclass, Config, GLOBAL_StorageClass, KVS};
use super::{storageclass, Config, GLOBAL_StorageClass};
use crate::disk::RUSTFS_META_BUCKET;
use crate::store_api::{ObjectInfo, ObjectOptions, PutObjReader, StorageAPI};
use crate::store_err::is_err_object_not_found;
@@ -191,7 +191,7 @@ async fn apply_dynamic_config_for_sub_sys<S: StorageAPI>(cfg: &mut Config, api:
if subsys == STORAGE_CLASS_SUB_SYS {
let kvs = cfg
.get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_KV_KEY)
.unwrap_or_else(|| KVS::new());
.unwrap_or_default();
for (i, count) in set_drive_counts.iter().enumerate() {
match storageclass::lookup_config(&kvs, *count) {

5
ecstore/src/disk/local.rs
View File

@@ -627,7 +627,7 @@ impl LocalDisk {
};
if let Some(dir) = data_dir {
let vid = fi.version_id.unwrap_or(Uuid::nil());
let vid = fi.version_id.unwrap_or_default();
let _ = fm.data.remove(vec![vid, dir]);
let dir_path = self.get_object_path(volume, format!("{}/{}", path, dir).as_str())?;
@@ -1194,7 +1194,6 @@ impl DiskAPI for LocalDisk {
Ok(())
}
#[must_use]
#[tracing::instrument(skip(self))]
async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
if volume == RUSTFS_META_BUCKET && path == super::FORMAT_CONFIG_FILE {
@@ -2183,7 +2182,7 @@ impl DiskAPI for LocalDisk {
let old_dir = meta.delete_version(&fi)?;
if let Some(uuid) = old_dir {
let vid = fi.version_id.unwrap_or(Uuid::nil());
let vid = fi.version_id.unwrap_or_default();
let _ = meta.data.remove(vec![vid, uuid])?;
let old_path = file_path.join(Path::new(uuid.to_string().as_str()));

2
ecstore/src/disk/mod.rs
View File

@@ -601,7 +601,7 @@ impl FileInfoVersions {
return None;
}
let vid = Uuid::parse_str(v).unwrap_or(Uuid::nil());
let vid = Uuid::parse_str(v).unwrap_or_default();
self.versions.iter().position(|v| v.version_id == Some(vid))
}

199
ecstore/src/file_meta.rs
View File

@@ -446,7 +446,7 @@ impl FileMeta {
let vid = fi.version_id;
if let Some(ref data) = fi.data {
let key = vid.unwrap_or(Uuid::nil()).to_string();
let key = vid.unwrap_or_default().to_string();
self.data.replace(&key, data.clone())?;
}
@@ -574,7 +574,7 @@ impl FileMeta {
fi.successor_mod_time = succ_mod_time;
}
if read_data {
fi.data = self.data.find(fi.version_id.unwrap_or(Uuid::nil()).to_string().as_str())?;
fi.data = self.data.find(fi.version_id.unwrap_or_default().to_string().as_str())?;
}
fi.num_versions = self.versions.len();
@@ -1004,7 +1004,7 @@ impl FileMetaVersionHeader {
rmp::encode::write_array_len(&mut wr, 7)?;
// version_id
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
// mod_time
rmp::encode::write_i64(&mut wr, self.mod_time.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp_nanos() as i64)?;
// signature
@@ -1430,11 +1430,11 @@ impl MetaObject {
// string "ID"
rmp::encode::write_str(&mut wr, "ID")?;
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
// string "DDir"
rmp::encode::write_str(&mut wr, "DDir")?;
rmp::encode::write_bin(&mut wr, self.data_dir.unwrap_or(Uuid::nil()).as_bytes())?;
rmp::encode::write_bin(&mut wr, self.data_dir.unwrap_or_default().as_bytes())?;
// string "EcAlgo"
rmp::encode::write_str(&mut wr, "EcAlgo")?;
@@ -1754,7 +1754,7 @@ impl MetaDeleteMarker {
// string "ID"
rmp::encode::write_str(&mut wr, "ID")?;
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or(Uuid::nil()).as_bytes())?;
rmp::encode::write_bin(&mut wr, self.version_id.unwrap_or_default().as_bytes())?;
// string "MTime"
rmp::encode::write_str(&mut wr, "MTime")?;
@@ -2174,6 +2174,7 @@ pub async fn read_xl_meta_no_data<R: AsyncRead + Unpin>(reader: &mut R, size: us
}
}
#[cfg(test)]
#[allow(clippy::field_reassign_with_default)]
mod test {
use super::*;
@@ -2392,10 +2393,12 @@ mod test {
#[test]
fn test_file_meta_version_header_methods() {
let mut header = FileMetaVersionHeader::default();
header.ec_n = 4;
header.ec_m = 2;
header.flags = XL_FLAG_FREE_VERSION;
let mut header = FileMetaVersionHeader {
ec_n: 4,
ec_m: 2,
flags: XL_FLAG_FREE_VERSION,
..Default::default()
};
// Test has_ec
assert!(header.has_ec());
@@ -2413,13 +2416,17 @@ mod test {
#[test]
fn test_file_meta_version_header_comparison() {
let mut header1 = FileMetaVersionHeader::default();
header1.mod_time = Some(OffsetDateTime::from_unix_timestamp(1000).unwrap());
header1.version_id = Some(Uuid::new_v4());
let mut header1 = FileMetaVersionHeader {
mod_time: Some(OffsetDateTime::from_unix_timestamp(1000).unwrap()),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
let mut header2 = FileMetaVersionHeader::default();
header2.mod_time = Some(OffsetDateTime::from_unix_timestamp(2000).unwrap());
header2.version_id = Some(Uuid::new_v4());
let mut header2 = FileMetaVersionHeader {
mod_time: Some(OffsetDateTime::from_unix_timestamp(2000).unwrap()),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
// Test sorts_before - header2 should sort before header1 (newer mod_time)
assert!(!header1.sorts_before(&header2));
@@ -2469,9 +2476,11 @@ mod test {
#[test]
fn test_meta_object_methods() {
let mut obj = MetaObject::default();
obj.data_dir = Some(Uuid::new_v4());
obj.size = 1024;
let mut obj = MetaObject {
data_dir: Some(Uuid::new_v4()),
size: 1024,
..Default::default()
};
// Test use_data_dir
assert!(obj.use_data_dir());
@@ -2667,16 +2676,20 @@ mod test {
fn test_decode_data_dir_from_meta() {
// Test with valid metadata containing data_dir
let data_dir = Some(Uuid::new_v4());
let mut obj = MetaObject::default();
obj.data_dir = data_dir;
obj.mod_time = Some(OffsetDateTime::now_utc());
obj.erasure_algorithm = ErasureAlgo::ReedSolomon;
obj.bitrot_checksum_algo = ChecksumAlgo::HighwayHash;
let obj = MetaObject {
data_dir,
mod_time: Some(OffsetDateTime::now_utc()),
erasure_algorithm: ErasureAlgo::ReedSolomon,
bitrot_checksum_algo: ChecksumAlgo::HighwayHash,
..Default::default()
};
// Create a valid FileMetaVersion with the object
let mut version = FileMetaVersion::default();
version.version_type = VersionType::Object;
version.object = Some(obj);
let version = FileMetaVersion {
version_type: VersionType::Object,
object: Some(obj),
..Default::default()
};
let encoded = version.marshal_msg().unwrap();
let result = FileMetaVersion::decode_data_dir_from_meta(&encoded);
@@ -2868,8 +2881,10 @@ fn test_file_meta_get_set_idx() {
assert!(result.is_err());
// Test set_idx
let mut new_version = FileMetaVersion::default();
new_version.version_type = VersionType::Object;
let new_version = FileMetaVersion {
version_type: VersionType::Object,
..Default::default()
};
let result = fm.set_idx(0, new_version);
assert!(result.is_ok());
@@ -2983,10 +2998,12 @@ fn test_file_meta_version_header_from_version() {
#[test]
fn test_meta_object_into_fileinfo() {
let mut obj = MetaObject::default();
obj.version_id = Some(Uuid::new_v4());
obj.size = 1024;
obj.mod_time = Some(OffsetDateTime::now_utc());
let obj = MetaObject {
version_id: Some(Uuid::new_v4()),
size: 1024,
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
let version_id = obj.version_id;
let expected_version_id = version_id;
@@ -3014,9 +3031,11 @@ fn test_meta_object_from_fileinfo() {
#[test]
fn test_meta_delete_marker_into_fileinfo() {
let mut marker = MetaDeleteMarker::default();
marker.version_id = Some(Uuid::new_v4());
marker.mod_time = Some(OffsetDateTime::now_utc());
let marker = MetaDeleteMarker {
version_id: Some(Uuid::new_v4()),
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
let version_id = marker.version_id;
let expected_version_id = version_id;
@@ -3049,30 +3068,42 @@ fn test_flags_enum() {
#[test]
fn test_file_meta_version_header_user_data_dir() {
let mut header = FileMetaVersionHeader::default();
let header = FileMetaVersionHeader {
flags: 0,
..Default::default()
};
// Test without UsesDataDir flag
header.flags = 0;
assert!(!header.user_data_dir());
// Test with UsesDataDir flag
header.flags = Flags::UsesDataDir as u8;
let header = FileMetaVersionHeader {
flags: Flags::UsesDataDir as u8,
..Default::default()
};
assert!(header.user_data_dir());
// Test with multiple flags including UsesDataDir
header.flags = Flags::UsesDataDir as u8 | Flags::FreeVersion as u8;
let header = FileMetaVersionHeader {
flags: Flags::UsesDataDir as u8 | Flags::FreeVersion as u8,
..Default::default()
};
assert!(header.user_data_dir());
}
#[test]
fn test_file_meta_version_header_ordering() {
let mut header1 = FileMetaVersionHeader::default();
header1.mod_time = Some(OffsetDateTime::from_unix_timestamp(1000).unwrap());
header1.version_id = Some(Uuid::new_v4());
let header1 = FileMetaVersionHeader {
mod_time: Some(OffsetDateTime::from_unix_timestamp(1000).unwrap()),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
let mut header2 = FileMetaVersionHeader::default();
header2.mod_time = Some(OffsetDateTime::from_unix_timestamp(2000).unwrap());
header2.version_id = Some(Uuid::new_v4());
let header2 = FileMetaVersionHeader {
mod_time: Some(OffsetDateTime::from_unix_timestamp(2000).unwrap()),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
// Test partial_cmp
assert!(header1.partial_cmp(&header2).is_some());
@@ -3200,64 +3231,90 @@ async fn test_file_info_from_raw_edge_cases() {
#[test]
fn test_file_meta_version_invalid_cases() {
// Test invalid version
let mut version = FileMetaVersion::default();
version.version_type = VersionType::Invalid;
let version = FileMetaVersion {
version_type: VersionType::Invalid,
..Default::default()
};
assert!(!version.valid());
// Test version with neither object nor delete marker
version.version_type = VersionType::Object;
version.object = None;
version.delete_marker = None;
let version = FileMetaVersion {
version_type: VersionType::Object,
object: None,
delete_marker: None,
..Default::default()
};
assert!(!version.valid());
}
#[test]
fn test_meta_object_edge_cases() {
let mut obj = MetaObject::default();
let obj = MetaObject {
data_dir: None,
..Default::default()
};
// Test use_data_dir with None (use_data_dir always returns true)
obj.data_dir = None;
assert!(obj.use_data_dir());
// Test use_inlinedata (always returns false in current implementation)
obj.size = 128 * 1024; // 128KB threshold
let obj = MetaObject {
size: 128 * 1024, // 128KB threshold
..Default::default()
};
assert!(!obj.use_inlinedata()); // Should be false
obj.size = 128 * 1024 - 1;
let obj = MetaObject {
size: 128 * 1024 - 1,
..Default::default()
};
assert!(!obj.use_inlinedata()); // Should also be false (always false)
}
#[test]
fn test_file_meta_version_header_edge_cases() {
let mut header = FileMetaVersionHeader::default();
let header = FileMetaVersionHeader {
ec_n: 0,
ec_m: 0,
..Default::default()
};
// Test has_ec with zero values
header.ec_n = 0;
header.ec_m = 0;
assert!(!header.has_ec());
// Test matches_not_strict with different signatures but same version_id
let mut other = FileMetaVersionHeader::default();
let version_id = Some(Uuid::new_v4());
header.version_id = version_id;
other.version_id = version_id;
header.version_type = VersionType::Object;
other.version_type = VersionType::Object;
header.signature = [1, 2, 3, 4];
other.signature = [5, 6, 7, 8];
let header = FileMetaVersionHeader {
version_id,
version_type: VersionType::Object,
signature: [1, 2, 3, 4],
..Default::default()
};
let other = FileMetaVersionHeader {
version_id,
version_type: VersionType::Object,
signature: [5, 6, 7, 8],
..Default::default()
};
// Should match because they have same version_id and type
assert!(header.matches_not_strict(&other));
// Test sorts_before with same mod_time but different version_id
let time = OffsetDateTime::from_unix_timestamp(1000).unwrap();
header.mod_time = Some(time);
other.mod_time = Some(time);
header.version_id = Some(Uuid::new_v4());
other.version_id = Some(Uuid::new_v4());
let header_time1 = FileMetaVersionHeader {
mod_time: Some(time),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
let header_time2 = FileMetaVersionHeader {
mod_time: Some(time),
version_id: Some(Uuid::new_v4()),
..Default::default()
};
// Should use version_id for comparison when mod_time is same
let sorts_before = header.sorts_before(&other);
assert!(sorts_before || other.sorts_before(&header)); // One should sort before the other
let sorts_before = header_time1.sorts_before(&header_time2);
assert!(sorts_before || header_time2.sorts_before(&header_time1)); // One should sort before the other
}
#[test]

15
ecstore/src/io.rs
View File

@@ -58,7 +58,7 @@ impl HttpFileWriter {
.body(body)
.send()
.await
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
.map_err(io::Error::other)
{
error!("HttpFileWriter put file err: {:?}", err);
@@ -111,7 +111,7 @@ impl HttpFileReader {
))
.send()
.await
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
.map_err(io::Error::other)?;
let inner = Box::new(StreamReader::new(resp.bytes_stream().map_err(io::Error::other)));
@@ -202,7 +202,8 @@ mod tests {
#[tokio::test]
async fn test_constants() {
assert_eq!(READ_BUFFER_SIZE, 1024 * 1024);
assert!(READ_BUFFER_SIZE > 0);
// READ_BUFFER_SIZE is a compile-time constant, no need to assert
// assert!(READ_BUFFER_SIZE > 0);
}
#[tokio::test]
@@ -463,7 +464,8 @@ mod tests {
let _writer: FileWriter = Box::new(writer_rx);
// If this compiles, the types are correctly defined
assert!(true);
// This is a placeholder test - remove meaningless assertion
// assert!(true);
}
#[tokio::test]
@@ -483,8 +485,9 @@ mod tests {
#[tokio::test]
async fn test_read_buffer_size_constant() {
assert_eq!(READ_BUFFER_SIZE, 1024 * 1024);
assert!(READ_BUFFER_SIZE > 0);
assert!(READ_BUFFER_SIZE % 1024 == 0, "Buffer size should be a multiple of 1024");
// READ_BUFFER_SIZE is a compile-time constant, no need to assert
// assert!(READ_BUFFER_SIZE > 0);
// assert!(READ_BUFFER_SIZE % 1024 == 0, "Buffer size should be a multiple of 1024");
}
#[tokio::test]

1
ecstore/src/rebalance.rs
View File

@@ -639,6 +639,7 @@ impl ECStore {
false
}
#[allow(unused_assignments)]
#[tracing::instrument(skip(self, wk, set))]
async fn rebalance_entry(
&self,

16
ecstore/src/store.rs
View File

@@ -40,7 +40,7 @@ use crate::{
ListObjectsV2Info, MakeBucketOptions, MultipartUploadResult, ObjectInfo, ObjectOptions, ObjectToDelete, PartInfo,
PutObjReader, StorageAPI,
},
store_init, utils,
store_init,
};
use common::error::{Error, Result};
@@ -2695,17 +2695,17 @@ mod tests {
// Test validation functions
#[test]
fn test_is_valid_object_name() {
assert_eq!(is_valid_object_name("valid-object-name"), true);
assert_eq!(is_valid_object_name(""), false);
assert_eq!(is_valid_object_name("object/with/slashes"), true);
assert_eq!(is_valid_object_name("object with spaces"), true);
assert!(is_valid_object_name("valid-object-name"));
assert!(!is_valid_object_name(""));
assert!(is_valid_object_name("object/with/slashes"));
assert!(is_valid_object_name("object with spaces"));
}
#[test]
fn test_is_valid_object_prefix() {
assert_eq!(is_valid_object_prefix("valid-prefix"), true);
assert_eq!(is_valid_object_prefix(""), true);
assert_eq!(is_valid_object_prefix("prefix/with/slashes"), true);
assert!(is_valid_object_prefix("valid-prefix"));
assert!(is_valid_object_prefix(""));
assert!(is_valid_object_prefix("prefix/with/slashes"));
}
#[test]

3
ecstore/src/store_api.rs
View File

@@ -1058,6 +1058,7 @@ pub trait StorageAPI: ObjectIO {
}
#[cfg(test)]
#[allow(clippy::field_reassign_with_default)]
mod tests {
use super::*;
use std::collections::HashMap;
@@ -1089,7 +1090,7 @@ mod tests {
// Test distribution uniqueness
let mut unique_values = std::collections::HashSet::new();
for &val in &file_info.erasure.distribution {
assert!(val >= 1 && val <= 6, "Distribution value should be between 1 and 6");
assert!((1..=6).contains(&val), "Distribution value should be between 1 and 6");
unique_values.insert(val);
}
assert_eq!(unique_values.len(), 6, "All distribution values should be unique");

4
ecstore/src/utils/os/mod.rs
View File

@@ -86,8 +86,8 @@ mod tests {
// The actual result depends on the system configuration
println!("Same disk result for temp dirs: {}", result);
// Just verify the function executes successfully
assert!(result == true || result == false);
// The function returns a boolean value as expected
let _: bool = result; // Type assertion to verify return type
}
#[test]

17
ecstore/src/utils/os/unix.rs
View File

@@ -2,7 +2,7 @@ use super::IOStats;
use crate::disk::Info;
use common::error::Result;
use nix::sys::{stat::stat, statfs::statfs};
use std::io::{Error, ErrorKind};
use std::io::Error;
use std::path::Path;
/// returns total and free bytes available in a directory, e.g. `/`.
@@ -17,10 +17,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
let reserved = match bfree.checked_sub(bavail) {
Some(reserved) => reserved,
None => {
return Err(Error::new(
ErrorKind::Other,
return Err(Error::other(
format!(
"detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run 'fsck'",
"detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run fsck",
bavail,
bfree,
p.as_ref().display()
@@ -32,10 +31,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
let total = match blocks.checked_sub(reserved) {
Some(total) => total * bsize,
None => {
return Err(Error::new(
ErrorKind::Other,
return Err(Error::other(
format!(
"detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run 'fsck'",
"detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run fsck",
reserved,
blocks,
p.as_ref().display()
@@ -48,10 +46,9 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<Info> {
let used = match total.checked_sub(free) {
Some(used) => used,
None => {
return Err(Error::new(
ErrorKind::Other,
return Err(Error::other(
format!(
"detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
"detected free space ({}) > total drive space ({}), fs corruption at ({}). please run fsck",
free,
total,
p.as_ref().display()

17
iam/src/manager.rs
View File

@@ -1666,10 +1666,9 @@ mod tests {
// In test environment, it might be None
let key = get_token_signing_key();
// Just verify it doesn't panic and returns an Option
match key {
Some(k) => assert!(!k.is_empty()),
None => {} // This is acceptable in test environment
}
if let Some(k) = key {
assert!(!k.is_empty());
} // This is acceptable in test environment when None
}
#[test]
@@ -1907,10 +1906,12 @@ mod tests {
#[test]
fn test_session_policy_constants() {
// Test session policy related constants
assert!(!SESSION_POLICY_NAME.is_empty());
assert!(!SESSION_POLICY_NAME_EXTRACTED.is_empty());
assert!(MAX_SVCSESSION_POLICY_SIZE > 0);
// Test session policy related constants - these are compile-time constants
// so we just verify they exist and have expected values
assert_eq!(SESSION_POLICY_NAME, "sessionPolicy");
assert_eq!(SESSION_POLICY_NAME_EXTRACTED, "sessionPolicy-extracted");
// MAX_SVCSESSION_POLICY_SIZE is a positive constant defined at compile time
assert_eq!(MAX_SVCSESSION_POLICY_SIZE, 4096); // Verify the actual expected value
}
#[test]

8
madmin/src/user.rs
View File

@@ -225,7 +225,7 @@ impl UpdateServiceAccountReq {
}
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct AccountInfo {
pub account_name: String,
pub server: BackendInfo,
@@ -233,7 +233,7 @@ pub struct AccountInfo {
pub buckets: Vec<BucketAccessInfo>,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct BucketAccessInfo {
pub name: String,
pub size: u64,
@@ -247,7 +247,7 @@ pub struct BucketAccessInfo {
pub access: AccountAccess,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct BucketDetails {
pub versioning: bool,
pub versioning_suspended: bool,
@@ -256,7 +256,7 @@ pub struct BucketDetails {
// pub tagging: Option<Tagging>,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct AccountAccess {
pub read: bool,
pub write: bool,

2
rustfs/src/admin/rpc.rs
View File

@@ -120,7 +120,7 @@ impl Operation for PutFile {
let mut body = StreamReader::new(
req.input
.into_stream()
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e)),
.map_err(std::io::Error::other),
);
tokio::io::copy(&mut body, &mut file)

4
rustfs/src/console.rs
View File

@@ -281,7 +281,7 @@ async fn start_server(server_addr: SocketAddr, tls_path: Option<String>, app: Ro
.handle(handle.clone())
.serve(app.into_make_service())
.await
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
.map_err(io::Error::other)?;
info!("HTTPS server running on https://{}", server_addr);
@@ -323,7 +323,7 @@ async fn start_http_server(addr: SocketAddr, app: Router, handle: axum_server::H
.handle(handle)
.serve(app.into_make_service())
.await
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
.map_err(io::Error::other)
}
async fn shutdown_signal() {

1
rustfs/src/grpc.rs
View File

@@ -2420,6 +2420,7 @@ impl Node for NodeService {
}
#[cfg(test)]
#[allow(unused_imports)]
mod tests {
use super::*;
use protos::proto_gen::node_service::{

2
rustfs/src/main.rs
View File

@@ -71,6 +71,7 @@ const MI_B: usize = 1024 * 1024;
#[global_allocator]
static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
#[allow(clippy::result_large_err)]
fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {
let token: MetadataValue<_> = "rustfs rpc".parse().unwrap();
@@ -79,6 +80,7 @@ fn check_auth(req: Request<()>) -> Result<Request<()>, Status> {
_ => Err(Status::unauthenticated("No valid auth token")),
}
}
#[instrument]
fn print_server_info() {
let cfg = CONSOLE_CONFIG.get().unwrap();

6
rustfs/src/storage/ecfs.rs
View File

@@ -119,7 +119,7 @@ impl FS {
let Some(body) = body else { return Err(s3_error!(IncompleteBody)) };
let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))));
let body = StreamReader::new(body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))));
// let etag_stream = EtagReader::new(body);
@@ -961,7 +961,7 @@ impl S3 for FS {
};
let body = Box::new(StreamReader::new(
body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))),
body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))),
));
let mut reader = PutObjReader::new(body, content_length as usize);
@@ -1077,7 +1077,7 @@ impl S3 for FS {
};
let body = Box::new(StreamReader::new(
body.map(|f| f.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))),
body.map(|f| f.map_err(|e| std::io::Error::other(e.to_string()))),
));
// mc cp step 4

5
s3select/api/src/lib.rs
View File

@@ -12,8 +12,9 @@ pub type QueryResult<T> = Result<T, QueryError>;
#[derive(Debug, Snafu)]
#[snafu(visibility(pub))]
pub enum QueryError {
#[snafu(display("DataFusion error: {}", source))]
Datafusion {
source: DataFusionError,
source: Box<DataFusionError>,
location: Location,
backtrace: Backtrace,
},
@@ -49,7 +50,7 @@ impl From<DataFusionError> for QueryError {
DataFusionError::External(e) if e.downcast_ref::<QueryError>().is_some() => *e.downcast::<QueryError>().unwrap(),
v => Self::Datafusion {
source: v,
source: Box::new(v),
location: Default::default(),
backtrace: Backtrace::capture(),
},

38
s3select/query/src/sql/dialect.rs
View File

@@ -23,7 +23,7 @@ mod tests {
#[test]
fn test_rustfs_dialect_creation() {
let dialect = RustFsDialect::default();
let _dialect = RustFsDialect;
// Test that dialect can be created successfully
assert!(std::mem::size_of::<RustFsDialect>() == 0, "Dialect should be zero-sized");
@@ -31,7 +31,7 @@ mod tests {
#[test]
fn test_rustfs_dialect_debug() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
let debug_str = format!("{:?}", dialect);
assert!(!debug_str.is_empty(), "Debug output should not be empty");
@@ -40,7 +40,7 @@ mod tests {
#[test]
fn test_is_identifier_start_alphabetic() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test alphabetic characters
assert!(dialect.is_identifier_start('a'), "Lowercase letter should be valid identifier start");
@@ -56,7 +56,7 @@ mod tests {
#[test]
fn test_is_identifier_start_special_chars() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test special characters that are allowed
assert!(dialect.is_identifier_start('_'), "Underscore should be valid identifier start");
@@ -66,7 +66,7 @@ mod tests {
#[test]
fn test_is_identifier_start_invalid_chars() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test characters that should not be valid identifier starts
assert!(!dialect.is_identifier_start('0'), "Digit should not be valid identifier start");
@@ -105,7 +105,7 @@ mod tests {
#[test]
fn test_is_identifier_part_alphabetic() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test alphabetic characters
assert!(dialect.is_identifier_part('a'), "Lowercase letter should be valid identifier part");
@@ -121,7 +121,7 @@ mod tests {
#[test]
fn test_is_identifier_part_digits() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test ASCII digits
assert!(dialect.is_identifier_part('0'), "Digit 0 should be valid identifier part");
@@ -132,7 +132,7 @@ mod tests {
#[test]
fn test_is_identifier_part_special_chars() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test special characters that are allowed
assert!(dialect.is_identifier_part('_'), "Underscore should be valid identifier part");
@@ -143,7 +143,7 @@ mod tests {
#[test]
fn test_is_identifier_part_invalid_chars() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test characters that should not be valid identifier parts
assert!(!dialect.is_identifier_part(' '), "Space should not be valid identifier part");
@@ -179,14 +179,14 @@ mod tests {
#[test]
fn test_supports_group_by_expr() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
assert!(dialect.supports_group_by_expr(), "RustFsDialect should support GROUP BY expressions");
}
#[test]
fn test_identifier_validation_comprehensive() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test valid identifier patterns
let valid_starts = ['a', 'A', 'z', 'Z', '_', '#', '@', 'α', '中'];
@@ -205,7 +205,7 @@ mod tests {
#[test]
fn test_identifier_edge_cases() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test edge cases with control characters
assert!(!dialect.is_identifier_start('\0'), "Null character should not be valid identifier start");
@@ -220,7 +220,7 @@ mod tests {
#[test]
fn test_identifier_unicode_support() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test various Unicode categories
let unicode_letters = ['α', 'β', 'γ', 'Α', 'Β', 'Γ', '中', '文', '日', '本', 'ñ', 'ü', 'ç'];
@@ -235,7 +235,7 @@ mod tests {
#[test]
fn test_identifier_ascii_digits() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test all ASCII digits
for digit in '0'..='9' {
@@ -248,7 +248,7 @@ mod tests {
#[test]
fn test_dialect_consistency() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test that all valid identifier starts are also valid identifier parts
let test_chars = [
@@ -266,7 +266,7 @@ mod tests {
#[test]
fn test_dialect_memory_efficiency() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test that dialect doesn't use excessive memory
let dialect_size = std::mem::size_of_val(&dialect);
@@ -275,7 +275,7 @@ mod tests {
#[test]
fn test_dialect_trait_implementation() {
let dialect = RustFsDialect::default();
let dialect = RustFsDialect;
// Test that dialect properly implements the Dialect trait
let dialect_ref: &dyn Dialect = &dialect;
@@ -290,8 +290,8 @@ mod tests {
#[test]
fn test_dialect_clone_and_default() {
let dialect1 = RustFsDialect::default();
let dialect2 = RustFsDialect::default();
let dialect1 = RustFsDialect;
let dialect2 = RustFsDialect;
// Test that multiple instances behave the same
let test_chars = ['a', 'A', '0', '_', '#', '@', '$', ' ', '.'];

30
s3select/query/src/sql/optimizer.rs
View File

@@ -87,7 +87,7 @@ mod tests {
#[test]
fn test_cascade_optimizer_builder_default() {
let builder = CascadeOptimizerBuilder::default();
let _builder = CascadeOptimizerBuilder::default();
// Test that builder can be created successfully
assert!(std::mem::size_of::<CascadeOptimizerBuilder>() > 0, "Builder should be created successfully");
@@ -95,17 +95,17 @@ mod tests {
#[test]
fn test_cascade_optimizer_builder_build_with_defaults() {
let builder = CascadeOptimizerBuilder::default();
let optimizer = builder.build();
let _builder = CascadeOptimizerBuilder::default();
let optimizer = _builder.build();
// Test that optimizer can be built with default components
assert!(std::mem::size_of_val(&optimizer) > 0, "Optimizer should be built successfully");
}
#[test]
#[test]
fn test_cascade_optimizer_builder_basic_functionality() {
// Test that builder methods can be called and return self
let builder = CascadeOptimizerBuilder::default();
let _builder = CascadeOptimizerBuilder::default();
// Test that we can call builder methods (even if we don't have mock implementations)
// This tests the builder pattern itself
@@ -114,23 +114,23 @@ mod tests {
#[test]
fn test_cascade_optimizer_builder_memory_efficiency() {
let builder = CascadeOptimizerBuilder::default();
let _builder = CascadeOptimizerBuilder::default();
// Test that builder doesn't use excessive memory
let builder_size = std::mem::size_of_val(&builder);
let builder_size = std::mem::size_of_val(&_builder);
assert!(builder_size < 1000, "Builder should not use excessive memory");
let optimizer = builder.build();
let optimizer = _builder.build();
let optimizer_size = std::mem::size_of_val(&optimizer);
assert!(optimizer_size < 1000, "Optimizer should not use excessive memory");
}
#[test]
#[test]
fn test_cascade_optimizer_builder_multiple_builds() {
let builder = CascadeOptimizerBuilder::default();
let _builder = CascadeOptimizerBuilder::default();
// Test that we can build multiple optimizers from the same configuration
let optimizer1 = builder.build();
let optimizer1 = _builder.build();
assert!(std::mem::size_of_val(&optimizer1) > 0, "First optimizer should be built successfully");
// Note: builder is consumed by build(), so we can't build again from the same instance
@@ -139,16 +139,14 @@ mod tests {
#[test]
fn test_cascade_optimizer_builder_default_fallbacks() {
let builder = CascadeOptimizerBuilder::default();
let optimizer = builder.build();
let _builder = CascadeOptimizerBuilder::default();
let optimizer = _builder.build();
// Test that default components are used when none are specified
// We can't directly access the internal components, but we can verify the optimizer was built
assert!(std::mem::size_of_val(&optimizer) > 0, "Optimizer should use default components");
}
#[test]
fn test_cascade_optimizer_component_types() {
let optimizer = CascadeOptimizerBuilder::default().build();
@@ -161,7 +159,7 @@ mod tests {
// This is a basic structural test
}
#[test]
#[test]
fn test_cascade_optimizer_builder_consistency() {
// Test that multiple builders with the same configuration produce equivalent optimizers
let optimizer1 = CascadeOptimizerBuilder::default().build();

8
s3select/query/src/sql/parser.rs
View File

@@ -98,7 +98,7 @@ mod tests {
#[test]
fn test_default_parser_creation() {
let parser = DefaultParser::default();
let _parser = DefaultParser::default();
// Test that parser can be created successfully
assert!(std::mem::size_of::<DefaultParser>() == 0, "Parser should be zero-sized");
@@ -230,7 +230,7 @@ mod tests {
#[test]
fn test_ext_parser_parse_sql_with_dialect() {
let sql = "SELECT * FROM S3Object";
let dialect = &RustFsDialect::default();
let dialect = &RustFsDialect;
let result = ExtParser::parse_sql_with_dialect(sql, dialect);
assert!(result.is_ok(), "ExtParser::parse_sql_with_dialect should work");
@@ -242,7 +242,7 @@ mod tests {
#[test]
fn test_ext_parser_new_with_dialect() {
let sql = "SELECT * FROM S3Object";
let dialect = &RustFsDialect::default();
let dialect = &RustFsDialect;
let result = ExtParser::new_with_dialect(sql, dialect);
assert!(result.is_ok(), "ExtParser::new_with_dialect should work");
@@ -418,7 +418,7 @@ mod tests {
#[test]
fn test_ext_parser_expected_method() {
let sql = "SELECT * FROM S3Object";
let dialect = &RustFsDialect::default();
let dialect = &RustFsDialect;
let parser = ExtParser::new_with_dialect(sql, dialect).unwrap();
let result: Result<()> = parser.expected("test token", "found token");