Attempt #2 to fix code coverage with kcov (#33)

* Attempt #2 to fix code coverage with kcov

* Fixed scripts issue

* testing

* typo in travis.yml

* using tarpaulin

* fixed up scripts a bit

* removed unused script

* some code coverage

* testing

* testing

* moar testing

* worktree testing

* worktree testing

* debugging worktree test in CI

* debugging worktree test in CI

* debugging worktree test in CI

* testing refactor

* more testing

* more test coverage

* last test for coverage

* better detached head test

* run against beta, nightly also

Co-authored-by: Jason Ozias <jason.ozias@kroger.com>

.travis.yml

@@ -1,37 +1,20 @@
+dist: bionic
 language: rust
-
+addons:
+    apt:
+        packages:
+            - libssl-dev
+cache: cargo
 rust:
-- stable
-- beta
-- nightly
+  - stable
+  - beta
+  - nightly
 
 os:
-- linux
+  - linux
 
-addons:
-  apt:
-    packages:
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-      - cmake
-      - gcc
-      - binutils-dev
-      - libiberty-dev
+before_script: cargo install cargo-tarpaulin
 
 script: "./scripts/run-tests.sh"
 
-after_success: |
-  wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
-  tar xzf master.tar.gz &&
-  cd kcov-master &&
-  mkdir build &&
-  cd build &&
-  cmake .. &&
-  make &&
-  make install DESTDIR=../../kcov-build &&
-  cd ../.. &&
-  rm -rf kcov-master &&
-  for file in target/debug/build/vergen-*[^\.d]; do mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
-  bash <(curl -s https://codecov.io/bash) &&
-  echo "Uploaded code coverage"
+after_success: cargo tarpaulin --ciserver travis-ci --coveralls $TRAVIS_JOB_ID

README.md

@@ -12,7 +12,7 @@
 | Appveyor     | [![Build status](https://ci.appveyor.com/api/projects/status/fjliwvxqayyecl1j?svg=true)](https://ci.appveyor.com/project/CraZySacX/vergen)|
 
 ## Code Coverage
-[![codecov](https://codecov.io/gh/rustyhorde/vergen/branch/master/graph/badge.svg)](https://codecov.io/gh/rustyhorde/vergen)
+[![Coverage Status](https://coveralls.io/repos/github/rustyhorde/vergen/badge.svg?branch=masterv)](https://coveralls.io/github/rustyhorde/vergen?branch=master)
 
 ## Documentation
 [Documentation](https://docs.rs/vergen)

build.rs

@@ -1,5 +1,3 @@
-extern crate chrono;
-
 pub fn main() {
     let now = chrono::Utc::now();
     println!(

src/output/envvar.rs

@@ -9,8 +9,14 @@
 //! Build time information.
 use crate::constants::ConstantsFlags;
 use crate::output::generate_build_info;
-use std::fs::{self, File};
-use std::io::Read;
+use std::{
+    fs::{self, File},
+    io::Write,
+};
+use std::{
+    io::{self, Read},
+    path::Path,
+};
 use std::{path::PathBuf, process::Command};
 
 use super::Result;
@@ -29,59 +35,76 @@ use super::Result;
 /// # Example `build.rs`
 ///
 /// ```
-/// extern crate vergen;
-///
 /// use vergen::{ConstantsFlags, generate_cargo_keys};
 ///
 /// fn main() {
 ///     generate_cargo_keys(ConstantsFlags::all()).expect("Unable to generate cargo keys!");
 /// }
 /// ```
 pub fn generate_cargo_keys(flags: ConstantsFlags) -> Result<()> {
+    let base = super::run_command(Command::new("git").args(&["rev-parse", "--show-toplevel"]));
+    let mut git_dir_or_file = PathBuf::from(base);
+    git_dir_or_file.push(".git");
+    gen_cargo_keys(
+        &flags,
+        git_dir_or_file,
+        &mut io::stdout(),
+        &mut io::stderr(),
+    )
+}
+
+fn gen_cargo_keys<P, T, E>(
+    flags: &ConstantsFlags,
+    git_path: P,
+    stdout: &mut T,
+    stderr: &mut E,
+) -> Result<()>
+where
+    P: AsRef<Path>,
+    T: Write,
+    E: Write,
+{
     // Generate the build info map.
     let build_info = generate_build_info(flags)?;
 
     // Generate the 'cargo:' key output
     for (k, v) in build_info {
-        println!("cargo:rustc-env={}={}", k.name(), v);
+        writeln!(stdout, "cargo:rustc-env={}={}", k.name(), v)?;
     }
 
-    let base = super::run_command(Command::new("git").args(&["rev-parse", "--show-toplevel"]));
-    let mut git_dir_or_file = PathBuf::from(base);
-    git_dir_or_file.push(".git");
-
-    if let Ok(metadata) = fs::metadata(&git_dir_or_file) {
+    if let Ok(metadata) = fs::symlink_metadata(&git_path) {
         if metadata.is_dir() {
             // Echo the HEAD path
-            let git_head_path = git_dir_or_file.join("HEAD");
-            println!("cargo:rerun-if-changed={}", git_head_path.display());
+            let gp = git_path.as_ref().to_path_buf();
+            let git_head_path = gp.join("HEAD");
+            writeln!(stdout, "cargo:rerun-if-changed={}", git_head_path.display())?;
 
             // Determine where HEAD points and echo that path also.
             let mut f = File::open(&git_head_path)?;
             let mut git_head_contents = String::new();
             let _ = f.read_to_string(&mut git_head_contents)?;
-            eprintln!("HEAD contents: {}", git_head_contents);
+            writeln!(stderr, "HEAD contents: {}", git_head_contents)?;
             let ref_vec: Vec<&str> = git_head_contents.split(": ").collect();
 
             if ref_vec.len() == 2 {
                 let current_head_file = ref_vec[1].trim();
-                let git_refs_path = PathBuf::from(".git").join(current_head_file);
-                println!("cargo:rerun-if-changed={}", git_refs_path.display());
+                let git_refs_path = gp.join(current_head_file);
+                writeln!(stdout, "cargo:rerun-if-changed={}", git_refs_path.display())?;
             } else {
-                eprintln!("You are most likely in a detached HEAD state");
+                writeln!(stderr, "You are most likely in a detached HEAD state")?;
             }
         } else if metadata.is_file() {
             // We are in a worktree, so find out where the actual worktrees/<name>/HEAD file is.
-            let mut git_file = File::open(&git_dir_or_file)?;
+            let mut git_file = File::open(&git_path)?;
             let mut git_contents = String::new();
             let _ = git_file.read_to_string(&mut git_contents)?;
             let dir_vec: Vec<&str> = git_contents.split(": ").collect();
-            eprintln!(".git contents: {}", git_contents);
+            writeln!(stderr, ".git contents: {}", git_contents)?;
             let git_path = dir_vec[1].trim();
 
-            // Echo the HEAD psth
+            // Echo the HEAD path
             let git_head_path = PathBuf::from(git_path).join("HEAD");
-            println!("cargo:rerun-if-changed={}", git_head_path.display());
+            writeln!(stdout, "cargo:rerun-if-changed={}", git_head_path.display())?;
 
             // Find out what the full path to the .git dir is.
             let mut actual_git_dir = PathBuf::from(git_path);
@@ -92,22 +115,136 @@ pub fn generate_cargo_keys(flags: ConstantsFlags) -> Result<()> {
             let mut f = File::open(&git_head_path)?;
             let mut git_head_contents = String::new();
             let _ = f.read_to_string(&mut git_head_contents)?;
-            eprintln!("HEAD contents: {}", git_head_contents);
+            writeln!(stderr, "HEAD contents: {}", git_head_contents)?;
             let ref_vec: Vec<&str> = git_head_contents.split(": ").collect();
 
             if ref_vec.len() == 2 {
                 let current_head_file = ref_vec[1].trim();
                 let git_refs_path = actual_git_dir.join(current_head_file);
-                println!("cargo:rerun-if-changed={}", git_refs_path.display());
+                writeln!(stdout, "cargo:rerun-if-changed={}", git_refs_path.display())?;
             } else {
-                eprintln!("You are most likely in a detached HEAD state");
+                writeln!(stderr, "You are most likely in a detached HEAD state")?;
             }
         } else {
             return Err("Invalid .git format (Not a directory or a file)".into());
         };
     } else {
-        eprintln!("Unable to generate 'cargo:rerun-if-changed'");
+        writeln!(stderr, "Unable to generate 'cargo:rerun-if-changed'")?;
     }
 
     Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use super::{gen_cargo_keys, generate_cargo_keys};
+    use crate::constants::ConstantsFlags;
+
+    #[test]
+    fn pub_api() {
+        assert!(generate_cargo_keys(ConstantsFlags::all()).is_ok());
+    }
+
+    #[test]
+    fn gitdir() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "testdata/gitdir",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_ok());
+        let stdout = String::from_utf8_lossy(&buf_stdout);
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/gitdir/HEAD"));
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/gitdir/kcov"));
+    }
+
+    #[test]
+    fn detached_gitdir() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "testdata/gitdir2",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_ok());
+        let stdout = String::from_utf8_lossy(&buf_stdout);
+        let stderr = String::from_utf8_lossy(&buf_stderr);
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/gitdir2/HEAD"));
+        assert!(stderr.contains("You are most likely in a detached HEAD state"));
+    }
+
+    #[test]
+    fn worktree() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "testdata/blahgit",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_ok());
+
+        let stdout = String::from_utf8_lossy(&buf_stdout);
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/blah/worktrees/vergen-1/HEAD"));
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/blah/refs/heads/vergen-1"));
+    }
+
+    #[test]
+    fn detached_worktree() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "testdata/blahgit2",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_ok());
+
+        let stdout = String::from_utf8_lossy(&buf_stdout);
+        let stderr = String::from_utf8_lossy(&buf_stderr);
+        assert!(stdout.contains("cargo:rerun-if-changed=testdata/blah2/worktrees/vergen-1/HEAD"));
+        assert!(stderr.contains("You are most likely in a detached HEAD state"));
+    }
+
+    #[test]
+    fn error_on_symlink() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "testdata/badgit",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn invalid_file() {
+        let mut buf_stdout = Vec::new();
+        let mut buf_stderr = Vec::new();
+
+        assert!(gen_cargo_keys(
+            &ConstantsFlags::all(),
+            "xxxxzzzyyy",
+            &mut buf_stdout,
+            &mut buf_stderr,
+        )
+        .is_ok());
+
+        let stderr = String::from_utf8_lossy(&buf_stderr);
+        assert!(stderr.contains("Unable to generate 'cargo:rerun-if-changed'"));
+    }
+}