Lifei Zhou
109 lines
3.8 KiB
Rust
109 lines
3.8 KiB
Rust
use anyhow::Result;
|
|
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
|
use thiserror::Error;
|
|
|
|
use crate::recipe::Recipe;
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum DecodeError {
|
|
#[error("Failed to decode recipe deeplink")]
|
|
AllMethodsFailed,
|
|
}
|
|
|
|
pub fn encode(recipe: &Recipe) -> Result<String, serde_json::Error> {
|
|
let recipe_json = serde_json::to_string(recipe)?;
|
|
let encoded = URL_SAFE_NO_PAD.encode(recipe_json.as_bytes());
|
|
Ok(encoded)
|
|
}
|
|
|
|
pub fn decode(link: &str) -> Result<Recipe, DecodeError> {
|
|
// Handle the current format: URL-safe Base64 without padding.
|
|
if let Ok(decoded_bytes) = URL_SAFE_NO_PAD.decode(link) {
|
|
if let Ok(recipe_json) = String::from_utf8(decoded_bytes) {
|
|
if let Ok(recipe) = serde_json::from_str::<Recipe>(&recipe_json) {
|
|
return Ok(recipe);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle legacy formats of 'standard base64 encoded' and standard base64 encoded that was then url encoded.
|
|
if let Ok(url_decoded) = urlencoding::decode(link) {
|
|
if let Ok(decoded_bytes) =
|
|
base64::engine::general_purpose::STANDARD.decode(url_decoded.as_bytes())
|
|
{
|
|
if let Ok(recipe_json) = String::from_utf8(decoded_bytes) {
|
|
if let Ok(recipe) = serde_json::from_str::<Recipe>(&recipe_json) {
|
|
return Ok(recipe);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(DecodeError::AllMethodsFailed)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::recipe::Recipe;
|
|
|
|
fn create_test_recipe() -> Recipe {
|
|
Recipe::builder()
|
|
.title("Test Recipe")
|
|
.description("A test recipe for deeplink encoding/decoding")
|
|
.instructions("Act as a helpful assistant")
|
|
.build()
|
|
.expect("Failed to build test recipe")
|
|
}
|
|
|
|
#[test]
|
|
fn test_encode_decode_round_trip() {
|
|
let original_recipe = create_test_recipe();
|
|
|
|
let encoded = encode(&original_recipe).expect("Failed to encode recipe");
|
|
assert!(!encoded.is_empty());
|
|
|
|
let decoded_recipe = decode(&encoded).expect("Failed to decode recipe");
|
|
|
|
assert_eq!(original_recipe.title, decoded_recipe.title);
|
|
assert_eq!(original_recipe.description, decoded_recipe.description);
|
|
assert_eq!(original_recipe.instructions, decoded_recipe.instructions);
|
|
assert_eq!(original_recipe.version, decoded_recipe.version);
|
|
}
|
|
|
|
#[test]
|
|
fn test_decode_legacy_standard_base64() {
|
|
let recipe = create_test_recipe();
|
|
let recipe_json = serde_json::to_string(&recipe).unwrap();
|
|
let legacy_encoded =
|
|
base64::engine::general_purpose::STANDARD.encode(recipe_json.as_bytes());
|
|
|
|
let decoded_recipe = decode(&legacy_encoded).expect("Failed to decode legacy format");
|
|
assert_eq!(recipe.title, decoded_recipe.title);
|
|
assert_eq!(recipe.description, decoded_recipe.description);
|
|
assert_eq!(recipe.instructions, decoded_recipe.instructions);
|
|
}
|
|
|
|
#[test]
|
|
fn test_decode_legacy_url_encoded_base64() {
|
|
let recipe = create_test_recipe();
|
|
let recipe_json = serde_json::to_string(&recipe).unwrap();
|
|
let base64_encoded =
|
|
base64::engine::general_purpose::STANDARD.encode(recipe_json.as_bytes());
|
|
let url_encoded = urlencoding::encode(&base64_encoded);
|
|
|
|
let decoded_recipe =
|
|
decode(&url_encoded).expect("Failed to decode URL-encoded legacy format");
|
|
assert_eq!(recipe.title, decoded_recipe.title);
|
|
assert_eq!(recipe.description, decoded_recipe.description);
|
|
assert_eq!(recipe.instructions, decoded_recipe.instructions);
|
|
}
|
|
|
|
#[test]
|
|
fn test_decode_invalid_input() {
|
|
let result = decode("invalid_base64!");
|
|
assert!(result.is_err());
|
|
assert!(matches!(result.unwrap_err(), DecodeError::AllMethodsFailed));
|
|
}
|
|
}
|