Skip to content

Commit

Permalink
Code cleanup. Generate more robust paths. Fix the Default bound req…
Browse files Browse the repository at this point in the history 
…uirement
  • Loading branch information
@DanikVitek
DanikVitek committed Jan 30, 2025
1 parent c978615 commit 6d9691a
Show file tree
Hide file tree
Showing 66 changed files with 575 additions and 672 deletions.
118 changes: 47 additions & 71 deletions borsh-derive/src/internals/attributes/field/mod.rs
View file

Large diffs are not rendered by default.

124 changes: 57 additions & 67 deletions borsh-derive/src/internals/attributes/item/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -121,135 +121,132 @@ pub(crate) fn get_crate(attrs: &[Attribute]) -> Result<Option<Path>, Error> {
#[cfg(test)]
mod tests {
use crate::internals::test_helpers::local_insta_assert_debug_snapshot;
use quote::{quote, ToTokens};
use syn::ItemEnum;
use quote::ToTokens;
use syn::{parse_quote, ItemEnum};

use super::*;

#[test]
fn test_use_discriminant() {
let item_enum: ItemEnum = syn::parse2(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(use_discriminant = false)]
enum AWithUseDiscriminantFalse {
X,
Y,
}
})
.unwrap();
};
let actual = contains_use_discriminant(&item_enum);
assert!(!actual.unwrap());
}

#[test]
fn test_use_discriminant_true() {
let item_enum: ItemEnum = syn::parse2(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(use_discriminant = true)]
enum AWithUseDiscriminantTrue {
X,
Y,
}
})
.unwrap();
};
let actual = contains_use_discriminant(&item_enum);
assert!(actual.unwrap());
}

#[test]
fn test_use_discriminant_wrong_value() {
let item_enum: ItemEnum = syn::parse2(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(use_discriminant = 111)]
enum AWithUseDiscriminantFalse {
X,
Y,
}
})
.unwrap();
};
let actual = contains_use_discriminant(&item_enum);
let err = match actual {
Ok(..) => unreachable!("expecting error here"),
Err(err) => err,
};
local_insta_assert_debug_snapshot!(err);
}

#[test]
fn test_check_attrs_use_discriminant_on_struct() {
let item_enum: DeriveInput = syn::parse2(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(use_discriminant = false)]
struct AWithUseDiscriminantFalse {
x: X,
y: Y,
}
})
.unwrap();
let actual = check_attributes(&item_enum);
};
let actual = check_attributes(&derive_input);
local_insta_assert_debug_snapshot!(actual.unwrap_err());
}

#[test]
fn test_check_attrs_borsh_skip_on_whole_item() {
let item_enum: DeriveInput = syn::parse2(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(skip)]
struct AWithUseDiscriminantFalse {
x: X,
y: Y,
}
})
.unwrap();
let actual = check_attributes(&item_enum);
};
let actual = check_attributes(&derive_input);
local_insta_assert_debug_snapshot!(actual.unwrap_err());
}

#[test]
fn test_check_attrs_borsh_invalid_on_whole_item() {
let item_enum: DeriveInput = syn::parse2(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(invalid)]
enum AWithUseDiscriminantFalse {
X,
Y,
}
})
.unwrap();
let actual = check_attributes(&item_enum);
};
let actual = check_attributes(&derive_input);
local_insta_assert_debug_snapshot!(actual.unwrap_err());
}

#[test]
fn test_check_attrs_init_function() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init = initialization_method)]
struct A<'a> {
x: u64,
}
})
.unwrap();
};

let actual = check_attributes(&item_struct);
let actual = check_attributes(&derive_input);
assert!(actual.is_ok());
}

#[test]
fn test_check_attrs_init_function_with_use_discriminant_reversed() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(use_discriminant=true, init = initialization_method)]
enum A {
B,
C,
D= 10,
}
})
.unwrap();
};

let actual = check_attributes(&item_struct);
let actual = check_attributes(&derive_input);
assert!(actual.is_ok());
}

#[test]
fn test_reject_multiple_borsh_attrs() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(use_discriminant=true)]
#[borsh(init = initialization_method)]
Expand All @@ -258,33 +255,31 @@ mod tests {
C,
D= 10,
}
})
.unwrap();
};

let actual = check_attributes(&item_struct);
let actual = check_attributes(&derive_input);
local_insta_assert_debug_snapshot!(actual.unwrap_err());
}

#[test]
fn test_check_attrs_init_function_with_use_discriminant() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init = initialization_method, use_discriminant=true)]
enum A {
B,
C,
D= 10,
}
})
.unwrap();
};

let actual = check_attributes(&item_struct);
let actual = check_attributes(&derive_input);
assert!(actual.is_ok());
}

#[test]
fn test_check_attrs_init_function_wrong_format() {
let item_struct: DeriveInput = syn::parse2(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshDeserialize, Debug)]
#[borsh(init_func = initialization_method)]
struct A<'a> {
Expand All @@ -295,23 +290,22 @@ mod tests {
v: Vec<String>,

}
})
.unwrap();
let actual = check_attributes(&item_struct);
};
let actual = check_attributes(&derive_input);
local_insta_assert_debug_snapshot!(actual.unwrap_err());
}

#[test]
fn test_init_function() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init = initialization_method)]
struct A<'a> {
x: u64,
}
})
.unwrap();
};

let actual = contains_initialize_with(&item_struct.attrs);
let actual = contains_initialize_with(&derive_input.attrs);
assert_eq!(
actual.unwrap().to_token_stream().to_string(),
"initialization_method"
Expand All @@ -320,16 +314,15 @@ mod tests {

#[test]
fn test_init_function_parsing_error() {
let item_struct = syn::parse2::<DeriveInput>(quote! {
let derive_input: DeriveInput = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init={strange; blocky})]
struct A {
lazy: Option<u64>,
}
})
.unwrap();
};

let actual = contains_initialize_with(&item_struct.attrs);
let actual = contains_initialize_with(&derive_input.attrs);
let err = match actual {
Ok(..) => unreachable!("expecting error here"),
Err(err) => err,
Expand All @@ -339,70 +332,67 @@ mod tests {

#[test]
fn test_init_function_with_use_discriminant() {
let item_struct = syn::parse2::<ItemEnum>(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init = initialization_method, use_discriminant=true)]
enum A {
B,
C,
D,
}
})
.unwrap();
};

let actual = contains_initialize_with(&item_struct.attrs);
let actual = contains_initialize_with(&item_enum.attrs);
assert_eq!(
actual.unwrap().to_token_stream().to_string(),
"initialization_method"
);
let actual = contains_use_discriminant(&item_struct);
let actual = contains_use_discriminant(&item_enum);
assert!(actual.unwrap());
}

#[test]
fn test_init_function_with_use_discriminant_reversed() {
let item_struct = syn::parse2::<ItemEnum>(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(use_discriminant=true, init = initialization_method)]
enum A {
B,
C,
D,
}
})
.unwrap();
};

let actual = contains_initialize_with(&item_struct.attrs);
let actual = contains_initialize_with(&item_enum.attrs);
assert_eq!(
actual.unwrap().to_token_stream().to_string(),
"initialization_method"
);
let actual = contains_use_discriminant(&item_struct);
let actual = contains_use_discriminant(&item_enum);
assert!(actual.unwrap());
}

#[test]
fn test_init_function_with_use_discriminant_with_crate() {
let item_struct = syn::parse2::<ItemEnum>(quote! {
let item_enum: ItemEnum = parse_quote! {
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
#[borsh(init = initialization_method, crate = "reexporter::borsh", use_discriminant=true)]
enum A {
B,
C,
D,
}
})
.unwrap();
};

let actual = contains_initialize_with(&item_struct.attrs);
let actual = contains_initialize_with(&item_enum.attrs);
assert_eq!(
actual.unwrap().to_token_stream().to_string(),
"initialization_method"
);
let actual = contains_use_discriminant(&item_struct);
let actual = contains_use_discriminant(&item_enum);
assert!(actual.unwrap());

let crate_ = get_crate(&item_struct.attrs);
let crate_ = get_crate(&item_enum.attrs);
assert_eq!(
crate_.unwrap().to_token_stream().to_string(),
"reexporter :: borsh"
Expand Down
Loading

0 comments on commit 6d9691a

Please sign in to comment.