proptest-http-message 0.1.0

Proptest strategies for generating HTTP request and response messages or individual components components
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

//! host domain strategies.

use proptest::{prop_oneof, strategy::Strategy};

fn alphanumeric_and_hyphen() -> impl Strategy<Value = String> {
  "[a-zA-Z0-9\\-]{0,61}"
}

fn alphanumeric_and_hyphen_ends_with_alphanumeric() -> impl Strategy<Value = String> {
  ((alphanumeric_and_hyphen()), "[a-zA-Z0-9]{1}").prop_map(move |(anh, an)| format!("{anh}{an}"))
}

fn optional_alphanumeric() -> impl Strategy<Value = String> {
  "[a-zA-Z0-9]{0,1}"
}

fn domain_label_remainder() -> impl Strategy<Value = String> {
  prop_oneof![optional_alphanumeric(), alphanumeric_and_hyphen_ends_with_alphanumeric()]
}

/// strategy for generating domain labels.
///
/// a domain is composed of labels separated by period.
pub fn domain_label() -> impl Strategy<Value = String> {
  ("[a-zA-Z]", (domain_label_remainder()))
    .prop_map(move |(a, remainder)| format!("{a}{remainder}"))
    .prop_filter("domain label starts with punycode prefix", |domain| {
      !domain.to_lowercase().starts_with("xn--")
    })
}

/// strategy for generating domains.
///
/// # Arguments
/// * `max_label_count`: the maximum number of labels composing the domain.
pub fn domain(max_label_count: usize) -> impl Strategy<Value = String> {
  ("\\.{0,1}", proptest::collection::vec(domain_label(), 1..=max_label_count))
    .prop_map(move |(root, labels)| format!("{}{}", root, labels.join(".")))
}

#[cfg(test)]
mod tests {
  use claims::{assert_ge, assert_le};
  use proptest::proptest;

  use super::*;

  fn assert_label_is_correct(label: &str) {
    assert_le!(label.len(), 63, "label must be no more than 63 characters but got {label:?}");
    assert_ge!(label.len(), 1, "label must have at least one letter but got {label:?}");
    assert!(
      label.starts_with(|c: char| c.is_ascii_alphabetic()),
      "domain label must start with letter but got {label:?}"
    );

    assert!(
      label.ends_with(|c: char| c.is_ascii_alphanumeric()),
      "domain label must end with alphanumeric but got {label:?}"
    );
    assert!(
      label.chars().all(|c| matches!(c, 'a'..='z'| 'A'..='Z' | '0'..='9' | '-')),
      "domain label must only contain letters, digits and hyphen"
    );
  }

  proptest! {
    #[test]
    fn domain_label_works(label in domain_label()) {
      assert_label_is_correct(&label);
    }

    #[test]
    fn domain_works(domain in domain(12)) {
      assert!(domain.starts_with(|c: char| c.is_ascii_alphabetic() || c == '.'));
      let domain = domain.strip_prefix('.').unwrap_or(&domain);
      for label in domain.split('.') {
        assert_label_is_correct(label);
      }
    }
  }
}