Problem Statement

We need you to build a URL shortener. We're going to use this with our text messaging system to send short links to people. It needs to support multiple domains, some internal and some external.

Redirects

• Short URL -> Long Url
• Doesn't exist -> 404 external
• Doesn't exist -> Redirect to UI internal

Create

• Can create named URLs
• Can generate short URLs
• Can create via API
• Can create via UI

Update

• Change the long URL of a short URL
• Can update via API
• Can update via UI

Delete

• Stops redirecting
• Maintains history after delete
• Can delete via API
• Can delete via UI

Query

• View short URL details (UI)
• Retrieve short URL details (api)

Multiple Domains

• Some internal facing (s.f, air/)
• Some external facing (st8.farm)
• URLs are unique to the domain

Product Dependencies

Goals

• Identify Dependencies Between Features
• Create a Rough Ordering

Dev Dependencies

Goals

• Identify Dev Dependencies
• Put them on our plan before the first time they are needed

Create Rough Sprints

Suggestions

• Aim to deliver value every sprint
• Don't plan to tackle more than one dev dependency in a sprint
• Group a dev dependency with product functionality
• Keep your sprints focused, you should be able to name your sprint like a Friends episode

Parallel Work Streams

Create Sprint 1 Stories

404 Story

Given a short URL that doesn't exist

And an external domain

When I navigate to the short URL

Then I should get a 404

Hard Mode

State Farm's

Release Process

• ~18 month release cycle
• Minimum 2 months system test
• Minimum of 1 month in performance test
• Minimum 2 months implementation test
• Minimum 3 months from the completion of integration test to production
• Builds must be certified by QA before being allowed into the next environment

Process Restrictions

• Every release must impact users
• Prove that every known function of the application works exactly as intended in every environment (dev, system, pre-production, production)
• 100% automated regression tests for all bugs
• Automate deployment to each environment
• Automate build certification
• Beyond dev must use real dependencies (db, service, logging, etc.)

Sure, but are there any hard problems?

Definition of Done

• 100% mutation test coverage (code coverage is a pointless metric)
• Every path must have an integration test
• Integration tests must be repeatable
• Integration tests must have net 0 impact (everything created by the test is cleaned up)
• Integration tests must have passed in all environments (including production)

Code Coverage

@Test
public void testMyMethod() {
    myObject.myMethod(null, null, null);
}

Mutation Testing

@Implementation
public int inRange(int min, int max, int valueToTest) {
    return valueToTest >= min && valueToTest <= max;
}


@Test
public void testMyMethod() {
    myObject.myMethod(null, null, null);
}

/* Failed mutation 1 -> 
    changing `valueToTest >= min` to `valueToTest < min` did not cause test to fail
*/

/* Failed mutation 2 -> 
    changing `valueToTest <= max` to `valueToTest > max` did not cause test to fail
*/

/* Failed mutation 3 ->
    changing `valueToTest >= min && valueToTest <= max` to
    `valueToTest >= min NAND valueToTest <= max` did not cause the test to fail
/*