Implement base64 fakes

fake/Cargo.toml

@@ -42,6 +42,7 @@ bson = { version = "2", optional = true }
 url = { version = "2", optional = true }
 indexmap = { version = "2", optional = true}
 clap = { version = "4.0.32", optional = true, features=["cargo"] }
+base64 = { version = "0.22.1", optional = true }
 
 [dev-dependencies]
 chrono = { version = "0.4", features = ["clock"], default-features = false }
@@ -62,6 +63,7 @@ geo = ["geo-types", "num-traits"]
 http = ["dep:http", "url-escape"]
 bson_oid = ["bson"]
 cli = ["dep:clap","random_color","chrono","http"]
+base64 = ["dep:base64"]
 
 [[example]]
 name = "basic"

fake/src/impls/base64/mod.rs

@@ -0,0 +1,52 @@
+use crate::{Dummy, Fake, Faker};
+use base64::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub struct UrlSafeBase64Value(pub String);
+
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub struct Base64Value(pub String);
+
+pub struct Base64;
+
+pub struct UrlSafeBase64;
+
+impl Dummy<Base64> for String {
+    fn dummy_with_rng<R: rand::Rng + ?Sized>(_: &Base64, rng: &mut R) -> Self {
+        let data: Vec<u8> = Faker.fake_with_rng(rng);
+        let padding = Faker.fake_with_rng(rng);
+        let encoded = if padding {
+            BASE64_STANDARD.encode(&data)
+        } else {
+            BASE64_STANDARD_NO_PAD.encode(&data)
+        };
+        encoded
+    }
+}
+
+impl Dummy<UrlSafeBase64> for String {
+    fn dummy_with_rng<R: rand::Rng + ?Sized>(_: &UrlSafeBase64, rng: &mut R) -> Self {
+        let data: Vec<u8> = Faker.fake_with_rng(rng);
+        let padding = Faker.fake_with_rng(rng);
+        let encoded = if padding {
+            BASE64_URL_SAFE.encode(&data)
+        } else {
+            BASE64_URL_SAFE_NO_PAD.encode(&data)
+        };
+        encoded
+    }
+}
+
+impl Dummy<Faker> for Base64Value {
+    fn dummy_with_rng<R: rand::Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self {
+        let s = String::dummy_with_rng(&Base64, rng);
+        Base64Value(s)
+    }
+}
+
+impl Dummy<Faker> for UrlSafeBase64Value {
+    fn dummy_with_rng<R: rand::Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self {
+        let s = String::dummy_with_rng(&UrlSafeBase64, rng);
+        UrlSafeBase64Value(s)
+    }
+}

fake/src/impls/mod.rs

@@ -1,5 +1,7 @@
 //! This module contains implementations of `Dummy` trait
 
+#[cfg(feature = "base64")]
+pub mod base64;
 #[cfg(feature = "bigdecimal-rs")]
 pub mod bigdecimal;
 #[cfg(feature = "bson_oid")]

fake/src/lib.rs

@@ -303,6 +303,10 @@ pub use impls::chrono;
 #[cfg_attr(docsrs, doc(cfg(feature = "bson_oid")))]
 pub use impls::bson_oid;
 
+#[cfg(feature = "base64")]
+#[cfg_attr(docsrs, doc(cfg(feature = "base64")))]
+pub use impls::base64;
+
 /// Fake value generation for specific formats.
 ///
 /// It is structured in a way such that the modules here describes the custom

fake/tests/determinism.rs

@@ -373,3 +373,13 @@ mod bson_oid {
 
     check_determinism! { one fake_bson_oid, ObjectId, Faker }
 }
+
+#[cfg(feature = "base64")]
+mod base64 {
+    use fake::base64::*;
+    use fake::{Fake, Faker};
+    use rand::SeedableRng as _;
+
+    check_determinism! { one fake_base64, Base64Value, Faker }
+    check_determinism! { one fake_url_safe_base64, UrlSafeBase64Value, Faker }
+}