perimeterx-fastly-enforcer 2.2.2

PerimeterX Fastly Compute@Edge Rust Enforcer
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
93
94
95

use crate::pxcontext::{BlockReason, PXModuleMode};
use crate::pxenforce::*;

fn enforcer_with_mode(mode: PXModuleMode) -> PXEnforcer {
    let mut enforcer = PXEnforcer::default();
    enforcer.conf.module_mode = mode;
    enforcer.ctx.risk_mode = mode;
    enforcer
}

#[test]
fn active_blocking_real_block_keeps_simulated_block_false() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Blocking);
    enforcer.ctx.block_reason = Some(BlockReason::ServerScore);
    enforcer.ctx.is_monitored_request = false;

    enforcer.apply_simulated_block_flag();

    assert!(!enforcer.ctx.is_simulated_block);
}

#[test]
fn active_blocking_cookie_score_block_keeps_simulated_block_false() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Blocking);
    enforcer.ctx.block_reason = Some(BlockReason::CookieScore);
    enforcer.ctx.is_monitored_request = false;

    enforcer.apply_simulated_block_flag();

    assert!(!enforcer.ctx.is_simulated_block);
}

#[test]
fn monitor_mode_cookie_score_block_marks_simulated_block_true() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Monitor);
    enforcer.ctx.block_reason = Some(BlockReason::CookieScore);
    enforcer.ctx.is_monitored_request = false;

    enforcer.apply_simulated_block_flag();

    assert!(enforcer.ctx.is_simulated_block);
}

#[test]
fn monitor_mode_server_score_block_marks_simulated_block_true() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Monitor);
    enforcer.ctx.block_reason = Some(BlockReason::ServerScore);
    enforcer.ctx.is_monitored_request = false;

    enforcer.apply_simulated_block_flag();

    assert!(enforcer.ctx.is_simulated_block);
}

#[test]
fn monitor_mode_enforced_request_keeps_simulated_block_false() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Monitor);
    enforcer.ctx.block_reason = Some(BlockReason::ServerScore);
    enforcer.ctx.is_enforced_request = true;

    enforcer.apply_simulated_block_flag();

    assert!(!enforcer.ctx.is_simulated_block);
}

#[test]
fn set_is_enforced_request_fn_stores_callback() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Monitor);
    assert!(enforcer.conf.is_enforced_request_fn.is_none());

    enforcer.set_is_enforced_request_fn(|_req, _conf| true);

    assert!(enforcer.conf.is_enforced_request_fn.is_some());
}

#[test]
fn set_is_monitored_request_fn_stores_callback() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Blocking);
    assert!(enforcer.conf.is_monitored_request_fn.is_none());

    enforcer.set_is_monitored_request_fn(|_req, _conf| true);

    assert!(enforcer.conf.is_monitored_request_fn.is_some());
}

#[test]
fn active_blocking_monitored_request_marks_simulated_block_true() {
    let mut enforcer = enforcer_with_mode(PXModuleMode::Blocking);
    enforcer.ctx.block_reason = Some(BlockReason::ServerScore);
    enforcer.ctx.is_monitored_request = true;

    enforcer.apply_simulated_block_flag();

    assert!(enforcer.ctx.is_simulated_block);
}