fix(kubernetes): Parse stacked kubeconfigs (#1678)

Have refactored the kubernetes module to better support stacked
kubeconfigs. Rather than trying to grab both the current-context and
namespace on a single pass we now do two passes. These changes should
fix the problems where the current-context is defined in one file but
the context and the namespace are defined in a different file.

src/modules/kubernetes.rs

@@ -9,7 +9,9 @@ use crate::configs::kubernetes::KubernetesConfig;
 use crate::formatter::StringFormatter;
 use crate::utils;
 
-fn get_kube_context(contents: &str) -> Option<(String, String)> {
+fn get_kube_context(filename: path::PathBuf) -> Option<String> {
+    let contents = utils::read_file(filename).ok()?;
+
     let yaml_docs = YamlLoader::load_from_str(&contents).ok()?;
     if yaml_docs.is_empty() {
         return None;
@@ -21,41 +23,33 @@ fn get_kube_context(contents: &str) -> Option<(String, String)> {
     if current_ctx.is_empty() {
         return None;
     }
+    Some(current_ctx.to_string())
+}
 
-    let ns = conf["contexts"]
+fn get_kube_ns(filename: path::PathBuf, current_ctx: String) -> Option<String> {
-        .as_vec()
+    let contents = utils::read_file(filename).ok()?;
-        .and_then(|contexts| {
+
+    let yaml_docs = YamlLoader::load_from_str(&contents).ok()?;
+    if yaml_docs.is_empty() {
+        return None;
+    }
+    let conf = &yaml_docs[0];
+
+    let ns = conf["contexts"].as_vec().and_then(|contexts| {
         contexts
             .iter()
             .filter_map(|ctx| Some((ctx, ctx["name"].as_str()?)))
             .find(|(_, name)| *name == current_ctx)
             .and_then(|(ctx, _)| ctx["context"]["namespace"].as_str())
-        })
+    })?;
-        .unwrap_or("");
 
-    Some((current_ctx.to_string(), ns.to_string()))
+    if ns.is_empty() {
-}
+        return None;
-
+    }
-fn parse_kubectl_file(filename: &path::PathBuf) -> Option<(String, String)> {
+    Some(ns.to_owned())
-    let contents = utils::read_file(filename).ok()?;
-    get_kube_context(&contents)
 }
 
 pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
-    let kube_cfg = match context.get_env("KUBECONFIG") {
-        Some(paths) => env::split_paths(&paths)
-            .filter_map(|filename| parse_kubectl_file(&filename))
-            .next(),
-        None => {
-            let filename = dirs_next::home_dir()?.join(".kube").join("config");
-            parse_kubectl_file(&filename)
-        }
-    };
-
-    match kube_cfg {
-        Some(kube_cfg) => {
-            let (kube_ctx, kube_ns) = kube_cfg;
-
     let mut module = context.new_module("kubernetes");
     let config: KubernetesConfig = KubernetesConfig::try_load(module.config);
 
@@ -65,6 +59,17 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
         return None;
     };
 
+    let default_config_file = dirs_next::home_dir()?.join(".kube").join("config");
+
+    let kube_cfg = context
+        .get_env("KUBECONFIG")
+        .unwrap_or(default_config_file.to_str()?.to_string());
+
+    let kube_ctx = env::split_paths(&kube_cfg).find_map(get_kube_context)?;
+
+    let kube_ns =
+        env::split_paths(&kube_cfg).find_map(|filename| get_kube_ns(filename, kube_ctx.clone()));
+
     let parsed = StringFormatter::new(config.format).and_then(|formatter| {
         formatter
             .map_meta(|variable, _| match variable {
@@ -80,16 +85,10 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
                     None => Some(Ok(kube_ctx.as_str())),
                     Some(&alias) => Some(Ok(alias)),
                 },
-                        _ => None,
+                "namespace" => match &kube_ns {
-                    })
+                    Some(kube_ns) => Some(Ok(kube_ns)),
-                    .map(|variable| match variable {
+                    None => None,
-                        "namespace" => {
+                },
-                            if kube_ns != "" {
-                                Some(Ok(kube_ns.as_str()))
-                            } else {
-                                None
-                            }
-                        }
                 _ => None,
             })
             .parse(None)
@@ -104,48 +103,29 @@ pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
     });
 
     Some(module)
-        }
-        None => None,
-    }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use crate::test::ModuleRenderer;
+    use ansi_term::Color;
+    use std::env;
+    use std::fs::File;
+    use std::io::{self, Write};
 
     #[test]
-    fn parse_empty_config() {
+    fn test_none_when_disabled() -> io::Result<()> {
-        let input = "";
+        let dir = tempfile::tempdir()?;
-        let result = get_kube_context(&input);
-        let expected = None;
 
-        assert_eq!(result, expected);
+        let filename = dir.path().join("config");
-    }
 
-    #[test]
+        let mut file = File::create(&filename)?;
-    fn parse_no_config() {
+        file.write_all(
-        let input = r#"
+            b"
-apiVersion: v1
-clusters: []
-contexts: []
-current-context: ""
-kind: Config
-preferences: {}
-users: []
-"#;
-        let result = get_kube_context(&input);
-        let expected = None;
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn parse_only_context() {
-        let input = r#"
 apiVersion: v1
 clusters: []
 contexts:
-- context:
+  - context:
       cluster: test_cluster
       user: test_user
     name: test_context
@@ -153,20 +133,112 @@ current-context: test_context
 kind: Config
 preferences: {}
 users: []
-"#;
+",
-        let result = get_kube_context(&input);
+        )?;
-        let expected = Some(("test_context".to_string(), "".to_string()));
+        file.sync_all()?;
 
-        assert_eq!(result, expected);
+        let actual = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env("KUBECONFIG", filename.to_string_lossy().as_ref())
+            .collect();
+
+        assert_eq!(None, actual);
+
+        dir.close()
     }
 
     #[test]
-    fn parse_context_and_ns() {
+    fn test_ctx_alias() -> io::Result<()> {
-        let input = r#"
+        let dir = tempfile::tempdir()?;
+
+        let filename = dir.path().join("config");
+
+        let mut file = File::create(&filename)?;
+        file.write_all(
+            b"
+apiVersion: v1
+clusters: []
+contexts: []
+current-context: test_context
+kind: Config
+preferences: {}
+users: []
+",
+        )?;
+        file.sync_all()?;
+
+        let actual = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env("KUBECONFIG", filename.to_string_lossy().as_ref())
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+                [kubernetes.context_aliases]
+                "test_context" = "test_alias"
+            })
+            .collect();
+
+        let expected = Some(format!("{} in ", Color::Cyan.bold().paint("☸ test_alias")));
+        assert_eq!(expected, actual);
+
+        dir.close()
+    }
+
+    #[test]
+    fn test_single_config_file_no_ns() -> io::Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        let filename = dir.path().join("config");
+
+        let mut file = File::create(&filename)?;
+        file.write_all(
+            b"
 apiVersion: v1
 clusters: []
 contexts:
-- context:
+  - context:
+      cluster: test_cluster
+      user: test_user
+    name: test_context
+current-context: test_context
+kind: Config
+preferences: {}
+users: []
+",
+        )?;
+        file.sync_all()?;
+
+        let actual = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env("KUBECONFIG", filename.to_string_lossy().as_ref())
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+            })
+            .collect();
+
+        let expected = Some(format!(
+            "{} in ",
+            Color::Cyan.bold().paint("☸ test_context")
+        ));
+        assert_eq!(expected, actual);
+
+        dir.close()
+    }
+
+    #[test]
+    fn test_single_config_file_with_ns() -> io::Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        let filename = dir.path().join("config");
+
+        let mut file = File::create(&filename)?;
+        file.write_all(
+            b"
+apiVersion: v1
+clusters: []
+contexts:
+  - context:
       cluster: test_cluster
       user: test_user
       namespace: test_namespace
@@ -175,25 +247,46 @@ current-context: test_context
 kind: Config
 preferences: {}
 users: []
-"#;
+",
-        let result = get_kube_context(&input);
+        )?;
-        let expected = Some(("test_context".to_string(), "test_namespace".to_string()));
+        file.sync_all()?;
 
-        assert_eq!(result, expected);
+        let actual = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env("KUBECONFIG", filename.to_string_lossy().as_ref())
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+            })
+            .collect();
+
+        let expected = Some(format!(
+            "{} in ",
+            Color::Cyan.bold().paint("☸ test_context (test_namespace)")
+        ));
+        assert_eq!(expected, actual);
+
+        dir.close()
     }
 
     #[test]
-    fn parse_multiple_contexts() {
+    fn test_single_config_file_with_multiple_ctxs() -> io::Result<()> {
-        let input = r#"
+        let dir = tempfile::tempdir()?;
+
+        let filename = dir.path().join("config");
+
+        let mut file = File::create(&filename)?;
+        file.write_all(
+            b"
 apiVersion: v1
 clusters: []
 contexts:
-- context:
+  - context:
       cluster: another_cluster
       user: another_user
       namespace: another_namespace
     name: another_context
-- context:
+  - context:
       cluster: test_cluster
       user: test_user
       namespace: test_namespace
@@ -202,22 +295,104 @@ current-context: test_context
 kind: Config
 preferences: {}
 users: []
-"#;
+",
-        let result = get_kube_context(&input);
+        )?;
-        let expected = Some(("test_context".to_string(), "test_namespace".to_string()));
+        file.sync_all()?;
 
-        assert_eq!(result, expected);
+        let actual = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env("KUBECONFIG", filename.to_string_lossy().as_ref())
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+            })
+            .collect();
+
+        let expected = Some(format!(
+            "{} in ",
+            Color::Cyan.bold().paint("☸ test_context (test_namespace)")
+        ));
+        assert_eq!(expected, actual);
+
+        dir.close()
     }
 
     #[test]
-    fn parse_broken_config() {
+    fn test_multiple_config_files_with_ns() -> io::Result<()> {
-        let input = r#"
+        let dir = tempfile::tempdir()?;
----
-dummy_string
-"#;
-        let result = get_kube_context(&input);
-        let expected = None;
 
-        assert_eq!(result, expected);
+        let filename_cc = dir.path().join("config_cc");
+
+        let mut file_cc = File::create(&filename_cc)?;
+        file_cc.write_all(
+            b"
+apiVersion: v1
+clusters: []
+contexts: []
+current-context: test_context
+kind: Config
+preferences: {}
+users: []
+",
+        )?;
+        file_cc.sync_all()?;
+
+        let filename_ctx = dir.path().join("config_ctx");
+        let mut file_ctx = File::create(&filename_ctx)?;
+        file_ctx.write_all(
+            b"
+apiVersion: v1
+clusters: []
+contexts:
+  - context:
+      cluster: test_cluster
+      user: test_user
+      namespace: test_namespace
+    name: test_context
+kind: Config
+preferences: {}
+users: []
+",
+        )?;
+        file_ctx.sync_all()?;
+
+        // Test current_context first
+        let actual_cc_first = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env(
+                "KUBECONFIG",
+                env::join_paths([&filename_cc, &filename_ctx].iter())
+                    .unwrap()
+                    .to_string_lossy(),
+            )
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+            })
+            .collect();
+
+        // And tes with context and namespace first
+        let actual_ctx_first = ModuleRenderer::new("kubernetes")
+            .path(dir.path())
+            .env(
+                "KUBECONFIG",
+                env::join_paths([&filename_ctx, &filename_cc].iter())
+                    .unwrap()
+                    .to_string_lossy(),
+            )
+            .config(toml::toml! {
+                [kubernetes]
+                disabled = false
+            })
+            .collect();
+
+        let expected = Some(format!(
+            "{} in ",
+            Color::Cyan.bold().paint("☸ test_context (test_namespace)")
+        ));
+        assert_eq!(expected, actual_cc_first);
+        assert_eq!(expected, actual_ctx_first);
+
+        dir.close()
     }
 }