Code Smell 275 - Missing Test Wrong Path

Check the happy path to be happy!

TL;DR: Ensure you fail the test when no exception is thrown in invalid conditions.

Problems

• Silent faulty tests
• Missing failure condition
• Poor error validation
• Unclear test outcome
• Skipped test logic

Solutions

1. Add failure assertion
2. Explicit exception validation
3. Test invalid actions
4. Catch specific errors
5. Check all your test paths
6. Use mutation testing

Context

When writing tests you expect certain cases to throw exceptions.

If you forget to add a fail condition when no exception is thrown, your test might pass silently.

If breaking some contract doesn't raise an exception, the test will still pass without you noticing the issue.

Always include a failure condition to ensure the test fails when the expected exception isn't thrown.

Sample Code

Wrong

// Test: firing at an already hit position should not be allowed

const game = new Battleship();
game.fireAt("A3");  
// First hit
            
try {
    game.fireAt("A3"); 
     // Firing at the same spot
} catch (e) {
    console.assert(e.message === 'Position already hit.', 
     'The error message should indicate the position is already hit.');
}

Right

// Test: firing at an already hit position should not be allowed

const game = new Battleship();
game.fireAt("A3"); 
// First hit

try {
    game.fireAt("A3");
     // Firing at the same spot
    
     // THIS LINE IS IMPORTANT
     cnsole.assert(false, 
        'An exception should have been thrown' .
        ' for firing at the same position.');
     // THIS LINE IS IMPORTANT
  
  
} catch (e) {
    console.assert(e.message === 'Position already hit.',
     'The error message should indicate the position is already hit.');
}

Detection

• [x]Semi-Automatic

You can detect this smell by looking for try-catch blocks without a failure condition after an action that should throw an exception.

Test cases expecting exceptions should always include assert(false) right after the invalid action.

Tags

• Testing

Level

• [x]Intermediate

AI Generation

AI generators can create this smell because they often focus on handling exceptions but might miss adding failure conditions when the exception doesn't occur.

This leads to the silent passing of faulty tests.

AI Detection

AI can detect this smell if you instruct it to check for missing failure assertions after expected exceptions.

It can automatically add the missing condition to ensure tests fail properly when no exception is thrown.

Conclusion

You must include a fail condition when testing invalid actions like firing at the same position in Battleship.

This ensures the test fails if no exception is thrown, preventing silent errors. Always validate the error message and ensure your tests catch valid and invalid behaviors.

Related Reading

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xvi

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvii

Time invested in writing tests and refactoring delivers impressive returns in delivery speed, and Continuous Integration is a core part of making that work in a team setting

Martin Fowler