use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use uuid::Uuid;
pub fn guid() -> String {
Uuid::new_v4().simple().to_string()
}
pub fn generate_guid_with_hyphens() -> String {
Uuid::new_v4().to_string()
}
pub fn string(length: usize) -> String {
thread_rng()
.sample_iter(&Alphanumeric)
.take(length)
.map(char::from)
.collect()
}
pub fn generate_random_string_with_charset(length: usize, charset: &str) -> String {
let chars: Vec<char> = charset.chars().collect();
if chars.is_empty() {
return String::new();
}
let mut rng = thread_rng();
(0..length)
.map(|_| chars[rng.gen_range(0..chars.len())])
.collect()
}
pub fn number(min: i64, max: i64) -> i64 {
if min > max {
return min;
}
thread_rng().gen_range(min..=max)
}
pub fn generate_random_float(min: f64, max: f64) -> f64 {
if min >= max {
return min;
}
thread_rng().gen_range(min..max)
}
pub fn generate_random_text(word_count: usize) -> String {
const WORDS: &[&str] = &[
"lorem",
"ipsum",
"dolor",
"sit",
"amet",
"consectetur",
"adipiscing",
"elit",
"sed",
"do",
"eiusmod",
"tempor",
"incididunt",
"ut",
"labore",
"et",
"dolore",
"magna",
"aliqua",
"enim",
"ad",
"minim",
"veniam",
"quis",
"nostrud",
"exercitation",
"ullamco",
"laboris",
"nisi",
"aliquip",
"ex",
"ea",
"commodo",
"consequat",
"duis",
"aute",
"irure",
"in",
"reprehenderit",
"voluptate",
"velit",
"esse",
"cillum",
"fugiat",
"nulla",
"pariatur",
"excepteur",
"sint",
"occaecat",
"cupidatat",
"non",
"proident",
"sunt",
"culpa",
"qui",
"officia",
"deserunt",
"mollit",
"anim",
"id",
"est",
"laborum",
];
let mut rng = thread_rng();
(0..word_count)
.map(|_| WORDS[rng.gen_range(0..WORDS.len())])
.collect::<Vec<&str>>()
.join(" ")
}
pub fn generate_secure_token(byte_length: usize) -> String {
use base64::{engine::general_purpose, Engine as _};
let mut bytes = vec![0u8; byte_length];
thread_rng().fill(&mut bytes[..]);
general_purpose::URL_SAFE_NO_PAD.encode(&bytes)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_generate_guid() {
let guid1 = guid();
let guid2 = guid();
assert_eq!(guid1.len(), 32);
assert_eq!(guid2.len(), 32);
assert_ne!(guid1, guid2);
assert!(guid1.chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn test_generate_guid_with_hyphens() {
let guid = generate_guid_with_hyphens();
assert_eq!(guid.len(), 36);
assert_eq!(guid.chars().nth(8), Some('-'));
assert_eq!(guid.chars().nth(13), Some('-'));
assert_eq!(guid.chars().nth(18), Some('-'));
assert_eq!(guid.chars().nth(23), Some('-'));
}
#[test]
fn test_generate_random_string() {
let str1 = string(10);
let str2 = string(10);
assert_eq!(str1.len(), 10);
assert_eq!(str2.len(), 10);
assert_ne!(str1, str2);
assert!(str1.chars().all(|c| c.is_alphanumeric()));
assert!(str2.chars().all(|c| c.is_alphanumeric()));
}
#[test]
fn test_generate_random_string_with_charset() {
let numbers = generate_random_string_with_charset(8, "0123456789");
assert_eq!(numbers.len(), 8);
assert!(numbers.chars().all(|c| c.is_ascii_digit()));
let empty = generate_random_string_with_charset(5, "");
assert!(empty.is_empty());
}
#[test]
fn test_generate_random_number() {
let num = number(1, 10);
assert!(num >= 1 && num <= 10);
let single = number(5, 5);
assert_eq!(single, 5);
let inverted = number(10, 5);
assert_eq!(inverted, 10); }
#[test]
fn test_generate_random_float() {
let num = generate_random_float(1.0, 10.0);
assert!(num >= 1.0 && num < 10.0);
let inverted = generate_random_float(10.0, 5.0);
assert_eq!(inverted, 10.0); }
#[test]
fn test_generate_random_text() {
let text = generate_random_text(5);
let words: Vec<&str> = text.split_whitespace().collect();
assert_eq!(words.len(), 5);
const WORDS: &[&str] = &[
"lorem",
"ipsum",
"dolor",
"sit",
"amet",
"consectetur",
"adipiscing",
"elit",
"sed",
"do",
"eiusmod",
"tempor",
"incididunt",
"ut",
"labore",
"et",
"dolore",
"magna",
"aliqua",
"enim",
"ad",
"minim",
"veniam",
"quis",
"nostrud",
"exercitation",
"ullamco",
"laboris",
"nisi",
"aliquip",
"ex",
"ea",
"commodo",
"consequat",
"duis",
"aute",
"irure",
"in",
"reprehenderit",
"voluptate",
"velit",
"esse",
"cillum",
"fugiat",
"nulla",
"pariatur",
"excepteur",
"sint",
"occaecat",
"cupidatat",
"non",
"proident",
"sunt",
"culpa",
"qui",
"officia",
"deserunt",
"mollit",
"anim",
"id",
"est",
"laborum",
];
for word in words {
assert!(WORDS.contains(&word));
}
}
#[test]
fn test_generate_secure_token() {
let token1 = generate_secure_token(32);
let token2 = generate_secure_token(32);
assert_ne!(token1, token2);
assert!(token1
.chars()
.all(|c| c.is_alphanumeric() || c == '-' || c == '_'));
assert!(token2
.chars()
.all(|c| c.is_alphanumeric() || c == '-' || c == '_'));
}
}