Merge pull request steam-bell-92#780 from jbkun069/fix/number-guessing-input-validation

fix: improve input validation and add proximity hints in number …

Author: steam-bell-92

games/Number-Guessing-Game/Number-Guessing-Game.py

@@ -1,65 +1,136 @@
 import random
+from typing import Tuple, List
+
+# Game constants
+MIN_NUMBER = 1
+MAX_NUMBER = 100
+
+# Difficulty levels
+DIFFICULTY_LEVELS = {
+    "1": {"level": "Easy", "attempts": 15},
+    "2": {"level": "Medium", "attempts": 10},
+    "3": {"level": "Hard", "attempts": 5},
+}
+DEFAULT_DIFFICULTY = "2"
+
+# Proximity hint thresholds
+VERY_CLOSE_THRESHOLD = 3
+CLOSE_THRESHOLD = 10
+NOT_CLOSE_THRESHOLD = 20
+
+
+def validate_guess(guess_num: int) -> bool:
+    """Check if guess is within valid range."""
+    return MIN_NUMBER <= guess_num <= MAX_NUMBER
+
+
+def get_proximity_hint(diff: int) -> str:
+    """Return a hint based on how close the guess is."""
+    if diff <= VERY_CLOSE_THRESHOLD:
+        return "Very close!"
+    elif diff <= CLOSE_THRESHOLD:
+        return "Close."
+    elif diff <= NOT_CLOSE_THRESHOLD:
+        return "Not very close."
+    else:
+        return "Far off."
+
+
+def choose_difficulty() -> int:
+    """Let the user choose a difficulty level."""
+    print("Choose difficulty:")
+    print("  1) Easy   - 15 attempts")
+    print("  2) Medium - 10 attempts")
+    print("  3) Hard   - 5 attempts")
 
-
-def choose_difficulty():
-    print("🎯 Choose difficulty:")
-    print("  1) 🟢 Easy   - 15 attempts")
-    print("  2) 🟡 Medium - 10 attempts")
-    print("  3) 🔴 Hard   - 5 attempts")
     while True:
-        choice = input("Select 1, 2 or 3 (default 2): ").strip() or "2"
-        if choice in ("1", "2", "3"):
-            return {"1": 15, "2": 10, "3": 5}[choice]
-        print("⚠️ Invalid selection. Please enter 1, 2 or 3.")
+        choice = input("Select 1, 2 or 3 (default 2): ").strip() or DEFAULT_DIFFICULTY
+
+        if choice in DIFFICULTY_LEVELS:
+            return DIFFICULTY_LEVELS[choice]["attempts"]
+
+        print("Invalid selection. Please enter 1, 2 or 3.")
+
+
+def get_guess_input(remaining: int) -> int | None:
+    """
+    Get and validate user input.
+
+    Args:
+        remaining: Attempts left
+
+    Returns:
+        Valid guess number or None
+    """
+    try:
+        guess = input(f"Guess ({remaining} left): ").strip()
+
+        if not guess:
+            print("Input cannot be empty.")
+            return None
+
+        guess_num = int(guess)
+
+        if not validate_guess(guess_num):
+            print(f"Enter a number between {MIN_NUMBER} and {MAX_NUMBER}.")
+            return None
 
+        return guess_num
+
+    except ValueError:
+        print("Invalid input. Please enter a whole number.")
+        return None
+
+
+def play_round(max_attempts: int) -> Tuple[bool, int]:
+    """
+    Run one round of the game.
 
-def play_round(max_attempts: int):
-    number = random.randint(1, 100)
+    Args:
+        max_attempts: Maximum guesses allowed
+
+    Returns:
+        Tuple of (won, attempts_used)
+    """
+    number = random.randint(MIN_NUMBER, MAX_NUMBER)
     attempts = 0
-    print(f"I'm thinking of a number between 1 and 100. You have {max_attempts} attempts.")
-    guess_history = []
+    guess_history: List[int] = []
+
+    print(f"I'm thinking of a number between {MIN_NUMBER} and {MAX_NUMBER}.")
+    print(f"You have {max_attempts} attempts.")
 
     while attempts < max_attempts:
         remaining = max_attempts - attempts
-        try:
-            guess = input(f"Guess ({remaining} left): ").strip()
-            guess_num = int(guess)
-        except ValueError:
-            print("⚠️ Invalid input — please enter an integer between 1 and 100.")
-            continue
+        guess_num = get_guess_input(remaining)
 
-        if not (1 <= guess_num <= 100):
-            print("🚫 Out of range — enter a number between 1 and 100.")
+        if guess_num is None:
             continue
 
         attempts += 1
         guess_history.append(guess_num)
 
         if guess_num == number:
-            print("🏆 Correct! You guessed the number!")
-            print(f"✨ number: {number} — attempts: {attempts}/{max_attempts}")
+            print("Correct! You guessed the number.")
+            print(f"Number: {number}")
+            print(f"Attempts: {attempts}/{max_attempts}")
+            print("Guesses:", ", ".join(map(str, guess_history)))
             return True, attempts
 
         if guess_num > number:
-            print("⬇️ High — try a smaller number.")
+            print("Too high.")
         else:
-            print("⬆️ Low — try a larger number.")
+            print("Too low.")
 
-        # proximity hint
+        # Show proximity hint
         diff = abs(guess_num - number)
-        if diff <= 3:
-            print("🔥 Very close!")
-        elif diff <= 10:
-            print("🙂 Close — you're getting there.")
-        elif diff <= 20:
-            print("🧭 Not very close yet.")
-        else:
-            print("❄️ Far off — try a different range.")
+        print(get_proximity_hint(diff))
 
-    print("💥 Out of attempts — you lost this round.")
+    print("Out of attempts.")
     print(f"The number was {number}.")
+
     if guess_history:
         print("Your guesses:", ", ".join(map(str, guess_history)))
+
     return False, attempts
 
 
@@ -71,21 +142,28 @@ def play_round_with_guesses(guesses, number, max_attempts: int):
     returns: (won: bool, attempts: int)
     """
     attempts = 0
+
     for g in guesses:
         if attempts >= max_attempts:
             break
+
         if not isinstance(g, int):
             continue
-        if not (1 <= g <= 100):
+
+        if not validate_guess(g):
             continue
+
         attempts += 1
+
         if g == number:
             return True, attempts
+
     return False, attempts
 
 
 def main():
-    print("🎮 Welcome to the Number Guessing Game! 🎮\n")
+    print("Welcome to the Number Guessing Game!\n")
+
     while True:
         max_attempts = choose_difficulty()
         won, tries = play_round(max_attempts)
@@ -96,10 +174,11 @@ def main():
             print(f"You used all {max_attempts} attempts.")
 
         again = input("Play again? (y/n): ").strip().lower()
+
         if again != "y":
-            print("👋 Thanks for playing — goodbye!")
+            print("Goodbye.")
             break
 
 
 if __name__ == "__main__":
-    main()
+    main()

tests/test_number_guessing.py

@@ -5,32 +5,77 @@
 
 class TestNumberGuessing(unittest.TestCase):
     def setUp(self):
-        # Load the module dynamically since it has hyphens in the name
         module_name = "number_guessing"
         file_path = os.path.join("games", "Number-Guessing-Game", "Number-Guessing-Game.py")
 
         spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load module spec for: {file_path}")
+
         self.module = importlib.util.module_from_spec(spec)
         sys.modules[module_name] = self.module
         spec.loader.exec_module(self.module)
 
+    # Existing tests
     def test_play_round_with_guesses_win(self):
-        # Test winning exactly on the last attempt
         won, attempts = self.module.play_round_with_guesses([10, 20, 50], number=50, max_attempts=3)
         self.assertTrue(won)
         self.assertEqual(attempts, 3)
 
     def test_play_round_with_guesses_lose(self):
-        # Test running out of attempts
         won, attempts = self.module.play_round_with_guesses([10, 20, 30], number=50, max_attempts=3)
         self.assertFalse(won)
         self.assertEqual(attempts, 3)
 
     def test_play_round_with_guesses_win_early(self):
-        # Test winning before max attempts are reached
         won, attempts = self.module.play_round_with_guesses([50, 60, 70], number=50, max_attempts=5)
         self.assertTrue(won)
         self.assertEqual(attempts, 1)
 
+    # NEW TESTS for refactored functions
+    def test_validate_guess_valid(self):
+        """Test that valid guesses are accepted."""
+        self.assertTrue(self.module.validate_guess(1))
+        self.assertTrue(self.module.validate_guess(50))
+        self.assertTrue(self.module.validate_guess(100))
+
+    def test_validate_guess_invalid(self):
+        """Test that out-of-range guesses are rejected."""
+        self.assertFalse(self.module.validate_guess(0))
+        self.assertFalse(self.module.validate_guess(101))
+        self.assertFalse(self.module.validate_guess(-5))
+
+    def test_proximity_hint_very_close(self):
+        """Test proximity hint for very close guesses."""
+        hint = self.module.get_proximity_hint(1)
+        self.assertIn("Very close", hint)
+
+    def test_proximity_hint_close(self):
+        """Test proximity hint for close guesses."""
+        hint = self.module.get_proximity_hint(5)
+        self.assertIn("Close", hint)
+
+    def test_proximity_hint_not_close(self):
+        """Test proximity hint for distant guesses."""
+        hint = self.module.get_proximity_hint(15)
+        self.assertIn("Not very close", hint)
+
+    def test_proximity_hint_far(self):
+        """Test proximity hint for very far guesses."""
+        hint = self.module.get_proximity_hint(50)
+        self.assertIn("Far off", hint)
+
+    def test_play_round_with_guesses_invalid_types(self):
+        """Test that non-integer guesses are skipped."""
+        won, attempts = self.module.play_round_with_guesses(["50", 50], number=50, max_attempts=2)
+        self.assertTrue(won)
+        self.assertEqual(attempts, 1)  # Only the integer 50 counts
+
+    def test_play_round_with_guesses_out_of_range(self):
+        """Test that out-of-range guesses are skipped."""
+        won, attempts = self.module.play_round_with_guesses([150, 50], number=50, max_attempts=2)
+        self.assertTrue(won)
+        self.assertEqual(attempts, 1)  # Only 50 counts, 150 is skipped
+
 if __name__ == "__main__":
     unittest.main()