patchify 0.2.2

Support for running applications to automatically update themselves
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! This module provides methods to create mock responses.
//! 
//! The `Updater` struct is responsible for managing application upgrades by
//! sending HTTP requests to the API server. This module mocks the critical
//! parts of the `reqwest` crate using `sham`, in order to test the `Updater`
//! struct without actually sending requests to the API server. This is
//! important because unit tests should not make actual network requests or rely
//! upon having a real server running.
//! 
//! The approach taken is that the "real" code imports the `Client` from
//! `reqwest` when running in non-test mode, but imports the mocked `Client`
//! when running in test mode. This is achieved by using conditional
//! compilation. The test code then configures the mocks to expect certain
//! requests and to return certain responses, and then runs the tests.
//! 



//		Packages																										

use std::collections::HashMap;
use crate::common::utils::*;
use ed25519_dalek::Signer as _;
use reqwest::{StatusCode, IntoUrl};
use rubedo::{
	crypto::{SigningKey, VerifyingKey},
	sugar::s,
};
use sham::reqwest::{MockError, MockResponse, create_mock_response as create_sham_response};



//		Enums																											

//		ResponseSignature														
#[expect(variant_size_differences, reason = "Doesn't matter here")]
pub enum ResponseSignature {
	Generate,
	GenerateUsing(SigningKey),
	Omit,
	Use(String),
}



//		Functions																										

//		create_mock_response													
pub fn create_mock_response<U: IntoUrl, S: Into<String>>(
	url:          U,
	status:       StatusCode,
	content_type: Option<S>,
	content_len:  Option<usize>,
	body:         Result<&String, MockError>,
	sign:         &ResponseSignature,
) -> (MockResponse, VerifyingKey) {
	let key = match *sign {
		ResponseSignature::GenerateUsing(ref key) => key.clone(),
		ResponseSignature::Generate |
		ResponseSignature::Omit     |
		ResponseSignature::Use(_)   => generate_new_private_key(),
	};
	let signature = match *sign {
		ResponseSignature::GenerateUsing(_) |
		ResponseSignature::Generate           => {
			body.as_ref().map_or_else(|_| s!(""), |b| key.sign(b.as_ref()).to_string())
		},
		ResponseSignature::Omit               => s!(""),
		ResponseSignature::Use(ref other_sig) => other_sig.clone(),
	};
	let mut headers = HashMap::new();
	match *sign {
		ResponseSignature::GenerateUsing(_) |
		ResponseSignature::Generate         |
		ResponseSignature::Use(_)           => drop(headers.insert("X-Signature", signature)),
		ResponseSignature::Omit             => {},
	}
	let mock_response = create_sham_response(
		url,
		status,
		content_type,
		content_len,
		headers,
		match body {
			Ok(b)  => Ok(b.as_bytes()),
			Err(e) => Err(e),
		},
	);
	(mock_response, key.verifying_key())
}

//		create_mock_binary_response												
pub fn create_mock_binary_response<U: IntoUrl, S: Into<String>>(
	url:          U,
	status:       StatusCode,
	content_type: Option<S>,
	content_len:  Option<usize>,
	body:         Result<&[u8], MockError>,
) -> MockResponse {
	create_sham_response(
		url,
		status,
		content_type,
		content_len,
		HashMap::<String, String>::new(),
		body,
	)
}