From fb7b1226fd610b53d1ba06e2c3d55f0100ebdb2f Mon Sep 17 00:00:00 2001
From: Clement Tsang <34804052+ClementTsang@users.noreply.github.com>
Date: Mon, 15 Feb 2021 14:12:43 -0500
Subject: feature: add nord and nord-light colours (#406)

Adds colour schemes for Nord, along with a light variant.
---
 tests/arg_tests.rs            | 42 ++++++++++++------------------------------
 tests/invalid_config_tests.rs | 39 +++++++++++++--------------------------
 2 files changed, 25 insertions(+), 56 deletions(-)

(limited to 'tests')

diff --git a/tests/arg_tests.rs b/tests/arg_tests.rs
index 6f19eb8c..51d8f383 100644
--- a/tests/arg_tests.rs
+++ b/tests/arg_tests.rs
@@ -11,7 +11,7 @@ fn get_binary_location() -> String {
 }
 
 #[test]
-fn test_small_rate() -> Result<(), Box<dyn std::error::Error>> {
+fn test_small_rate() {
     Command::new(get_binary_location())
         .arg("-r")
         .arg("249")
@@ -20,11 +20,10 @@ fn test_small_rate() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your update rate to be at least 250 milliseconds.",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_large_default_time() -> Result<(), Box<dyn std::error::Error>> {
+fn test_large_default_time() {
     Command::new(get_binary_location())
         .arg("-t")
         .arg("18446744073709551616")
@@ -33,11 +32,10 @@ fn test_large_default_time() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your default value to be at most",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_small_default_time() -> Result<(), Box<dyn std::error::Error>> {
+fn test_small_default_time() {
     Command::new(get_binary_location())
         .arg("-t")
         .arg("900")
@@ -46,11 +44,10 @@ fn test_small_default_time() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your default value to be at least",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_large_delta_time() -> Result<(), Box<dyn std::error::Error>> {
+fn test_large_delta_time() {
     Command::new(get_binary_location())
         .arg("-d")
         .arg("18446744073709551616")
@@ -59,11 +56,10 @@ fn test_large_delta_time() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your time delta to be at most",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_small_delta_time() -> Result<(), Box<dyn std::error::Error>> {
+fn test_small_delta_time() {
     Command::new(get_binary_location())
         .arg("-d")
         .arg("900")
@@ -72,11 +68,10 @@ fn test_small_delta_time() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your time delta to be at least",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_large_rate() -> Result<(), Box<dyn std::error::Error>> {
+fn test_large_rate() {
     Command::new(get_binary_location())
         .arg("-r")
         .arg("18446744073709551616")
@@ -85,11 +80,10 @@ fn test_large_rate() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your update rate to be at most unsigned INT_MAX.",
         ));
-    Ok(())
 }
 
 #[test]
-fn test_negative_rate() -> Result<(), Box<dyn std::error::Error>> {
+fn test_negative_rate() {
     // This test should auto fail due to how clap works
     Command::new(get_binary_location())
         .arg("-r")
@@ -99,24 +93,20 @@ fn test_negative_rate() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "wasn't expected, or isn't valid in this context",
         ));
-
-    Ok(())
 }
 
 #[test]
-fn test_invalid_rate() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_rate() {
     Command::new(get_binary_location())
         .arg("-r")
         .arg("100-1000")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid digit"));
-
-    Ok(())
 }
 
 #[test]
-fn test_conflicting_temps() -> Result<(), Box<dyn std::error::Error>> {
+fn test_conflicting_temps() {
     Command::new(get_binary_location())
         .arg("-c")
         .arg("-f")
@@ -125,24 +115,20 @@ fn test_conflicting_temps() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "cannot be used with one or more of the other specified arguments",
         ));
-
-    Ok(())
 }
 
 #[test]
-fn test_invalid_default_widget_1() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_default_widget_1() {
     Command::new(get_binary_location())
         .arg("--default_widget_type")
         .arg("fake_widget")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid widget name"));
-
-    Ok(())
 }
 
 #[test]
-fn test_invalid_default_widget_2() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_default_widget_2() {
     Command::new(get_binary_location())
         .arg("--default_widget_type")
         .arg("cpu")
@@ -153,12 +139,10 @@ fn test_invalid_default_widget_2() -> Result<(), Box<dyn std::error::Error>> {
         .stderr(predicate::str::contains(
             "set your widget count to be at most unsigned INT_MAX",
         ));
-
-    Ok(())
 }
 
 #[test]
-fn test_missing_default_widget_type() -> Result<(), Box<dyn std::error::Error>> {
+fn test_missing_default_widget_type() {
     Command::new(get_binary_location())
         .arg("--default_widget_count")
         .arg("3")
@@ -167,6 +151,4 @@ fn test_missing_default_widget_type() -> Result<(), Box<dyn std::error::Error>>
         .stderr(predicate::str::contains(
             "The following required arguments were not provided",
         ));
-
-    Ok(())
 }
diff --git a/tests/invalid_config_tests.rs b/tests/invalid_config_tests.rs
index f21a0ff7..ca3f7e24 100644
--- a/tests/invalid_config_tests.rs
+++ b/tests/invalid_config_tests.rs
@@ -9,150 +9,137 @@ fn get_binary_location() -> String {
 }
 
 #[test]
-fn test_toml_mismatch_type() -> Result<(), Box<dyn std::error::Error>> {
+fn test_toml_mismatch_type() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/toml_mismatch_type.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid type"));
-    Ok(())
 }
 
 #[test]
-fn test_empty_layout() -> Result<(), Box<dyn std::error::Error>> {
+fn test_empty_layout() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/empty_layout.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("at least one widget"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_layout_widget_type() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_layout_widget_type() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_layout_widget_type.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid widget name"));
-    Ok(())
 }
 
 /// This test isn't really needed as this is technically covered by TOML spec.
 /// However, I feel like it's worth checking anyways - not like it takes long.
 #[test]
-fn test_duplicate_temp_type() -> Result<(), Box<dyn std::error::Error>> {
+fn test_duplicate_temp_type() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/duplicate_temp_type.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("duplicate field"));
-    Ok(())
 }
 
 /// Checks for if a hex is valid
 #[test]
-fn test_invalid_colour_hex() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_hex() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_hex.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid hex colour"));
-    Ok(())
 }
 
 /// Checks for if a hex is too long
 #[test]
-fn test_invalid_colour_hex_2() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_hex_2() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_hex_2.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid hex colour"));
-    Ok(())
 }
 
 /// Checks unicode hex because the way we originally did it could cause char
 /// boundary errors!
 #[test]
-fn test_invalid_colour_hex_3() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_hex_3() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_hex_3.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid hex colour"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_colour_name() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_name() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_name.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid named colour"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_colour_rgb() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_rgb() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_rgb.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid RGB"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_colour_rgb_2() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_rgb_2() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_rgb_2.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid RGB"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_colour_string() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_colour_string() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_colour_string.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid named colour"));
-    Ok(())
 }
 
 #[test]
-fn test_lone_default_widget_count() -> Result<(), Box<dyn std::error::Error>> {
+fn test_lone_default_widget_count() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/lone_default_widget_count.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("it must be used with"));
-    Ok(())
 }
 
 #[test]
-fn test_invalid_default_widget_count() -> Result<(), Box<dyn std::error::Error>> {
+fn test_invalid_default_widget_count() {
     Command::new(get_binary_location())
         .arg("-C")
         .arg("./tests/invalid_configs/invalid_default_widget_count.toml")
         .assert()
         .failure()
         .stderr(predicate::str::contains("invalid number"));
-    Ok(())
 }
-- 
cgit v1.2.3