test(config): bump project dependencies, add tests (#56)

- [x] update cargo dependencies;
- [x] add tests for configuration submodules;

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2023 rfprod.
+Copyright (c) 2023-2024 rfprod.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/data_pipeline/artifact/configuration/mod.rs

@@ -4,9 +4,9 @@ use colored::Colorize;
 use std::env::{self};
 
 /// Artifact module context configuration.
-pub fn choose_context(contexts: [&str; 2], context_arg: Option<String>) -> usize {
+pub fn choose_context(contexts: [&str; 2], context: Option<String>) -> usize {
     let p = ArtifactConfiguration::new(contexts);
-    p.choose_context(context_arg)
+    p.choose_context(context)
 }
 
 /// Artifact module file system configuration.
@@ -33,10 +33,10 @@ impl<'a> ArtifactConfiguration<'a> {
     }
 
     /// Artifact module context configuration.
-    fn choose_context(&self, context_arg: Option<String>) -> usize {
-        let is_some = context_arg.is_some();
-        let context_arg_input = if is_some {
-            match context_arg.unwrap().trim().parse::<String>() {
+    fn choose_context(&self, context: Option<String>) -> usize {
+        let is_some = context.is_some();
+        let context_input = if is_some {
+            match context.unwrap().trim().parse::<String>() {
                 Ok(value) => value,
                 Err(_) => String::new(),
             }
@@ -46,7 +46,7 @@ impl<'a> ArtifactConfiguration<'a> {
 
         let mut index = usize::MAX;
         for (i, ctx) in self.contexts.iter().enumerate() {
-            if ctx.to_owned().eq(context_arg_input.as_str()) {
+            if ctx.to_owned().eq(context_input.as_str()) {
                 index = i;
                 break;
             }
@@ -83,3 +83,6 @@ impl<'a> ArtifactConfiguration<'a> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests;

src/data_pipeline/artifact/configuration/tests/mod.rs

@@ -0,0 +1,42 @@
+mod artifact_configuration {
+    use crate::data_pipeline::artifact::{configuration::ArtifactConfiguration, CONTEXTS};
+
+    #[test]
+    fn choose_context() {
+        let program = ArtifactConfiguration::new(CONTEXTS);
+        let contexts = program.contexts;
+        for (i, record) in contexts.iter().enumerate() {
+            let index = program.choose_context(Some(record.to_string()));
+            assert_eq!(i, index);
+        }
+    }
+
+    #[test]
+    fn fs_config() {
+        let program = ArtifactConfiguration::new(CONTEXTS);
+        let collection = String::from("test");
+        let config = program.fs_config(collection.clone());
+
+        let json_base_path = String::from("./.data/output/github/");
+        assert_eq!(
+            config.json_collection_path,
+            json_base_path + &collection + "/"
+        );
+
+        let partial_artifact_base_path = "/.data/artifact/github/";
+        assert!(config
+            .artifact_base_path
+            .contains(partial_artifact_base_path));
+
+        let artifact_file_name_prefix = String::from("github-");
+        assert_eq!(
+            config.artifact_file_name,
+            artifact_file_name_prefix.clone() + &collection + ".tar.gz"
+        );
+
+        assert_eq!(
+            config.encrypted_artifact_file_name,
+            artifact_file_name_prefix + &collection + ".tar.gz.gpg"
+        )
+    }
+}

src/data_pipeline/configuration/mod.rs

@@ -188,3 +188,6 @@ impl<'a> DataPipelineConfiguration<'a> {
         String::new()
     }
 }
+
+#[cfg(test)]
+mod tests;

src/data_pipeline/configuration/tests/mod.rs

@@ -0,0 +1,25 @@
+mod data_pipeline_configuration {
+    use crate::data_pipeline::{
+        artifact::CONTEXTS, configuration::DataPipelineConfiguration, mongo::COLLECTIONS,
+    };
+
+    #[test]
+    fn choose_context() {
+        let program = DataPipelineConfiguration::new(CONTEXTS, COLLECTIONS);
+        let contexts = program.contexts;
+        for (i, record) in contexts.iter().enumerate() {
+            let index = program.choose_context(Some(i.to_string()));
+            assert_eq!(contexts.get(index), Some(record));
+        }
+    }
+
+    #[test]
+    fn choose_collection() {
+        let program = DataPipelineConfiguration::new(CONTEXTS, COLLECTIONS);
+        let collections = program.collections;
+        for (i, record) in collections.iter().enumerate() {
+            let index = program.choose_collection(Some(i.to_string()));
+            assert_eq!(collections.get(index), Some(record));
+        }
+    }
+}

src/data_pipeline/mongo/configuration/mod.rs

@@ -23,10 +23,10 @@ impl<'a> MongoDbConfiguration<'a> {
     }
 
     /// MongoDb module collection configuration.
-    pub fn choose_collection(&self, collection_arg: Option<String>) -> usize {
-        let is_some = collection_arg.is_some();
-        let collection_arg_input = if is_some {
-            match collection_arg.unwrap().trim().parse::<String>() {
+    pub fn choose_collection(&self, collection: Option<String>) -> usize {
+        let is_some = collection.is_some();
+        let collection_input = if is_some {
+            match collection.unwrap().trim().parse::<String>() {
                 Ok(value) => value,
                 Err(_) => String::new(),
             }
@@ -36,7 +36,7 @@ impl<'a> MongoDbConfiguration<'a> {
 
         let mut index = usize::MAX;
         for (i, ctx) in self.collections.iter().enumerate() {
-            if ctx.to_owned().eq(collection_arg_input.as_str()) {
+            if ctx.to_owned().eq(collection_input.as_str()) {
                 index = i;
                 break;
             }
@@ -100,3 +100,6 @@ impl<'a> MongoDbConfiguration<'a> {
         MongoDbFileConfig { json_data_dir }
     }
 }
+
+#[cfg(test)]
+mod tests;

src/data_pipeline/mongo/configuration/tests/mod.rs

@@ -0,0 +1,24 @@
+mod mongo_db_configuration {
+    use crate::data_pipeline::mongo::{configuration::MongoDbConfiguration, COLLECTIONS};
+
+    #[test]
+    fn collections() {
+        let program = MongoDbConfiguration::new(COLLECTIONS);
+        let collections = program.collections;
+        for (i, record) in collections.iter().enumerate() {
+            let index = program.choose_collection(Some(record.to_string()));
+            assert_eq!(i, index);
+        }
+    }
+
+    #[test]
+    fn fs_config() {
+        let program = MongoDbConfiguration::new(COLLECTIONS);
+        let collection = String::from("test");
+        let config = program.fs_config(collection.clone());
+
+        let json_base_path = String::from("/.data/output/github/");
+        let partial_json_data_dir = json_base_path + &collection + "/";
+        assert!(config.json_data_dir.contains(&partial_json_data_dir));
+    }
+}