Integration tests now automatically test with parallel feature

Author: sirno

src/main.rs

@@ -26,113 +26,117 @@ fn main() {
     runner.start();
 }
 
-/// TODO: These tests should run for multiple feature flags
 #[cfg(test)]
 mod tests {
     use std::process::Command;
 
-    struct Cleanup<'a> {
+    /// Create a temporary directory for testing and clean it up after the test
+    struct TmpDir<'a> {
         dir: &'a str,
     }
 
-    impl<'a> Drop for Cleanup<'a> {
+    impl<'a> TmpDir<'a> {
+        fn new(dir: &'a str) -> Self {
+            std::fs::create_dir(dir).unwrap();
+            TmpDir { dir }
+        }
+    }
+
+    impl<'a> Drop for TmpDir<'a> {
         fn drop(&mut self) {
             std::fs::remove_dir_all(self.dir).unwrap();
         }
     }
 
+    #[cfg(feature = "parallel")]
+    static RUN_CMD: [&str; 4] = ["run", "--features", "parallel", "--"];
+
+    #[cfg(not(feature = "parallel"))]
+    static RUN_CMD: [&str; 2] = ["run", "--"];
+
+    static DEFAULT_ARGS: [&str; 5] = [
+        "--disable-progress-bar",
+        "--n-compartments",
+        "2",
+        "--generations",
+        "1",
+    ];
+
     /// Test invocation of program for singlehost setup with 1 generation
     #[test]
     fn test_singlehost() {
-        let tmp_dir = ".tmp_singlehost";
-        let _cleanup = Cleanup { dir: tmp_dir };
+        let tmp = TmpDir::new(".tmp_singlehost");
         let output = Command::new("cargo")
+            .args(RUN_CMD)
+            .args(DEFAULT_ARGS)
             .args([
-                "run",
-                "--",
-                "--disable-progress-bar",
                 "--settings",
-                "test/singlehost/singlehost.yaml",
+                "tests/singlehost/singlehost.yaml",
                 "--sequence",
-                "test/singlehost/ref.fasta",
-                "--generations",
-                "1",
-                "--n-compartments",
-                "2",
+                "tests/singlehost/ref.fasta",
                 "--outdir",
-                tmp_dir,
+                tmp.dir,
             ])
             .output()
             .expect("Failed to execute command");
 
         assert!(output.status.success());
 
         // Check if output files are created
-        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp_dir)).exists());
-        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp_dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp.dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp.dir)).exists());
     }
 
     /// Test invocation of program for multihost setup with 1 generation
     #[test]
     fn test_multihost() {
-        let tmp_dir = ".tmp_multihost";
-        let _cleanup = Cleanup { dir: tmp_dir };
+        let tmp = TmpDir::new(".tmp_multihost");
 
         let output = Command::new("cargo")
+            .args(RUN_CMD)
+            .args(DEFAULT_ARGS)
             .args([
-                "run",
-                "--",
-                "--disable-progress-bar",
                 "--settings",
-                "test/multihost/multihost.yaml",
+                "tests/multihost/multihost.yaml",
                 "--sequence",
-                "test/multihost/ref.fasta",
-                "--generations",
-                "1",
-                "--n-compartments",
-                "2",
+                "tests/multihost/ref.fasta",
                 "--outdir",
-                tmp_dir,
+                tmp.dir,
             ])
             .output()
             .expect("Failed to execute command");
 
         assert!(output.status.success());
 
         // Check if output files are created
-        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp_dir)).exists());
-        assert!(std::path::Path::new(&format!("{}/fitness_table_1.npy", tmp_dir)).exists());
-        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp_dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp.dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/fitness_table_1.npy", tmp.dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp.dir)).exists());
     }
 
     /// Test invocation of program for epistasis setup with 1 generation
     #[test]
     fn test_epistasis() {
-        let tmp_dir = ".tmp_epistasis";
+        let tmp = TmpDir::new(".tmp_epistasis");
         let output = Command::new("cargo")
+            .args(RUN_CMD)
+            .args(DEFAULT_ARGS)
             .args([
-                "run",
-                "--",
-                "--disable-progress-bar",
                 "--settings",
-                "test/epistasis/epistasis.yaml",
+                "tests/epistasis/epistasis.yaml",
                 "--sequence",
-                "test/epistasis/ref.fasta",
-                "--generations",
-                "1",
-                "--n-compartments",
-                "2",
+                "tests/epistasis/ref.fasta",
                 "--outdir",
-                tmp_dir,
+                tmp.dir,
             ])
             .output()
             .expect("Failed to execute command");
 
         assert!(output.status.success());
 
         // Check if output files are created
-        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp_dir)).exists());
-        assert!(std::path::Path::new(&format!("{}/epistasis_table_0.npy", tmp_dir)).exists());
-        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp_dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/fitness_table_0.npy", tmp.dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/epistasis_table_0.npy", tmp.dir)).exists());
+        assert!(std::path::Path::new(&format!("{}/virolution.log", tmp.dir)).exists());
     }
 }

tests/epistasis/epistasis.yaml

@@ -0,0 +1,38 @@
+parameters:
+  - mutation_rate: 1e-6
+    recombination_rate: 0
+    host_population_size: 100000
+    infection_fraction: 0.7
+    basic_reproductive_number: 100.0
+    max_population: 100000
+    dilution: 0.02
+    substitution_matrix:
+      - - 0.0
+        - 1.0
+        - 1.0
+        - 1.0
+      - - 1.0
+        - 0.0
+        - 1.0
+        - 1.0
+      - - 1.0
+        - 1.0
+        - 0.0
+        - 1.0
+      - - 1.0
+        - 1.0
+        - 1.0
+        - 0.0
+    fitness_model: !SingleHost
+      distribution: !Epistatic
+        path: fitness_table.npy
+        epi_path: epistasis_table.npy
+      utility: !Algebraic
+        upper: 1.5
+schedule:
+  - generation: "{} % 1"
+    event: transmission
+    value: "[[0.9, 0.1], [0.1, 0.9]]"
+  - generation: "{} % 200"
+    event: sample
+    value: 1000

tests/epistasis/epistasis_table.npy

@@ -0,0 +1,78 @@
+>NC_001422.1 Enterobacteria phage phiX174 sensu lato, complete genome
+GAGTTTTATCGCTTCCATGACGCAGAAGTTAACACTTTCGGATATTTCTGATGAGTCGAAAAATTATCTT
+GATAAAGCAGGAATTACTACTGCTTGTTTACGAATTAAATCGAAGTGGACTGCTGGCGGAAAATGAGAAA
+ATTCGACCTATCCTTGCGCAGCTCGAGAAGCTCTTACTTTGCGACCTTTCGCCATCAACTAACGATTCTG
+TCAAAAACTGACGCGTTGGATGAGGAGAAGTGGCTTAATATGCTTGGCACGTTCGTCAAGGACTGGTTTA
+GATATGAGTCACATTTTGTTCATGGTAGAGATTCTCTTGTTGACATTTTAAAAGAGCGTGGATTACTATC
+TGAGTCCGATGCTGTTCAACCACTAATAGGTAAGAAATCATGAGTCAAGTTACTGAACAATCCGTACGTT
+TCCAGACCGCTTTGGCCTCTATTAAGCTCATTCAGGCTTCTGCCGTTTTGGATTTAACCGAAGATGATTT
+CGATTTTCTGACGAGTAACAAAGTTTGGATTGCTACTGACCGCTCTCGTGCTCGTCGCTGCGTTGAGGCT
+TGCGTTTATGGTACGCTGGACTTTGTGGGATACCCTCGCTTTCCTGCTCCTGTTGAGTTTATTGCTGCCG
+TCATTGCTTATTATGTTCATCCCGTCAACATTCAAACGGCCTGTCTCATCATGGAAGGCGCTGAATTTAC
+GGAAAACATTATTAATGGCGTCGAGCGTCCGGTTAAAGCCGCTGAATTGTTCGCGTTTACCTTGCGTGTA
+CGCGCAGGAAACACTGACGTTCTTACTGACGCAGAAGAAAACGTGCGTCAAAAATTACGTGCGGAAGGAG
+TGATGTAATGTCTAAAGGTAAAAAACGTTCTGGCGCTCGCCCTGGTCGTCCGCAGCCGTTGCGAGGTACT
+AAAGGCAAGCGTAAAGGCGCTCGTCTTTGGTATGTAGGTGGTCAACAATTTTAATTGCAGGGGCTTCGGC
+CCCTTACTTGAGGATAAATTATGTCTAATATTCAAACTGGCGCCGAGCGTATGCCGCATGACCTTTCCCA
+TCTTGGCTTCCTTGCTGGTCAGATTGGTCGTCTTATTACCATTTCAACTACTCCGGTTATCGCTGGCGAC
+TCCTTCGAGATGGACGCCGTTGGCGCTCTCCGTCTTTCTCCATTGCGTCGTGGCCTTGCTATTGACTCTA
+CTGTAGACATTTTTACTTTTTATGTCCCTCATCGTCACGTTTATGGTGAACAGTGGATTAAGTTCATGAA
+GGATGGTGTTAATGCCACTCCTCTCCCGACTGTTAACACTACTGGTTATATTGACCATGCCGCTTTTCTT
+GGCACGATTAACCCTGATACCAATAAAATCCCTAAGCATTTGTTTCAGGGTTATTTGAATATCTATAACA
+ACTATTTTAAAGCGCCGTGGATGCCTGACCGTACCGAGGCTAACCCTAATGAGCTTAATCAAGATGATGC
+TCGTTATGGTTTCCGTTGCTGCCATCTCAAAAACATTTGGACTGCTCCGCTTCCTCCTGAGACTGAGCTT
+TCTCGCCAAATGACGACTTCTACCACATCTATTGACATTATGGGTCTGCAAGCTGCTTATGCTAATTTGC
+ATACTGACCAAGAACGTGATTACTTCATGCAGCGTTACCATGATGTTATTTCTTCATTTGGAGGTAAAAC
+CTCTTATGACGCTGACAACCGTCCTTTACTTGTCATGCGCTCTAATCTCTGGGCATCTGGCTATGATGTT
+GATGGAACTGACCAAACGTCGTTAGGCCAGTTTTCTGGTCGTGTTCAACAGACCTATAAACATTCTGTGC
+CGCGTTTCTTTGTTCCTGAGCATGGCACTATGTTTACTCTTGCGCTTGTTCGTTTTCCGCCTACTGCGAC
+TAAAGAGATTCAGTACCTTAACGCTAAAGGTGCTTTGACTTATACCGATATTGCTGGCGACCCTGTTTTG
+TATGGCAACTTGCCGCCGCGTGAAATTTCTATGAAGGATGTTTTCCGTTCTGGTGATTCGTCTAAGAAGT
+TTAAGATTGCTGAGGGTCAGTGGTATCGTTATGCGCCTTCGTATGTTTCTCCTGCTTATCACCTTCTTGA
+AGGCTTCCCATTCATTCAGGAACCGCCTTCTGGTGATTTGCAAGAACGCGTACTTATTCGCCACCATGAT
+TATGACCAGTGTTTCCAGTCCGTTCAGTTGTTGCAGTGGAATAGTCAGGTTAAATTTAATGTGACCGTTT
+ATCGCAATCTGCCGACCACTCGCGATTCAATCATGACTTCGTGATAAAAGATTGAGTGTGAGGTTATAAC
+GCCGAAGCGGTAAAAATTTTAATTTTTGCCGCTGAGGGGTTGACCAAGCGAAGCGCGGTAGGTTTTCTGC
+TTAGGAGTTTAATCATGTTTCAGACTTTTATTTCTCGCCATAATTCAAACTTTTTTTCTGATAAGCTGGT
+TCTCACTTCTGTTACTCCAGCTTCTTCGGCACCTGTTTTACAGACACCTAAAGCTACATCGTCAACGTTA
+TATTTTGATAGTTTGACGGTTAATGCTGGTAATGGTGGTTTTCTTCATTGCATTCAGATGGATACATCTG
+TCAACGCCGCTAATCAGGTTGTTTCTGTTGGTGCTGATATTGCTTTTGATGCCGACCCTAAATTTTTTGC
+CTGTTTGGTTCGCTTTGAGTCTTCTTCGGTTCCGACTACCCTCCCGACTGCCTATGATGTTTATCCTTTG
+AATGGTCGCCATGATGGTGGTTATTATACCGTCAAGGACTGTGTGACTATTGACGTCCTTCCCCGTACGC
+CGGGCAATAACGTTTATGTTGGTTTCATGGTTTGGTCTAACTTTACCGCTACTAAATGCCGCGGATTGGT
+TTCGCTGAATCAGGTTATTAAAGAGATTATTTGTCTCCAGCCACTTAAGTGAGGTGATTTATGTTTGGTG
+CTATTGCTGGCGGTATTGCTTCTGCTCTTGCTGGTGGCGCCATGTCTAAATTGTTTGGAGGCGGTCAAAA
+AGCCGCCTCCGGTGGCATTCAAGGTGATGTGCTTGCTACCGATAACAATACTGTAGGCATGGGTGATGCT
+GGTATTAAATCTGCCATTCAAGGCTCTAATGTTCCTAACCCTGATGAGGCCGCCCCTAGTTTTGTTTCTG
+GTGCTATGGCTAAAGCTGGTAAAGGACTTCTTGAAGGTACGTTGCAGGCTGGCACTTCTGCCGTTTCTGA
+TAAGTTGCTTGATTTGGTTGGACTTGGTGGCAAGTCTGCCGCTGATAAAGGAAAGGATACTCGTGATTAT
+CTTGCTGCTGCATTTCCTGAGCTTAATGCTTGGGAGCGTGCTGGTGCTGATGCTTCCTCTGCTGGTATGG
+TTGACGCCGGATTTGAGAATCAAAAAGAGCTTACTAAAATGCAACTGGACAATCAGAAAGAGATTGCCGA
+GATGCAAAATGAGACTCAAAAAGAGATTGCTGGCATTCAGTCGGCGACTTCACGCCAGAATACGAAAGAC
+CAGGTATATGCACAAAATGAGATGCTTGCTTATCAACAGAAGGAGTCTACTGCTCGCGTTGCGTCTATTA
+TGGAAAACACCAATCTTTCCAAGCAACAGCAGGTTTCCGAGATTATGCGCCAAATGCTTACTCAAGCTCA
+AACGGCTGGTCAGTATTTTACCAATGACCAAATCAAAGAAATGACTCGCAAGGTTAGTGCTGAGGTTGAC
+TTAGTTCATCAGCAAACGCAGAATCAGCGGTATGGCTCTTCTCATATTGGCGCTACTGCAAAGGATATTT
+CTAATGTCGTCACTGATGCTGCTTCTGGTGTGGTTGATATTTTTCATGGTATTGATAAAGCTGTTGCCGA
+TACTTGGAACAATTTCTGGAAAGACGGTAAAGCTGATGGTATTGGCTCTAATTTGTCTAGGAAATAACCG
+TCAGGATTGACACCCTCCCAATTGTATGTTTTCATGCCTCCAAATCTTGGAGGCTTTTTTATGGTTCGTT
+CTTATTACCCTTCTGAATGTCACGCTGATTATTTTGACTTTGAGCGTATCGAGGCTCTTAAACCTGCTAT
+TGAGGCTTGTGGCATTTCTACTCTTTCTCAATCCCCAATGCTTGGCTTCCATAAGCAGATGGATAACCGC
+ATCAAGCTCTTGGAAGAGATTCTGTCTTTTCGTATGCAGGGCGTTGAGTTCGATAATGGTGATATGTATG
+TTGACGGCCATAAGGCTGCTTCTGACGTTCGTGATGAGTTTGTATCTGTTACTGAGAAGTTAATGGATGA
+ATTGGCACAATGCTACAATGTGCTCCCCCAACTTGATATTAATAACACTATAGACCACCGCCCCGAAGGG
+GACGAAAAATGGTTTTTAGAGAACGAGAAGACGGTTACGCAGTTTTGCCGCAAGCTGGCTGCTGAACGCC
+CTCTTAAGGATATTCGCGATGAGTATAATTACCCCAAAAAGAAAGGTATTAAGGATGAGTGTTCAAGATT
+GCTGGAGGCCTCCACTATGAAATCGCGTAGAGGCTTTGCTATTCAGCGTTTGATGAATGCAATGCGACAG
+GCTCATGCTGATGGTTGGTTTATCGTTTTTGACACTCTCACGTTGGCTGACGACCGATTAGAGGCGTTTT
+ATGATAATCCCAATGCTTTGCGTGACTATTTTCGTGATATTGGTCGTATGGTTCTTGCTGCCGAGGGTCG
+CAAGGCTAATGATTCACACGCCGACTGCTATCAGTATTTTTGTGTGCCTGAGTATGGTACAGCTAATGGC
+CGTCTTCATTTCCATGCGGTGCACTTTATGCGGACACTTCCTACAGGTAGCGTTGACCCTAATTTTGGTC
+GTCGGGTACGCAATCGCCGCCAGTTAAATAGCTTGCAAAATACGTGGCCTTATGGTTACAGTATGCCCAT
+CGCAGTTCGCTACACGCAGGACGCTTTTTCACGTTCTGGTTGGTTGTGGCCTGTTGATGCTAAAGGTGAG
+CCGCTTAAAGCTACCAGTTATATGGCTGTTGGTTTCTATGTGGCTAAATACGTTAACAAAAAGTCAGATA
+TGGACCTTGCTGCTAAAGGTCTAGGAGCTAAAGAATGGAACAACTCACTAAAAACCAAGCTGTCGCTACT
+TCCCAAGAAGCTGTTCAGAATCAGAATGAGCCGCAACTTCGGGATGAAAATGCTCACAATGACAAATCTG
+TCCACGGAGTGCTTAATCCAACTTACCAAGCTGGGTTACGACGCGACGCCGTTCAACCAGATATTGAAGC
+AGAACGCAAAAAGAGAGATGAGATTGAGGCTGGGAAAAGTTACTGTAGCCGACGTTTTGGCGGCGCAACC
+TGTGACGACAAATCTGCTCAAATTTATGCGCGCTTCGATAAAAATGATTGGCGTATCCAACCTGCA

tests/epistasis/fitness_table.npy

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+import numpy as np
+
+rdist = np.array(
+    [
+        ["++", 0.1],
+        ["+-", 0.1],
+        ["+x", 0.1],
+        ["-+", 0.1],
+        ["--", 0.1],
+        ["-x", 0.1],
+        ["x+", 0.1],
+        ["x-", 0.1],
+        ["xx", 0.2],
+    ]
+)
+
+rdist = [
+    rdist[:, 0],
+    rdist[:, 1].astype(float),
+]
+
+dist = {
+    "+": lambda: 1 + np.random.exponential(scale=0.03),
+    "-": lambda: max(0, 1 - np.random.exponential(scale=0.21)),
+    "x": lambda: 0,
+}
+
+c = np.random.choice(rdist[0], p=rdist[1], size=(1000, 4))
+
+
+def apply_dist(x: str, axis: int) -> float:
+    return dist[x[axis]]()
+
+
+f = np.vectorize(apply_dist, otypes=[np.float64])
+
+tables = [f(c, axis=axis) for axis in range(2)]
+
+for i, table in enumerate(tables):
+    np.save(f"fitness_table_{i}", table)
+
+print(tables)