test: add tests for item systems & movement types

tests/item.rs

@@ -0,0 +1,159 @@
+use pacman::systems::components::EntityType;
+
+// Helper functions that extract the core scoring logic from item_system
+// This allows us to test the business rules without ECS complexity
+
+fn calculate_score_for_item(entity_type: EntityType) -> Option<u32> {
+    match entity_type {
+        EntityType::Pellet => Some(10),
+        EntityType::PowerPellet => Some(50),
+        _ => None,
+    }
+}
+
+fn is_collectible_item(entity_type: EntityType) -> bool {
+    matches!(entity_type, EntityType::Pellet | EntityType::PowerPellet)
+}
+
+fn should_trigger_audio_on_collection(entity_type: EntityType) -> bool {
+    is_collectible_item(entity_type)
+}
+
+#[test]
+fn test_pellet_scoring() {
+    assert_eq!(calculate_score_for_item(EntityType::Pellet), Some(10));
+}
+
+#[test]
+fn test_power_pellet_scoring() {
+    assert_eq!(calculate_score_for_item(EntityType::PowerPellet), Some(50));
+}
+
+#[test]
+fn test_non_collectible_items_no_score() {
+    assert_eq!(calculate_score_for_item(EntityType::Player), None);
+    assert_eq!(calculate_score_for_item(EntityType::Ghost), None);
+}
+
+#[test]
+fn test_collectible_item_detection() {
+    assert!(is_collectible_item(EntityType::Pellet));
+    assert!(is_collectible_item(EntityType::PowerPellet));
+    assert!(!is_collectible_item(EntityType::Player));
+    assert!(!is_collectible_item(EntityType::Ghost));
+}
+
+#[test]
+fn test_audio_trigger_for_collectibles() {
+    assert!(should_trigger_audio_on_collection(EntityType::Pellet));
+    assert!(should_trigger_audio_on_collection(EntityType::PowerPellet));
+    assert!(!should_trigger_audio_on_collection(EntityType::Player));
+    assert!(!should_trigger_audio_on_collection(EntityType::Ghost));
+}
+
+#[test]
+fn test_score_progression() {
+    // Test that power pellets are worth more than regular pellets
+    let pellet_score = calculate_score_for_item(EntityType::Pellet).unwrap();
+    let power_pellet_score = calculate_score_for_item(EntityType::PowerPellet).unwrap();
+
+    assert!(power_pellet_score > pellet_score);
+    assert_eq!(power_pellet_score / pellet_score, 5); // Power pellets are worth 5x regular pellets
+}
+
+#[test]
+fn test_entity_type_variants() {
+    // Test all EntityType variants to ensure they're handled appropriately
+    let all_types = vec![
+        EntityType::Player,
+        EntityType::Ghost,
+        EntityType::Pellet,
+        EntityType::PowerPellet,
+    ];
+
+    let mut collectible_count = 0;
+    let mut non_collectible_count = 0;
+
+    for entity_type in all_types {
+        if is_collectible_item(entity_type) {
+            collectible_count += 1;
+            // All collectible items should have a score
+            assert!(calculate_score_for_item(entity_type).is_some());
+        } else {
+            non_collectible_count += 1;
+            // Non-collectible items should not have a score
+            assert!(calculate_score_for_item(entity_type).is_none());
+        }
+    }
+
+    // Verify we have the expected number of each type
+    assert_eq!(collectible_count, 2); // Pellet and PowerPellet
+    assert_eq!(non_collectible_count, 2); // Player and Ghost
+}
+
+#[test]
+fn test_score_accumulation() {
+    // Test score accumulation logic (simulating multiple collections)
+    let mut total_score = 0u32;
+
+    // Collect some items
+    let collected_items = vec![
+        EntityType::Pellet,
+        EntityType::Pellet,
+        EntityType::PowerPellet,
+        EntityType::Pellet,
+        EntityType::PowerPellet,
+    ];
+
+    for item in collected_items {
+        if let Some(score) = calculate_score_for_item(item) {
+            total_score += score;
+        }
+    }
+
+    // Expected: 3 pellets (30) + 2 power pellets (100) = 130
+    assert_eq!(total_score, 130);
+}
+
+#[test]
+fn test_collision_filtering_logic() {
+    // Test the logic for determining valid collision pairs
+    // This mirrors the logic in item_system that checks entity types
+
+    let test_cases = vec![
+        (EntityType::Player, EntityType::Pellet, true),
+        (EntityType::Player, EntityType::PowerPellet, true),
+        (EntityType::Player, EntityType::Ghost, false), // Not handled by item system
+        (EntityType::Player, EntityType::Player, false), // Not a valid collision
+        (EntityType::Ghost, EntityType::Pellet, false), // Ghosts don't collect items
+        (EntityType::Pellet, EntityType::PowerPellet, false), // Items don't interact
+    ];
+
+    for (entity1, entity2, should_be_valid) in test_cases {
+        let is_valid_item_collision = (entity1 == EntityType::Player && is_collectible_item(entity2))
+            || (entity2 == EntityType::Player && is_collectible_item(entity1));
+
+        assert_eq!(
+            is_valid_item_collision, should_be_valid,
+            "Failed for collision between {:?} and {:?}",
+            entity1, entity2
+        );
+    }
+}
+
+#[test]
+fn test_item_collection_side_effects() {
+    // Test that collecting items should trigger the expected side effects
+    let collectible_items = vec![EntityType::Pellet, EntityType::PowerPellet];
+
+    for item in collectible_items {
+        // Should provide score
+        assert!(calculate_score_for_item(item).is_some());
+
+        // Should trigger audio
+        assert!(should_trigger_audio_on_collection(item));
+
+        // Should be marked as collectible
+        assert!(is_collectible_item(item));
+    }
+}