chore(tests): Added test coverage

shahen94 · Feb 5, 2024 · 7672cdf · 7672cdf
1 parent 54950b0
commit 7672cdf
Show file tree

Hide file tree

Showing 8 changed files with 276 additions and 15 deletions.
diff --git a/src/command/command.rs b/src/command/command.rs
@@ -5,6 +5,9 @@ use clap::Parser;
 /// # Example
 /// 
 /// ```
+/// use clap::Parser;
+/// use craft::command::Command;
+/// 
 /// let data = Command::parse();
 /// println!("{:?}", data);
 /// ```
@@ -19,8 +22,11 @@ pub struct Command {
 /// 
 /// # Example
 /// ```
+/// use clap::Parser;
+/// use craft::command::{Command, SubCommand};
+/// 
 /// let data = Command::parse();
-/// let command = data.command.unwrap();
+/// let command = data.command;
 /// println!("{:?}", command);
 /// ```
 #[derive(Debug, Parser, Clone)]
@@ -38,7 +44,15 @@ pub enum SubCommand {
 ///
 /// # Example
 /// ```
+/// use clap::Parser;
+/// use craft::command::{Command, SubCommand, Install};
+/// 
 /// let data = Command::parse();
+/// 
+/// if data.command.is_none() {
+///    println!("Reading package.json");
+///     return;
+/// }
 /// let command = data.command.unwrap();
 /// let install = match command {
 ///  SubCommand::Install(install) => install,

diff --git a/src/package/npm_package.rs b/src/package/npm_package.rs
@@ -5,11 +5,6 @@ use serde::{Deserialize, Serialize};
 /// This struct represents a package from the registry.
 /// 
 /// It is used to deserialize the JSON response from the registry.
-/// 
-/// # Example
-/// ```
-/// let package: RemotePackage = response.json().await?;
-/// ```
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct NpmPackage {
   pub name: String,
@@ -35,12 +30,6 @@ impl PartialEq for NpmPackage {
 /// This struct represents the distribution of a package.
 /// 
 /// It is used to deserialize the JSON response from the registry.
-/// 
-/// # Example
-/// ```
-/// let package: RemotePackage = response.json().await?;
-/// package.dist.integrity;
-/// ```
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct Distribution {
   pub integrity: Option<String>,

diff --git a/src/package/version/connector.rs b/src/package/version/connector.rs
@@ -20,4 +20,20 @@ impl FromStr for Connector {
             _ => Ok(Connector::And),
         }
     }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_connector_from_str() {
+        assert_eq!(",".parse::<Connector>().unwrap(), Connector::And);
+        assert_eq!("|".parse::<Connector>().unwrap(), Connector::Or);
+        assert_eq!(" ".parse::<Connector>().unwrap(), Connector::And);
+        assert_eq!("||".parse::<Connector>().unwrap(), Connector::Or);
+        assert_eq!("".parse::<Connector>().unwrap(), Connector::And);
+    }
 }
diff --git a/src/package/version/constants.rs b/src/package/version/constants.rs
@@ -5,4 +5,4 @@ pub const SEMVER_REGEX: &str = r"^(?P<operator>\^|~|=)?\s?(?P<major>\d+|x|\*)(?:
 pub const RANGE_REGEX: &str = r"^(\s+)?(?P<start_operator>~?[<>]=?|~|\^)?\s?(?P<start_major>\d+|x|\*)(?:\.(?P<start_minor>\d+|x|\*))?(?:\.(?P<start_patch>\d+|x|\*))?(?:(?P<connector>,|\|\|)?\s*(?P<end_operator>[<>]=?|~|\^)?\s*(?P<end_major>\d+|x|\*)(?:\.(?P<end_minor>\d+|x|\*))?(?:\.(?P<end_patch>\d+|x|\*))?)?$";
 
 // To match 1.50.5 - 2.0.0 like version strings
-pub const LINEAR_RANGE_REGEX: &str = r"^(?P<operator>\^|~|)?(?P<start_major>(\d)+|x|\*)\.?(?P<start_minor>(\d)+|x|\*)?\.?(?P<start_patch>(\d)+|x|\*)?\s?-(\^|~|)?(?P<end_major>(\d)+|x|\*)\.?(?P<end_minor>(\d)+|x|\*)?\.?(?P<end_patch>(\d)+|x|\*)?";
+pub const LINEAR_RANGE_REGEX: &str = r"^(?P<operator>\^|~|)?(?P<start_major>(\d)+|x|\*)\.?(?P<start_minor>(\d)+|x|\*)?\.?(?P<start_patch>(\d)+|x|\*)?\s?-(\^|~|)?(\s+)?(?P<end_major>(\d)+|x|\*)\.?(?P<end_minor>(\d)+|x|\*)?\.?(?P<end_patch>(\d)+|x|\*)?";
diff --git a/src/package/version/constraint.rs b/src/package/version/constraint.rs
@@ -149,3 +149,104 @@ impl ToString for VersionConstraint {
         version
     }
 }
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_version_constraint_parse() {
+        let version = VersionConstraint::parse("1.0.0");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Equal);
+        assert_eq!(version.pre_release, None);
+        assert_eq!(version.build, None);
+
+        let version = VersionConstraint::parse("=1.0.0");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Equal);
+        assert_eq!(version.pre_release, None);
+        assert_eq!(version.build, None);
+
+        let version = VersionConstraint::parse("^1.0.0-alpha");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Caret);
+        assert_eq!(version.pre_release, Some("alpha".to_string()));
+        assert_eq!(version.build, None);
+
+        let version = VersionConstraint::parse("~1.0.0+build");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Tilde);
+        assert_eq!(version.pre_release, None);
+        assert_eq!(version.build, Some("build".to_string()));
+
+        let version = VersionConstraint::parse("1.0.0-alpha+build");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Equal);
+        assert_eq!(version.pre_release, Some("alpha".to_string()));
+        assert_eq!(version.build, Some("build".to_string()));
+
+        let version = VersionConstraint::parse("=1.0.0");
+        assert_eq!(version.major, VersionField::Exact(1));
+        assert_eq!(version.minor, VersionField::Exact(0));
+        assert_eq!(version.patch, VersionField::Exact(0));
+        assert_eq!(version.operator, Operator::Equal);
+        assert_eq!(version.pre_release, None);
+        assert_eq!(version.build, None);
+    }
+
+    #[test]
+    fn test_version_constraint_to_string() {
+        let version = VersionConstraint {
+            major: VersionField::Exact(1),
+            minor: VersionField::Exact(0),
+            patch: VersionField::Exact(0),
+            operator: Operator::Equal,
+            pre_release: None,
+            build: None,
+        };
+        assert_eq!(version.to_string(), "1.0.0");
+
+        let version = VersionConstraint {
+            major: VersionField::Exact(1),
+            minor: VersionField::Exact(0),
+            patch: VersionField::Exact(0),
+            operator: Operator::GreaterThan,
+            pre_release: None,
+            build: None,
+        };
+        assert_eq!(version.to_string(), ">1.0.0");
+
+        let version = VersionConstraint {
+            major: VersionField::Exact(1),
+            minor: VersionField::Exact(0),
+            patch: VersionField::Exact(0),
+            operator: Operator::GreaterThan,
+            pre_release: Some("alpha".to_string()),
+            build: None,
+        };
+        assert_eq!(version.to_string(), ">1.0.0-alpha");
+
+        let version = VersionConstraint {
+            major: VersionField::Exact(1),
+            minor: VersionField::Exact(0),
+            patch: VersionField::Exact(0),
+            operator: Operator::GreaterThan,
+            pre_release: Some("alpha".to_string()),
+            build: Some("build".to_string()),
+        };
+        assert_eq!(version.to_string(), ">1.0.0-alpha+build");
+    }
+}
diff --git a/src/package/version/group.rs b/src/package/version/group.rs
@@ -36,4 +36,32 @@ impl ToString for VersionGroup {
 
         constraints
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_version_group_to_string() {
+        let group = VersionGroup::new(
+            vec![
+                VersionConstraint::parse("1.0.0"),
+                VersionConstraint::parse("2.0.0"),
+            ],
+            Connector::And,
+        );
+
+        assert_eq!(group.to_string(), "1.0.0 2.0.0");
+
+        let group = VersionGroup::new(
+            vec![
+                VersionConstraint::parse("1.0.0"),
+                VersionConstraint::parse("2.0.0"),
+            ],
+            Connector::Or,
+        );
+
+        assert_eq!(group.to_string(), "(1.0.0 2.0.0)");
+    }
 }
diff --git a/src/package/version/operator.rs b/src/package/version/operator.rs
@@ -48,3 +48,33 @@ impl ToString for Operator {
       }
   }
 }
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_operator_from_str() {
+      assert_eq!("~".parse::<Operator>().unwrap(), Operator::Tilde);
+      assert_eq!("^".parse::<Operator>().unwrap(), Operator::Caret);
+      assert_eq!(">".parse::<Operator>().unwrap(), Operator::GreaterThan);
+      assert_eq!(">=".parse::<Operator>().unwrap(), Operator::GreaterThanOrEqual);
+      assert_eq!("<".parse::<Operator>().unwrap(), Operator::LessThan);
+      assert_eq!("<=".parse::<Operator>().unwrap(), Operator::LessThanOrEqual);
+      assert_eq!("=".parse::<Operator>().unwrap(), Operator::Equal);
+      assert_eq!("".parse::<Operator>().is_err(), true);
+  }
+
+  #[test]
+  fn test_operator_to_string() {
+      assert_eq!(Operator::Tilde.to_string(), "~");
+      assert_eq!(Operator::Caret.to_string(), "^");
+      assert_eq!(Operator::GreaterThan.to_string(), ">");
+      assert_eq!(Operator::GreaterThanOrEqual.to_string(), ">=");
+      assert_eq!(Operator::LessThan.to_string(), "<");
+      assert_eq!(Operator::LessThanOrEqual.to_string(), "<=");
+      assert_eq!(Operator::Equal.to_string(), "=");
+  }
+}
diff --git a/src/package/version/version.rs b/src/package/version/version.rs
@@ -113,7 +113,7 @@ impl VersionImpl {
         }
 
         constraints.push(VersionConstraint {
-            operator: Operator::LessThanOrEqual,
+            operator: Operator::GreaterThanOrEqual,
             major: start_major,
             minor: start_minor,
             patch: start_patch,
@@ -122,7 +122,7 @@ impl VersionImpl {
         });
 
         constraints.push(VersionConstraint {
-            operator: Operator::GreaterThanOrEqual,
+            operator: Operator::LessThanOrEqual,
             major: end_major,
             minor: end_minor,
             patch: end_patch,
@@ -295,3 +295,86 @@ impl Satisfies for VersionImpl {
         true
     }
 }
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_version_new() {
+        let version = VersionImpl::new("1.0.0");
+        assert_eq!(version.inner.len(), 1);
+        assert_eq!(version.inner[0].constraints.len(), 1);
+        assert_eq!(version.inner[0].constraints[0].operator, Operator::Equal);
+        assert_eq!(version.inner[0].constraints[0].major, VersionField::Exact(1));
+        assert_eq!(version.inner[0].constraints[0].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[0].patch, VersionField::Exact(0));
+
+        let version = VersionImpl::new("1.0.0 || 2.0.0");
+        assert_eq!(version.inner.len(), 2);
+        assert_eq!(version.inner[0].constraints.len(), 1);
+        assert_eq!(version.inner[0].constraints[0].operator, Operator::Equal);
+        assert_eq!(version.inner[0].constraints[0].major, VersionField::Exact(1));
+        assert_eq!(version.inner[0].constraints[0].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[0].patch, VersionField::Exact(0));
+        assert_eq!(version.inner[1].constraints.len(), 1);
+        assert_eq!(version.inner[1].constraints[0].operator, Operator::Equal);
+        assert_eq!(version.inner[1].constraints[0].major, VersionField::Exact(2));
+        assert_eq!(version.inner[1].constraints[0].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[1].constraints[0].patch, VersionField::Exact(0));
+
+        let version = VersionImpl::new(">=1.0.0 <2.0.0");
+        assert_eq!(version.inner.len(), 1);
+        assert_eq!(version.inner[0].constraints.len(), 2);
+        assert_eq!(version.inner[0].constraints[0].operator, Operator::GreaterThanOrEqual);
+        assert_eq!(version.inner[0].constraints[0].major, VersionField::Exact(1));
+        assert_eq!(version.inner[0].constraints[0].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[0].patch, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[1].operator, Operator::LessThan);
+        assert_eq!(version.inner[0].constraints[1].major, VersionField::Exact(2));
+        assert_eq!(version.inner[0].constraints[1].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[1].patch, VersionField::Exact(0));
+
+        let version = VersionImpl::new("1.0.0 - 2.0.0");
+        assert_eq!(version.inner.len(), 1);
+        assert_eq!(version.inner[0].constraints.len(), 2);
+        assert_eq!(version.inner[0].constraints[0].operator, Operator::GreaterThanOrEqual);
+        assert_eq!(version.inner[0].constraints[0].major, VersionField::Exact(1));
+        assert_eq!(version.inner[0].constraints[0].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[0].patch, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[1].operator, Operator::LessThanOrEqual);
+        assert_eq!(version.inner[0].constraints[1].major, VersionField::Exact(2));
+        assert_eq!(version.inner[0].constraints[1].minor, VersionField::Exact(0));
+        assert_eq!(version.inner[0].constraints[1].patch, VersionField::Exact(0));
+    }
+
+    #[test]
+    fn test_version_is_exact() {
+        let version = VersionImpl::new("1.0.0");
+        assert_eq!(version.is_exact(), true);
+
+        let version = VersionImpl::new("1.0.0 || 2.0.0");
+        assert_eq!(version.is_exact(), false);
+
+        let version = VersionImpl::new(">=1.0.0 <2.0.0");
+        assert_eq!(version.is_exact(), false);
+
+        let version = VersionImpl::new("1.0.0 - 2.0.0");
+        assert_eq!(version.is_exact(), false);
+
+        let version = VersionImpl::new("1.*.*");
+        assert_eq!(version.is_exact(), false);
+    }
+
+    #[test]
+    fn test_version_satisfies() {
+
+    }
+
+    #[test]
+    fn test_version_satisfies_range() {
+
+    }
+}