|
4 years ago | |
---|---|---|
.. | ||
README.md | 4 years ago |
README.md
error types
Instructions
For this exercise, you will have to implement an error type.
The main objective is to create a form validator, where you must implement an error type. This must validate the password and the first name. The first name must not be empty and the password must have at least 8 char, a combination of alphanumeric, none-alphanumeric (ex: <, & or /, ...)
ex: "asDd123=%" => good (as 8 char, alphanumeric and non-alphanumeric)
"asgfD" => error (does only have alphabetic letters)
"asdsdf2" => error (missing none-alphanumeric)
"sad_#$" => error (does not have a combination of alphanumeric)
Create a structure called Form
that will have the following fields:
first_name
, that will be a stringlast_name
, that will be a stringbirth
, of typeNaiveDate
that will convert a string "2015-09-05" to a date of that formatsex
, SexType that must be aenum
with the fieldsMale
andFemale
birth_location
, that will be a stringpassword
, that will be a string
You must also implement for this structure a function to initialize the structure, new
and a function called
validate
that will validate the form
For the error type you must create a type struct called FErr
, that will be the type for the error
It must have the fields:
form_values
, this will be a tuple of strings that will save the value that the user inserted into the form
ex: ("password", "asdaSD_") ("first_name", "someone")
date
, that will have the date that the error occurred in the format "2020-12-14 09:33:41"err
, that will have the error description:- "No user name"
- "At least 8 characters"
- "Combination of different ASCII character types (numbers, letters and none alphanumeric characters)"
Notions
Expected Function
pub use chrono::{Utc, NaiveDate};
// this will be the structure that wil handle the errors
#[derive(Debug, Eq, PartialEq)]
pub struct FErr {
// expected public fields
}
impl FErr {
pub fn new(name: String, error: String, err: String) -> FErr {}
}
#[derive(Debug, Eq, PartialEq)]
pub enum SexType {
// expected public fields
}
#[derive(Debug, Eq, PartialEq)]
pub struct Form {
// expected public fields
}
impl Form {
pub fn new(first_name: String,
last_name: String,
birth: NaiveDate,
sex: SexType,
birth_location: String,
password: String) -> Form {}
pub fn validate(&self) -> Result<Vec<&str>, FErr> {}
}
Usage
Here is a program to test your function:
use error_types::*;
fn main() {
let mut form_output = Form::new(
String::from("Alice"),
String::from("Bear"),
create_date("2015-09-05"),
SexType::Male,
String::from("Africa"),
String::from("qwqwsa1dty_"));
println!("{:?}", form_output);
println!("{:?}", form_output.validate().unwrap());
form_output.first_name = String::from("");
println!("{:?}", form_output.validate().unwrap_err());
form_output.first_name = String::from("as");
form_output.password = String::from("dty_1");
println!("{:?}", form_output.validate().unwrap_err());
form_output.password = String::from("asdasASd(_");
println!("{:?}", form_output.validate().unwrap_err());
form_output.password = String::from("asdasASd123SA");
println!("{:?}", form_output.validate().unwrap_err());
}
And its output:
student@ubuntu:~/[[ROOT]]/test$ cargo run
Form { first_name: "Lee", last_name: "Silva", birth: 2015-09-05, sex: Male, birth_location: "Africa", password: "qwqwsa1dty_" }
["Valid first name", "Valid password"]
FErr { form_values: ("first_name", ""), date: "2020-12-28 13:29:11", err: "No user name" }
FErr { form_values: ("password", "dty_1"), date: "2020-12-28 13:29:11", err: "At least 8 characters" }
FErr { form_values: ("password", "asdasASd(_"), date: "2020-12-28 13:29:11", err: "Combination of different ASCII character types (numbers, letters and none alphanumeric characters)" }
FErr { form_values: ("password", "asdasASd123SA"), date: "2020-12-28 13:29:11", err: "Combination of different ASCII character types (numbers, letters and none alphanumeric characters)" }
student@ubuntu:~/[[ROOT]]/test$