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"));
    }
}

// io.thecodeforge — cs-fundamentals tutorial

import sys
import locale

def assert_encoding_match(expected_encoding: str = "UTF-8") -> None:
    actual_default = sys.getdefaultencoding()
    actual_filesystem = sys.getfilesystemencoding()
    actual_locale = locale.getpreferredencoding()

    print(f"Default encoding: {actual_default}")
    print(f"Filesystem encoding: {actual_filesystem}")
    print(f"Locale preferred encoding: {actual_locale}")

    # If these drift from production, your string tests are worthless
    if actual_default != expected_encoding:
        raise RuntimeError(
            f"Environment encoding mismatch: got {actual_default}, "
            f"expected {expected_encoding}"
        )

    print("Encoding assertion passed.")

if __name__ == "__main__":
    assert_encoding_match()

// io.thecodeforge — cs-fundamentals tutorial

import json
import hashlib
from datetime import datetime, timezone

def run_audited_test(test_id: str, requirement_id: str, input_data: dict, expected_output: dict) -> dict:
    # Build an immutable test record
    record = {
        "test_id": test_id,
        "requirement_id": requirement_id,
        "tester": "deploy_user",
        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
        "input_data": input_data,
        "expected_output": expected_output,
        "actual_output": None,
        "passed": None,
    }

    # Simulate the test logic (replace with real logic)
    actual = input_data  # dummy
    record["actual_output"] = actual
    record["passed"] = (actual == expected_output)

    # Create a signature to detect tampering
    record["hash"] = hashlib.sha256(
        json.dumps(record, sort_keys=True).encode()
    ).hexdigest()

    return record

result = run_audited_test(
    test_id="TC-101",
    requirement_id="REQ-42",
    input_data={"user_role": "admin"},
    expected_output={"user_role": "admin"}
)

print(json.dumps(result, indent=2))

// io.thecodeforge — cs-fundamentals tutorial

import subprocess
import json

# List of licenses your legal team has approved
APPROVED_LICENSES = {
    "MIT", "Apache 2.0", "BSD 3-Clause", "Python Software Foundation License"
}

def check_dependency_licenses() -> None:
    # Use pip-licenses to get machine-readable output
    result = subprocess.run(
        ["pip-licenses", "--format=json"],
        capture_output=True,
        text=True
    )

    packages = json.loads(result.stdout)
    blocked_packages = []

    for pkg in packages:
        name = pkg["Name"]
        license_type = pkg.get("License", "UNKNOWN")

        if license_type not in APPROVED_LICENSES:
            blocked_packages.append(f"{name} ({license_type})")

    if blocked_packages:
        raise RuntimeError(
            f"License compliance check FAILED. Blocked packages:\n"
            + "\n".join(blocked_packages)
        )

    print("All dependency licenses are approved.")

if __name__ == "__main__":
    check_dependency_licenses()

// io.thecodeforge — cs-fundamentals tutorial

def validate_age(age: int) -> bool:
    if not isinstance(age, int):
        raise TypeError("Age must be an integer")
    # Equivalence classes: invalid low, valid, invalid high
    return 0 <= age <= 120

def test_validate_age():
    # One representative from each class
    assert validate_age(-1) == False   # invalid low
    assert validate_age(25) == True    # valid
    assert validate_age(121) == False  # invalid high

    # Edge case boundaries (still valid classes)
    assert validate_age(0) == True
    assert validate_age(120) == True

// io.thecodeforge — cs-fundamentals tutorial

from enum import Enum, auto

class AuthState(Enum):
    LOGGED_OUT = auto()
    PENDING_2FA = auto()
    LOGGED_IN = auto()
    LOCKED = auto()

def transition(state: AuthState, event: str) -> AuthState:
    transitions = {
        AuthState.LOGGED_OUT: {"login": AuthState.PENDING_2FA},
        AuthState.PENDING_2FA: {"verify": AuthState.LOGGED_IN, "fail": AuthState.LOGGED_OUT},
        AuthState.LOGGED_IN: {"logout": AuthState.LOGGED_OUT},
    }
    return transitions.get(state, {}).get(event, state)  # stay on invalid

def test_state_transitions():
    assert transition(AuthState.LOGGED_OUT, "login") == AuthState.PENDING_2FA
    assert transition(AuthState.PENDING_2FA, "verify") == AuthState.LOGGED_IN
    assert transition(AuthState.PENDING_2FA, "fail") == AuthState.LOGGED_OUT
    assert transition(AuthState.LOGGED_IN, "logout") == AuthState.LOGGED_OUT
    # Illegal transition stays in same state
    assert transition(AuthState.LOGGED_OUT, "verify") == AuthState.LOGGED_OUT

// io.thecodeforge — cs-fundamentals tutorial

# STLC phases mapped to SDLC for a feature toggle
requirement_starts = "Feature X: rate limit per user"
test_cases_written = ["RATE_001: 10 req/sec blocked", "RATE_002: 9 req/sec allowed"]
execution_phase = "run tests against staging"

# If test closure happens before release, you missed regression
if execution_phase == "after deploy":
    print("Risk: untested edge cases will surface in prod")
else:
    print("Shift-left: tests ready before code freeze")

// io.thecodeforge — cs-fundamentals tutorial

import hypothesis
from hypothesis import given, strategies as st

# Property: reversing a list twice gives the original
@given(st.lists(st.integers()))
def test_reverse_invariant(lst):
    assert lst[::-1][::-1] == lst

# Mutation: flipping > to < would break this test
@hypothesis.example([1, 2, 3])
def test_sort_preserves_length(arr):
    sorted_arr = sorted(arr)
    assert len(sorted_arr) == len(arr)  # survives mutant if len logic is wrong? fix: assert sorted_arr[0] <= sorted_arr[-1]

import random
from feature_flag import FeatureFlag

flag = FeatureFlag('new-checkout')

if flag.is_enabled(user_id=random.randint(1, 100)):
    # New checkout flow
    process_checkout_v2()
else:
    # Old checkout flow
    process_checkout_v1()

@Pact(consumer="UserServiceClient")
public V4Pact createPact(PactDslWithProvider builder) {
    return builder
        .given("user with ID 1 exists")
        .uponReceiving("a request for user 1")
            .path("/users/1")
            .method("GET")
        .willRespondWith()
            .status(200)
            .headers(Map.of("Content-Type", "application/json"))
            .body(new PactDslJsonBody()
                .integerType("id", 1)
                .stringType("name", "Alice"))
        .toPact();
}

apiVersion: litmuschaos.io/v1alpha1
kind: ChaosEngine
metadata:
  name: pod-kill
spec:
  appinfo:
    appns: 'default'
    applabel: 'app=my-service'
    appkind: 'deployment'
  chaosServiceAccount: litmus
  experiments:
    - name: pod-kill
      spec:
        components:
          env:
            - name: TOTAL_CHAOS_DURATION
              value: '30'
            - name: CHAOS_INTERVAL
              value: '10'
            - name: FORCE
              value: 'true'