Now let's take a silly one
1mod clock;
2mod entropy;
3mod http;
4mod signer;
5
6pub use clock::{Clock, ManualClock, SystemClock, UnixMicros};
7pub use entropy::{Entropy, OsEntropy, SeededEntropy};
8pub use http::{
9 FakeHttp, HttpFuture, HttpLimits, HttpRequest, HttpResponse, HttpTransport, NetworkError,
10 ReqwestHttp, is_blocked_ip,
11};
12pub use signer::{
13 K256Signer, MAX_SCALAR_ATTEMPTS, PublicKeyBytes, Signature, SignatureScheme, Signer,
14 SignerError, verify,
15};
16
17#[cfg(test)]
18mod contract {
19 use super::*;
20
21 fn clock_contract(clock: &dyn Clock) {
22 let first = clock.now_unix_micros();
23 let second = clock.now_unix_micros();
24 assert!(second >= first);
25 }
26
27 #[test]
28 fn every_clock_is_non_decreasing() {
29 clock_contract(&SystemClock);
30 clock_contract(&ManualClock::new(UnixMicros::new(1_000)));
31 }
32
33 fn entropy_contract(entropy: &dyn Entropy) {
34 let mut buffer = [0u8; 16];
35 entropy.fill(&mut buffer);
36 assert!(buffer.iter().any(|byte| *byte != 0));
37 entropy.fill(&mut []);
38 let _ = entropy.next_u64();
39 }
40
41 #[test]
42 fn every_entropy_produces_output() {
43 entropy_contract(&OsEntropy);
44 entropy_contract(&SeededEntropy::new(1));
45 }
46
47 fn signer_contract(signer: &dyn Signer) {
48 let signature = signer.sign(b"the message");
49 assert!(verify(&signer.public_key(), b"the message", &signature));
50 assert!(!verify(
51 &signer.public_key(),
52 b"another message",
53 &signature
54 ));
55 }
56
57 #[test]
58 fn the_seeded_signer_is_the_test_double() {
59 signer_contract(&K256Signer::generate(&SeededEntropy::new(3)));
60 }
61
62 fn ok_response() -> HttpResponse {
63 HttpResponse {
64 status: ::http::StatusCode::OK,
65 headers: ::http::HeaderMap::new(),
66 body: bytes::Bytes::from_static(b"ok"),
67 }
68 }
69
70 #[test]
71 fn http_transport_surfaces_ok_and_typed_error() {
72 let url = url::Url::parse("https://oyster.cafe/").unwrap();
73 let okay = FakeHttp::new(|_| Ok(ok_response()));
74 let response =
75 futures::executor::block_on(okay.execute(HttpRequest::get(url.clone()))).unwrap();
76 assert_eq!(response.body.as_ref(), b"ok");
77
78 let failing = FakeHttp::new(|_| Err(NetworkError::Timeout("slow".to_string())));
79 let error =
80 futures::executor::block_on(failing.execute(HttpRequest::get(url))).unwrap_err();
81 assert!(matches!(error, NetworkError::Timeout(_)));
82 }
83}