On June 17th, HBO accidentally sent out an email meant for only internal developer audiences. This email was an integration test, confirming that the code was running as intended. Except, they sent it out to everyone... by an intern.
On June 17th, HBO accidentally sent out an email meant for only internal developer audiences. This email was an integration test, confirming that the code was running as intended.
Except, they sent it out to everyone.
… and the culprit was an intern. Oof.
The internet went wild:
Go look up the "Dear Intern" trend on Twitter. It's people all admitting their mistakes and noting they're still present/successful. It's so heartwarming, and I wish society would look more kindly on mistakes in general. We're all humans, not robots. Well, for now, anyway.June 18, 2021
Including an HBO Intern mock account:
Perhaps because I’ve used a number of different accounts as HBO’s digital offerings have evolved, I got more than one email.
As far as corporate error states go, this one was rather innocent. No private information disclosed, nothing too amiss. So what is an
Most software goes through a few different types of testing:
- Unit Testing
- Integration Testing
- End-to-End Testing
- User Acceptance Testing
Unit Tests are tests written to validate that a function runs correctly. Given
x input, we expect
y output. A lot of unit tests are done by the developers themselves, and best practices mandate that these functional “unit” tests are automated.
Integration Tests evaluate how different functions/units come together to perform larger functions. Sometimes this is evaluating literal integrations between pieces (is your function talking to the other vendor?), and other times it tests a feature that is made up of multiple functions.
End-to-End Tests (or Systems Testing) evaluates the complete system, end-to-end. During this testing, the goal is to make sure that everything still works, even areas your code may not have touched. Because of emergent complexity in software development, bugs, defects, and unforeseen behaviors have a way of showing up far downstream from where changes are made.
For example: a unit test might show a function that works as intended, and the integration test might mean that all of the new units come together as expected. However, if the output of the integration testing has changed, a feature somewhere else might not be able to accept it and that will be the breaking change. End to end tests are long and rigorous for complex software, but aim to catch these emergent issues for both “happy” paths (if everything is supposed to go as it should) and “edge” cases (strange input behaviors that are allowable but uncommon).
User Acceptance Testing is the last type of testing. It asks: does the thing that was built actually meet the requirements and acceptance criteria that was defined for it? It might work, but not be accepted by a user. Or – the user might accept it with known defects because those defects might be out of scope of the original request.
So there we have it. Some intern somewhere in the engineering department likely triggered an integration test while having their environment variables connected to the “real” email system, instead of the testing system. And the rest as they say is history.