Add initial set of tests

src/nix/mod.rs

@@ -31,6 +31,9 @@ pub use profile::{Profile, ProfileMap};
 pub mod deployment;
 pub use deployment::{Goal, Target, Deployment};
 
+#[cfg(test)]
+mod tests;
+
 pub const SYSTEM_PROFILE: &'static str = "/nix/var/nix/profiles/system";
 
 pub type NixResult<T> = Result<T, NixError>;

src/nix/tests.rs

@@ -0,0 +1,212 @@
+//! Integration-ish tests
+
+use super::*;
+
+use std::collections::HashSet;
+use std::hash::Hash;
+use std::io::Write;
+use std::iter::{FromIterator, Iterator};
+use std::ops::Deref;
+
+use tempfile::NamedTempFile;
+use tokio_test::block_on;
+
+fn set_eq<T>(a: &[T], b: &[T]) -> bool
+where
+    T: Eq + Hash,
+{
+    let a: HashSet<_> = HashSet::from_iter(a);
+    let b: HashSet<_> = HashSet::from_iter(b);
+
+    a == b
+}
+
+/// An ad-hoc Hive configuration.
+struct TempHive {
+    hive: Hive,
+    _temp_file: NamedTempFile,
+}
+
+impl TempHive {
+    pub fn new(text: &str) -> Self {
+        let mut temp_file = NamedTempFile::new().unwrap();
+        temp_file.write_all(text.as_bytes()).unwrap();
+
+        let hive = Hive::new(temp_file.path()).unwrap();
+
+        Self {
+            hive,
+            _temp_file: temp_file,
+        }
+    }
+
+    /// Asserts that the configuration is valid.
+    ///
+    /// Note that this _does not_ attempt to evaluate `config.toplevel`.
+    pub fn valid(text: &str) {
+        let mut hive = Self::new(text);
+        hive.hive.show_trace(true);
+        assert!(block_on(hive.deployment_info()).is_ok());
+    }
+
+    /// Asserts that the configuration is invalid.
+    ///
+    /// Note that this _does not_ attempt to evaluate `config.toplevel`.
+    pub fn invalid(text: &str) {
+        let hive = Self::new(text);
+        assert!(block_on(hive.deployment_info()).is_err());
+    }
+}
+
+impl Deref for TempHive {
+    type Target = Hive;
+
+    fn deref(&self) -> &Hive {
+        &self.hive
+    }
+}
+
+// eval.nix tests
+
+#[test]
+fn test_parse_simple() {
+    let hive = TempHive::new(r#"
+      {
+        defaults = { pkgs, ... }: {
+          environment.systemPackages = with pkgs; [
+            vim wget curl
+          ];
+          boot.loader.grub.device = "/dev/sda";
+          fileSystems."/" = {
+            device = "/dev/sda1";
+            fsType = "ext4";
+          };
+
+          deployment.tags = [ "common-tag" ];
+        };
+
+        host-a = { name, nodes, ... }: {
+          networking.hostName = name;
+          time.timeZone = nodes.host-b.config.time.timeZone;
+
+          deployment.tags = [ "a-tag" ];
+        };
+
+        host-b = {
+          deployment = {
+            targetHost = "somehost.tld";
+            targetPort = 1234;
+            targetUser = "luser";
+          };
+          time.timeZone = "America/Los_Angeles";
+        };
+      }
+    "#);
+    let nodes = block_on(hive.deployment_info()).unwrap();
+
+    assert!(set_eq(
+        &["host-a", "host-b"],
+        &nodes.keys().map(String::as_str).collect::<Vec<&str>>(),
+    ));
+
+    // host-a
+    assert!(set_eq(
+        &["common-tag", "a-tag"],
+        &nodes["host-a"].tags.iter().map(String::as_str).collect::<Vec<&str>>(),
+    ));
+    assert_eq!(Some("host-a"), nodes["host-a"].target_host.as_deref());
+    assert_eq!(None, nodes["host-a"].target_port);
+    assert_eq!("root", &nodes["host-a"].target_user);
+
+    // host-b
+    assert!(set_eq(
+        &["common-tag"],
+        &nodes["host-b"].tags.iter().map(String::as_str).collect::<Vec<&str>>(),
+    ));
+    assert_eq!(Some("somehost.tld"), nodes["host-b"].target_host.as_deref());
+    assert_eq!(Some(1234), nodes["host-b"].target_port);
+    assert_eq!("luser", &nodes["host-b"].target_user);
+}
+
+#[test]
+fn test_parse_node_references() {
+    TempHive::valid(r#"
+      with builtins;
+      {
+        host-a = { name, nodes, ... }:
+          assert name == "host-a";
+          assert length (attrNames nodes) == 2;
+        {
+          time.timeZone = "America/Los_Angeles";
+        };
+        host-b = { name, nodes, ... }:
+          assert name == "host-b";
+          assert length (attrNames nodes) == 2;
+          assert nodes.host-a.config.time.timeZone == "America/Los_Angeles";
+        {};
+      }
+    "#);
+}
+
+#[test]
+fn test_parse_unknown_option() {
+    TempHive::invalid(r#"
+      {
+        bad = {
+          deployment.noSuchOption = "not kidding";
+        };
+      }
+    "#);
+}
+
+#[test]
+fn test_parse_key_text() {
+    TempHive::valid(r#"
+      {
+        test = {
+          deployment.keys.topSecret = {
+            text = "be sure to drink your ovaltine";
+          };
+        };
+      }
+    "#);
+}
+
+#[test]
+fn test_parse_key_command_good() {
+    TempHive::valid(r#"
+      {
+        test = {
+          deployment.keys.elohim = {
+            keyCommand = [ "eternalize" ];
+          };
+        };
+      }
+    "#);
+}
+
+#[test]
+fn test_parse_key_command_bad() {
+    TempHive::invalid(r#"
+      {
+        test = {
+          deployment.keys.elohim = {
+            keyCommand = "transcend";
+          };
+        };
+      }
+    "#);
+}
+
+#[test]
+fn test_parse_key_file() {
+    TempHive::valid(r#"
+      {
+        test = {
+          deployment.keys.l337hax0rwow = {
+            keyFile = "/etc/passwd";
+          };
+        };
+      }
+    "#);
+}