helpdesk_rating_five_stars/tests/test_star_highlighting.py

# -*- coding: utf-8 -*-

from odoo.tests.common import TransactionCase
from hypothesis import given, strategies as st, settings


class TestStarHighlighting(TransactionCase):
    """
    Test cases for star highlighting behavior
    
    Property 2: Star highlighting follows selection
    For any star selected, the system should highlight that star 
    and all stars with lower numbers.
    
    Validates: Requirements 1.2
    """

    def setUp(self):
        super(TestStarHighlighting, self).setUp()
        # We'll test the highlighting logic that would be used in the frontend
        # The logic is: if star_number <= selected_value, then star is highlighted
        self.max_stars = 5

    def _get_highlighted_stars(self, selected_value):
        """
        Simulate the highlighting logic from the JavaScript component.
        Returns a list of star numbers that should be highlighted.
        
        This mirrors the isStarFilled() logic in rating_stars.js:
        - A star is filled if starNumber <= displayValue
        """
        if selected_value == 0:
            return []
        return list(range(1, int(selected_value) + 1))

    def _verify_highlighting_property(self, selected_star):
        """
        Verify that when a star is selected, that star and all stars 
        with lower numbers are highlighted.
        
        Args:
            selected_star: The star number that was selected (1-5)
        """
        highlighted = self._get_highlighted_stars(selected_star)
        
        # Property: All stars from 1 to selected_star should be highlighted
        expected_highlighted = list(range(1, selected_star + 1))
        
        self.assertEqual(
            highlighted, 
            expected_highlighted,
            f"When star {selected_star} is selected, stars {expected_highlighted} "
            f"should be highlighted, but got {highlighted}"
        )
        
        # Verify the count matches
        self.assertEqual(
            len(highlighted),
            selected_star,
            f"When star {selected_star} is selected, exactly {selected_star} "
            f"stars should be highlighted, but {len(highlighted)} were highlighted"
        )
        
        # Verify all highlighted stars are <= selected_star
        for star in highlighted:
            self.assertLessEqual(
                star,
                selected_star,
                f"Highlighted star {star} should be <= selected star {selected_star}"
            )
        
        # Verify all stars > selected_star are NOT highlighted
        for star in range(selected_star + 1, self.max_stars + 1):
            self.assertNotIn(
                star,
                highlighted,
                f"Star {star} should NOT be highlighted when star {selected_star} is selected"
            )

    # Feature: helpdesk-rating-five-stars, Property 2: Star highlighting follows selection
    @given(selected_star=st.integers(min_value=1, max_value=5))
    @settings(max_examples=100, deadline=None)
    def test_property_star_highlighting_follows_selection(self, selected_star):
        """
        Property 2: Star highlighting follows selection
        
        For any star selected (1-5), the system should highlight that star 
        and all stars with lower numbers.
        
        This tests the core highlighting logic that ensures:
        1. The selected star is highlighted
        2. All stars with numbers < selected star are highlighted
        3. All stars with numbers > selected star are NOT highlighted
        
        Validates: Requirements 1.2
        """
        self._verify_highlighting_property(selected_star)

    def test_star_highlighting_specific_cases(self):
        """
        Test specific cases to ensure highlighting works correctly
        """
        # Test case 1: Select star 1 -> only star 1 highlighted
        highlighted = self._get_highlighted_stars(1)
        self.assertEqual(highlighted, [1], "Only star 1 should be highlighted")
        
        # Test case 2: Select star 3 -> stars 1, 2, 3 highlighted
        highlighted = self._get_highlighted_stars(3)
        self.assertEqual(highlighted, [1, 2, 3], "Stars 1, 2, 3 should be highlighted")
        
        # Test case 3: Select star 5 -> all stars highlighted
        highlighted = self._get_highlighted_stars(5)
        self.assertEqual(highlighted, [1, 2, 3, 4, 5], "All stars should be highlighted")
        
        # Test case 4: No selection (0) -> no stars highlighted
        highlighted = self._get_highlighted_stars(0)
        self.assertEqual(highlighted, [], "No stars should be highlighted")

    def test_star_highlighting_sequential_selection(self):
        """
        Test that highlighting updates correctly when selection changes
        """
        # Simulate selecting stars in sequence
        for star in range(1, self.max_stars + 1):
            highlighted = self._get_highlighted_stars(star)
            
            # Verify correct number of stars highlighted
            self.assertEqual(
                len(highlighted),
                star,
                f"Selecting star {star} should highlight {star} stars"
            )
            
            # Verify the highlighted stars are exactly [1, 2, ..., star]
            self.assertEqual(
                highlighted,
                list(range(1, star + 1)),
                f"Selecting star {star} should highlight stars 1 through {star}"
            )

    def test_star_highlighting_reverse_selection(self):
        """
        Test that highlighting works correctly when selecting in reverse order
        """
        # Simulate selecting stars in reverse sequence
        for star in range(self.max_stars, 0, -1):
            highlighted = self._get_highlighted_stars(star)
            
            # Verify correct number of stars highlighted
            self.assertEqual(
                len(highlighted),
                star,
                f"Selecting star {star} should highlight {star} stars"
            )
            
            # Verify the highlighted stars are exactly [1, 2, ..., star]
            self.assertEqual(
                highlighted,
                list(range(1, star + 1)),
                f"Selecting star {star} should highlight stars 1 through {star}"
            )

    def test_star_highlighting_boundary_cases(self):
        """
        Test boundary cases for star highlighting
        """
        # Minimum valid selection (star 1)
        highlighted = self._get_highlighted_stars(1)
        self.assertEqual(len(highlighted), 1, "Minimum selection should highlight 1 star")
        self.assertIn(1, highlighted, "Star 1 should be highlighted")
        
        # Maximum valid selection (star 5)
        highlighted = self._get_highlighted_stars(5)
        self.assertEqual(len(highlighted), 5, "Maximum selection should highlight 5 stars")
        for star in range(1, 6):
            self.assertIn(star, highlighted, f"Star {star} should be highlighted")
        
        # No selection (0)
        highlighted = self._get_highlighted_stars(0)
        self.assertEqual(len(highlighted), 0, "No selection should highlight 0 stars")

    def test_star_highlighting_consistency(self):
        """
        Test that highlighting is consistent across multiple calls
        """
        for star in range(1, self.max_stars + 1):
            # Call multiple times with same value
            result1 = self._get_highlighted_stars(star)
            result2 = self._get_highlighted_stars(star)
            result3 = self._get_highlighted_stars(star)
            
            # All results should be identical
            self.assertEqual(result1, result2, "Highlighting should be consistent")
            self.assertEqual(result2, result3, "Highlighting should be consistent")
            self.assertEqual(result1, result3, "Highlighting should be consistent")