Merge pull request #31 from WeareJH/no-config

fix: should support a 'default' configuration (zero config) - fixes #29

Author: shakyShane

src/lib/config.rs

@@ -1,10 +1,11 @@
+extern crate serde_json;
 extern crate serde_yaml;
 
 use clap::Error;
 use from_file::FromFile;
 use from_file::FromFileError;
 use options::ConfigError;
-use serde_yaml::Value;
+use serde_json::Value;
 use std;
 
 #[derive(Deserialize, Debug, Clone)]
@@ -21,12 +22,20 @@ impl Default for ProgramConfig {
 impl FromFile for ProgramConfig {}
 
 impl ProgramConfig {
-    pub fn get_opts(&self, name: &str) -> Option<serde_yaml::Value> {
+    pub fn get_opts(&self, name: &str) -> Option<serde_json::Value> {
         self.presets
             .iter()
             .find(|p| p.name == name)
             .map(|p| p.options.clone())
     }
+    pub fn default_preset() -> ProgramConfig {
+        ProgramConfig {
+            presets: vec![PresetConfig {
+                name: "m2".into(),
+                options: json!({}),
+            }],
+        }
+    }
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -39,7 +48,7 @@ pub struct PresetConfig {
 pub enum ProgramStartError {
     ConfigFileOpen,
     ConfigFileRead,
-    ConfigParseError(serde_yaml::Error),
+    ConfigParseError(serde_json::Error),
     ConfigCliError(ConfigError),
     InvalidArgs(Error),
     FromFile(FromFileError),

src/lib/options.rs

@@ -67,8 +67,7 @@ impl ProgramOptions {
                 Arg::with_name("config")
                     .short("c")
                     .long("config")
-                    .takes_value(true)
-                    .required(true),
+                    .takes_value(true),
             )
             .arg(Arg::with_name("seed").long("seed").takes_value(true))
             .get_matches_from_safe(args);
@@ -89,14 +88,16 @@ impl ProgramOptions {
             .parse()
             .map_err(|_e| ProgramStartError::ConfigCliError(ConfigError::UrlInvalidPort))?;
 
-        let config_file = matches
-            .value_of("config")
-            .expect("config is a required field");
-
-        Ok(ProgramOptions::new(host, scheme)
+        let outgoing_opts = ProgramOptions::new(host, scheme)
             .with_port(port)
-            .with_config_file(config_file)
-            .with_seed_file(matches.value_of("seed")))
+            .with_seed_file(matches.value_of("seed"));
+
+        let outgoing_opts = match matches.value_of("config") {
+            Some(cfg_file) => outgoing_opts.with_config_file(cfg_file),
+            None => outgoing_opts,
+        };
+
+        Ok(outgoing_opts)
     }
     pub fn with_port(mut self, port: u16) -> ProgramOptions {
         self.port = port;

src/lib/presets/m2/bundle_config.rs

@@ -2,12 +2,21 @@ extern crate serde_yaml;
 
 use from_file::FromFile;
 
-#[derive(Serialize, Deserialize, Debug, Default)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct BundleConfig {
     pub bundles: Vec<ConfigItem>,
     pub module_blacklist: Option<Vec<String>>,
 }
 
+impl Default for BundleConfig {
+    fn default() -> BundleConfig {
+        BundleConfig {
+            bundles: vec![],
+            module_blacklist: None,
+        }
+    }
+}
+
 impl FromFile for BundleConfig {}
 
 #[derive(Serialize, Deserialize, Debug, Default)]

src/lib/presets/m2/opts.rs

@@ -1,5 +1,5 @@
 use config::ProgramConfig;
-use serde_yaml;
+use serde_json;
 
 #[derive(Deserialize, Debug)]
 pub struct M2PresetOptions {
@@ -42,28 +42,34 @@ impl Default for AuthBasic {
 
 impl M2PresetOptions {
     pub fn get_opts(prog_config: &ProgramConfig) -> Option<M2PresetOptions> {
-        serde_yaml::from_value(prog_config.get_opts("m2")?).ok()?
+        serde_json::from_value(prog_config.get_opts("m2")?).ok()?
     }
 }
 
-#[test]
-fn test_parse_preset_options_all_given() {
-    let i = r#"
-require_path: /js/require.js
-bundle_config: file:test/fixtures/bundle-config.yaml
-auth_basic:
-    username: shane
-    password: other
-    "#;
-    let y: M2PresetOptions = serde_yaml::from_str(&i).unwrap();
-    assert_eq!(y.require_path, Some("/js/require.js".to_string()));
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_yaml;
+
+    #[test]
+    fn test_parse_preset_options_all_given() {
+        let i = r#"
+    require_path: /js/require.js
+    bundle_config: file:test/fixtures/bundle-config.yaml
+    auth_basic:
+        username: shane
+        password: other
+        "#;
+        let y: M2PresetOptions = serde_yaml::from_str(&i).unwrap();
+        assert_eq!(y.require_path, Some("/js/require.js".to_string()));
+    }
 
-#[test]
-fn test_defaults() {
-    let i = r#"
-    bundle_config: "here"
-    "#;
-    let y: M2PresetOptions = serde_yaml::from_str(&i).unwrap();
-    assert_eq!(y.bundle_config, Some("here".to_string()));
+    #[test]
+    fn test_defaults() {
+        let i = r#"
+        bundle_config: "here"
+        "#;
+        let y: M2PresetOptions = serde_yaml::from_str(&i).unwrap();
+        assert_eq!(y.bundle_config, Some("here".to_string()));
+    }
 }

src/lib/presets/m2/state.rs

@@ -25,41 +25,41 @@ pub fn gather_state(
 
     let maybe_opts = M2PresetOptions::get_opts(&req.state().program_config)
         .expect("should clone program config");
-    let bundle_path = maybe_opts.bundle_config;
 
-    match bundle_path {
-        Some(bun_config_path) => match BundleConfig::from_file(&bun_config_path) {
-            Ok(bundle_config) => {
-                let module_blacklist = bundle_config.module_blacklist.clone().unwrap_or(vec![]);
-                let mut blacklist = vec!["js-translation".to_string()];
-                blacklist.extend(module_blacklist);
+    let bundle_config = match maybe_opts.bundle_config {
+        Some(bc_path) => BundleConfig::from_file(&bc_path),
+        None => Ok(BundleConfig::default()),
+    };
 
-                let filtered =
-                    RequireJsBuildConfig::drop_blacklisted(&modules.to_vec(), &blacklist);
-                let bundle_modules = config_gen::generate_modules(filtered, bundle_config);
-                let mut derived_build_config = RequireJsBuildConfig::default();
+    match bundle_config {
+        Err(e) => Err(e.to_string()),
+        Ok(bundle_config) => {
+            let module_blacklist = bundle_config.module_blacklist.clone().unwrap_or(vec![]);
+            let mut blacklist = vec!["js-translation".to_string()];
+            blacklist.extend(module_blacklist);
 
-                derived_build_config.deps = client_config.deps.clone();
-                derived_build_config.map = client_config.map.clone();
-                derived_build_config.config = client_config.config.clone();
+            let filtered = RequireJsBuildConfig::drop_blacklisted(&modules.to_vec(), &blacklist);
+            let bundle_modules = config_gen::generate_modules(filtered, bundle_config);
+            let mut derived_build_config = RequireJsBuildConfig::default();
 
-                let mut c = client_config.paths.clone();
-                derived_build_config.paths = RequireJsBuildConfig::strip_paths(&c);
+            derived_build_config.deps = client_config.deps.clone();
+            derived_build_config.map = client_config.map.clone();
+            derived_build_config.config = client_config.config.clone();
 
-                let mut shims = client_config.shim.clone();
+            let mut c = client_config.paths.clone();
+            derived_build_config.paths = RequireJsBuildConfig::strip_paths(&c);
 
-                {
-                    RequireJsBuildConfig::fix_shims(&mut shims);
-                }
+            let mut shims = client_config.shim.clone();
 
-                derived_build_config.shim = shims;
+            {
+                RequireJsBuildConfig::fix_shims(&mut shims);
+            }
 
-                derived_build_config.modules = Some(bundle_modules.clone());
+            derived_build_config.shim = shims;
 
-                Ok((derived_build_config, bundle_modules))
-            }
-            Err(e) => Err(e.to_string()),
-        },
-        _ => Err("didnt match both".to_string()),
+            derived_build_config.modules = Some(bundle_modules.clone());
+
+            Ok((derived_build_config, bundle_modules))
+        }
     }
 }

src/lib/setup.rs

@@ -9,7 +9,7 @@ use presets::m2::preset_m2::M2Preset;
 use presets::m2::requirejs_config::RequireJsClientConfig;
 use presets::m2::seed::SeedData;
 use proxy_transform::proxy_transform;
-use serde_yaml;
+use serde_json;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -58,7 +58,7 @@ pub fn state_and_presets(
         match p.name.as_str() {
             "m2" => {
                 let preset_opts: M2PresetOptions =
-                    serde_yaml::from_value(p.options.clone()).unwrap();
+                    serde_json::from_value(p.options.clone()).unwrap();
                 let preset = M2Preset::new(preset_opts);
                 presets_map.insert(index, Box::new(preset));
             }

src/lib/system.rs

@@ -16,20 +16,15 @@ pub fn create(opts: ProgramOptions) -> Result<(actix::SystemRunner, String), Pro
     //
     let sys = actix::System::new("https-proxy");
 
-    //
-    // Get program configuration, from the input above, and
-    // then eventually from a file
-    //
-    let file_path = opts
-        .config_file
-        .clone()
-        .expect("config_file cannot be missing");
-
     //
     // Pull the ProgramConfig from a  file
     //
-    let program_config =
-        ProgramConfig::from_file(&file_path).map_err(|e| ProgramStartError::FromFile(e))?;
+    let program_config = match opts.config_file.clone() {
+        Some(cfg_path) => {
+            ProgramConfig::from_file(&cfg_path).map_err(|e| ProgramStartError::FromFile(e))?
+        }
+        None => ProgramConfig::default_preset(),
+    };
 
     //
     // Clone server opts to be used in multi threads

tests/api.rs

@@ -97,6 +97,34 @@ fn test_build_json_from_json_config() {
     });
 }
 
+#[test]
+fn test_build_json_without_config() {
+    let args = vec!["config-gen", "http://example.com"];
+    api(args, "/__bs/build.json", |result| {
+        let (_sys, _url, mut res) = result.expect("api returned");
+        let _c: RequireJsBuildConfig = serde_json::from_str(
+            &res.text().expect("unwrap text response"),
+        ).expect("serde deserialize");
+    });
+}
+
+#[test]
+fn test_build_json_with_seed_without_config() {
+    let args = vec![
+        "config-gen",
+        "http://example.com",
+        "--seed",
+        "test/fixtures/seed.json",
+    ];
+    api(args, "/__bs/build.json", |result| {
+        let (_sys, _url, mut res) = result.expect("api returned");
+        let _c: RequireJsBuildConfig = serde_json::from_str(
+            &res.text().expect("unwrap text response"),
+        ).expect("serde deserialize");
+        println!("_c={:?}", _c);
+    });
+}
+
 ///
 /// Test helper to run the server from a Vec of args
 /// just like you would in the the CLI

tests/proxy_transform_test.rs

@@ -87,7 +87,7 @@ fn test_redirect() {
         });
     });
 
-    let (mut proxy, proxy_address) = get_test_proxy(&target, |app| {
+    let (mut proxy, _proxy_address) = get_test_proxy(&target, |app| {
         app.handler(proxy_transform);
     });
 
@@ -100,13 +100,14 @@ fn test_redirect() {
         .expect("finish request");
 
     let (resp, _resp_body) = get_resp(&mut proxy, request);
-    let expected_redirect = format!("http://{}/login", proxy_address);
-    let _actual_redirect = resp
-        .headers()
-        .get(header::LOCATION)
-        .expect("has location header")
-        .to_str()
-        .expect("header->str");
     assert_eq!(resp.status(), 302);
+
+    //    let _actual_redirect = resp
+    //        .headers()
+    //        .get(header::LOCATION)
+    //        .expect("has location header")
+    //        .to_str()
+    //        .expect("header->str");
+    //    let expected_redirect = format!("http://{}/login", proxy_address);
     //    assert_eq!(actual_redirect, expected_redirect);
 }