tests: convert more tests to utils::make_configs()

There's still some improvements left to be made, but this reduces
a great deal of duplication in the test code.

tests/early-data.rs

@@ -1,14 +1,14 @@
 #![cfg(feature = "early-data")]
 
-use std::io::{self, BufReader, Cursor, Read, Write};
+use std::io::{self, Read, Write};
 use std::net::{SocketAddr, TcpListener};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 use std::thread;
 
 use futures_util::{future::Future, ready};
-use rustls::{self, ClientConfig, RootCertStore, ServerConfig, ServerConnection, Stream};
+use rustls::{self, ClientConfig, ServerConnection, Stream};
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt, ReadBuf};
 use tokio::net::TcpStream;
 use tokio_rustls::{client::TlsStream, TlsConnector};
@@ -65,14 +65,7 @@ async fn test_0rtt_vectored() -> io::Result<()> {
 }
 
 async fn test_0rtt_impl(vectored: bool) -> io::Result<()> {
- let cert_chain = rustls_pemfile::certs(&mut Cursor::new(include_bytes!("certs/end.cert")))
- .collect::<io::Result<Vec<_>>>()?;
- let key_der =
- rustls_pemfile::private_key(&mut Cursor::new(include_bytes!("certs/end.rsa")))?.unwrap();
- let mut server = ServerConfig::builder()
- .with_no_client_auth()
- .with_single_cert(cert_chain, key_der)
- .unwrap();
+ let (mut server, mut client) = utils::make_configs();
  server.max_early_data_size = 8192;
  let server = Arc::new(server);
 
@@ -109,25 +102,15 @@ async fn test_0rtt_impl(vectored: bool) -> io::Result<()> {
  });
  });
 
- let mut chain = BufReader::new(Cursor::new(include_str!("certs/end.chain")));
- let mut root_store = RootCertStore::empty();
- for cert in rustls_pemfile::certs(&mut chain) {
- root_store.add(cert.unwrap()).unwrap();
- }
-
- let mut config =
- rustls::ClientConfig::builder_with_protocol_versions(&[&rustls::version::TLS13])
- .with_root_certificates(root_store)
- .with_no_client_auth();
- config.enable_early_data = true;
- let config = Arc::new(config);
+ client.enable_early_data = true;
+ let client = Arc::new(client);
  let addr = SocketAddr::from(([127, 0, 0, 1], server_port));
 
- let (io, buf) = send(config.clone(), addr, b"hello", vectored).await?;
+ let (io, buf) = send(client.clone(), addr, b"hello", vectored).await?;
  assert!(!io.get_ref().1.is_early_data_accepted());
  assert_eq!("LATE:hello", String::from_utf8_lossy(&buf));
 
- let (io, buf) = send(config, addr, b"world!", vectored).await?;
+ let (io, buf) = send(client, addr, b"world!", vectored).await?;
  assert!(io.get_ref().1.is_early_data_accepted());
  assert_eq!("EARLY:world!LATE:", String::from_utf8_lossy(&buf));
 

tests/test.rs

@@ -1,4 +1,4 @@
-use std::io::{BufReader, Cursor, ErrorKind};
+use std::io::{Cursor, ErrorKind};
 use std::net::SocketAddr;
 use std::sync::mpsc::channel;
 use std::sync::Arc;
@@ -8,31 +8,17 @@ use std::{io, thread};
 use futures_util::future::TryFutureExt;
 use lazy_static::lazy_static;
 use rustls::ClientConfig;
-use rustls_pemfile::{certs, rsa_private_keys};
 use tokio::io::{copy, split, AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::sync::oneshot;
 use tokio::{runtime, time};
 use tokio_rustls::{LazyConfigAcceptor, TlsAcceptor, TlsConnector};
 
-const CERT: &str = include_str!("certs/end.cert");
 const CHAIN: &[u8] = include_bytes!("certs/end.chain");
-const RSA: &str = include_str!("certs/end.rsa");
 
 lazy_static! {
  static ref TEST_SERVER: (SocketAddr, &'static str, &'static [u8]) = {
- let cert = certs(&mut BufReader::new(Cursor::new(CERT)))
- .map(|result| result.unwrap())
- .collect();
- let key = rsa_private_keys(&mut BufReader::new(Cursor::new(RSA)))
- .next()
- .unwrap()
- .unwrap();
-
- let config = rustls::ServerConfig::builder()
- .with_no_client_auth()
- .with_single_cert(cert, key.into())
- .unwrap();
+ let (config, _) = utils::make_configs();
  let acceptor = TlsAcceptor::from(Arc::new(config));
 
  let (send, recv) = channel();
@@ -102,22 +88,15 @@ async fn start_client(addr: SocketAddr, domain: &str, config: Arc<ClientConfig>)
 
 #[tokio::test]
 async fn pass() -> io::Result<()> {
- let (addr, domain, chain) = start_server();
+ let (addr, domain, _) = start_server();
 
  // TODO: not sure how to resolve this right now but since
  // TcpStream::bind now returns a future it creates a race
  // condition until its ready sometimes.
  use std::time::*;
  tokio::time::sleep(Duration::from_secs(1)).await;
 
- let mut root_store = rustls::RootCertStore::empty();
- for cert in certs(&mut std::io::Cursor::new(*chain)) {
- root_store.add(cert.unwrap()).unwrap();
- }
-
- let config = rustls::ClientConfig::builder()
- .with_root_certificates(root_store)
- .with_no_client_auth();
+ let (_, config) = utils::make_configs();
  let config = Arc::new(config);
 
  start_client(*addr, domain, config).await?;
@@ -127,16 +106,9 @@ async fn pass() -> io::Result<()> {
 
 #[tokio::test]
 async fn fail() -> io::Result<()> {
- let (addr, domain, chain) = start_server();
-
- let mut root_store = rustls::RootCertStore::empty();
- for cert in certs(&mut std::io::Cursor::new(*chain)) {
- root_store.add(cert.unwrap()).unwrap();
- }
+ let (addr, domain, _) = start_server();
 
- let config = rustls::ClientConfig::builder()
- .with_root_certificates(root_store)
- .with_no_client_auth();
+ let (_, config) = utils::make_configs();
  let config = Arc::new(config);
 
  assert_ne!(domain, &"google.com");