419 lines
13 KiB
Rust
419 lines
13 KiB
Rust
// MIT License
|
|
// Copyright (c) 2025 Mahesh @ HeshApps
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
//! Unit tests for Weather module for Unibar
|
|
use super::*;
|
|
use crate::bar_modules::BarModuleActions; // Add this line
|
|
use crate::common::AppOptions;
|
|
use crate::common::TemperatureUnits;
|
|
|
|
/// Creates a default AppOptions instance for testing
|
|
fn create_test_options(metric: bool) -> AppOptions {
|
|
AppOptions {
|
|
interval: 1,
|
|
weather_units: if metric { TemperatureUnits::Metric } else { TemperatureUnits::Imperial },
|
|
weather_station: "test_station".to_string(),
|
|
music_progress: false,
|
|
debug: false,
|
|
debug_modules: false,
|
|
debug_update: false,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Test get_current_temperature returns correct value for metric and imperial units
|
|
fn test_get_current_temperature_units() {
|
|
let mut metric_module = UnibarModuleWeather::new(create_test_options(true));
|
|
let mut imperial_module = UnibarModuleWeather::new(create_test_options(false));
|
|
|
|
metric_module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": 25.0
|
|
}
|
|
}
|
|
}]
|
|
});
|
|
imperial_module.weather_info = metric_module.weather_info.clone();
|
|
|
|
assert_eq!(metric_module.get_current_temperature().unwrap(), 25.0);
|
|
assert!((imperial_module.get_current_temperature().unwrap() - 77.0).abs() < 0.01);
|
|
}
|
|
|
|
#[test]
|
|
/// Test get_unicode_symbol returns default for unknown condition
|
|
fn test_get_unicode_symbol_default() {
|
|
let module = UnibarModuleWeather::new(create_test_options(true));
|
|
assert_eq!(module.get_unicode_symbol("not_a_real_condition"), "🌤️");
|
|
}
|
|
|
|
#[test]
|
|
/// Test clear resets weather_info to Null
|
|
fn test_clear_resets_weather_info() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
module.weather_info = json!({"features": []});
|
|
module.clear();
|
|
assert_eq!(module.weather_info, json!(serde_json::Value::Null));
|
|
}
|
|
|
|
#[test]
|
|
/// Test get_content returns formatted temperature string
|
|
fn test_get_content_format() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": 18.7
|
|
}
|
|
}
|
|
}]
|
|
});
|
|
let content = module.get_content();
|
|
assert!(content.starts_with("19°C"));
|
|
}
|
|
|
|
#[test]
|
|
/// Test get_icon returns fallback when icon is missing
|
|
fn test_get_icon_missing_icon() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"icon": serde_json::Value::Null
|
|
}
|
|
}]
|
|
});
|
|
assert_eq!(module.get_icon(), "⁈");
|
|
}
|
|
|
|
#[test]
|
|
/// Test get_icon returns fallback when weather_info is Null
|
|
fn test_get_icon_null_weather_info() {
|
|
let module = UnibarModuleWeather::new(create_test_options(true));
|
|
assert_eq!(module.get_icon(), "⁈");
|
|
}
|
|
|
|
#[test]
|
|
/// Test weather module initialization
|
|
fn test_module_initialization() {
|
|
let module = UnibarModuleWeather::new(create_test_options(true));
|
|
assert_eq!(module.update_cnt, 0);
|
|
assert_eq!(module.weather_info, json!(serde_json::Value::Null));
|
|
}
|
|
|
|
#[test]
|
|
/// Test temperature unit display
|
|
fn test_temperature_unit_display() {
|
|
let metric_module = UnibarModuleWeather::new(create_test_options(true));
|
|
let imperial_module = UnibarModuleWeather::new(create_test_options(false));
|
|
|
|
assert_eq!(metric_module.get_temperature_unit(), "°C");
|
|
assert_eq!(imperial_module.get_temperature_unit(), "°F");
|
|
}
|
|
|
|
#[test]
|
|
/// Test weather condition to Unicode symbol mapping
|
|
fn test_unicode_symbol_mapping() {
|
|
let module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
assert_eq!(module.get_unicode_symbol("snow"), "❄️");
|
|
assert_eq!(module.get_unicode_symbol("ovc"), "☁️");
|
|
assert_eq!(module.get_unicode_symbol("rain"), "🌧️");
|
|
assert_eq!(module.get_unicode_symbol("unknown"), "🌤️");
|
|
}
|
|
|
|
#[test]
|
|
/// Test error handling for invalid temperature data
|
|
fn test_error_handling() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
// Test null weather info
|
|
assert!(module.get_current_temperature().is_ok());
|
|
assert_eq!(module.get_current_temperature().unwrap(), 0.0);
|
|
|
|
// Test invalid JSON structure
|
|
module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": "invalid"
|
|
}
|
|
}
|
|
}]
|
|
});
|
|
assert!(module.get_current_temperature().is_err());
|
|
}
|
|
|
|
#[test]
|
|
/// Test update counter behavior. Update only when update_cnt==0
|
|
fn test_update_counter() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
assert_eq!(module.update_cnt, 0);
|
|
assert_eq!(module.should_update(), UpdateResult::Update);
|
|
|
|
module.update_cnt = UPDATE_INTERVAL - 1;
|
|
assert_eq!(module.should_update(), UpdateResult::Skip);
|
|
|
|
module.update_cnt = UPDATE_INTERVAL;
|
|
assert_eq!(module.should_update(), UpdateResult::Skip);
|
|
}
|
|
|
|
#[test]
|
|
/// Test JSON parsing with valid weather data
|
|
fn test_valid_weather_data_parsing() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
// Simulate valid weather data
|
|
module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": 20.5
|
|
}
|
|
}
|
|
}]
|
|
});
|
|
|
|
// println!("{:#?}", module.weather_info);
|
|
let result = module.get_current_temperature();
|
|
// println!("{:#?}", result);
|
|
match result {
|
|
Ok(20.5) => {
|
|
// This is fine - we expect 20.5 for valid weather_info
|
|
assert_eq!(module.weather_info["features"][0]["properties"]["temperature"]["value"], 20.5);
|
|
},
|
|
Err(WeatherError::ApiResponseStrErr(_)) => {
|
|
assert!(false, "Expected valid temperature but got ApiResponseStrErr");
|
|
},
|
|
other => {
|
|
panic!("Unexpected result: {:?}", other);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Test icon extraction from weather API URL
|
|
fn test_icon_extraction() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
// Simulate weather data with icon URL
|
|
module.weather_info = json!({
|
|
"features": [{
|
|
"properties": {
|
|
"icon": "https://api.weather.gov/icons/land/night/ovc?size=medium"
|
|
}
|
|
}]
|
|
});
|
|
let icon = module.get_icon();
|
|
// println!("Extracted icon: {}", icon);
|
|
// Check if the icon is correctly extracted
|
|
assert_eq!(icon, "☁️");
|
|
}
|
|
|
|
#[test]
|
|
/// Test handling of malformed/incomplete JSON structures
|
|
fn test_missing_json_structure() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
// Test cases with increasingly incomplete JSON structures
|
|
let test_cases = vec![
|
|
// Missing value field
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {}
|
|
}
|
|
}]
|
|
}),
|
|
// Missing temperature object
|
|
json!({
|
|
"features": [{
|
|
"properties": {}
|
|
}]
|
|
}),
|
|
// Missing properties
|
|
json!({
|
|
"features": [{}]
|
|
}),
|
|
// Empty features array
|
|
json!({
|
|
"features": []
|
|
}),
|
|
// Missing features
|
|
json!({}),
|
|
// Completely different structure
|
|
json!({
|
|
"unexpected": "structure"
|
|
}),
|
|
// Empty object
|
|
json!({}),
|
|
// Null value
|
|
json!(null),
|
|
// Array instead of object
|
|
json!([1, 2, 3]),
|
|
// Wrong data types
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": true // boolean instead of number
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
];
|
|
|
|
for (i, test_case) in test_cases.into_iter().enumerate() {
|
|
module.weather_info = test_case;
|
|
let result = module.get_current_temperature();
|
|
|
|
match result {
|
|
Ok(0.0) => {
|
|
// This is fine - we expect 0.0 for null weather_info
|
|
assert_eq!(module.weather_info, json!(null),
|
|
"Case {}: Should return 0.0 only for null weather_info", i);
|
|
},
|
|
Err(WeatherError::ApiResponseStrErr(_)) => {
|
|
// This is also fine - we expect ApiResponseStrErr for malformed data
|
|
},
|
|
other => {
|
|
panic!("Case {}: Unexpected result: {:?}", i, other);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Test handling of malformed temperature values
|
|
fn test_invalid_temperature_values() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
let test_cases = vec![
|
|
// Invalid temperature values
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": "not a number"
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": ""
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": null
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": {}
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": []
|
|
}
|
|
}
|
|
}]
|
|
})
|
|
];
|
|
|
|
for (i, test_case) in test_cases.into_iter().enumerate() {
|
|
module.weather_info = test_case;
|
|
let result = module.get_current_temperature();
|
|
|
|
assert!(matches!(result, Err(WeatherError::ApiResponseStrErr(_))),
|
|
"Case {}: Expected ApiResponseStrErr for invalid temperature value", i);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Test that deep nested access is safe
|
|
fn test_deep_nested_access() {
|
|
let mut module = UnibarModuleWeather::new(create_test_options(true));
|
|
|
|
// Test accessing nested fields that don't exist
|
|
let test_cases = vec![
|
|
// Deeper nesting than expected
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"value": {
|
|
"nested": "too deep"
|
|
}
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
// Missing intermediate fields
|
|
json!({
|
|
"features": [{
|
|
"properties": {
|
|
"temperature": {
|
|
"missing_value": 20.5
|
|
}
|
|
}
|
|
}]
|
|
}),
|
|
// Wrong nesting structure
|
|
json!({
|
|
"features": { // Object instead of array
|
|
"properties": {
|
|
"temperature": {
|
|
"value": 20.5
|
|
}
|
|
}
|
|
}
|
|
})
|
|
];
|
|
|
|
for (i, test_case) in test_cases.into_iter().enumerate() {
|
|
module.weather_info = test_case;
|
|
let result = module.get_current_temperature();
|
|
|
|
assert!(matches!(result, Err(WeatherError::ApiResponseStrErr(_))),
|
|
"Case {}: Expected ApiResponseStrErr for invalid nested structure", i);
|
|
}
|
|
}
|