ptth/src/tests.rs

use std::{
	convert::TryFrom,
	sync::{
		Arc,
	},
	time::Duration,
};

use tokio::{
	runtime::Runtime,
	spawn,
	sync::oneshot,
	time::delay_for,
};

#[test]
fn end_to_end () {
	use reqwest::Client;
	use tracing::{debug, info};
	
	// Prefer this form for tests, since all tests share one process
	// and we don't care if another test already installed a subscriber.
	
	tracing_subscriber::fmt ().try_init ().ok ();
	let mut rt = Runtime::new ().expect ("Can't create runtime for testing");
	
	// Spawn the root task
	rt.block_on (async {
		let server_name = "aliens_wildland";
		let api_key = "AnacondaHardcoverGrannyUnlatchLankinessMutate";
		let tripcode = base64::encode (blake3::hash (api_key.as_bytes ()).as_bytes ());
		debug! ("Relay is expecting tripcode {}", tripcode);
		let config_file = ptth_relay::config::file::Config {
			port: None,
			servers: vec! [
				ptth_relay::config::file::Server {
					name: server_name.to_string (),
					tripcode,
					display_name: None,
				},
			],
		};
		
		let config = ptth_relay::config::Config::try_from (config_file).expect ("Can't load config");
		
		let relay_state = Arc::new (ptth_relay::RelayState::try_from (config).expect ("Can't create relay state"));
		
		let relay_state_2 = relay_state.clone ();
		let (stop_relay_tx, stop_relay_rx) = oneshot::channel ();
		let task_relay = spawn (async move {
			ptth_relay::run_relay (relay_state_2, stop_relay_rx, None).await
		});
		
		assert! (relay_state.list_servers ().await.is_empty ());
		
		let relay_url = "http://127.0.0.1:4000";
		
		let config_file = ptth_server::ConfigFile {
			name: server_name.into (),
			api_key: api_key.into (),
			relay_url: "http://127.0.0.1:4000/7ZSFUKGV".into (),
			file_server_root: None,
		};
		
		let (stop_server_tx, stop_server_rx) = oneshot::channel ();
		let task_server = {
			spawn (async move {
				ptth_server::run_server (config_file, stop_server_rx, None, None).await
			})
		};
		
		delay_for (Duration::from_millis (500)).await;
		
		assert_eq! (relay_state.list_servers ().await, vec! [
			server_name.to_string (),
		]);
		
		let client = Client::builder ()
		.timeout (Duration::from_secs (2))
		.build ().expect ("Couldn't build HTTP client");
		
		let resp = client.get (&format! ("{}/frontend/relay_up_check", relay_url))
		.send ().await.expect ("Couldn't check if relay is up").bytes ().await.expect ("Couldn't check if relay is up");
		
		assert_eq! (resp, "Relay is up\n");
		
		let resp = client.get (&format! ("{}/frontend/servers/{}/files/COPYING", relay_url, server_name))
		.send ().await.expect ("Couldn't find license").bytes ().await.expect ("Couldn't find license");
		
		if blake3::hash (&resp) != blake3::Hash::from ([
			0xca, 0x02, 0x92, 0x78,
			0x9c, 0x0a, 0x0e, 0xcb,
			0xa7, 0x06, 0xf4, 0xb3,
			0xf3, 0x49, 0x30, 0x07,
			
			0xa9, 0x95, 0x17, 0x31,
			0xc1, 0xd4, 0x32, 0xc5,
			0x2c, 0x4a, 0xac, 0x1f,
			0x1a, 0xbb, 0xa8, 0xef,
		]) {
			panic! ("{}", String::from_utf8 (resp.to_vec ()).expect ("???"));
		}
		
		// Requesting a file from a server that isn't registered
		// will error out
		
		let resp = client.get (&format! ("{}/frontend/servers/obviously_this_server_does_not_exist/files/COPYING", relay_url))
		.send ().await.expect ("Couldn't send request to bogus server");
		
		assert_eq! (resp.status (), reqwest::StatusCode::NOT_FOUND);
		
		info! ("Shutting down end-to-end test");
		
		stop_server_tx.send (()).expect ("Couldn't shut down server");
		stop_relay_tx.send (()).expect ("Couldn't shut down relay");
		
		info! ("Sent stop messages");
		
		task_relay.await.expect ("Couldn't join relay").expect ("Relay error");
		info! ("Relay stopped");
		
		task_server.await.expect ("Couldn't join server").expect ("Server error");
		info! ("Server stopped");
	});
}