refactor: remove verbose AI-generated comments from tests

Author: mariuspruvot

tests/integration/test_recording_flow.py

@@ -15,12 +15,10 @@
 @pytest.mark.asyncio
 async def test_transcribe_audio_success(tmp_path: Path) -> None:
     """Test successful transcription with mocked OpenAI API."""
-    # Create sample audio file
     audio_data = np.random.randn(16000).astype(np.float32) * 0.5
     wav_path = save_audio_to_wav(audio_data)
 
     try:
-        # Mock the OpenAI API response
         with patch("shh.adapters.whisper.client.AsyncOpenAI") as mock_client:
             mock_transcription = MagicMock()
             mock_transcription.text = "Hello, this is a test transcription."
@@ -30,7 +28,6 @@ async def test_transcribe_audio_success(tmp_path: Path) -> None:
                 return_value=mock_transcription
             )
 
-            # Call transcribe_audio
             result = await transcribe_audio(
                 audio_file_path=wav_path,
                 api_key="sk-test-key",
@@ -127,20 +124,17 @@ async def test_format_transcription_with_translation() -> None:
         )
 
         assert result.text == "Hello, this is a test."
-        # Verify translation was requested in prompt
         call_args = mock_agent.run.call_args
         assert "English" in call_args[0][0]
 
 
 @pytest.mark.asyncio
 async def test_full_pipeline_mock(tmp_path: Path) -> None:
     """Test the complete pipeline: audio → transcribe → format."""
-    # Create sample audio
     audio_data = np.random.randn(16000).astype(np.float32) * 0.5
     wav_path = save_audio_to_wav(audio_data)
 
     try:
-        # Mock Whisper API
         with patch("shh.adapters.whisper.client.AsyncOpenAI") as mock_whisper:
             mock_transcription = MagicMock()
             mock_transcription.text = "Um, this is a test transcription."
@@ -150,11 +144,9 @@ async def test_full_pipeline_mock(tmp_path: Path) -> None:
                 return_value=mock_transcription
             )
 
-            # Step 1: Transcribe
             raw_text = await transcribe_audio(wav_path, "sk-test-key")
             assert raw_text == "Um, this is a test transcription."
 
-            # Mock PydanticAI for formatting
             with (
                 patch("shh.adapters.llm.formatter.OpenAIChatModel"),
                 patch("shh.adapters.llm.formatter.Agent") as mock_agent_class,
@@ -166,7 +158,6 @@ async def test_full_pipeline_mock(tmp_path: Path) -> None:
                 mock_agent.run = AsyncMock(return_value=mock_result)
                 mock_agent_class.return_value = mock_agent
 
-                # Step 2: Format
                 formatted = await format_transcription(
                     raw_text,
                     style=TranscriptionStyle.CASUAL,

tests/unit/adapters/audio/test_processor.py

@@ -24,123 +24,87 @@ def sample_audio_data() -> NDArray[np.float32]:
 
 def test_save_audio_to_wav_creates_file(sample_audio_data: NDArray[np.float32]) -> None:
     """Test that save_audio_to_wav creates a WAV file."""
-    # Act
     wav_path = save_audio_to_wav(sample_audio_data)
 
     try:
-        # Assert
         assert wav_path.exists(), "WAV file should exist"
         assert wav_path.suffix == ".wav", "File should have .wav extension"
         assert wav_path.stat().st_size > 0, "WAV file should not be empty"
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()
 
 
 def test_save_audio_to_wav_correct_sample_rate(sample_audio_data: NDArray[np.float32]) -> None:
     """Test that saved WAV file has correct sample rate."""
-    # Act
     wav_path = save_audio_to_wav(sample_audio_data)
 
     try:
-        # Read back the WAV file
         sample_rate, _ = wavfile.read(wav_path)
-
-        # Assert
         assert sample_rate == SAMPLE_RATE, f"Sample rate should be {SAMPLE_RATE}Hz"
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()
 
 
 def test_save_audio_to_wav_correct_data_conversion(sample_audio_data: NDArray[np.float32]) -> None:
     """Test that audio data is correctly converted from float32 to int16."""
-    # Act
     wav_path = save_audio_to_wav(sample_audio_data)
 
     try:
-        # Read back the WAV file
         _, audio_int16 = wavfile.read(wav_path)
-
-        # Assert
         assert audio_int16.dtype == np.int16, "Audio data should be int16"
 
-        # Convert back to float32 for comparison
         audio_float_reconstructed = audio_int16.astype(np.float32) / 32767.0
 
-        # Check that values are approximately equal (allowing for conversion loss)
-        # Tolerance is relatively high because int16 has lower precision than float32
         np.testing.assert_allclose(
             audio_float_reconstructed,
             sample_audio_data,
             atol=1e-4,
             err_msg="Reconstructed audio should match original (within conversion tolerance)",
         )
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()
 
 
 def test_save_audio_to_wav_custom_sample_rate() -> None:
     """Test that custom sample rate is respected."""
-    # Arrange
-    custom_rate = 44100  # CD quality
-    duration = 0.5  # seconds
+    custom_rate = 44100
+    duration = 0.5
     samples = int(custom_rate * duration)
-    audio_data = np.random.randn(samples).astype(np.float32) * 0.5  # Random audio
+    audio_data = np.random.randn(samples).astype(np.float32) * 0.5
 
-    # Act
     wav_path = save_audio_to_wav(audio_data, sample_rate=custom_rate)
 
     try:
-        # Read back
         sample_rate, _ = wavfile.read(wav_path)
-
-        # Assert
         assert sample_rate == custom_rate, f"Sample rate should be {custom_rate}Hz"
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()
 
 
 def test_save_audio_to_wav_handles_empty_array() -> None:
     """Test that empty audio array raises an error or handles gracefully."""
-    # Arrange
     empty_audio = np.array([], dtype=np.float32)
-
-    # Act & Assert
-    # scipy should handle this, but let's verify it doesn't crash
     wav_path = save_audio_to_wav(empty_audio)
 
     try:
         assert wav_path.exists(), "Should create file even for empty audio"
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()
 
 
 def test_save_audio_to_wav_handles_large_values() -> None:
     """Test that audio values outside [-1.0, 1.0] are clipped correctly."""
-    # Arrange - audio with values outside normal range
-    audio_data = np.array([0.5, 1.5, -1.5, 0.0], dtype=np.float32)  # Some values > 1.0
-
-    # Act
+    audio_data = np.array([0.5, 1.5, -1.5, 0.0], dtype=np.float32)
     wav_path = save_audio_to_wav(audio_data)
 
     try:
-        # Read back
         _, audio_int16 = wavfile.read(wav_path)
-
-        # Assert - values should be converted (may overflow/clip)
         assert audio_int16.dtype == np.int16
-        # Note: Values > 1.0 will cause overflow in int16 conversion
-        # This is expected behavior - caller should ensure normalized audio
     finally:
-        # Cleanup
         if wav_path.exists():
             wav_path.unlink()

tests/unit/cli/test_commands.py

@@ -34,14 +34,12 @@ def get_test_config_path(cls: type) -> Path:
         classmethod(get_test_config_path),
     )
 
-    # Simulate user input
     result = runner.invoke(app, ["setup"], input="sk-test-key-12345678\n")
 
     assert result.exit_code == 0
     assert "Setup Complete" in result.stdout
     assert "sk-***5678" in result.stdout
 
-    # Verify file was saved
     assert config_file.exists()
     settings = Settings.load_from_file()
     assert settings is not None
@@ -82,7 +80,6 @@ def test_config_set_valid(mock_settings: Settings) -> None:
     assert result.exit_code == 0
     assert "Updated default_style = casual" in result.stdout
 
-    # Verify it was saved
     settings = Settings.load_from_file()
     assert settings is not None
     assert settings.default_style == TranscriptionStyle.CASUAL