feat(tests): implement initial unit tests

Author: jsrwell

.github/workflows/ci.yml

@@ -64,11 +64,45 @@ jobs:
               uses: Swatinem/rust-cache@v2
             - name: Generate coverage
               run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+            - name: Generate coverage JSON
+              run: cargo llvm-cov --all-features --workspace --json --output-path coverage.json
+            - name: Extract coverage percentage
+              id: coverage
+              run: |
+                  COVERAGE=$(cargo llvm-cov --all-features --workspace 2>&1 | grep "TOTAL" | awk '{print $NF}' | tr -d '%')
+                  echo "percentage=${COVERAGE}" >> $GITHUB_OUTPUT
+                  echo "Coverage: ${COVERAGE}%"
+
+                  # Create badge JSON for shields.io endpoint
+                  COLOR="red"
+                  if (( $(echo "$COVERAGE >= 90" | bc -l) )); then
+                    COLOR="brightgreen"
+                  elif (( $(echo "$COVERAGE >= 80" | bc -l) )); then
+                    COLOR="green"
+                  elif (( $(echo "$COVERAGE >= 70" | bc -l) )); then
+                    COLOR="yellowgreen"
+                  elif (( $(echo "$COVERAGE >= 60" | bc -l) )); then
+                    COLOR="yellow"
+                  elif (( $(echo "$COVERAGE >= 50" | bc -l) )); then
+                    COLOR="orange"
+                  fi
+
+                  echo "{\"schemaVersion\":1,\"label\":\"coverage\",\"message\":\"${COVERAGE}%\",\"color\":\"${COLOR}\"}" > coverage-badge.json
             - name: Upload coverage to Codecov
               uses: codecov/codecov-action@v4
               with:
                   files: lcov.info
                   fail_ci_if_error: false
+            - name: Upload coverage badge artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: coverage-badge
+                  path: coverage-badge.json
+            - name: Upload coverage report
+              uses: actions/upload-artifact@v4
+              with:
+                  name: coverage-report
+                  path: coverage.json
 
     build:
         name: Build

crates/ev-core/src/domain/mod.rs

@@ -10,7 +10,7 @@ mod types;
 mod vehicle;
 
 pub use battery::{Battery, Preconditioning, UsableSocWindow, Warranty};
-pub use body::{Body, Capacity, Dimensions, Weights};
+pub use body::{Body, Capacity, Dimensions, Performance, Weights};
 pub use charging::{
     ChargeCurve, ChargeCurvePoint, ChargePort, Charging, ChargingAc, ChargingDc, ChargingProtocols,
     ChargingTime, Conditions,
@@ -22,5 +22,5 @@ pub use sources::Source;
 pub use types::{SlugName, VehicleId, Year};
 pub use vehicle::{Vehicle, VehicleAvailability};
 
-pub use charging::{V2LOutlet, V2G, V2H, V2L, V2X};
+pub use charging::{V2G, V2H, V2L, V2LOutlet, V2X};
 pub use metadata::{Msrp, Pricing, Software, WheelsTires};

crates/ev-core/src/domain/types.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::error::ValidationError;
-use crate::validation::{validate_slug, validate_year, Validate};
+use crate::validation::{Validate, validate_slug, validate_year};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct SlugName {

crates/ev-core/src/domain/vehicle.rs

@@ -309,4 +309,149 @@ mod tests {
             Err(ValidationError::MissingChargePort)
         ));
     }
+
+    #[test]
+    fn test_vehicle_missing_range() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.range.rated = vec![];
+        assert!(matches!(
+            vehicle.validate(),
+            Err(ValidationError::MissingRatedRange)
+        ));
+    }
+
+    #[test]
+    fn test_vehicle_missing_sources() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.sources = vec![];
+        assert!(matches!(
+            vehicle.validate(),
+            Err(ValidationError::MissingSource)
+        ));
+    }
+
+    #[test]
+    fn test_vehicle_multiple_validation_errors() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.battery = Battery::default();
+        vehicle.charge_ports = vec![];
+        vehicle.range.rated = vec![];
+        vehicle.sources = vec![];
+        assert!(matches!(
+            vehicle.validate(),
+            Err(ValidationError::Multiple(_))
+        ));
+    }
+
+    #[test]
+    fn test_vehicle_is_variant_false() {
+        let vehicle = create_test_vehicle();
+        assert!(!vehicle.is_variant());
+    }
+
+    #[test]
+    fn test_vehicle_is_variant_true() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.variant = Some(Variant {
+            slug: "long_range".to_string(),
+            name: "Long Range".to_string(),
+            kind: None,
+            notes: None,
+        });
+        assert!(vehicle.is_variant());
+    }
+
+    #[test]
+    fn test_vehicle_usable_battery_kwh() {
+        let vehicle = create_test_vehicle();
+        assert_eq!(vehicle.usable_battery_kwh(), Some(60.0));
+    }
+
+    #[test]
+    fn test_vehicle_usable_battery_kwh_none() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.battery = Battery::default();
+        assert_eq!(vehicle.usable_battery_kwh(), None);
+    }
+
+    #[test]
+    fn test_vehicle_wltp_range_km() {
+        let vehicle = create_test_vehicle();
+        assert_eq!(vehicle.wltp_range_km(), Some(513.0));
+    }
+
+    #[test]
+    fn test_vehicle_epa_range_km_none() {
+        let vehicle = create_test_vehicle();
+        assert_eq!(vehicle.epa_range_km(), None);
+    }
+
+    #[test]
+    fn test_vehicle_epa_range_km_some() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.range.rated.push(RangeRated {
+            cycle: RangeCycle::Epa,
+            range_km: 400.0,
+            notes: None,
+        });
+        assert_eq!(vehicle.epa_range_km(), Some(400.0));
+    }
+
+    #[test]
+    fn test_vehicle_max_dc_power_kw_none() {
+        let vehicle = create_test_vehicle();
+        assert_eq!(vehicle.max_dc_power_kw(), None);
+    }
+
+    #[test]
+    fn test_vehicle_max_dc_power_kw_some() {
+        use crate::domain::charging::ChargingDc;
+        let mut vehicle = create_test_vehicle();
+        vehicle.charging.dc = Some(ChargingDc {
+            max_power_kw: 250.0,
+            voltage_range_v: None,
+            max_current_a: None,
+            architecture_voltage_class: None,
+            power_limits_by_voltage: None,
+            notes: None,
+        });
+        assert_eq!(vehicle.max_dc_power_kw(), Some(250.0));
+    }
+
+    #[test]
+    fn test_vehicle_max_ac_power_kw_none() {
+        let vehicle = create_test_vehicle();
+        assert_eq!(vehicle.max_ac_power_kw(), None);
+    }
+
+    #[test]
+    fn test_vehicle_max_ac_power_kw_some() {
+        use crate::domain::charging::ChargingAc;
+        let mut vehicle = create_test_vehicle();
+        vehicle.charging.ac = Some(ChargingAc {
+            max_power_kw: 11.0,
+            supported_power_steps_kw: None,
+            phases: None,
+            voltage_range_v: None,
+            frequency_hz: None,
+            max_current_a: None,
+            onboard_charger_count: None,
+            notes: None,
+        });
+        assert_eq!(vehicle.max_ac_power_kw(), Some(11.0));
+    }
+
+    #[test]
+    fn test_vehicle_invalid_make_slug() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.make.slug = "INVALID".to_string();
+        assert!(vehicle.validate().is_err());
+    }
+
+    #[test]
+    fn test_vehicle_invalid_year() {
+        let mut vehicle = create_test_vehicle();
+        vehicle.year = 1800;
+        assert!(vehicle.validate().is_err());
+    }
 }

crates/ev-core/src/lib.rs

@@ -11,9 +11,9 @@ pub mod validation;
 pub use domain::{
     Battery, Body, Capacity, ChargeCurve, ChargeCurvePoint, ChargePort, Charging, ChargingAc,
     ChargingDc, ChargingProtocols, ChargingTime, Conditions, Dimensions, Efficiency, Images, Links,
-    Metadata, Motor, Msrp, Powertrain, Preconditioning, Pricing, Range, RangeRated, RangeRealWorld,
-    SlugName, Source, Transmission, UsableSocWindow, V2LOutlet, Variant, Vehicle,
-    VehicleAvailability, VehicleId, Warranty, Weights, WheelsTires, Year, V2G, V2H, V2L, V2X,
+    Metadata, Motor, Msrp, Performance, Powertrain, Preconditioning, Pricing, Range, RangeRated,
+    RangeRealWorld, SlugName, Source, Transmission, UsableSocWindow, V2G, V2H, V2L, V2LOutlet, V2X,
+    Variant, Vehicle, VehicleAvailability, VehicleId, Warranty, Weights, WheelsTires, Year,
 };
 
 pub use domain::enums::{

crates/ev-core/src/validation.rs

@@ -131,4 +131,53 @@ mod tests {
         assert!(validate_currency_code("usd").is_err());
         assert!(validate_currency_code("US").is_err());
     }
+
+    #[test]
+    fn test_validate_url_valid() {
+        assert!(validate_url("https://example.com").is_ok());
+        assert!(validate_url("http://example.com").is_ok());
+        assert!(validate_url("https://example.com/path").is_ok());
+    }
+
+    #[test]
+    fn test_validate_url_invalid() {
+        assert!(validate_url("").is_err());
+        assert!(validate_url("example.com").is_err());
+        assert!(validate_url("ftp://example.com").is_err());
+        assert!(validate_url("www.example.com").is_err());
+    }
+
+    #[test]
+    fn test_collect_errors_empty() {
+        let items: Vec<String> = vec![];
+        let result = collect_errors(items, |_: &String| Ok(()));
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_collect_errors_all_valid() {
+        let items = vec!["tesla", "byd", "rivian"];
+        let result = collect_errors(items, |s: &&str| validate_slug(s));
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_collect_errors_single_error() {
+        let items = vec!["tesla", "INVALID", "rivian"];
+        let result = collect_errors(items, |s: &&str| validate_slug(s));
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(matches!(e, ValidationError::InvalidSlug { .. }));
+        }
+    }
+
+    #[test]
+    fn test_collect_errors_multiple_errors() {
+        let items = vec!["INVALID1", "INVALID2", "INVALID3"];
+        let result = collect_errors(items, |s: &&str| validate_slug(s));
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert!(matches!(e, ValidationError::Multiple(_)));
+        }
+    }
 }

crates/ev-etl/src/main.rs

@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use clap::Parser;
 use ev_etl::{cli::Cli, run_pipeline, run_validation};
-use tracing::{info, Level};
+use tracing::{Level, info};
 use tracing_subscriber::FmtSubscriber;
 
 fn main() -> Result<()> {

crates/ev-etl/src/merge/strategy.rs

@@ -97,4 +97,77 @@ mod tests {
         let result = deep_merge(&base, &overlay);
         assert_eq!(result, json!({"ports": ["nacs"]}));
     }
+
+    #[test]
+    fn test_merge_arrays_replace() {
+        let base = vec![json!("a"), json!("b")];
+        let overlay = vec![json!("c")];
+        let result = merge_arrays_replace(&base, &overlay);
+        assert_eq!(result, vec![json!("c")]);
+    }
+
+    #[test]
+    fn test_merge_arrays_replace_empty_overlay() {
+        let base = vec![json!("a"), json!("b")];
+        let overlay: Vec<Value> = vec![];
+        let result = merge_arrays_replace(&base, &overlay);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_remove_null_values_simple() {
+        let mut value = json!({"a": 1, "b": null, "c": 3});
+        remove_null_values(&mut value);
+        assert_eq!(value, json!({"a": 1, "c": 3}));
+    }
+
+    #[test]
+    fn test_remove_null_values_nested() {
+        let mut value = json!({
+            "a": 1,
+            "nested": {
+                "b": null,
+                "c": 2
+            }
+        });
+        remove_null_values(&mut value);
+        assert_eq!(value, json!({"a": 1, "nested": {"c": 2}}));
+    }
+
+    #[test]
+    fn test_remove_null_values_array() {
+        let mut value = json!([{"a": null}, {"b": 1}]);
+        remove_null_values(&mut value);
+        assert_eq!(value, json!([{}, {"b": 1}]));
+    }
+
+    #[test]
+    fn test_remove_null_values_no_nulls() {
+        let mut value = json!({"a": 1, "b": 2});
+        remove_null_values(&mut value);
+        assert_eq!(value, json!({"a": 1, "b": 2}));
+    }
+
+    #[test]
+    fn test_remove_null_values_scalar() {
+        let mut value = json!(42);
+        remove_null_values(&mut value);
+        assert_eq!(value, json!(42));
+    }
+
+    #[test]
+    fn test_deep_merge_scalar_override() {
+        let base = json!({"value": 1});
+        let overlay = json!({"value": "string"});
+        let result = deep_merge(&base, &overlay);
+        assert_eq!(result["value"], "string");
+    }
+
+    #[test]
+    fn test_deep_merge_non_object_base() {
+        let base = json!("scalar");
+        let overlay = json!({"a": 1});
+        let result = deep_merge(&base, &overlay);
+        assert_eq!(result, json!({"a": 1}));
+    }
 }