rustauth-core 0.2.0

Core types and primitives for RustAuth.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use rustauth_core::db::{IdGeneration, IdPolicy, IdValue};

#[test]
fn id_policy_defaults_to_required_string_id() {
    let field = IdPolicy::default().field();

    assert!(field.required);
    assert_eq!(field.field_type, rustauth_core::db::DbFieldType::String);
}

#[test]
fn id_policy_uses_number_for_serial_ids() {
    let field = IdPolicy::new(IdGeneration::Serial).field();

    assert!(!field.required);
    assert_eq!(field.field_type, rustauth_core::db::DbFieldType::Number);
    assert_eq!(field.generated_id, Some(IdGeneration::Serial));
}

#[test]
fn id_policy_disables_required_id_when_generation_is_disabled() {
    let field = IdPolicy::new(IdGeneration::Disabled).field();

    assert!(!field.required);
    assert_eq!(field.generated_id, Some(IdGeneration::Disabled));
}

#[test]
fn id_policy_marks_database_uuid_generation_when_supported() {
    let field = IdPolicy::new(IdGeneration::Uuid)
        .with_database_uuid_support(true)
        .field();

    assert!(!field.required);
    assert_eq!(field.generated_id, Some(IdGeneration::Uuid));
}

#[test]
fn id_policy_converts_serial_input_to_number() {
    let policy = IdPolicy::new(IdGeneration::Serial);

    assert_eq!(
        policy.transform_input(Some("42")),
        Some(IdValue::Number(42))
    );
}

#[test]
fn id_policy_drops_invalid_serial_input() {
    let policy = IdPolicy::new(IdGeneration::Serial);

    assert_eq!(policy.transform_input(Some("not-a-number")), None);
}

#[test]
fn id_policy_drops_uuid_input_when_database_generates_uuid() {
    let policy = IdPolicy::new(IdGeneration::Uuid).with_database_uuid_support(true);

    assert_eq!(
        policy.transform_input(Some("550e8400-e29b-41d4-a716-446655440000")),
        None
    );
}

#[test]
fn id_policy_accepts_uuid_input_when_force_allow_id_is_true() {
    let policy = IdPolicy::new(IdGeneration::Uuid).with_force_allow_id(true);

    assert_eq!(
        policy.transform_input(Some("550e8400-e29b-41d4-a716-446655440000")),
        Some(IdValue::String(
            "550e8400-e29b-41d4-a716-446655440000".to_owned()
        ))
    );
}

#[test]
fn id_policy_drops_invalid_uuid_input_when_force_allow_id_is_true() {
    let policy = IdPolicy::new(IdGeneration::Uuid).with_force_allow_id(true);

    assert_eq!(policy.transform_input(Some("invalid")), None);
}

#[test]
fn id_policy_outputs_values_as_strings() {
    let policy = IdPolicy::default();

    assert_eq!(
        policy.transform_output(Some(IdValue::Number(123))),
        Some("123".to_owned())
    );
}