Software Testing Types — Silent Regression Loop

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;

// This is the class we want to test
class Calculator {

    // Adds two integers and returns the result
    public int add(int firstNumber, int secondNumber) {
        return firstNumber + secondNumber;
    }

    // Divides numerator by denominator
    // Throws ArithmeticException if denominator is zero
    public double divide(double numerator, double denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return numerator / denominator;
    }

    // Returns true if a number is even
    public boolean isEven(int number) {
        return number % 2 == 0;
    }
}

// The test class — JUnit discovers methods annotated with @Test
public class CalculatorTest {

    // Create ONE shared instance of the thing we're testing
    Calculator calculator = new Calculator();

    @Test
    @DisplayName("Adding two positive numbers returns their sum")
    void testAdditionOfTwoPositiveNumbers() {
        // ARRANGE — set up the inputs
        int firstNumber = 7;
        int secondNumber = 3;

        // ACT — call the method under test
        int result = calculator.add(firstNumber, secondNumber);

        // ASSERT — verify the result is what we expect
        assertEquals(10, result, "7 + 3 should equal 10");
    }

    @Test
    @DisplayName("Adding a positive and a negative number works correctly")
    void testAdditionWithNegativeNumber() {
        int result = calculator.add(10, -4);
        // Negative numbers are a classic edge case — always test them
        assertEquals(6, result, "10 + (-4) should equal 6");
    }

    @Test
    @DisplayName("Dividing by zero throws an ArithmeticException")
    void testDivisionByZeroThrowsException() {
        // assertThrows checks that calling this code DOES throw the expected exception
        // If it does NOT throw, the test FAILS
        assertThrows(
            ArithmeticException.class,
            () -> calculator.divide(10, 0),
            "Dividing by zero must throw ArithmeticException"
        );
    }

    @Test
    @DisplayName("Even number check returns true for 4")
    void testIsEvenReturnsTrueForEvenNumber() {
        assertTrue(calculator.isEven(4), "4 is even, so isEven should return true");
    }

    @Test
    @DisplayName("Even number check returns false for 7")
    void testIsEvenReturnsFalseForOddNumber() {
        assertFalse(calculator.isEven(7), "7 is odd, so isEven should return false");
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

// A simple in-memory "database" simulating a real data store
// In a real integration test this would be a test database (e.g. H2 for Java)
class InMemoryUserDatabase {
    private final Map<Integer, String> userStore = new HashMap<>();
    private int nextId = 1;

    // Saves a user and returns the auto-generated ID (like a real DB would)
    public int saveUser(String userName) {
        int assignedId = nextId++;
        userStore.put(assignedId, userName);
        return assignedId;
    }

    // Finds a user by ID — returns Optional to handle "not found" cleanly
    public Optional<String> findUserById(int userId) {
        return Optional.ofNullable(userStore.get(userId));
    }

    // Clears all data — useful for resetting state between tests
    public void clearAll() {
        userStore.clear();
        nextId = 1;
    }
}

// The service layer — it DEPENDS on the database. This dependency is what
// integration tests exercise. Unit tests would mock the database away.
class UserRegistrationService {
    private final InMemoryUserDatabase userDatabase;

    // The database is injected — this is dependency injection in action
    public UserRegistrationService(InMemoryUserDatabase userDatabase) {
        this.userDatabase = userDatabase;
    }

    // Registers a new user after basic validation
    public int registerUser(String userName) {
        if (userName == null || userName.isBlank()) {
            throw new IllegalArgumentException("Username cannot be empty");
        }
        // Delegates to the database — this is the integration point under test
        return userDatabase.saveUser(userName.trim());
    }

    // Looks up a user by their ID
    public String getUserById(int userId) {
        return userDatabase.findUserById(userId)
            .orElseThrow(() -> new RuntimeException("User with ID " + userId + " not found"));
    }
}

// Integration test — testing UserRegistrationService WITH a real database
public class UserRepositoryIntegrationTest {

    private InMemoryUserDatabase userDatabase;
    private UserRegistrationService userRegistrationService;

    // Runs BEFORE each test — creates a clean state so tests don't interfere
    @BeforeEach
    void setUpFreshEnvironment() {
        userDatabase = new InMemoryUserDatabase();
        // We wire up the real service with the real database — no mocks!
        userRegistrationService = new UserRegistrationService(userDatabase);
    }

    // Runs AFTER each test — cleans up to prevent test pollution
    @AfterEach
    void tearDown() {
        userDatabase.clearAll();
    }

    @Test
    @DisplayName("Registering a user saves them to the database and returns a valid ID")
    void testUserRegistrationPersistsToDatabase() {
        // ACT — register a new user through the service layer
        int newUserId = userRegistrationService.registerUser("alice_smith");

        // ASSERT — the ID should be a positive integer (valid database ID)
        assertTrue(newUserId > 0, "Database should assign a positive ID");

        // ASSERT — we can retrieve the same user back from the database
        String retrievedUserName = userRegistrationService.getUserById(newUserId);
        assertEquals("alice_smith", retrievedUserName, "Retrieved name must match the registered name");
    }

    @Test
    @DisplayName("Registering multiple users assigns unique IDs to each")
    void testMultipleUsersGetUniqueIds() {
        int aliceId = userRegistrationService.registerUser("alice_smith");
        int bobId   = userRegistrationService.registerUser("bob_jones");

        // The two IDs must be different — IDs are not shared
        assertNotEquals(aliceId, bobId, "Each user must receive a unique ID");

        // Verify each ID retrieves the correct owner
        assertEquals("alice_smith", userRegistrationService.getUserById(aliceId));
        assertEquals("bob_jones",   userRegistrationService.getUserById(bobId));
    }

    @Test
    @DisplayName("Looking up a non-existent user throws a RuntimeException")
    void testLookupOfNonExistentUserThrowsException() {
        int nonExistentUserId = 9999;

        // The service + database together must correctly report missing data
        assertThrows(
            RuntimeException.class,
            () -> userRegistrationService.getUserById(nonExistentUserId),
            "Fetching a missing user ID must throw RuntimeException"
        );
    }
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
import static org.junit.jupiter.api.Assertions.*;

// A simple e-commerce Order system — we'll use this to demonstrate
// how regression tests protect existing behaviour when new code ships
class ShoppingCart {
    private double totalPrice = 0.0;
    private int itemCount = 0;

    // Adds an item to the cart
    public void addItem(String itemName, double itemPrice, int quantity) {
        if (itemPrice < 0) throw new IllegalArgumentException("Price cannot be negative");
        if (quantity < 1) throw new IllegalArgumentException("Quantity must be at least 1");
        totalPrice += itemPrice * quantity;
        itemCount  += quantity;
    }

    // Applies a percentage discount (e.g. 10 means 10% off)
    public void applyDiscountPercent(double discountPercent) {
        if (discountPercent < 0 || discountPercent > 100) {
            throw new IllegalArgumentException("Discount must be between 0 and 100");
        }
        totalPrice = totalPrice * (1 - discountPercent / 100);
    }

    // NEW FEATURE ADDED: free shipping threshold
    // Imagine a developer added this — regression tests make sure
    // the discount and total logic still work correctly alongside it
    public boolean qualifiesForFreeShipping() {
        return totalPrice >= 50.0;
    }

    public double getTotalPrice() { return totalPrice; }
    public int    getItemCount()  { return itemCount;  }
}

// @Tag("regression") marks these tests so CI pipelines can run
// this specific group after every code change
@Tag("regression")
public class RegressionTestSuite {

    @Test
    @DisplayName("[REGRESSION] Cart total calculates correctly after adding multiple items")
    void testCartTotalAfterAddingItems() {
        ShoppingCart cart = new ShoppingCart();

        cart.addItem("Java Programming Book", 29.99, 1);
        cart.addItem("USB-C Cable",            9.99, 2);

        // 29.99 + (9.99 * 2) = 29.99 + 19.98 = 49.97
        assertEquals(49.97, cart.getTotalPrice(), 0.001,
            "Total must be sum of all item prices times quantities");
        assertEquals(3, cart.getItemCount(), "Item count must reflect total quantity added");
    }

    @Test
    @DisplayName("[REGRESSION] 10% discount correctly reduces the cart total")
    void testDiscountReducesTotalCorrectly() {
        ShoppingCart cart = new ShoppingCart();
        cart.addItem("Mechanical Keyboard", 100.00, 1);

        cart.applyDiscountPercent(10); // 10% off £100 = £90

        assertEquals(90.0, cart.getTotalPrice(), 0.001,
            "10% discount on £100 should give £90 total");
    }

    @Test
    @DisplayName("[REGRESSION] Adding item with negative price throws exception")
    void testNegativePriceIsRejected() {
        ShoppingCart cart = new ShoppingCart();

        // This behaviour was working before the new feature was added.
        // The regression test confirms the NEW code didn't accidentally remove
        // this validation.
        assertThrows(
            IllegalArgumentException.class,
            () -> cart.addItem("Broken Item", -5.00, 1),
            "Negative price must still throw IllegalArgumentException after new feature added"
        );
    }

    @Test
    @DisplayName("[REGRESSION] New free-shipping feature doesn't break existing discount logic")
    void testFreeShippingAndDiscountCoexist() {
        ShoppingCart cart = new ShoppingCart();
        cart.addItem("Laptop Stand", 60.00, 1);

        // Before discount: qualifies for free shipping (£60 >= £50)
        assertTrue(cart.qualifiesForFreeShipping(), "£60 cart should qualify for free shipping");

        // Apply 20% discount — now £48, just below the threshold
        cart.applyDiscountPercent(20);

        // After discount: should NOT qualify (£48 < £50)
        assertFalse(cart.qualifiesForFreeShipping(),
            "After 20% discount, £60 becomes £48 — should no longer qualify for free shipping");

        // And the total itself must still be calculated correctly
        assertEquals(48.0, cart.getTotalPrice(), 0.001,
            "Discount must still apply correctly after free-shipping feature was introduced");
    }
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;
import java.time.Duration;

class SearchService {
    // Simulates a slow search that might degrade under load
    public String search(String query) {
        // Simulate network latency
        try { Thread.sleep(20); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        if (query == null || query.isBlank()) throw new IllegalArgumentException();
        return "Results for " + query;
    }
}

public class PerformanceRegressionTest {

    private SearchService searchService = new SearchService();

    @Test
    @DisplayName("[PERF] Search should complete within 200ms under normal conditions")
    void testSearchPerformanceBaseline() {
        assertTimeout(Duration.ofMillis(200), () -> {
            String result = searchService.search("Java testing");
            assertNotNull(result);
        });
    }

    @Test
    @DisplayName("[PERF] Concurrency test: 50 parallel searches should all complete")
    void testConcurrentSearches() throws InterruptedException {
        int threadCount = 50;
        Thread[] threads = new Thread[threadCount];
        boolean[] results = new boolean[threadCount];
        for (int i = 0; i < threadCount; i++) {
            int index = i;
            threads[i] = new Thread(() -> {
                try {
                    searchService.search("concurrent test " + index);
                    results[index] = true;
                } catch (Exception e) {
                    results[index] = false;
                }
            });
            threads[i].start();
        }
        for (Thread t : threads) {
            t.join(5000); // wait up to 5 seconds
        }
        for (int i = 0; i < threadCount; i++) {
            assertTrue(results[i], "Thread " + i + " failed to complete");
        }
    }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

// Simulated security checks you can run as unit tests
class SecurityScanner {

    // Checks if a string contains patterns indicative of SQL injection attempts
    public boolean detectSQLInjection(String input) {
        String[] patterns = {"'", "\"", "OR 1=1", "DROP TABLE", "--"};
        for (String pattern : patterns) {
            if (input.toUpperCase().contains(pattern.toUpperCase())) {
                return true;
            }
        }
        return false;
    }

    // Check if a password meets minimum strength requirements
    public boolean isWeakPassword(String password) {
        return password.length() < 8 || password.equalsIgnoreCase("password123");
    }
}

public class SecurityScanTest {

    private SecurityScanner scanner = new SecurityScanner();

    @Test
    @DisplayName("[SEC] Detect basic SQL injection pattern in input")
    void testDetectSQLInjection() {
        assertTrue(scanner.detectSQLInjection("' OR '1'='1"));
        assertFalse(scanner.detectSQLInjection("hello world"));
    }

    @Test
    @DisplayName("[SEC] Block weak passwords during registration")
    void testWeakPasswordDetection() {
        assertTrue(scanner.isWeakPassword("password123"));
        assertTrue(scanner.isWeakPassword("abc"));
        assertFalse(scanner.isWeakPassword("Tr0ub4dor&3"));
    }

    @Test
    @DisplayName("[SEC] Ensure sensitive data is not hardcoded in source")
    void testNoHardcodedSecrets() {
        // In production, use a static analysis tool like FindSecBugs or Sonar
        String sourceCode = "";
        // Simulated check: source should not contain API keys or passwords
        assertFalse(sourceCode.contains("apiKey") && sourceCode.contains("="));
        assertFalse(sourceCode.contains("password"));
    }
}