Fix code coverage analysis in CI (#351)

Fix code coverage step in CI erroring. It seems like the primary issue here is Tarpaulin is trying to run doc tests annotated with `no_run`, which aren't necessarily designed to pass. Just disable doc tests in Tarpaulin to work around this since they don't contribute much to the overall code coverage anyway. I suspect a new Cargo or Rust version at some point caused this issue.

See also xd009642/tarpaulin#848.

.github/workflows/ci.yml

@@ -64,8 +64,8 @@ jobs:
  - name: Generate code coverage report
  uses: actions-rs/[email protected]
  with:
- version: '0.16.0'
- args: "-p isahc --run-types Doctests Tests --features ${{ env.FEATURES }}"
+ version: '0.18.2'
+ args: "-p isahc --run-types Tests --features ${{ env.FEATURES }}"
 
  - name: Upload coverage to Codecov
  uses: codecov/codecov-action@v1

examples/head_length.rs

@@ -0,0 +1,13 @@
+use std::io::Cursor;
+
+use isahc::{Body, Request};
+
+fn main() -> Result<(), isahc::Error> {
+ let weird_request = Request::head("http:https://download.opensuse.org/update/tumbleweed/repodata/repomd.xml")
+ .body(Body::from_reader(Cursor::new(b"")))?;
+
+ let error = isahc::send(weird_request).unwrap_err();
+ eprintln!("{}", error);
+
+ Ok(())
+}

examples/spurious_abort_logs.rs

@@ -0,0 +1,50 @@
+use std::{error::Error, io, time::Duration};
+
+use isahc::{
+ config::{Configurable, RedirectPolicy},
+ Request,
+ RequestExt,
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+ env_logger::init();
+
+ read_url("https://tynan.com/feed/")?;
+
+ Ok(())
+}
+
+pub fn read_url(url: &str) -> Result<Vec<u8>, String> {
+ let client = match Request::get(url)
+ .timeout(Duration::from_secs(5))
+ .header("User-Agent", "el_monitorro/0.1.0")
+ .redirect_policy(RedirectPolicy::Limit(10))
+ .body(())
+ {
+ Ok(cl) => cl,
+ Err(er) => {
+ let msg = format!("{:?}", er);
+
+ return Err(msg);
+ }
+ };
+
+ match client.send() {
+ Ok(mut response) => {
+ let mut writer: Vec<u8> = vec![];
+
+ if let Err(err) = io::copy(response.body_mut(), &mut writer) {
+ let msg = format!("{:?}", err);
+
+ return Err(msg);
+ }
+
+ Ok(writer)
+ }
+ Err(error) => {
+ let msg = format!("{:?}", error);
+
+ Err(msg)
+ }
+ }
+}

testserver/src/server.rs

@@ -0,0 +1,111 @@
+use std::{io::{BufRead, BufReader, Read, Result}, net::TcpListener};
+
+use httparse::parse_headers;
+
+pub(crate) struct Server {
+ listener: TcpListener,
+}
+
+impl Server {
+ pub(crate) fn accept(&mut self) -> Result<Connection> {
+ let (stream, addr) = self.listener.accept()?;
+
+ let mut reader = GrowableBufReader::new(stream);
+ let mut headers = [httparse::EMPTY_HEADER; 16];
+ let mut request = httparse::Request::new(&mut headers);
+
+ loop {
+ reader.fill_buf_additional(8192)?;
+
+ let result = request.parse(reader.buffer());
+ match result {
+ Ok(httparse::Status::Partial) => continue,
+ Ok(httparse::Status::Complete(offset)) => {
+ reader.consume(offset);
+ },
+ Err(_) => unimplemented!(),
+ }
+ }
+
+ unimplemented!()
+ }
+}
+
+pub(crate) struct Connection {
+
+}
+
+struct GrowableBufReader<R: Read> {
+ inner: R,
+ buffer: Vec<u8>,
+ low: usize,
+ high: usize,
+}
+
+impl<R: Read> GrowableBufReader<R> {
+ fn new(inner: R) -> Self {
+ Self {
+ inner,
+ buffer: Vec::with_capacity(8192),
+ low: 0,
+ high: 0,
+ }
+ }
+
+ #[inline]
+ fn available(&self) -> usize {
+ self.high - self.low
+ }
+
+ #[inline]
+ fn buffer(&self) -> &[u8] {
+ &self.buffer[self.low..self.high]
+ }
+
+ fn fill_buf_additional(&mut self, max: usize) -> Result<usize> {
+ self.reserve(max);
+ let amt = self.inner.read(&mut self.buffer[self.high..])?;
+ self.high += amt;
+
+ Ok(amt)
+ }
+
+ fn reserve(&mut self, capacity: usize) {
+ let desired_buffer_size = self.high + capacity;
+
+ if self.buffer.len() < desired_buffer_size {
+ self.buffer.resize(desired_buffer_size, 0);
+ }
+ }
+}
+
+impl<R: Read> BufRead for GrowableBufReader<R> {
+ fn fill_buf(&mut self) -> Result<&[u8]> {
+ if self.available() == 0 {
+ self.fill_buf_additional(8192)?;
+ }
+
+ Ok(self.buffer())
+ }
+
+ fn consume(&mut self, amt: usize) {
+ if amt >= self.available() {
+ self.low = 0;
+ self.high = 0;
+ self.buffer.clear();
+ } else {
+ self.low += amt;
+ }
+ }
+}
+
+impl<R: Read> Read for GrowableBufReader<R> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+ let src = self.fill_buf()?;
+ let amt = buf.len().min(src.len());
+ buf[..amt].copy_from_slice(&src[..amt]);
+ self.consume(amt);
+
+ Ok(amt)
+ }
+}