+ #[test]
+ fn test_valid_site_name() {
+ let valid_names = [
+ (0..SITE_NAME_MAX_LENGTH).map(|_| 'A').collect::<String>(),
+ String::from("A"),
+ ];
+ let invalid_names = [
+ (
+ &(0..SITE_NAME_MAX_LENGTH + 1)
+ .map(|_| 'A')
+ .collect::<String>(),
+ LemmyErrorType::SiteNameLengthOverflow,
+ ),
+ (&String::new(), LemmyErrorType::SiteNameRequired),
+ ];
+
+ valid_names.iter().for_each(|valid_name| {
+ assert!(
+ site_name_length_check(valid_name).is_ok(),
+ "Expected {} of length {} to be Ok.",
+ valid_name,
+ valid_name.len()
+ )
+ });
+
+ invalid_names
+ .iter()
+ .for_each(|(invalid_name, expected_err)| {
+ let result = site_name_length_check(invalid_name);
+
+ assert!(result.is_err());
+ assert!(
+ result.unwrap_err().error_type.eq(&expected_err.clone()),
+ "Testing {}, expected error {}",
+ invalid_name,
+ expected_err
+ );
+ });
+ }
+
+ #[test]
+ fn test_valid_bio() {
+ assert!(is_valid_bio_field(&(0..BIO_MAX_LENGTH).map(|_| 'A').collect::<String>()).is_ok());
+
+ let invalid_result =
+ is_valid_bio_field(&(0..BIO_MAX_LENGTH + 1).map(|_| 'A').collect::<String>());
+
+ assert!(
+ invalid_result.is_err()
+ && invalid_result
+ .unwrap_err()
+ .error_type
+ .eq(&LemmyErrorType::BioLengthOverflow)
+ );
+ }
+
+ #[test]
+ fn test_valid_site_description() {
+ assert!(site_description_length_check(
+ &(0..SITE_DESCRIPTION_MAX_LENGTH)
+ .map(|_| 'A')
+ .collect::<String>()
+ )
+ .is_ok());
+
+ let invalid_result = site_description_length_check(
+ &(0..SITE_DESCRIPTION_MAX_LENGTH + 1)
+ .map(|_| 'A')
+ .collect::<String>(),
+ );
+
+ assert!(
+ invalid_result.is_err()
+ && invalid_result
+ .unwrap_err()
+ .error_type
+ .eq(&LemmyErrorType::SiteDescriptionLengthOverflow)
+ );
+ }
+
+ #[test]
+ fn test_valid_slur_regex() {
+ let valid_regexes = [&None, &Some(""), &Some("(foo|bar)")];
+
+ valid_regexes.iter().for_each(|regex| {
+ let result = build_and_check_regex(regex);
+
+ assert!(result.is_ok(), "Testing regex: {:?}", regex);
+ });
+ }
+
+ #[test]
+ fn test_too_permissive_slur_regex() {
+ let match_everything_regexes = [
+ (&Some("["), LemmyErrorType::InvalidRegex),
+ (&Some("(foo|bar|)"), LemmyErrorType::PermissiveRegex),
+ (&Some(".*"), LemmyErrorType::PermissiveRegex),
+ ];
+
+ match_everything_regexes
+ .iter()
+ .for_each(|(regex_str, expected_err)| {
+ let result = build_and_check_regex(regex_str);
+
+ assert!(result.is_err());
+ assert!(
+ result.unwrap_err().error_type.eq(&expected_err.clone()),
+ "Testing regex {:?}, expected error {}",
+ regex_str,
+ expected_err
+ );
+ });
+ }
+