From ee7163980fc6d3d3325fe1202188fb353d1e880c Mon Sep 17 00:00:00 2001
From: Jerry Gu <jag2430@columbia.edu>
Date: Thu, 4 Dec 2025 18:57:04 -0500
Subject: [PATCH 1/4] Fixed minor logic error in RouteController, improved
 javadoc comments, enhanced API test collection, updated overall project
 documentation

---
 README.md                                     |  183 +-
 api-testing.md                                | 1757 ++------
 checkstyle.html                               |   28 +-
 cpd.html                                      |  127 +-
 index.html                                    |    2 +-
 pmd_after.html => old_pmd_after.html          |    0
 pmd_before.html => old_pmd_before.html        |    0
 pmd_after_dec.html                            |   61 +
 pmd_before_dec.html                           |  121 +
 pom.xml                                       |  292 +-
 postman/postman_collection.json               | 1589 ++++++-
 .../java/dev/ase/teamproject/Application.java |    6 +-
 .../controller/RouteController.java           |  401 +-
 .../ase/teamproject/filter/LoggerFilter.java  |   34 +-
 .../ase/teamproject/model/Transaction.java    |  152 +-
 .../java/dev/ase/teamproject/model/User.java  |   21 +-
 .../teamproject/service/MockApiService.java   |  185 +-
 src/main/resources/all-java.xml               |   17 -
 src/main/resources/custom-java-rules.xml      |   49 +
 .../MockApiServiceIntegrationTests.java       |  839 +++-
 .../ase/teamproject/MockApiServiceTests.java  | 2278 ++++++----
 .../RouteControllerIntegrationTests.java      |  977 ++++-
 .../ase/teamproject/RouteControllerTests.java | 3761 +++++++----------
 .../ase/teamproject/TransactionUnitTests.java |  910 ++--
 .../dev/ase/teamproject/UserUnitTests.java    |  411 +-
 25 files changed, 8393 insertions(+), 5808 deletions(-)
 rename pmd_after.html => old_pmd_after.html (100%)
 rename pmd_before.html => old_pmd_before.html (100%)
 create mode 100644 pmd_after_dec.html
 create mode 100644 pmd_before_dec.html
 delete mode 100644 src/main/resources/all-java.xml
 create mode 100644 src/main/resources/custom-java-rules.xml

diff --git a/README.md b/README.md
index 97f8b14..f7155c5 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,8 @@ Repository for Team GLACJ's Fall 2025 Advanced Software Engineering team project
 
 This project implements a Ledger Service that allows users to:
 - Manage users and their transactions
-  Track budgets and spending summaries
-  View analytics such as weekly and monthly summaries
+- Track budgets and spending summaries
+- View analytics such as weekly and monthly summaries
 
 It is built with Spring Boot (Java), uses a Cloud SQL database, and exposes RESTful APIs for client interaction.
 
@@ -36,22 +36,30 @@ mvn spring-boot:run
 Once started, navigate to http://127.0.0.1:8080 or http://localhost:8080/ in your web browser.
 Alternatively, access GCP-hosted version at https://ase-team-project-141125434285.europe-west1.run.app
 
+## Client Program
 
-## Viewing Log
-- Open the GCP project hosting our service [here](https://console.cloud.google.com/welcome?authuser=0&hl=en&project=ageless-answer-474618-u4)
-- Navigate to **Monitoring → Logs Explorer**
-- Use the time selection tool on the top right to set timeframe of logs you want to view
-- In the query textbox, enter the following query: `textPayload:"CLIENT_LOG:"`
-Following these instructions will show you a list of all API endpoint calls made as well as their time and the IP address of the client.
+View our client repository here: https://github.com/hc8756/ASE-Team-Project-Client
 
-## Client Program
-View our client repository here: https://github.com/hc8756/ASE-Team-Project-Client  
-  
-This is an example of a client for general users. It allows the user to log in or create an account before viewing their homepage. The homepage contains a list of the user's transactions which can be added to and edited by the viewer. It also shows a user analyitics of their weekly and monthly budgets.
+This is an example of a client for general users. It allows the user to log in or create an account before viewing their homepage. The homepage contains a list of the user's transactions which can be added to and edited by the viewer. It also shows a user analytics of their weekly and monthly budgets.
 
 Multiple people can build and run the client locally following the instructions on the client repo README. All client instances would automatically make calls to the GCP instance hosting our service. How this was implemented can be seen in [this client script](https://github.com/hc8756/ASE-Team-Project-Client/blob/main/src/main/java/dev/ase/client/service/MockApiService.java). The handling of multiple users at once is done by GCP's Cloud Run and Cloud SQL services. As mentioned in the **Viewing Log** section, GCP's Log Explorer keeps track of the IP addresses of each endpoint call, which is how we differentiate clients.
 
-A hypothetical second client is one for banking institutions. This client would be different in that they would have a view of multiple accounts rather than only one. They could implement this by creating a database of their users. They could then view and manage their users, user transactions, and user analytics through our GET endpoints. However, they would have limited edit access to user information and trasactions.
+A hypothetical second client is one for banking institutions. This client would be different in that they would have a view of multiple accounts rather than only one. They could implement this by creating a database of their users. They could then view and manage their users, user transactions, and user analytics through our GET endpoints. However, they would have limited edit access to user information and transactions.
+
+## Multiple Client Instances
+
+Multiple clients can connect to the service simultaneously. The service differentiates clients by:
+
+1. **User-based isolation:** Each client creates/uses their own `userId`. All data (transactions, budgets) is scoped to that user.
+2. **IP logging:** GCP's Log Explorer tracks the IP address of each API call for auditing purposes.
+3. **Stateless API:** The REST API is stateless - no session is maintained between requests. Clients must include `userId` in each request.
+
+## Viewing Log
+To view client activity:
+1. Open [GCP Logs Explorer](https://console.cloud.google.com/welcome?authuser=0&hl=en&project=ageless-answer-474618-u4)
+2. Navigate to **Monitoring → Logs Explorer**
+3. Query: `textPayload:"CLIENT_LOG:"`
+   Following these instructions will show you a list of all API endpoint calls made as well as their time and the IP address of the client.
 
 ## API Documentation
 
@@ -81,12 +89,12 @@ A hypothetical second client is one for banking institutions. This client would
 | `/users/{userId}/transactions/create-form` | GET | — → `text/html` | `userId` | `200 OK` HTML form | `404 Not Found` (HTML body) | Browser-only helper |
 | `/users/{userId}/transactions/{transactionId}` | PUT | `application/json` → `application/json` | `updates: Map<String,Object>` | `200 OK` updated `Transaction` | `404 Not Found` `{"error":"User ... not found"}` or `{"error":"Transaction ... not found for user ..."}` or `{"error":"Transaction ... not found"}` | Partial update keys handled by service |
 | `/users/{userId}/transactions/{transactionId}` | DELETE | — → `application/json` | `userId,transactionId` | `200 OK` `{"deleted":true,"userId":...,"transactionId":...}` | `404 Not Found` `{"error":"User ... not found"}` or `{"error":"Transaction ... not found for user ..."}` or `{"error":"Transaction ... not found"}` | Deletes transaction |
-| `/users/{userId}/deletetransaction/{transactionId}` | GET | — → `text/plain` | `userId,transactionId` | `200 OK` `"Transaction deleted successfully!"` | `200 OK` `"Error: User ... not found"` or `"Error: Transaction ... not found for user ..."` or `"Error: Failed to delete transaction ..."` (plain strings, not HTTP errors) | Browser-friendly delete; returns 200 with error text on failures |
+| `/users/{userId}/deletetransaction/{transactionId}` | GET | — → `text/plain` | `userId,transactionId` | `200 OK` `"Transaction deleted successfully!"` | `404 Not Found` `"Error: User ... not found"` or `"Error: Transaction ... not found for user ..."`, `500 Internal Server Error` `"Error: Failed to delete transaction ..."` | Browser-friendly delete |
 | `/users/{userId}/budget` | GET | — → `text/html` | `userId` | `200 OK` HTML budget dashboard | `404 Not Found` (HTML body) | Renders current budget, remaining, weekly spend, and links |
 | `/users/{userId}/budget` | PUT | `application/json` → `application/json` | `budgetUpdate: Map` e.g. `{"budget":123.45}` | `200 OK` budget report JSON | `404 Not Found` `{"error":"User ... not found"}` | Persists new budget via service |
 | `/users/{userId}/update-budget` | POST | `application/x-www-form-urlencoded` → `text/html` | `budget` | `200 OK` HTML confirmation | `404 Not Found` (HTML body) | Browser-friendly budget update |
-| `/users/{userId}/weekly-summary` | GET | — → `text/html` | `userId` | `200 OK` HTML with table and total | `404 Not Found` (HTML body) | Renders last 7 days transactions |
-| `/users/{userId}/monthly-summary` | GET | — → `text/html` | `userId` | `200 OK` HTML `<pre>` summary | `404 Not Found` (HTML body) | Text summary produced by service |
+| `/users/{userId}/weekly-summary` | GET | — → `application/json` | `userId` | `200 OK` JSON with `username`, `weeklyTotal`, `transactionCount`, `transactions` | `404 Not Found` `{"error":"User ... not found"}` | Returns last 7 days transactions |
+| `/users/{userId}/monthly-summary` | GET | — → `application/json` | `userId` | `200 OK` JSON with `summary` key | `404 Not Found` `{"error":"User ... not found"}` | Text summary produced by service |
 | `/users/{userId}/budget-report` | GET | — → `application/json` | `userId` | `200 OK` budget report JSON `{totalSpent, remaining, ...}` | `404 Not Found` `{"error":"User ... not found"}` | Read-only |
 
 #### Global Error Handling
@@ -104,11 +112,37 @@ To run all unit tests:
 mvn test
 ```
 
-### Endpoint Testing
+### Integration Testing
+- Framework: JUnit 5 with Spring Boot Test
+- Database: Embedded test configuration with JdbcTemplate
 
-Please see `api-testing.md` in the root of this repository for detailed instructions on running tests with `curl`.
+Integration tests verify:
+- **Internal integration:** Controller ↔ Service ↔ Models working together
+- **External integration:** Service ↔ JdbcTemplate ↔ PostgreSQL database
+- **Shared data:** User-Transaction foreign key relationships, budget calculations, cascade deletes
 
-Calls were logged for endpoints. Logging information appears in the terminal that is running the application.
+Test files:
+- `RouteControllerIntegrationTests.java` - Controller-Service integration
+- `MockApiServiceIntegrationTests.java` - Service-Database integration
+
+To run all integration tests:
+```bash
+mvn test
+```
+
+### API Testing (Postman/Newman)
+- Tool: Postman with Newman CLI for CI integration
+
+API tests cover:
+- All REST endpoints with valid and invalid equivalence partitions
+- Boundary value testing (zero, negative, large values)
+- Multiple client simulation
+- Persistent data verification
+
+Our CI configuration automatically run the entire collection of API tests when new pull requests
+are accepted to commit to the main branch
+
+See `api-testing.md` for detailed partition documentation.
 
 ### Test Coverage
 - Tool: JaCoCo
@@ -120,7 +154,7 @@ mvn jacoco:report
 
 The report is accessible at `target/site/jacoco/index.html`.
 
-For the first iteration, we acheived 85% branch coverage. A copy of the report `index.html` is also included in the root of this repository.
+For our service, we have achieved 85% branch coverage. A copy of the report `index.html` is also included in the root of this repository.
 
 
 ## Style Checker
@@ -144,35 +178,105 @@ The report is accessible at `target/site/checkstyle.html`. A copy of a clean rep
 
 ## Static Analysis with PMD
 
-This project uses PMD for static code analysis to enforce consistent quality and style. 
+This project uses PMD for static code analysis to enforce consistent quality and style.
 
 1. Ensure `pom.xml` in the root directory is updated.
-2. Ensure `all-java.xml` is present in `/src/main/resources`
-3. Run PMD:
+2. Ensure `custom-java-rules.xml` is present in `/src/main/resources`
+3. For our project, we chose to use custom, more stringent rule set than the default rules.
+4. Run PMD:
+```bash
+mvn clean pmd:pmd
+``` 
+The report will be available at `/target/reports/pmd.html`
+5. Can also run this command:
 ```bash
 mvn clean site
 ``` 
 The reports will be available at `/target/site/pmd.html` and `/target/site/cpd.html`
 
-A copy of a "before" PMD report and a clean "after" PMD report are available in the root directory. The CPD reports were always clean, and a copy is also included in the root directory.
+Copies of "before" PMD reports and clean "after" PMD reports are available in the root directory.
+The most up-to-date before and after PMD reports in the root directory are `pmd_before_dec.html` and `pmd_after_dec.html`
+The CPD reports were always clean, and a copy is also included in the root directory.
+
+## Continuous Integration
+
+This project uses GitHub Actions for CI. The pipeline runs automatically on pushes and pull requests to `main`.
+
+### CI Pipeline Jobs
 
-In several cases, certain rules were intentionally suppressed because their recommendations conflict with established design decisions, necessary framework patterns, or clarity/readability requirements. Below is a summary of the suppressed warnings and the rationale behind each:
+| Job | Description |
+|-----|-------------|
+| Unit Tests | Runs all unit tests (`*UnitTests`, `*Tests`) |
+| Integration Tests | Runs database integration tests (`*IntegrationTests`) |
+| API Tests | Runs Newman/Postman API tests against live application |
+| Code Coverage | Generates JaCoCo coverage report |
+| Static Analysis | Runs Checkstyle and PMD |
+
+### CI Configuration
+
+The CI workflow is defined in `.github/workflows/maven.yml`.
+
+### Running Tests Locally
+```bash
+# Unit tests
+mvn test -Dtest="*UnitTests,*Tests"
+
+# Integration tests (requires PostgreSQL)
+mvn test -Dtest="*IntegrationTests"
+
+# API tests (requires application running)
+newman run postman/postman_collection.json -e postman/postman_environment.json
+```
+
+## Developing a Third-Party Client
+
+To develop your own client application that uses this service:
+
+### 1. Base URL
+- **Local:** `http://localhost:8080`
+- **Production:** `https://ase-team-project-141125434285.europe-west1.run.app`
+
+### 2. Required Request Flow
+1. **Create a user first** via `POST /users` (JSON) or `POST /users/form` (HTML)
+2. Store the returned `userId` (UUID) for subsequent requests
+3. All `/users/{userId}/...` endpoints require a valid `userId`
+4. Transaction endpoints require the transaction to belong to the specified user
+
+### 3. Content Types
+- **JSON endpoints:** Set `Content-Type: application/json` header
+- **Form endpoints:** Set `Content-Type: application/x-www-form-urlencoded` header
+
+### 4. Example: Creating a User (JSON)
+```bash
+curl -X POST http://localhost:8080/users \
+  -H "Content-Type: application/json" \
+  -d '{"username": "john_doe", "email": "john@example.com", "budget": 1000.00}'
+```
+
+Response:
+```json
+{
+  "userId": "550e8400-e29b-41d4-a716-446655440000",
+  "username": "john_doe",
+  "email": "john@example.com",
+  "budget": 1000.00
+}
+```
+
+### 5. Example: Creating a Transaction
+```bash
+curl -X POST http://localhost:8080/users/{userId}/transactions \
+  -H "Content-Type: application/json" \
+  -d '{"description": "Groceries", "amount": 50.00, "category": "FOOD"}'
+```
 
- **Rule** | **Scope (File/Class)** | **Reason for Suppression** |
-|-----------|------------------------|-----------------------------|
-| `OnlyOneReturn` | `RouteController`, `MockApiService`, `Transaction` | Multiple return statements are used intentionally for clearer control flow and early error handling, especially in REST endpoints. Enforcing a single return would reduce readability. |
-| `AvoidCatchingGenericException` | `RouteController`, `MockApiService` | Generic exceptions (e.g., `RuntimeException`) are caught at well-defined boundaries to ensure proper logging and consistent API responses. |
-| `CyclomaticComplexity`, `CognitiveComplexity` | `RouteController`, `MockApiService`, `Transaction` | Some methods inherently require multiple conditional branches for validation or comparison logic. Refactoring would reduce clarity without simplifying logic. |
-| `TooManyMethods` | `RouteController`, `MockApiService` | These classes act as centralized controller/service entry points. Splitting them would fragment logically related functionality. |
-| `CommentSize` | `RouteController`, `Transaction` | Large comments were preserved to provide clear documentation and educational explanations of logic flow. |
-| `DataClass` | `User`, `Transaction` | Both are intentionally implemented as plain data holder classes (POJOs) with standard getters/setters, consistent with Java domain modeling best practices. |
-| `ShortClassName` | `User` | The name `User` is concise, standard, and domain-appropriate. Extending it would reduce clarity. |
-| `ConstructorCallsOverridableMethod` | `Transaction` | The constructor calls `setDescription()` for input normalization. The method has no side effects and is effectively safe to call. |
-| `NullAssignment` | `Transaction` | Null assignments used for optional initialization (e.g., timestamps) are controlled and do not introduce unsafe behavior. |
-| `OnlyOneReturn` (repeated instances) | Multiple classes | Each suppression corresponds to methods where early returns improve clarity and maintainability. |
-| `SystemPrintln` | `LoggerFilter` | Direct `System.out` logging was replaced by a proper logger; suppression documents the historical rule hit. |
+### 6. Some Examples Of Valid Transaction Categories
+`FOOD`, `TRANSPORTATION`, `ENTERTAINMENT`, `UTILITIES`, `HEALTHCARE`, `OTHER`
 
-All PMD suppressions are deliberate, documented, and localized to specific cases where strict compliance would hinder clarity or architectural intent.
+### 7. Error Handling
+- `400 Bad Request`: Invalid input (check `error` field in response)
+- `404 Not Found`: User or transaction not found
+- `500 Internal Server Error`: Server-side error
 
 ## Documentation and Organization
 
@@ -190,6 +294,7 @@ Official documentation and reference materials used throughout the project inclu
 - **Maven Checkstyle Plugin:** https://maven.apache.org/plugins/maven-checkstyle-plugin/
 - **Google Java Style Guide (Checkstyle Rules):** https://google.github.io/styleguide/javaguide.html
 - **Spring Testing (MockMvc):** https://docs.spring.io/spring-framework/docs/current/reference/html/testing.html#spring-mvc-test-framework
+- **Postman/Newman (API Testing):** https://learning.postman.com/docs/collections/using-newman-cli/command-line-integration-with-newman/
 
 ChatGPT assisted in referencing documentation, fixing style warnings (long lines, import order), and minor debugging.
 
diff --git a/api-testing.md b/api-testing.md
index 8189014..606e5bf 100644
--- a/api-testing.md
+++ b/api-testing.md
@@ -1,1611 +1,396 @@
-# API Testing with curl
-
-For setup and run instructions, please see `README.md` in the root of this repository.
-
-You can test every endpoint in this application using `curl`. By default, the server runs at `http://127.0.0.1:8080` or `http://localhost:8080`. These examples use `http://localhost:8080`. Some curl commands also in refer to user/transaction IDs placeholder for real values.
-
-Note: For more visually appealing formatting, we use **Lynx**. If you want this too, install these tools.
-
-Mac:
-```
-brew install lynx
-```
-Windows:
-```
-sudo apt install lynx
-```
-
----
-
-## GET `/` or `/index` — homepage
-
-### Typical Valid Input — Normal case with existing users
-```
-# Create a few users if needed
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Alice", "email": "alice@columbia.edu", "budget": 500}' ; echo
-
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Bob", "email": "bob@gmail.com", "budget": 1200}' ; echo
-
-# Access the home page using either / or /index
-curl -isS http://localhost:8080/ ; echo
-curl -isS http://localhost:8080/index ; echo
-
-# Nice formatting
-curl -isS http://localhost:8080/index -o response.html \
-&& echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html \
-&& echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist
-
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html
-Content-Length: 310
-Date: Fri, 24 Oct 2025 00:30:03 GMT
-
-
-                    Welcome to the Personal Finance Tracker
-
-   Existing Users:
-   - Alice | alice@columbia.edu | Budget: $500.00
-   - Bob | bob@gmail.com | Budget: $1200.00
-```
-
-### Atypical Valid Input — No users exist
-```
-# Delete existing users if needed
-# Replace {UUID} with actual IDs from GET /users
-curl -isS http://localhost:8080/deleteuser/{UUID} ; echo
-
-# Acces the home page using either / or /index
-curl -isS http://localhost:8080/ ; echo
-curl -isS http://localhost:8080/index ; echo
-
-# Nice formatting
-curl -isS http://localhost:8080/index -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html
-Content-Length: 96
-Date: Fri, 24 Oct 2025 00:31:11 GMT
-
-
-                    Welcome to the Personal Finance Tracker
-
-   No users found.
-```
-
-### Invalid Input — Wrong path
-```
-# Misspelled endpoint
-curl -isS http://localhost:8080/inde ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Vary: Origin
-Vary: Access-Control-Request-Method
-Vary: Access-Control-Request-Headers
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:31:24 GMT
-
-{"timestamp":"2025-10-24T00:31:24.879+00:00","status":404,"error":"Not Found","path":"/inde"}
-```
+# API Equivalence Partitions Documentation
+
+This document defines the equivalence partitions for each API endpoint in the Personal Finance Tracker service. Each partition represents a class of inputs that should be treated equivalently by the system.
+
+## Table of Contents
+[Index/Home Endpoints](#indexhome-endpoints)  
+[User Management - GET /users](#user-management---get-users)  
+[User Management - POST /users (JSON)](#user-management---post-users-json)  
+[User Management - GET /users/{userId}](#user-management---get-usersuserid)  
+[User Management - PUT /users/{userId}](#user-management---put-usersuserid)  
+[User Management - POST /users/form (HTML)](#user-management---post-usersform-html)  
+[User Management - POST /users/{userId}/update-form (HTML)](#user-management---post-usersuseridupdate-form-html)  
+[User Management - GET Forms](#user-management---get-forms)  
+[User Management - DELETE /users/{userId}](#user-management---delete-usersuserid)  
+[User Management - GET /deleteuser/{userId}](#user-management---get-deleteuseruserid)  
+[Transaction Management - POST](#transaction-management---post-transactions)  
+[Transaction Management - GET List](#transaction-management---get-transactions-list)  
+[Transaction Management - GET Single](#transaction-management---get-single-transaction)  
+[Transaction Management - PUT](#transaction-management---put-transaction)  
+[Transaction Management - DELETE](#transaction-management---delete-transaction)  
+[Transaction Management - GET /deletetransaction](#transaction-management---get-deletetransaction)  
+[Transaction Management - Forms](#transaction-management---forms)  
+[Budget Management - GET Page](#budget-management---get-budget-page)  
+[Budget Management - PUT /budget](#budget-management---put-budget-json)  
+[Budget Management - POST /update-budget](#budget-management---post-update-budget-form)  
+[Analytics - Weekly Summary](#analytics---weekly-summary)  
+[Analytics - Monthly Summary](#analytics---monthly-summary)  
+[Analytics - Budget Report](#analytics---budget-report)
 
 ---
 
-## GET `/users` — Retrieve all users
-
-### Typical Valid Input — Normal case with existing users
-```
-# Create a few users if needed
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Alice", "email": "alice@columbia.edu", "budget": 500}' ; echo
-
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Bob", "email": "bob@gmail.com", "budget": 1200}' ; echo
-
-# Retrieve all users
-curl -isS http://localhost:8080/users -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:33:40 GMT
-
-
-   [{"userId":"31cc9c67-c23c-462b-9a13-a1db18530ee2","username":"Alice","e
-   mail":"alice@columbia.edu","budget":500.0},{"userId":"a031ac86-5c6a-473
-   2-8742-16b6fb83c11a","username":"Bob","email":"bob@gmail.com","budget":
-   1200.0}]
-```
-
-### Atypical Valid Input — No users exist
-```
-# Delete existing users if needed
-# Replace {UUID} with actual IDs from GET /users
-curl -isS http://localhost:8080/deleteuser/{UUID} ; echo
-
-# Retrieve all users again
-curl -isS http://localhost:8080/users -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:31:58 GMT
-
-
-   []
-```
-
-### Invalid Input — Wrong path
-```
-# Misspelled endpoint
-curl -isS http://localhost:8080/user ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Vary: Origin
-Vary: Access-Control-Request-Method
-Vary: Access-Control-Request-Headers
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:34:20 GMT
-
-{"timestamp":"2025-10-24T00:34:20.235+00:00","status":404,"error":"Not Found","path":"/user"}
-```
+## Index/Home Endpoints
 
----
-
-## GET `/users/{userId}` — Retrieve details of a specific user
-
-### Typical Valid Input — Retrieve an existing user by ID
-```
-# Create a user if needed
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Charlie", "email": "charlie@columbia.edu", "budget": 900}' ; echo
-
-curl -isS http://localhost:8080/users/{UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:37:00 GMT
-
-
-   {"userId":"31cc9c67-c23c-462b-9a13-a1db18530ee2","username":"Alice","em
-   ail":"alice@columbia.edu","budget":500.0}
-```
-
-### Atypical Valid Input — UUID format is valid but user does not exist
-```
-# Use a valid UUID that does not correspond to any existing user
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000 -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:37:52 GMT
-
-
-   {"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
-
-### Invalid Input — Invalid UUID
-```
-# Invalid UUID format
-curl -isS http://localhost:8080/users/not-a-valid-uuid ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:38:16 GMT
-Connection: close
-
-{"error":"Invalid UUID string: not-a-valid-uuid"}
-```
----
+### GET / and GET /index
 
-## POST `/users` — Create a new user via JSON
-
-### Typical Valid Input — Normal case with valid JSON data
-```
-# Create a new user
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Ethan", "email": "ethan@gmail.com", "budget": 950}' \
-  -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:39:04 GMT
-
-
-   {"userId":"00df6c5a-9321-4744-b653-3a15be39f085","username":"Ethan","em
-   ail":"ethan@gmail.com","budget":950.0}
-```
-
-### Atypical Valid Input — Missing optional field or empty string
-```
-# Create a user with minimal data or empty name (edge case)
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "", "email": "noname@example.com", "budget": 300}' \
-  -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:39:47 GMT
-
-
-   {"userId":"67a337ac-9034-4b52-a463-6fb3e60572ce","username":"","email":
-   "noname@example.com","budget":300.0}
-```
-
-### Invalid Input — Incomplete JSON
-```
-# Invalid payload
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d 'not-valid-json' ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:40:11 GMT
-Connection: close
-
-{"timestamp":"2025-10-24T00:40:11.717+00:00","status":400,"error":"Bad Request","path":"/users"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid GET request to `/` | 200 OK, HTML with welcome message | `GET / - Home Page (Valid)` |
+| P2 | Valid | Valid GET request to `/index` | 200 OK, HTML with welcome message | `GET /index - Index Page (Valid)` |
+| P3 | Invalid | Invalid path | 404 Not Found | `GET /invalid-path - Invalid Path` |
 
 ---
 
-## POST `/users/form` — Create a new user via HTML form submission
-
-### Typical Valid Input — Normal case with proper form data
-```
-# Submit a new user using form-encoded data
-curl -isS -X POST http://localhost:8080/users/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "username=Grace&email=grace@gmail.com&budget=650" \
-  -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 254
-Date: Fri, 24 Oct 2025 00:40:48 GMT
-
-
-User Created Successfully!
-
-   User ID: 149119d7-dab0-4535-a854-8d2e43f930b5
-
-   Username: Grace
-
-   Email: grace@gmail.com
-
-   Budget: $650.00
-```
-
-### Atypical Valid Input — Zero budget value
-```
-# Submit a user with edge-case budget values
-curl -isS -X POST http://localhost:8080/users/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "username=ZeroBudget&email=zerobudget@test.com&budget=0" \
-  -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+## User Management - GET /users
 
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 261
-Date: Fri, 24 Oct 2025 00:42:04 GMT
+### GET /users
 
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid GET request | 200 OK, JSON array of users | `GET /users - List All Users (Valid)` |
 
-User Created Successfully!
-
-   User ID: bae3e580-f710-43aa-b5d1-343531682c77
-
-   Username: ZeroBudget
-
-   Email: zerobudget@test.com
+---
 
-   Budget: $0.00
-```
+## User Management - POST /users (JSON)
 
-### Invalid Input — Missing required form field(s)
-```
-# Missing budget field
-curl -isS -X POST http://localhost:8080/users/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "username=InvalidUser&email=invalid@test.com" ; echo
-```
+### POST /users
 
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:42:33 GMT
-Connection: close
+**Input Parameters:**
+- `username` (String, required)
+- `email` (String, required)
+- `budget` (Double, required, >= 0)
 
-{"timestamp":"2025-10-24T00:42:33.378+00:00","status":400,"error":"Bad Request","path":"/users/form"
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | All fields valid (username, email, positive budget) | 201 Created with user data | `POST /users - Create Valid User` |
+| P2 | Valid/Boundary | budget = 0 (minimum valid) | 201 Created | `POST /users - Zero Budget` |
+| P3 | Valid/Boundary | budget = 99999999.99 (high value) | 201 Created | `POST /users - Large Budget` |
+| P4 | Invalid | username = null | 400 Bad Request | `POST /users - Missing Username` |
+| P5 | Invalid | email = null | 400 Bad Request | `POST /users - Missing Email` |
+| P6 | Invalid | Malformed JSON | 400 Bad Request | `POST /users - Malformed JSON` |
+| P7 | Invalid | Duplicate username | 400 Bad Request | `POST /users - Duplicate Username` |
+| P8 | Invalid | Duplicate email | 400 Bad Request | `POST /users - Duplicate Email` |
 
 ---
 
-## GET `/users/create-form` — Display HTML form for creating a new user
-
-### Typical Valid Input — Normal request to view the form
-```
-# Access the user creation form
-curl -isS http://localhost:8080/users/create-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 323
-Date: Fri, 24 Oct 2025 00:58:34 GMT
-
-
-Create New User
-
-   Username: ____________________
-   Email: ____________________
-   Budget: ____________________
-   Create User
-```
-
-### Atypical Valid Input — Access form repeatedly
-```
-# Perform multiple requests (user refreshes the form page)
-curl -isS http://localhost:8080/users/create-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 323
-Date: Fri, 24 Oct 2025 00:59:23 GMT
-
-
-Create New User
-
-   Username: ____________________
-   Email: ____________________
-   Budget: ____________________
-   Create User
-```
-
-### Invalid Input — Wrong path/misspelled route
-```
-# Misspelled endpoint path
-curl -isS http://localhost:8080/users/createform ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 00:59:43 GMT
-Connection: close
-
-{"error":"Invalid UUID string: createform"}
-```
+## User Management - GET /users/{userId}
 
----
+### GET /users/{userId}
 
-## GET `/users/{userId}/edit-form` — Display editable form for an existing user
-
-### Typical Valid Input — Retrieve edit form for an existing user
-```
-# Replace {UUID} below with an existing user's ID
-curl -isS http://localhost:8080/users/{UUID}/edit-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 420
-Date: Fri, 24 Oct 2025 01:01:03 GMT
-
-
-Edit User
-
-   Username: Ethan_______________
-   Email: ethan@gmail.com_____
-   Budget: 950.0_______________
-   Update User
-```
-
-### Atypical Valid Input — Access the edit form multiple times (repeated requests)
-```
-# Perform multiple consecutive GET requests to the same edit form
-curl -isS http://localhost:8080/users/{UUID}/edit-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 420
-Date: Fri, 24 Oct 2025 01:01:03 GMT
-
-
-Edit User
-
-   Username: Ethan_______________
-   Email: ethan@gmail.com_____
-   Budget: 950.0_______________
-   Update User
-```
-
-### Invalid Input — Nonexistent user ID
-```
-# Use a UUID that does not exist
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/edit-form ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:02:01 GMT
-
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+**Input Parameters:**
+- `userId` (UUID, path parameter)
 
----
-
-## DELETE `/users/{userId}` — Delete a user by ID (JSON API)
-
-### Typical Valid Input — Delete an existing user
-```
-# Replace {UUID} with an existing user ID
-curl -isS -X DELETE http://localhost:8080/users/{UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:03:22 GMT
-
-
-   {"deleted":true,"userId":"67a337ac-9034-4b52-a463-6fb3e60572ce"}
-```
-
-### Atypical Valid Input — Delete an already deleted user
-```
-# Attempt to delete the same user again
-curl -isS -X DELETE http://localhost:8080/users/{UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:03:47 GMT
-
-
-   {"error":"User 67a337ac-9034-4b52-a463-6fb3e60572ce not found"}
-```
-
-### Invalid Input — Invalid or incorrect UUID
-```
-# Use an invalid UUID string
-curl -isS -X DELETE http://localhost:8080/users/not-a-valid-uuid ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:05:23 GMT
-Connection: close
-
-{"error":"Invalid UUID string: not-a-valid-uuid"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK with user data | `GET /users/{userId} - Existing User` |
+| P2 | Invalid | Non-existent but valid UUID format | 404 Not Found | `GET /users/{userId} - Non-existent UUID` |
+| P3 | Invalid | Invalid UUID format | 400 Bad Request | `GET /users/{userId} - Invalid UUID Format` |
 
 ---
 
-## GET `/deleteuser/{userId}` — Delete a user via GET (HTML Response)
-
-### Typical Valid Input — Delete an existing user
-```
-# Replace {UUID} with the an existin user ID
-curl -isS http://localhost:8080/deleteuser/{UUID} -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/plain;charset=UTF-8
-Content-Length: 25
-Date: Fri, 24 Oct 2025 01:06:35 GMT
-
-
-   User deleted successfully
-```
-
-### Atypical Valid Input — Attempt to delete an already deleted user
-```
-# Try deleting the same user again
-curl -isS http://localhost:8080/deleteuser/{UUID} -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:07:03 GMT
-
-
-   {"error":"User bae3e580-f710-43aa-b5d1-343531682c77 not found"}
-```
-
-### Invalid Input — Invalid UUID
-```
-# Step 1: Provide an invalid UUID format
-curl -isS http://localhost:8080/deleteuser/not-a-valid-uuid ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:07:37 GMT
-Connection: close
-
-{"error":"Invalid UUID string: not-a-valid-uuid"}
-```
-
----
+## User Management - PUT /users/{userId}
 
-## GET `/users/{userId}/transactions` — Retrieve all transactions for a specific user
-
-### Typical Valid Input — User exists and has transactions
-```
-# Replace {USER_UUID} with the user ID
-# Add two transactions for this user
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Groceries", "amount": 120.5, "category": "FOOD"}' ; echo
-
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "MetroCard Refill", "amount": 40, "category": "TRANSPORTATION"}' ; echo
-
-# Retrieve all transactions for the user
-curl -isS http://localhost:8080/users/{USER_UUID}/transactions -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:09:54 GMT
-
-
-   [{"transactionId":"45ed2ed8-2964-4b56-84cb-2d5832d806c7","userId":"00df
-   6c5a-9321-4744-b653-3a15be39f085","description":"MetroCard
-   Refill","amount":40.0,"category":"TRANSPORTATION","timestamp":"2025-10-
-   23T21:09:34.305769","date":"2025-10-23"},{"transactionId":"c7bb37bf-ab0
-   4-4e8b-a0ac-d348464a9a65","userId":"00df6c5a-9321-4744-b653-3a15be39f08
-   5","description":"Groceries","amount":120.5,"category":"FOOD","timestam
-   p":"2025-10-23T21:09:09.821857","date":"2025-10-23"}]
-```
-
-### Atypical Valid Input — User exists but has no transactions
-```
-# Step 1: Create a new user without adding transactions
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Olivia", "email": "olivia@columbia.edu", "budget": 800}' ; echo
-
-# Step 2: Replace {USER_UUID} with the ID from the response
-
-# Step 3: Retrieve transactions (expect an empty array)
-curl -isS http://localhost:8080/users/{USER_UUID}/transactions -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:10:33 GMT
-
-
-   []
-```
-
-### Invalid Input — Non-existent or invalid user ID
-```
-# Non-existent UUID
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/transactions ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: text/plain;charset=UTF-8
-Content-Length: 58
-Date: Fri, 24 Oct 2025 01:11:14 GMT
-
-Error: User 00000000-0000-0000-0000-000000000000 not found
-```
+### PUT /users/{userId}
 
----
+**Input Parameters:**
+- `userId` (UUID, path parameter)
+- `username` (String, body)
+- `email` (String, body)
+- `budget` (Double, body)
 
-## GET `/users/{userId}/transactions/{transactionId}` — Retrieve details of a specific transaction
-
-### Typical Valid Input — Valid user and existing transaction
-```
-# Replace {USER_UUID} with the valid user ID
-# Replace {TRANSACTION_UUID} with existing transaction ID
-curl -isS http://localhost:8080/users/{USER_UUID}/transactions/{TRANSACTION_UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:13:19 GMT
-
-
-   {"transactionId":"45ed2ed8-2964-4b56-84cb-2d5832d806c7","userId":"00df6
-   c5a-9321-4744-b653-3a15be39f085","description":"MetroCard
-   Refill","amount":40.0,"category":"TRANSPORTATION","timestamp":"2025-10-
-   23T21:09:34.305769","date":"2025-10-23"}
-```
-
-### Atypical Valid Input — Valid user but transaction belongs to another user
-```
-# Create a user if needed
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Isabella", "email": "isabella@columbia.edu", "budget": 950}' ; echo
-
-# Create a transaction for the new user
-curl -isS -X POST http://localhost:8080/users/{NEW_USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Dinner", "amount": 80.75, "category": "FOOD"}' ; echo
-
-# Try fetching that transaction under a different valid user
-curl -isS http://localhost:8080/users/{USER_1_UUID}/transactions/{TRANSACTION_NEW_UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:18:23 GMT
-
-
-   {"error":"Transaction 6ce98f89-de4c-4d44-9d3d-d01024bfbf91 not found
-   for user 00df6c5a-9321-4744-b653-3a15be39f085"}
-```
-
-### Invalid Input — Nonexistent/invalid UUIDs
-```
-curl -isS http://localhost:8080/users/{VALID_USER_UUID}/transactions/00000000-0000-0000-0000-000000000000 ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:19:00 GMT
-Connection: close
-
-{"error":"Invalid UUID string: VALID_USER_UUID"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing user, valid update data | 200 OK with updated user | `PUT /users/{userId} - Update All Fields` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `PUT /users/{userId} - Non-existent User` |
+| P3 | Invalid | Duplicate username (conflict with other user) | 400 Bad Request | `PUT /users/{userId} - Duplicate Username` |
+| P4 | Invalid | Duplicate email (conflict with other user) | 400 Bad Request | `PUT /users/{userId} - Duplicate Email` |
+| P5 | Valid/Boundary | budget = 0 | 200 OK | `PUT /users/{userId} - Zero Budget` |
 
 ---
 
-## POST `/users/{userId}/transactions` — Create a new transaction for a user (JSON)
-
-### Typical Valid Input — Valid user with correct JSON payload
-```
-# Create a transaction for a valid user
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Coffee and Bagel", "amount": 8.75, "category": "FOOD"}' -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:20:40 GMT
-
-
-   {"transactionId":"01eb0e59-258e-4828-8ed9-388f534ec498","userId":"00df6
-   c5a-9321-4744-b653-3a15be39f085","description":"Coffee and
-   Bagel","amount":8.75,"category":"FOOD","timestamp":"2025-10-23T21:20:40
-   .313522","date":"2025-10-23"}0
-```
-
-### Atypical Valid Input — Zero transaction amount
-```
-# Create a transaction with a zero amount
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Free coupon coffee", "amount": 0.0, "category": "FOOD"}' -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:21:30 GMT
-
-
-   {"transactionId":"2f67194a-442a-4a00-8771-bd7e334c5fe8","userId":"00df6
-   c5a-9321-4744-b653-3a15be39f085","description":"Free coupon
-   coffee","amount":0.0,"category":"FOOD","timestamp":"2025-10-23T21:21:30
-   .343616","date":"2025-10-23"}
-```
-
-### Invalid Input — Non-existent user or malformed payload
-```
-# Non-existent user
-curl -isS -X POST http://localhost:8080/users/00000000-0000-0000-0000-000000000000/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Lunch", "amount": 12.0, "category": "FOOD"}' ; echo
-
-# Malformed JSON payload
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Invalid JSON", "amount": , "category": "FOOD"}' ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 400 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:22:11 GMT
-Connection: close
-
-{"error":"Invalid UUID string: USER_UUID"}
-```
+## User Management - POST /users/form (HTML)
 
----
+### POST /users/form
 
-## POST `/users/{userId}/transactions/form` — Create a new transaction (HTML form)
+**Input Parameters:**
+- `username` (form field)
+- `email` (form field)
+- `budget` (form field)
 
-### Typical Valid Input — Valid user submitting correct form data
-```
-# Create a new transaction via HTML form submission
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "description=Gym+Membership&amount=50.00&category=HEALTHCARE" -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | All fields valid | 201 Created, HTML success page | `POST /users/form - Valid Form Data` |
+| P2 | Invalid | Duplicate username | 400 Bad Request, HTML error | `POST /users/form - Duplicate Username` |
+| P3 | Invalid | Duplicate email | 400 Bad Request, HTML error | `POST /users/form - Duplicate Email` |
 
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 205
-Date: Fri, 24 Oct 2025 01:23:05 GMT
+---
 
+## User Management - POST /users/{userId}/update-form (HTML)
 
-Transaction Created Successfully!
+### POST /users/{userId}/update-form
 
-   Description: Gym Membership
+**Input Parameters:**
+- `userId` (UUID, path parameter)
+- `username` (form field)
+- `email` (form field)
+- `budget` (form field)
 
-   Amount: $50.00
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing user, valid data | 200 OK, HTML success page | `POST /users/{userId}/update-form - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `POST /users/{userId}/update-form - User Not Found` |
+| P3 | Invalid | Duplicate username | 400 Bad Request | `POST /users/{userId}/update-form - Duplicate Username` |
+| P4 | Invalid | Duplicate email | 400 Bad Request | `POST /users/{userId}/update-form - Duplicate Email` |
 
-   Category: HEALTHCARE
-```
+---
 
-### Atypical Valid Input — Edge case with zero amount
-```
-# Create a transaction with a zero amount
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "description=Free+Trial&amount=0&category=OTHER" -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+## User Management - GET Forms
 
-Sample Output:
-```
-HTTP/1.1 201 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 195
-Date: Fri, 24 Oct 2025 01:24:15 GMT
+### GET /users/create-form
 
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid GET request | 200 OK, HTML form | `GET /users/create-form` |
 
-Transaction Created Successfully!
+### GET /users/{userId}/edit-form
 
-   Description: Free Trial
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, HTML form with user data | `GET /users/{userId}/edit-form - Existing User` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET /users/{userId}/edit-form - Non-existent User` |
 
-   Amount: $0.00
+---
 
-   Category: OTHER
-```
+## Transaction Management - POST Transactions
 
-### Invalid Input — Non-existent user or missing parameters
-```
-# Non-existent user ID
-curl -isS -X POST http://localhost:8080/users/00000000-0000-0000-0000-000000000000/transactions/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "description=Snacks&amount=5.50&category=FOOD" ; echo
+### POST /users/{userId}/transactions
 
-# Missing parameter (no category)
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions/form \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "description=Snacks&amount=5.50" ; echo
-```
+**Input Parameters:**
+- `userId` (UUID, path parameter)
+- `description` (String, required, non-empty)
+- `amount` (Double, required, > 0)
+- `category` (String, required, valid enum value)
 
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 58
-Date: Fri, 24 Oct 2025 01:24:47 GMT
+**Valid Categories:** FOOD, TRANSPORTATION, ENTERTAINMENT, UTILITIES, SHOPPING, HEALTHCARE, TRAVEL, EDUCATION, OTHER
 
-Error: User 00000000-0000-0000-0000-000000000000 not found
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | All fields valid | 201 Created with transaction data | `POST Transaction - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `POST Transaction - Non-existent User` |
+| P3 | Invalid | Invalid category | 400/500 Error | `POST Transaction - Invalid Category` |
+| P4 | Invalid/Boundary | amount < 0 (negative) | 400/500 Error | `POST Transaction - Negative Amount` |
+| P5 | Invalid/Boundary | amount = 0 | 400/500 Error | `POST Transaction - Zero Amount` |
+| P6 | Invalid | description = "" (empty) | 400/500 Error | `POST Transaction - Empty Description` |
+| P7 | Valid | Large amount (boundary high) | 201 Created | `POST Transaction - Large Amount` |
 
 ---
 
-## GET `/users/{userId}/transactions/create-form` — Display the HTML form for creating a new transaction
-
-### Typical Valid Input — Display form for an existing user
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/transactions/create-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 793
-Date: Fri, 24 Oct 2025 01:49:41 GMT
-
-
-Create New Transaction
-
-   Description: ____________________
-   Amount: ____________________
-   Category: [Food__________]
-   Create Transaction
-```
-
-### Atypical Valid Input — User exists but has no prior transactions
-```
-# Access the form for a user who has no transactions yet
-curl -isS http://localhost:8080/users/{USER_UUID}/transactions/create-form -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 793
-Date: Fri, 24 Oct 2025 01:52:00 GMT
-
-
-Create New Transaction
-
-   Description: ____________________
-   Amount: ____________________
-   Category: [Food__________]
-   Create Transaction
-```
-
-### Invalid Input — Nonexistent user ID
-```
-# Case 1: Non-existent user UUID
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/transactions/create-form ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:52:49 GMT
-
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+## Transaction Management - GET Transactions List
 
----
+### GET /users/{userId}/transactions
 
-## DELETE `/users/{userId}/transactions/{transactionId}` — Delete a transaction (JSON)
-
-### Typical Valid Input — Delete an existing transaction for a valid user
-```
-curl -isS -X DELETE http://localhost:8080/users/{USER_UUID}/transactions/{TRANSACTION_UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:54:27 GMT
-
-
-   {"deleted":true,"transactionId":"62e35ca8-dc11-403d-ad2d-4e7d538e046c",
-   "userId":"00df6c5a-9321-4744-b653-3a15be39f085"}
-```
-
-### Atypical Valid Input — Try deleting the same transaction twice
-```
-# Attempt to delete the same transaction again
-curl -isS -X DELETE http://localhost:8080/users/{USER_UUID}/transactions/{TRANSACTION_UUID} -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:54:39 GMT
-
-
-   {"error":"Transaction 62e35ca8-dc11-403d-ad2d-4e7d538e046c not found
-   for user 00df6c5a-9321-4744-b653-3a15be39f085"}
-```
-
-### Invalid Input — Transaction belongs to another user
-```
-# Transaction belongs to another user
-curl -isS -X DELETE http://localhost:8080/users/{DIFFERENT_USER_UUID}/transactions/{TRANSACTION_UUID} ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 01:55:32 GMT
-
-{"error":"Transaction 135dd178-9e17-4f30-a6f2-84b6d035fb31 not found for user 149119d7-dab0-4535-a854-8d2e43f930b5"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, JSON array | `GET Transactions - Valid User` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET Transactions - Non-existent User` |
 
 ---
 
-## GET `/users/{userId}/deletetransaction/{transactionId}` — Delete a transaction via GET (plain text)
-
-### Typical Valid Input — Delete an existing transaction
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/deletetransaction/{TRANSACTION_UUID} -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/plain;charset=UTF-8
-Content-Length: 33
-Date: Fri, 24 Oct 2025 01:57:01 GMT
-
+## Transaction Management - GET Single Transaction
 
-   Transaction deleted successfully!
-```
+### GET /users/{userId}/transactions/{transactionId}
 
-### Atypical Valid Input — Attempt to delete the same transaction twice
-```
-# Attempt to delete again using the same UUIDs
-curl -isS http://localhost:8080/users/{USER_UUID}/deletetransaction/{TRANSACTION_UUID} -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output (Nice Format):
-```
-HTTP/1.1 200 
-Content-Type: text/plain;charset=UTF-8
-Content-Length: 111
-Date: Fri, 24 Oct 2025 01:57:10 GMT
-
-
-   Error: Transaction 2f67194a-442a-4a00-8771-bd7e334c5fe8 not found for
-   user 00df6c5a-9321-4744-b653-3a15be39f085
-```
-
-### Invalid Input — Nonexistent user/transaction ID
-```
-# Non-existent user UUID
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/deletetransaction/{TRANSACTION_UUID} ; echo
-
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/plain;charset=UTF-8
-Content-Length: 58
-Date: Fri, 24 Oct 2025 01:57:54 GMT
-
-Error: User 00000000-0000-0000-0000-000000000000 not found
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid userId and transactionId | 200 OK with transaction | `GET Single Transaction - Valid` |
+| P2 | Invalid | Transaction belongs to different user | 404 Not Found | `GET Single Transaction - Wrong User` |
+| P3 | Invalid | Non-existent transactionId | 404 Not Found | `GET Single Transaction - Non-existent Transaction` |
 
 ---
 
-## GET `/users/{userId}/budget` — Display the budget management page for a user
-
-### Typical Valid Input — Display budget dashboard for an existing user
-```
-# Step 1: Create a user
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Sophia", "email": "sophia@columbia.edu", "budget": 1000}' ; echo
-
-# Step 2: Replace {USER_UUID} with the user ID from the response
-
-# Step 3: Add a few transactions for realism
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "Lunch", "amount": 25.75, "category": "FOOD"}' ; echo
-
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/transactions \
-  -H "Content-Type: application/json" \
-  -d '{"description": "MetroCard Refill", "amount": 33.00, "category": "TRANSPORTATION"}' ; echo
-
-# Step 4: View the budget management dashboard
-curl -isS http://localhost:8080/users/{USER_UUID}/budget -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 835
-Date: Fri, 24 Oct 2025 01:58:35 GMT
-
-
-                           Budget Management - Ethan
-
-Current Budget
-
-   Total Budget: $950.00
-
-   Total Spent: $219.25
-
-   Remaining: $730.75
+## Transaction Management - PUT Transaction
 
-   Weekly Spending: $0.00
+### PUT /users/{userId}/transactions/{transactionId}
 
-Update Budget
+**Input Parameters:**
+- `userId` (UUID, path parameter)
+- `transactionId` (UUID, path parameter)
+- `amount` (Double, optional)
+- `description` (String, optional)
+- `category` (String, optional)
 
-   New Budget: 950.0_______________
-   Update Budget
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid userId, transactionId, update data | 200 OK with updated transaction | `PUT Transaction - Update Amount` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `PUT Transaction - Non-existent User` |
+| P3 | Invalid | Transaction belongs to different user | 404 Not Found | `PUT Transaction - Wrong User` |
+| P4 | Invalid | Non-existent transactionId | 404 Not Found | `PUT Transaction - Non-existent Transaction` |
+| P5 | Invalid | Invalid category in update | 400 Bad Request | `PUT Transaction - Invalid Category` |
 
-Quick Reports
-
-     * Weekly Summary
-     * Monthly Summary
-     * Budget Report (JSON)
-```
-
-### Atypical Valid Input — User exists but has no transactions
-```
-# Create a new user with no transactions if needed
-curl -isS -X POST http://localhost:8080/users \
-  -H "Content-Type: application/json" \
-  -d '{"username": "Liam", "email": "liam@columbia.edu", "budget": 500}' ; echo
-
-# Access the budget dashboard
-curl -isS http://localhost:8080/users/{USER_UUID}/budget -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 830
-Date: Fri, 24 Oct 2025 02:00:00 GMT
+---
 
+## Transaction Management - Forms
 
-                            Budget Management - Liam
+### GET /users/{userId}/transactions/create-form
 
-Current Budget
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, HTML form | `GET /transactions/create-form - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET /transactions/create-form - User Not Found` |
 
-   Total Budget: $500.00
+### POST /users/{userId}/transactions/form
 
-   Total Spent: $0.0
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid form data | 201 Created, HTML success | `POST /transactions/form - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `POST /transactions/form - User Not Found` |
+| P3 | Invalid | Invalid category | 500 Error | `POST /transactions/form - Invalid Category` |
 
-   Remaining: $500.0
+---
 
-   Weekly Spending: $0.00
+## Budget Management - GET Budget Page
 
-Update Budget
+### GET /users/{userId}/budget
 
-   New Budget: 500.0_______________
-   Update Budget
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, HTML budget page | `GET Budget Page - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET Budget Page - Non-existent User` |
 
-Quick Reports
+---
 
-     * Weekly Summary
-     * Monthly Summary
-     * Budget Report (JSON)
-```
+## Budget Management - PUT /budget (JSON)
 
-### Invalid Input — Nonexistent user ID
-```
-# Non-existent user
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/budget ; echo
-```
+### PUT /users/{userId}/budget
 
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:00:23 GMT
+**Input Parameters:**
+- `userId` (UUID, path parameter)
+- `budget` (Double, body, >= 0)
 
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing user, valid budget | 200 OK with budget report | `PUT Budget - Update` |
+| P2 | Valid/Boundary | budget = 0 | 200 OK | `PUT Budget - Zero Budget` |
+| P3 | Invalid/Boundary | budget < 0 (negative) | 400/500 Error | `PUT Budget - Negative` |
+| P4 | Invalid | Non-existent userId | 404 Not Found | `PUT Budget - Non-existent User` |
 
 ---
 
-## PUT `/users/{userId}/budget` — Update a user's budget (JSON)
-
-### Typical Valid Input — Update budget for an existing user
-```
-curl -isS -X PUT http://localhost:8080/users/{USER_UUID}/budget \
-  -H "Content-Type: application/json" \
-  -d '{"budget": 1200}' -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:01:13 GMT
-
-
-   {"userId":"00df6c5a-9321-4744-b653-3a15be39f085","warnings":"","remaini
-   ng":980.75,"isOverBudget":false,"totalSpent":219.25,"hasWarnings":false
-   ,"categories":{"HEALTHCARE":50.0,"TRANSPORTATION":40.0,"FOOD":129.25},"
-   totalBudget":1200.0,"username":"Ethan"}
-```
-
-### Atypical Valid Input — Budget updated with same value (no effective change)
-```
-curl -isS -X PUT http://localhost:8080/users/{USER_UUID}/budget \
-  -H "Content-Type: application/json" \
-  -d '{"budget": 1200}' -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:02:15 GMT
-
-
-   {"userId":"00df6c5a-9321-4744-b653-3a15be39f085","warnings":"","remaini
-   ng":980.75,"isOverBudget":false,"totalSpent":219.25,"hasWarnings":false
-   ,"categories":{"HEALTHCARE":50.0,"TRANSPORTATION":40.0,"FOOD":129.25},"
-   totalBudget":1200.0,"username":"Ethan"}
-```
-
-### Invalid Input — Nonexistent user
-```
-# Non-existent user
-curl -isS -X PUT http://localhost:8080/users/00000000-0000-0000-0000-000000000000/budget \
-  -H "Content-Type: application/json" \
-  -d '{"budget": 1500}' ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:02:45 GMT
-
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+## Budget Management - POST /update-budget (Form)
 
----
+### POST /users/{userId}/update-budget
 
-## POST `/users/{userId}/update-budget` — Update a user’s budget via HTML form
-
-### Typical Valid Input — Update budget for existing user
-```
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/update-budget \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "budget=950" -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 106
-Date: Fri, 24 Oct 2025 02:03:47 GMT
-
-
-Budget Updated Successfully!
-
-   New Budget: $950.00
-```
-
-### Atypical Valid Input — Submit same budget amount (no change)
-```
-# Submit the same budget value again
-curl -isS -X POST http://localhost:8080/users/{USER_UUID}/update-budget \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "budget=950" -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 106
-Date: Fri, 24 Oct 2025 02:04:03 GMT
-
-
-Budget Updated Successfully!
-
-   New Budget: $950.00
-```
-
-### Invalid Input — Nonexistent user
-```
-curl -isS -X POST http://localhost:8080/users/00000000-0000-0000-0000-000000000000/update-budget \
-  -H "Content-Type: application/x-www-form-urlencoded" \
-  -d "budget=1200" ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:04:26 GMT
-
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing user, valid budget | 200 OK, HTML success | `POST Update Budget Form - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `POST Update Budget Form - User Not Found` |
 
 ---
 
-## GET `/users/{userId}/weekly-summary` — Display the user’s weekly spending summary
-
-### Typical Valid Input — User with transactions in the past week
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/weekly-summary -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+## Analytics - Weekly Summary
 
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 693
-Date: Fri, 24 Oct 2025 02:05:22 GMT
+### GET /users/{userId}/weekly-summary
 
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, JSON summary | `GET Weekly Summary - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET Weekly Summary - Non-existent User` |
 
-                             Weekly Summary - Ethan
-
-   Total Spent Last 7 Days: $0.00
-
-Recent Transactions
+---
 
-     Description    Amount     Category       Date
-   Free Trial       $0.00   OTHER          2025-10-23
-   Gym Membership   $50.00  HEALTHCARE     2025-10-23
-   Coffee and Bagel $8.75   FOOD           2025-10-23
-   MetroCard Refill $40.00  TRANSPORTATION 2025-10-23
-   Groceries        $120.50 FOOD           2025-10-23
-```
+## Analytics - Monthly Summary
 
-### Atypical Valid Input — User exists but has no transactions in the past week
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/weekly-summary -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+### GET /users/{userId}/monthly-summary
 
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 180
-Date: Fri, 24 Oct 2025 02:05:59 GMT
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, JSON with summary | `GET Monthly Summary - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET Monthly Summary - Non-existent User` |
 
+---
 
-                             Weekly Summary - Liam
+## Analytics - Budget Report
 
-   Total Spent Last 7 Days: $0.00
+### GET /users/{userId}/budget-report
 
-Recent Transactions
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, JSON report | `GET Budget Report - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET Budget Report - Non-existent User` |
 
-   No transactions in the last 7 days.
-```
+---
 
-### Invalid Input — Nonexistent user ID
-```
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/weekly-summary ; echo
-```
+## Transaction Management - DELETE Transaction
 
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:06:31 GMT
+### DELETE /users/{userId}/transactions/{transactionId}
 
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid userId and transactionId | 200 OK, deletion confirmed | `DELETE Transaction - Valid` |
+| P2 | Invalid | Already deleted transaction | 404 Not Found | `DELETE Transaction - Already Deleted` |
+| P3 | Invalid | Transaction belongs to different user | 404 Not Found | `DELETE Transaction - Wrong User` |
 
 ---
 
-## GET `/users/{userId}/monthly-summary` — Display the user’s monthly spending summary
+## Transaction Management - GET /deletetransaction
 
-### Typical Valid Input — User with transactions this month
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/monthly-summary -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+### GET /users/{userId}/deletetransaction/{transactionId}
 
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 251
-Date: Fri, 24 Oct 2025 02:07:15 GMT
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Valid userId and transactionId | 200 OK, success message | `GET /deletetransaction - Valid` |
+| P2 | Invalid | Non-existent or wrong user | Error message | `GET /deletetransaction - Invalid` |
 
+## User Management - DELETE /users/{userId}
 
-                                Monthly Summary
+### DELETE /users/{userId}
 
-Monthly Summary for Ethan (OCTOBER 2025)
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, deletion confirmed | `DELETE /users/{userId} - Valid` |
+| P2 | Invalid | Already deleted user | 404 Not Found | `DELETE /users/{userId} - Already Deleted` |
+| P3 | Invalid | Non-existent UUID | 404 Not Found | `DELETE /users/{userId} - Non-existent UUID` |
+| P4 | Invalid | Invalid UUID format | 400 Bad Request | `DELETE /users/{userId} - Invalid UUID Format` |
 
-Total Budget: $1200.00
-Total Spent: $219.25
-Remaining: $980.75
+---
 
-Spending by Category:
-- FOOD: $129.25
-- HEALTHCARE: $50.00
-- TRANSPORTATION: $40.00
-```
+## User Management - GET /deleteuser/{userId}
 
-### Atypical Valid Input — User exists but has no transactions this month
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/monthly-summary -o response.html ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.html ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.html | lynx -dump -stdin -nolist ; echo
-```
+### GET /deleteuser/{userId}
 
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: text/html;charset=UTF-8
-Content-Length: 185
-Date: Fri, 24 Oct 2025 02:07:53 GMT
+| Partition | Type | Input | Expected Output | Test Coverage |
+|-----------|------|-------|-----------------|---------------|
+| P1 | Valid | Existing userId | 200 OK, success message | `GET /deleteuser/{userId} - Valid` |
+| P2 | Invalid | Non-existent userId | 404 Not Found | `GET /deleteuser/{userId} - Not Found` |
 
+---
 
-                                Monthly Summary
+## Boundary Value Analysis Summary
 
-Monthly Summary for Liam (OCTOBER 2025)
+| Input | Lower Boundary | Upper Boundary |
+|-------|----------------|----------------|
+| User budget | 0 (valid) | 99999999.99 (valid) |
+| Transaction amount | 0 (invalid), 0.01 (valid) | Large value (valid) |
+| UUID format | Valid UUID | Invalid string |
+| String fields | Empty string (invalid) | Non-empty (valid) |
 
-Total Budget: $950.00
-Total Spent: $0.00
-Remaining: $950.00
+---
 
-Spending by Category:
-```
+## Multiple Clients Testing
 
-### Invalid Input — Nonexistent user ID
-```
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/monthly-summary ; echo
-```
+The test suite exercises multiple clients through:
+- Creating two test users (`testUserId` and `testUserId2`)
+- Testing transaction ownership validation (accessing another user's transactions)
+- Testing concurrent data isolation
 
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:08:19 GMT
+## Persistent Data Testing
 
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
+The test suite verifies data persistence through:
+- Create → Retrieve sequences
+- Update → Retrieve sequences
+- Delete → Verify deletion sequences
+- Cascade delete verification (user deletion removes transactions)
 
----
+## CI Integration
 
-## GET `/users/{userId}/budget-report` — Retrieve a user’s budget report in JSON
-
-### Typical Valid Input — Retrieve JSON report for existing user
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/budget-report -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:09:10 GMT
-
-
-   {"userId":"00df6c5a-9321-4744-b653-3a15be39f085","warnings":"","remaini
-   ng":980.75,"isOverBudget":false,"totalSpent":219.25,"hasWarnings":false
-   ,"categories":{"HEALTHCARE":50.0,"TRANSPORTATION":40.0,"FOOD":129.25},"
-   totalBudget":1200.0,"username":"Ethan"}
-```
-
-### Atypical Valid Input — No transactions yet
-```
-curl -isS http://localhost:8080/users/{USER_UUID}/budget-report -o response.json ; echo \
-&& awk '/^\r?$/{print; exit} {print}' response.json ; echo \
-&& awk 'f; /^\r?$/{f=1}' response.json | lynx -dump -stdin -nolist ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 200 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:09:47 GMT
-
-
-   {"userId":"5a3c181f-39ee-42e0-a1ff-88cfc5a301d1","warnings":"","remaini
-   ng":950.0,"isOverBudget":false,"totalSpent":0.0,"hasWarnings":false,"ca
-   tegories":{},"totalBudget":950.0,"username":"Liam"}
-```
-
-### Invalid Input — Nonexistent user ID
-```
-curl -isS http://localhost:8080/users/00000000-0000-0000-0000-000000000000/budget-report ; echo
-```
-
-Sample Output:
-```
-HTTP/1.1 404 
-Content-Type: application/json
-Transfer-Encoding: chunked
-Date: Fri, 24 Oct 2025 02:10:19 GMT
-
-{"error":"User 00000000-0000-0000-0000-000000000000 not found"}
-```
\ No newline at end of file
+These tests run automatically via Newman in the CI pipeline (./github/workflows/maven.yml).
\ No newline at end of file
diff --git a/checkstyle.html b/checkstyle.html
index 929485f..bc06855 100644
--- a/checkstyle.html
+++ b/checkstyle.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html>
 <!--
- | Generated by Apache Maven Doxia Site Renderer 1.11.1 at 2025-10-23
+ | Generated by Apache Maven Doxia Site Renderer 1.11.1 at 2025-12-04
 
  | Rendered using Apache Maven Default Skin
 -->
@@ -10,10 +10,10 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="generator" content="Apache Maven Doxia Site Renderer 1.11.1" />
     <title>ledger &#x2013; Checkstyle Results</title>
-    <link rel="stylesheet" href="./css/maven-base.css" />
-    <link rel="stylesheet" href="./css/maven-theme.css" />
-    <link rel="stylesheet" href="./css/site.css" />
-    <link rel="stylesheet" href="./css/print.css" media="print" />
+    <link rel="stylesheet" href="target/site/css/maven-base.css" />
+    <link rel="stylesheet" href="target/site/css/maven-theme.css" />
+    <link rel="stylesheet" href="target/site/css/site.css" />
+    <link rel="stylesheet" href="target/site/css/print.css" media="print" />
   </head>
   <body class="composite">
     <div id="banner">
@@ -23,7 +23,7 @@
     </div>
     <div id="breadcrumbs">
       <div class="xleft">
-        <span id="publishDate">Last Published: 2025-10-23</span>
+        <span id="publishDate">Last Published: 2025-12-04</span>
            | <span id="projectVersion">Version: 0.0.1-SNAPSHOT</span>
       </div>
       <div class="xright">      </div>
@@ -34,7 +34,7 @@
     <div id="leftColumn">
       <div id="navcolumn">
       <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
-        <img class="poweredBy" alt="Built by Maven" src="./images/logos/maven-feather.png" />
+        <img class="poweredBy" alt="Built by Maven" src="target/site/images/logos/maven-feather.png" />
       </a>
       </div>
     </div>
@@ -47,11 +47,11 @@ <h2><a name="Summary"></a>Summary</h2>
 <table border="0" class="bodyTable">
 <tr class="a">
 <th>Files</th>
-<th><figure><img src="images/icon_info_sml.gif" alt="" /></figure>&#160;Info</th>
-<th><figure><img src="images/icon_warning_sml.gif" alt="" /></figure>&#160;Warnings</th>
-<th><figure><img src="images/icon_error_sml.gif" alt="" /></figure>&#160;Errors</th></tr>
+<th><figure><img src="target/site/images/icon_info_sml.gif" alt="" /></figure>&#160;Info</th>
+<th><figure><img src="target/site/images/icon_warning_sml.gif" alt="" /></figure>&#160;Warnings</th>
+<th><figure><img src="target/site/images/icon_error_sml.gif" alt="" /></figure>&#160;Errors</th></tr>
 <tr class="b">
-<td>10</td>
+<td>13</td>
 <td>0</td>
 <td>0</td>
 <td>0</td></tr></table></section><section>
@@ -59,9 +59,9 @@ <h2><a name="Files"></a>Files</h2>
 <table border="0" class="bodyTable">
 <tr class="a">
 <th>File</th>
-<th><figure><img src="images/icon_info_sml.gif" alt="" /></figure>&#160;I</th>
-<th><figure><img src="images/icon_warning_sml.gif" alt="" /></figure>&#160;W</th>
-<th><figure><img src="images/icon_error_sml.gif" alt="" /></figure>&#160;E</th></tr></table></section><section>
+<th><figure><img src="target/site/images/icon_info_sml.gif" alt="" /></figure>&#160;I</th>
+<th><figure><img src="target/site/images/icon_warning_sml.gif" alt="" /></figure>&#160;W</th>
+<th><figure><img src="target/site/images/icon_error_sml.gif" alt="" /></figure>&#160;E</th></tr></table></section><section>
 <h2><a name="Rules"></a>Rules</h2>
 <table border="0" class="bodyTable">
 <tr class="b">
diff --git a/cpd.html b/cpd.html
index 0214ebe..5e423b9 100644
--- a/cpd.html
+++ b/cpd.html
@@ -1,70 +1,81 @@
 <!DOCTYPE html>
-<!--
- | Generated by Apache Maven Doxia Site Renderer 1.11.1 from org.apache.maven.plugins:maven-pmd-plugin:3.27.0:cpd at 2025-11-10
 
- | Rendered using Apache Maven Default Skin
+
+<!--
+ | Generated by Apache Maven Doxia Site Renderer 2.0.0-M16 from org.apache.maven.plugins:maven-pmd-plugin:3.28.0:cpd at 2025-12-04
+ | Rendered using Apache Maven Fluido Skin 2.0.0-M8
 -->
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
   <head>
     <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="generator" content="Apache Maven Doxia Site Renderer 1.11.1" />
-    <title>ledger &#x2013; CPD Results</title>
-    <link rel="stylesheet" href="./css/maven-base.css" />
-    <link rel="stylesheet" href="./css/maven-theme.css" />
-    <link rel="stylesheet" href="./css/site.css" />
-    <link rel="stylesheet" href="./css/print.css" media="print" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="generator" content="Apache Maven Doxia Site Renderer 2.0.0-M16" />
+    <title>ledger – CPD Results</title>
+    <link rel="stylesheet" href="target/site/css/apache-maven-fluido-2.0.0-M8.min.css" />
+    <link rel="stylesheet" href="target/site/css/site.css" />
+    <link rel="stylesheet" href="target/site/css/print.css" media="print" />
+    <script src="target/site/js/apache-maven-fluido-2.0.0-M8.min.js"></script>
   </head>
-  <body class="composite">
-    <div id="banner">
-<div id="bannerLeft">ledger
-</div>
-      <div class="clear">
-        <hr/>
-      </div>
-    </div>
-    <div id="breadcrumbs">
-      <div class="xleft">
-        <span id="publishDate">Last Published: 2025-11-10</span>
-           | <span id="projectVersion">Version: 0.0.1-SNAPSHOT</span>
-      </div>
-      <div class="xright"><a href="" title="ledger">ledger</a>      </div>
-      <div class="clear">
-        <hr/>
-      </div>
-    </div>
-    <div id="leftColumn">
-      <div id="navcolumn">
-       <h5>Project Documentation</h5>
-    <ul>
-     <li class="expanded"><a href="project-reports.html" title="Project Reports">Project Reports</a>
-      <ul>
-       <li class="none"><a href="pmd.html" title="PMD">PMD</a></li>
-       <li class="none"><strong>CPD</strong></li>
-      </ul></li>
-    </ul>
-      <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
-        <img class="poweredBy" alt="Built by Maven" src="./images/logos/maven-feather.png" />
-      </a>
-      </div>
-    </div>
-    <div id="bodyColumn">
-      <div id="contentBox">
-<section><a name="CPD_Results"></a>
-<h2><a name="CPD_Results"></a>CPD Results</h2>
-<p>The following document contains the results of PMD's  <a class="externalLink" href="https://pmd.github.io/latest/pmd_userdocs_cpd.html">CPD</a> 7.14.0.</p>
+  <body>
+    <div class="container-fluid container-fluid-top">
+      <header>
+        <div id="banner">
+          <div class="pull-left"><div id="bannerLeft"><h1>ledger</h1></div></div>
+          <div class="pull-right"></div>
+          <div class="clear"><hr/></div>
+        </div>
+
+        <div id="breadcrumbs">
+          <ul class="breadcrumb">
+        <li id="publishDate">Last Published: 2025-12-04<span class="divider">|</span>
+</li>
+          <li id="projectVersion">Version: 0.0.1-SNAPSHOT</li>
+        <li class="pull-right"><a href="target/site">ledger</a></li>
+          </ul>
+        </div>
+      </header>
+      <div class="row-fluid">
+        <header id="leftColumn" class="span2">
+          <nav class="well sidebar-nav">
+  <ul class="nav nav-list">
+   <li class="nav-header">Project Documentation</li>
+    <li><a href="target/site/project-reports.html"><span class="icon-chevron-down"></span>Project Reports</a>
+     <ul class="nav nav-list">
+      <li><a href="target/site/pmd.html">PMD</a></li>
+      <li class="active"><a>CPD</a></li>
+     </ul></li>
+  </ul>
+          </nav>
+          <div class="well sidebar-nav">
+            <div id="poweredBy">
+              <div class="clear"></div>
+              <div class="clear"></div>
+              <div class="clear"></div>
+<a href="https://maven.apache.org/" class="builtBy" target="_blank"><img class="builtBy" alt="Built by Maven" src="target/site/images/logos/maven-feather.png" /></a>
+            </div>
+          </div>
+        </header>
+        <main id="bodyColumn" class="span10">
+<section><a id="CPD_Results"></a>
+<h1>CPD Results</h1>
+<p>The following document contains the results of PMD's  <a class="externalLink" href="https://pmd.github.io/latest/pmd_userdocs_cpd.html">CPD</a> 7.17.0.</p>
 <p>CPD found no problems in your source code.</p></section>
+        </main>
       </div>
     </div>
-    <div class="clear">
-      <hr/>
-    </div>
-    <div id="footer">
-      <div class="xright">
-        Copyright &#169;      2025..      </div>
-      <div class="clear">
-        <hr/>
+    <hr/>
+    <footer>
+      <div class="container-fluid">
+        <div class="row-fluid">
+            <p>©      2025
+</p>
+        </div>
       </div>
-    </div>
+    </footer>
+<script>
+  if(anchors) {
+    anchors.add();
+  }
+</script>
   </body>
 </html>
diff --git a/index.html b/index.html
index 3c26447..831126a 100644
--- a/index.html
+++ b/index.html
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/><link rel="stylesheet" href="jacoco-resources/report.css" type="text/css"/><link rel="shortcut icon" href="jacoco-resources/report.gif" type="image/gif"/><title>ledger</title><script type="text/javascript" src="jacoco-resources/sort.js"></script></head><body onload="initialSort(['breadcrumb', 'coveragetable'])"><div class="breadcrumb" id="breadcrumb"><span class="info"><a href="jacoco-sessions.html" class="el_session">Sessions</a></span><span class="el_report">ledger</span></div><h1>ledger</h1><table class="coverage" cellspacing="0" id="coveragetable"><thead><tr><td class="sortable" id="a" onclick="toggleSort(this)">Element</td><td class="down sortable bar" id="b" onclick="toggleSort(this)">Missed Instructions</td><td class="sortable ctr2" id="c" onclick="toggleSort(this)">Cov.</td><td class="sortable bar" id="d" onclick="toggleSort(this)">Missed Branches</td><td class="sortable ctr2" id="e" onclick="toggleSort(this)">Cov.</td><td class="sortable ctr1" id="f" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="g" onclick="toggleSort(this)">Cxty</td><td class="sortable ctr1" id="h" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="i" onclick="toggleSort(this)">Lines</td><td class="sortable ctr1" id="j" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="k" onclick="toggleSort(this)">Methods</td><td class="sortable ctr1" id="l" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="m" onclick="toggleSort(this)">Classes</td></tr></thead><tfoot><tr><td>Total</td><td class="bar">154 of 2,642</td><td class="ctr2">94%</td><td class="bar">26 of 182</td><td class="ctr2">85%</td><td class="ctr1">29</td><td class="ctr2">186</td><td class="ctr1">31</td><td class="ctr2">569</td><td class="ctr1">6</td><td class="ctr2">95</td><td class="ctr1">1</td><td class="ctr2">5</td></tr></tfoot><tbody><tr><td id="a3"><a href="dev.ase.teamproject.service/index.html" class="el_package">dev.ase.teamproject.service</a></td><td class="bar" id="b0"><img src="jacoco-resources/redbar.gif" width="8" height="10" title="96" alt="96"/><img src="jacoco-resources/greenbar.gif" width="78" height="10" title="896" alt="896"/></td><td class="ctr2" id="c1">90%</td><td class="bar" id="d0"><img src="jacoco-resources/redbar.gif" width="25" height="10" title="15" alt="15"/><img src="jacoco-resources/greenbar.gif" width="94" height="10" title="55" alt="55"/></td><td class="ctr2" id="e2">78%</td><td class="ctr1" id="f0">15</td><td class="ctr2" id="g1">64</td><td class="ctr1" id="h0">19</td><td class="ctr2" id="i1">197</td><td class="ctr1" id="j0">2</td><td class="ctr2" id="k2">29</td><td class="ctr1" id="l1">0</td><td class="ctr2" id="m1">1</td></tr><tr><td id="a2"><a href="dev.ase.teamproject.model/index.html" class="el_package">dev.ase.teamproject.model</a></td><td class="bar" id="b1"><img src="jacoco-resources/redbar.gif" width="3" height="10" title="38" alt="38"/><img src="jacoco-resources/greenbar.gif" width="21" height="10" title="242" alt="242"/></td><td class="ctr2" id="c2">86%</td><td class="bar" id="d1"><img src="jacoco-resources/redbar.gif" width="13" height="10" title="8" alt="8"/><img src="jacoco-resources/greenbar.gif" width="68" height="10" title="40" alt="40"/></td><td class="ctr2" id="e1">83%</td><td class="ctr1" id="f1">9</td><td class="ctr2" id="g2">55</td><td class="ctr1" id="h1">7</td><td class="ctr2" id="i2">95</td><td class="ctr1" id="j1">2</td><td class="ctr2" id="k1">31</td><td class="ctr1" id="l2">0</td><td class="ctr2" id="m0">2</td></tr><tr><td id="a1"><a href="dev.ase.teamproject.controller/index.html" class="el_package">dev.ase.teamproject.controller</a></td><td class="bar" id="b2"><img src="jacoco-resources/redbar.gif" width="1" height="10" title="12" alt="12"/><img src="jacoco-resources/greenbar.gif" width="118" height="10" title="1,350" alt="1,350"/></td><td class="ctr2" id="c0">99%</td><td class="bar" id="d2"><img src="jacoco-resources/redbar.gif" width="5" height="10" title="3" alt="3"/><img src="jacoco-resources/greenbar.gif" width="104" height="10" title="61" alt="61"/></td><td class="ctr2" id="e0">95%</td><td class="ctr1" id="f2">3</td><td class="ctr2" id="g0">65</td><td class="ctr1" id="h3">2</td><td class="ctr2" id="i0">274</td><td class="ctr1" id="j3">0</td><td class="ctr2" id="k0">33</td><td class="ctr1" id="l3">0</td><td class="ctr2" id="m2">1</td></tr><tr><td id="a0"><a href="dev.ase.teamproject/index.html" class="el_package">dev.ase.teamproject</a></td><td class="bar" id="b3"/><td class="ctr2" id="c3">0%</td><td class="bar" id="d3"/><td class="ctr2" id="e3">n/a</td><td class="ctr1" id="f3">2</td><td class="ctr2" id="g3">2</td><td class="ctr1" id="h2">3</td><td class="ctr2" id="i3">3</td><td class="ctr1" id="j2">2</td><td class="ctr2" id="k3">2</td><td class="ctr1" id="l0">1</td><td class="ctr2" id="m3">1</td></tr></tbody></table><div class="footer"><span class="right">Created with <a href="http://www.jacoco.org/jacoco">JaCoCo</a> 0.8.11.202310140853</span></div></body></html>
\ No newline at end of file
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/><link rel="stylesheet" href="target/site/jacoco/jacoco-resources/report.css" type="text/css"/><link rel="shortcut icon" href="target/site/jacoco/jacoco-resources/report.gif" type="image/gif"/><title>ledger</title><script type="text/javascript" src="target/site/jacoco/jacoco-resources/sort.js"></script></head><body onload="initialSort(['breadcrumb', 'coveragetable'])"><div class="breadcrumb" id="breadcrumb"><span class="info"><a href="target/site/jacoco/jacoco-sessions.html" class="el_session">Sessions</a></span><span class="el_report">ledger</span></div><h1>ledger</h1><table class="coverage" cellspacing="0" id="coveragetable"><thead><tr><td class="sortable" id="a" onclick="toggleSort(this)">Element</td><td class="down sortable bar" id="b" onclick="toggleSort(this)">Missed Instructions</td><td class="sortable ctr2" id="c" onclick="toggleSort(this)">Cov.</td><td class="sortable bar" id="d" onclick="toggleSort(this)">Missed Branches</td><td class="sortable ctr2" id="e" onclick="toggleSort(this)">Cov.</td><td class="sortable ctr1" id="f" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="g" onclick="toggleSort(this)">Cxty</td><td class="sortable ctr1" id="h" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="i" onclick="toggleSort(this)">Lines</td><td class="sortable ctr1" id="j" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="k" onclick="toggleSort(this)">Methods</td><td class="sortable ctr1" id="l" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="m" onclick="toggleSort(this)">Classes</td></tr></thead><tfoot><tr><td>Total</td><td class="bar">44 of 3,535</td><td class="ctr2">98%</td><td class="bar">64 of 440</td><td class="ctr2">85%</td><td class="ctr1">63</td><td class="ctr2">319</td><td class="ctr1">8</td><td class="ctr2">772</td><td class="ctr1">1</td><td class="ctr2">99</td><td class="ctr1">1</td><td class="ctr2">6</td></tr></tfoot><tbody><tr><td id="a4"><a href="target/site/jacoco/dev.ase.teamproject.service/index.html" class="el_package">dev.ase.teamproject.service</a></td><td class="bar" id="b0"><img src="target/site/jacoco/jacoco-resources/redbar.gif" width="2" height="10" title="32" alt="32"/><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="85" height="10" title="1,330" alt="1,330"/></td><td class="ctr2" id="c2">97%</td><td class="bar" id="d1"><img src="target/site/jacoco/jacoco-resources/redbar.gif" width="10" height="10" title="22" alt="22"/><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="56" height="10" title="118" alt="118"/></td><td class="ctr2" id="e2">84%</td><td class="ctr1" id="f1">21</td><td class="ctr2" id="g1">101</td><td class="ctr1" id="h0">5</td><td class="ctr2" id="i1">270</td><td class="ctr1" id="j1">0</td><td class="ctr2" id="k1">31</td><td class="ctr1" id="l1">0</td><td class="ctr2" id="m1">1</td></tr><tr><td id="a0"><a href="target/site/jacoco/dev.ase.teamproject/index.html" class="el_package">dev.ase.teamproject</a></td><td class="bar" id="b1"/><td class="ctr2" id="c4">0%</td><td class="bar" id="d4"/><td class="ctr2" id="e4">n/a</td><td class="ctr1" id="f3">1</td><td class="ctr2" id="g4">1</td><td class="ctr1" id="h1">2</td><td class="ctr2" id="i4">2</td><td class="ctr1" id="j0">1</td><td class="ctr2" id="k4">1</td><td class="ctr1" id="l0">1</td><td class="ctr2" id="m2">1</td></tr><tr><td id="a3"><a href="target/site/jacoco/dev.ase.teamproject.model/index.html" class="el_package">dev.ase.teamproject.model</a></td><td class="bar" id="b2"><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="16" height="10" title="264" alt="264"/></td><td class="ctr2" id="c1">98%</td><td class="bar" id="d3"><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="20" height="10" title="43" alt="43"/></td><td class="ctr2" id="e0">97%</td><td class="ctr1" id="f4">1</td><td class="ctr2" id="g2">53</td><td class="ctr1" id="h2">1</td><td class="ctr2" id="i2">95</td><td class="ctr1" id="j2">0</td><td class="ctr2" id="k2">31</td><td class="ctr1" id="l2">0</td><td class="ctr2" id="m0">2</td></tr><tr><td id="a2"><a href="target/site/jacoco/dev.ase.teamproject.filter/index.html" class="el_package">dev.ase.teamproject.filter</a></td><td class="bar" id="b3"><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="1" height="10" title="30" alt="30"/></td><td class="ctr2" id="c3">90%</td><td class="bar" id="d2"><img src="target/site/jacoco/jacoco-resources/redbar.gif" width="1" height="10" title="3" alt="3"/></td><td class="ctr2" id="e3">25%</td><td class="ctr1" id="f2">2</td><td class="ctr2" id="g3">4</td><td class="ctr1" id="h3">0</td><td class="ctr2" id="i3">11</td><td class="ctr1" id="j3">0</td><td class="ctr2" id="k3">2</td><td class="ctr1" id="l3">0</td><td class="ctr2" id="m3">1</td></tr><tr><td id="a1"><a href="target/site/jacoco/dev.ase.teamproject.controller/index.html" class="el_package">dev.ase.teamproject.controller</a></td><td class="bar" id="b4"><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="120" height="10" title="1,867" alt="1,867"/></td><td class="ctr2" id="c0">100%</td><td class="bar" id="d0"><img src="target/site/jacoco/jacoco-resources/redbar.gif" width="18" height="10" title="38" alt="38"/><img src="target/site/jacoco/jacoco-resources/greenbar.gif" width="101" height="10" title="214" alt="214"/></td><td class="ctr2" id="e1">84%</td><td class="ctr1" id="f0">38</td><td class="ctr2" id="g0">160</td><td class="ctr1" id="h4">0</td><td class="ctr2" id="i0">394</td><td class="ctr1" id="j4">0</td><td class="ctr2" id="k0">34</td><td class="ctr1" id="l4">0</td><td class="ctr2" id="m4">1</td></tr></tbody></table><div class="footer"><span class="right">Created with <a href="http://www.jacoco.org/jacoco">JaCoCo</a> 0.8.11.202310140853</span></div></body></html>
\ No newline at end of file
diff --git a/pmd_after.html b/old_pmd_after.html
similarity index 100%
rename from pmd_after.html
rename to old_pmd_after.html
diff --git a/pmd_before.html b/old_pmd_before.html
similarity index 100%
rename from pmd_before.html
rename to old_pmd_before.html
diff --git a/pmd_after_dec.html b/pmd_after_dec.html
new file mode 100644
index 0000000..02bd6a2
--- /dev/null
+++ b/pmd_after_dec.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+
+
+<!--
+ | Generated by Apache Maven Doxia Site Renderer 2.0.0 from org.apache.maven.plugins:maven-pmd-plugin:3.28.0:pmd at 2025-12-04
+ | Rendered using Apache Maven Fluido Skin 2.0.0-M9
+-->
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="generator" content="Apache Maven Doxia Site Renderer 2.0.0" />
+    <title>PMD Results – ledger</title>
+    <link rel="stylesheet" href="target/reports/css/apache-maven-fluido-2.0.0-M9.min.css" />
+    <link rel="stylesheet" href="target/reports/css/site.css" />
+    <link rel="stylesheet" href="target/reports/css/print.css" media="print" />
+    <script src="target/reports/js/apache-maven-fluido-2.0.0-M9.min.js"></script>
+  </head>
+  <body>
+    <div class="container container-top">
+      <header>
+        <div id="banner">
+          <div class="pull-left"><div id="bannerLeft"><h1>ledger</h1></div></div>
+          <div class="pull-right"></div>
+          <div class="clear"><hr/></div>
+        </div>
+
+        <div id="breadcrumbs">
+          <ul class="breadcrumb">
+        <li id="publishDate">Last Published: 2025-12-04<span class="divider">|</span>
+</li>
+          <li id="projectVersion">Version: 0.0.1-SNAPSHOT</li>
+        <li class="pull-right"><a href="https://spring.io/projects/spring-boot/ledger" class="externalLink">ledger</a></li>
+          </ul>
+        </div>
+      </header>
+        <main id="bodyColumn">
+<section><a id="PMD_Results"></a>
+<h1>PMD Results</h1>
+<p>The following document contains the results of <a class="externalLink" href="https://pmd.github.io">PMD</a> 7.17.0.</p>
+<p>PMD found no problems in your source code.</p></section>
+        </main>
+    </div>
+    <hr/>
+    <footer>
+      <div class="container">
+        <div class="row">
+            <p>©      2025
+</p>
+        </div>
+        <p id="poweredBy" class="pull-right"><a href="https://maven.apache.org/" class="builtBy" target="_blank"><img class="builtBy" alt="Built by Maven" src="target/reports/images/logos/maven-feather.png" /></a>
+</p>
+      </div>
+    </footer>
+<script>
+  if(anchors) {
+    anchors.add();
+  }
+</script>
+  </body>
+</html>
diff --git a/pmd_before_dec.html b/pmd_before_dec.html
new file mode 100644
index 0000000..c242bda
--- /dev/null
+++ b/pmd_before_dec.html
@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+
+
+<!--
+ | Generated by Apache Maven Doxia Site Renderer 2.0.0 from org.apache.maven.plugins:maven-pmd-plugin:3.28.0:pmd at 2025-12-04
+ | Rendered using Apache Maven Fluido Skin 2.0.0-M9
+-->
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="generator" content="Apache Maven Doxia Site Renderer 2.0.0" />
+    <title>PMD Results – ledger</title>
+    <link rel="stylesheet" href="target/reports/css/apache-maven-fluido-2.0.0-M9.min.css" />
+    <link rel="stylesheet" href="target/reports/css/site.css" />
+    <link rel="stylesheet" href="target/reports/css/print.css" media="print" />
+    <script src="target/reports/js/apache-maven-fluido-2.0.0-M9.min.js"></script>
+  </head>
+  <body>
+    <div class="container container-top">
+      <header>
+        <div id="banner">
+          <div class="pull-left"><div id="bannerLeft"><h1>ledger</h1></div></div>
+          <div class="pull-right"></div>
+          <div class="clear"><hr/></div>
+        </div>
+
+        <div id="breadcrumbs">
+          <ul class="breadcrumb">
+        <li id="publishDate">Last Published: 2025-12-04<span class="divider">|</span>
+</li>
+          <li id="projectVersion">Version: 0.0.1-SNAPSHOT</li>
+        <li class="pull-right"><a href="https://spring.io/projects/spring-boot/ledger" class="externalLink">ledger</a></li>
+          </ul>
+        </div>
+      </header>
+        <main id="bodyColumn">
+<section><a id="PMD_Results"></a>
+<h1>PMD Results</h1>
+<p>The following document contains the results of <a class="externalLink" href="https://pmd.github.io">PMD</a> 7.17.0.</p><section><a id="Violations_By_Priority"></a>
+<h2>Violations By Priority</h2><section><a id="Priority_3"></a>
+<h3>Priority 3</h3><section><a id="dev.2Fase.2Fteamproject.2Ffilter.2FLoggerFilter.java"></a>
+<h4>dev/ase/teamproject/filter/LoggerFilter.java</h4>
+<table class="table table-striped">
+<tr class="a">
+<th>Rule</th>
+<th>Violation</th>
+<th>Line</th></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#atleastoneconstructor">AtLeastOneConstructor</a></td>
+<td>Each class should declare at least one constructor</td>
+<td>17</td></tr>
+<tr class="a">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'request' is not assigned and could be declared final</td>
+<td>21</td></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'response' is not assigned and could be declared final</td>
+<td>21</td></tr>
+<tr class="a">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'chain' is not assigned and could be declared final</td>
+<td>21</td></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
+<td>Local variable 'httpRequest' could be declared final</td>
+<td>23</td></tr></table></section></section></section><section><a id="Files"></a>
+<h2>Files</h2><section><a id="dev.2Fase.2Fteamproject.2Ffilter.2FLoggerFilter.java"></a>
+<h3>dev/ase/teamproject/filter/LoggerFilter.java</h3>
+<table class="table table-striped">
+<tr class="a">
+<th>Rule</th>
+<th>Violation</th>
+<th>Priority</th>
+<th>Line</th></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#atleastoneconstructor">AtLeastOneConstructor</a></td>
+<td>Each class should declare at least one constructor</td>
+<td>3</td>
+<td>17</td></tr>
+<tr class="a">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'request' is not assigned and could be declared final</td>
+<td>3</td>
+<td>21</td></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'response' is not assigned and could be declared final</td>
+<td>3</td>
+<td>21</td></tr>
+<tr class="a">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#methodargumentcouldbefinal">MethodArgumentCouldBeFinal</a></td>
+<td>Parameter 'chain' is not assigned and could be declared final</td>
+<td>3</td>
+<td>21</td></tr>
+<tr class="b">
+<td><a class="externalLink" href="https://docs.pmd-code.org/pmd-doc-7.17.0/pmd_rules_java_codestyle.html#localvariablecouldbefinal">LocalVariableCouldBeFinal</a></td>
+<td>Local variable 'httpRequest' could be declared final</td>
+<td>3</td>
+<td>23</td></tr></table></section></section></section>
+        </main>
+    </div>
+    <hr/>
+    <footer>
+      <div class="container">
+        <div class="row">
+            <p>©      2025
+</p>
+        </div>
+        <p id="poweredBy" class="pull-right"><a href="https://maven.apache.org/" class="builtBy" target="_blank"><img class="builtBy" alt="Built by Maven" src="target/reports/images/logos/maven-feather.png" /></a>
+</p>
+      </div>
+    </footer>
+<script>
+  if(anchors) {
+    anchors.add();
+  }
+</script>
+  </body>
+</html>
diff --git a/pom.xml b/pom.xml
index 42fbc16..0119036 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,159 +1,151 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<parent>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>3.4.4</version>
-		<relativePath/> <!-- lookup parent from repository -->
-	</parent>
-	<groupId>dev.coms4156.project</groupId>
-	<artifactId>ledger</artifactId>
-	<version>0.0.1-SNAPSHOT</version>
-	<name>ledger</name>
-	<description>ledger</description>
-	<url/>
-	<licenses>
-		<license/>
-	</licenses>
-	<developers>
-		<developer/>
-	</developers>
-	<scm>
-		<connection/>
-		<developerConnection/>
-		<tag/>
-		<url/>
-	</scm>
-	<properties>
-		<java.version>17</java.version>
-	</properties>
-	<dependencies>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-web</artifactId>
-		</dependency>
-
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.4.4</version>
+        <relativePath/>
+    </parent>
+    <groupId>dev.coms4156.project</groupId>
+    <artifactId>ledger</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>ledger</name>
+    <description>ledger</description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
-		
-		<dependency>
+        <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
             <version>42.6.0</version>
         </dependency>
-
-		<dependency>
-			<groupId>org.testcontainers</groupId>
-			<artifactId>postgresql</artifactId>
-			<version>1.19.0</version>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.testcontainers</groupId>
-			<artifactId>junit-jupiter</artifactId>
-			<version>1.19.0</version>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
-
-	<build>
-		<plugins>
-			<plugin>
-				<groupId>org.springframework.boot</groupId>
-				<artifactId>spring-boot-maven-plugin</artifactId>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-checkstyle-plugin</artifactId>
-				<version>3.2.0</version>
-				<configuration>
-					<configLocation>google_checks.xml</configLocation>
-					<includeTestSourceDirectory>true</includeTestSourceDirectory>
-					<consoleOutput>true</consoleOutput>
-					<failsOnError>true</failsOnError>
-					<linkXRef>false</linkXRef>
-				</configuration>
-				<executions>
-					<execution>
-						<id>validate</id>
-						<phase>validate</phase>
-						<goals>
-							<goal>check</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-
-			<plugin>
-				<groupId>org.jacoco</groupId>
-				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.11</version>
-				<executions>
-					<execution>
-						<id>default-prepare-agent</id>
-						<goals>
-							<goal>prepare-agent</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>default-report</id>
-						<phase>prepare-package</phase>
-						<goals>
-							<goal>report</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-		</plugins>
-
-		<testResources>
-        <testResource>
-            <directory>src/test/resources</directory>
-            <includes>
-                <include>**/*.sql</include>
-				<include>**/*.properties</include>
-            </includes>
-        </testResource>
-    </testResources>
-	</build>
-
-	<reporting>
-		<excludeDefaults>true</excludeDefaults>
-		<plugins>
-			<plugin>
-			<groupId>org.apache.maven.plugins</groupId>
-			<artifactId>maven-pmd-plugin</artifactId>
-			<version>3.27.0</version>
-
-			<reportSets>
-				<reportSet>
-				<reports>
-					<report>pmd</report>
-					<report>cpd</report>
-				</reports>
-				</reportSet>
-			</reportSets>
-
-			<configuration>
-				<rulesets>
-				<ruleset>src/main/resources/all-java.xml</ruleset>
-				</rulesets>
-				<linkXRef>false</linkXRef>
-				<printFailingErrors>true</printFailingErrors>
-			</configuration>
-			</plugin>
-		</plugins>
-	</reporting>
-
-</project>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>1.19.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>1.19.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <version>3.2.0</version>
+                <configuration>
+                    <configLocation>google_checks.xml</configLocation>
+                    <includeTestSourceDirectory>true</includeTestSourceDirectory>
+                    <consoleOutput>true</consoleOutput>
+                    <failsOnError>true</failsOnError>
+                    <linkXRef>false</linkXRef>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>validate</id>
+                        <phase>validate</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-pmd-plugin</artifactId>
+                <version>3.28.0</version>
+                <configuration>
+                    <rulesets>
+                        <ruleset>src/main/resources/custom-java-rules.xml</ruleset>
+                    </rulesets>
+                    <linkXRef>false</linkXRef>
+                    <printFailingErrors>true</printFailingErrors>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.11</version>
+                <executions>
+                    <execution>
+                        <id>default-prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-report</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-site-plugin</artifactId>
+                <version>4.0.0-M13</version>
+            </plugin>
+        </plugins>
+        <testResources>
+            <testResource>
+                <directory>src/test/resources</directory>
+                <includes>
+                    <include>**/*.sql</include>
+                    <include>**/*.properties</include>
+                </includes>
+            </testResource>
+        </testResources>
+    </build>
+    <reporting>
+        <excludeDefaults>true</excludeDefaults>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-pmd-plugin</artifactId>
+                <version>3.28.0</version>
+                <reportSets>
+                    <reportSet>
+                        <reports>
+                            <report>pmd</report>
+                            <report>cpd</report>
+                        </reports>
+                    </reportSet>
+                </reportSets>
+                <configuration>
+                    <rulesets>
+                        <ruleset>src/main/resources/custom-java-rules.xml</ruleset>
+                    </rulesets>
+                    <linkXRef>false</linkXRef>
+                    <printFailingErrors>true</printFailingErrors>
+                </configuration>
+            </plugin>
+        </plugins>
+    </reporting>
+</project>
\ No newline at end of file
diff --git a/postman/postman_collection.json b/postman/postman_collection.json
index b08baee..4b99dea 100644
--- a/postman/postman_collection.json
+++ b/postman/postman_collection.json
@@ -2,7 +2,7 @@
   "info": {
     "_postman_id": "ase-team-project-api-tests",
     "name": "ASE Team Project - Personal Finance Tracker API Tests",
-    "description": "Comprehensive API tests covering all endpoints with equivalence partitions.\n\n## Equivalence Partitions Documentation\n\nSee individual requests for partition coverage details.",
+    "description": "Comprehensive API tests for the Personal Finance Tracker service.\n\n## Test Coverage\n\nThis collection provides complete API testing with:\n- Valid and invalid equivalence partitions for each endpoint\n- Boundary value testing (zero, negative, large values)\n- Multiple client simulation (testUserId and testUserId2)\n- Persistent data verification (create-retrieve-update-delete sequences)\n\n## Equivalence Partition Documentation\n\nSee API_EQUIVALENCE_PARTITIONS.md for detailed partition definitions and test mappings.\n\n## Running Tests\n\n### Via Postman\nImport both the collection and environment files, then run the collection.\n\n### Via Newman (CLI)\n\n### In CI Pipeline\nTests run automatically during CI using Newman.",
     "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
   },
   "variable": [
@@ -60,8 +60,12 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         }
@@ -101,8 +105,12 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/",
-              "host": ["{{baseUrl}}"],
-              "path": [""]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                ""
+              ]
             }
           }
         },
@@ -131,8 +139,12 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/index",
-              "host": ["{{baseUrl}}"],
-              "path": ["index"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "index"
+              ]
             }
           }
         },
@@ -157,8 +169,12 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/invalid-path",
-              "host": ["{{baseUrl}}"],
-              "path": ["invalid-path"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "invalid-path"
+              ]
             }
           }
         }
@@ -203,8 +219,12 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         }
@@ -233,7 +253,7 @@
                   "    pm.expect(jsonData).to.have.property('userId');",
                   "    pm.expect(jsonData.userId).to.not.be.null;",
                   "    // Store for later tests",
-                  "    pm.collectionVariables.set('testUserId', jsonData.userId);",
+                  "    pm.environment.set('testUserId', jsonData.userId);",
                   "});",
                   "",
                   "pm.test('P1: Response contains correct username', function () {",
@@ -277,8 +297,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -295,7 +319,7 @@
                   "});",
                   "",
                   "const jsonData = pm.response.json();",
-                  "pm.collectionVariables.set('testUserId2', jsonData.userId);"
+                  "pm.environment.set('testUserId2', jsonData.userId);"
                 ],
                 "type": "text/javascript"
               }
@@ -326,8 +350,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -380,8 +408,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -434,8 +466,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -487,8 +523,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -540,8 +580,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -577,8 +621,12 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         },
@@ -627,6 +675,50 @@
               "mode": "raw",
               "raw": "{\n    \"username\": \"{{uniqueUsername}}\",\n    \"email\": \"duplicate_{{timestamp}}@test.com\",\n    \"budget\": 100\n}"
             },
+            "url": {
+              "raw": "{{baseUrl}}/users",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users - Duplicate Email (P8: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P8 - Invalid: duplicate email",
+                  "pm.test('P8: Status code is 400 for duplicate email', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});",
+                  "",
+                  "pm.test('P8: Error message mentions email exists', function () {",
+                  "    const jsonData = pm.response.json();",
+                  "    pm.expect(jsonData.error).to.include('already exists');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"username\": \"UniqueUser_DupEmail\",\n    \"email\": \"{{uniqueEmail}}\",\n    \"budget\": 500\n}"
+            },
             "url": {
               "raw": "{{baseUrl}}/users",
               "host": ["{{baseUrl}}"],
@@ -674,8 +766,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}"
+              ]
             }
           }
         },
@@ -707,8 +804,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000"
+              ]
             }
           }
         },
@@ -740,8 +842,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/not-a-valid-uuid",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "not-a-valid-uuid"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "not-a-valid-uuid"
+              ]
             }
           }
         }
@@ -798,8 +905,13 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}"
+              ]
             }
           }
         },
@@ -835,8 +947,142 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000"
+              ]
+            }
+          }
+        },
+        {
+          "name": "PUT /users/{userId} - Duplicate Username (P3: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P3 - Invalid: duplicate username",
+                  "pm.test('P3: Status code is 400', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"username\": \"{{uniqueUsername2}}\", \"email\": \"unique_put@test.com\", \"budget\": 100}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}"
+              ]
+            }
+          }
+        },
+        {
+          "name": "PUT /users/{userId} - Duplicate Email (P4: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P4 - Invalid: duplicate email",
+                  "pm.test('P4: Status code is 400 for duplicate email', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"username\": \"unique_put_user\",\n    \"email\": \"{{uniqueEmail2}}\",\n    \"budget\": 100\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}",
               "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000"]
+              "path": ["users", "{{testUserId}}"]
+            }
+          }
+        },
+        {
+          "name": "PUT /users/{userId} - Zero Budget (P5: Boundary)",
+          "event": [
+            {
+              "listen": "prerequest",
+              "script": {
+                "exec": [
+                  "const ts = Date.now();",
+                  "pm.environment.set('zeroPutUser', 'ZeroPut_' + ts);",
+                  "pm.environment.set('zeroPutEmail', 'zeroput_' + ts + '@test.com');"
+                ],
+                "type": "text/javascript"
+              }
+            },
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P5 - Boundary: zero budget",
+                  "pm.test('P5: Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});",
+                  "pm.test('P5: Budget is 0', function () {",
+                  "    pm.expect(pm.response.json().budget).to.eql(0);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"username\": \"{{zeroPutUser}}\", \"email\": \"{{zeroPutEmail}}\", \"budget\": 0}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}"
+              ]
             }
           }
         }
@@ -912,31 +1158,26 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "form"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "form"
+              ]
             }
           }
-        }
-      ]
-    },
-    {
-      "name": "7. User Management - GET Forms",
-      "item": [
+        },
         {
-          "name": "GET /users/create-form (P1: Valid)",
+          "name": "POST /users/form - Duplicate Username (P2: Invalid)",
           "event": [
             {
               "listen": "test",
               "script": {
                 "exec": [
-                  "// Equivalence Partition: P1 - Valid: get create form",
-                  "pm.test('P1: Status code is 200', function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "pm.test('P1: Response contains form', function () {",
-                  "    pm.expect(pm.response.text()).to.include('<form');",
-                  "    pm.expect(pm.response.text()).to.include('Create New User');",
+                  "// Equivalence Partition: P2 - Invalid: duplicate username",
+                  "pm.test('P2: Status code is 400', function () {",
+                  "    pm.response.to.have.status(400);",
                   "});"
                 ],
                 "type": "text/javascript"
@@ -944,30 +1185,59 @@
             }
           ],
           "request": {
-            "method": "GET",
-            "header": [],
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "username",
+                  "value": "{{uniqueUsername}}",
+                  "type": "text"
+                },
+                {
+                  "key": "email",
+                  "value": "unique_form@test.com",
+                  "type": "text"
+                },
+                {
+                  "key": "budget",
+                  "value": "500",
+                  "type": "text"
+                }
+              ]
+            },
             "url": {
-              "raw": "{{baseUrl}}/users/create-form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "create-form"]
+              "raw": "{{baseUrl}}/users/form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "form"
+              ]
             }
           }
         },
         {
-          "name": "GET /users/{userId}/edit-form - Existing User (P1: Valid)",
+          "name": "POST /users/form - Duplicate Email (P3: Invalid)",
           "event": [
             {
               "listen": "test",
               "script": {
                 "exec": [
-                  "// Equivalence Partition: P1 - Valid: get edit form for existing user",
-                  "pm.test('P1: Status code is 200', function () {",
-                  "    pm.response.to.have.status(200);",
+                  "// Equivalence Partition: P3 - Invalid: duplicate email",
+                  "pm.test('P3: Status code is 400 for duplicate email', function () {",
+                  "    pm.response.to.have.status(400);",
                   "});",
                   "",
-                  "pm.test('P1: Response contains edit form', function () {",
-                  "    pm.expect(pm.response.text()).to.include('<form');",
-                  "    pm.expect(pm.response.text()).to.include('Edit User');",
+                  "pm.test('P3: Error message mentions email', function () {",
+                  "    pm.expect(pm.response.text()).to.include('User Creation Failed');",
                   "});"
                 ],
                 "type": "text/javascript"
@@ -975,19 +1245,334 @@
             }
           ],
           "request": {
-            "method": "GET",
-            "header": [],
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {"key": "username", "value": "unique_form_username", "type": "text"},
+                {"key": "email", "value": "{{uniqueEmail}}", "type": "text"},
+                {"key": "budget", "value": "500", "type": "text"}
+              ]
+            },
             "url": {
-              "raw": "{{baseUrl}}/users/{{testUserId}}/edit-form",
+              "raw": "{{baseUrl}}/users/form",
               "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "edit-form"]
+              "path": ["users", "form"]
             }
           }
-        },
-        {
-          "name": "GET /users/{userId}/edit-form - Non-existent User (P2: Invalid)",
-          "event": [
-            {
+        }
+      ]
+    },
+    {
+      "name": "7. User Management - POST /users/{userId}/update-form (HTML)",
+      "item": [
+        {
+          "name": "POST /users/{userId}/update-form - Valid (P1)",
+          "event": [
+            {
+              "listen": "prerequest",
+              "script": {
+                "exec": [
+                  "const timestamp = Date.now();",
+                  "pm.variables.set('updateFormUsername', 'UpdatedForm_' + timestamp);",
+                  "pm.variables.set('updateFormEmail', 'updatedform_' + timestamp + '@test.com');"
+                ],
+                "type": "text/javascript"
+              }
+            },
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P1 - Valid update via form",
+                  "pm.test('P1: Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});",
+                  "",
+                  "pm.test('P1: Response is HTML', function () {",
+                  "    pm.expect(pm.response.headers.get('Content-Type')).to.include('text/html');",
+                  "});",
+                  "",
+                  "pm.test('P1: Success message present', function () {",
+                  "    pm.expect(pm.response.text()).to.include('User Updated Successfully');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "username",
+                  "value": "{{updateFormUsername}}",
+                  "type": "text"
+                },
+                {
+                  "key": "email",
+                  "value": "{{updateFormEmail}}",
+                  "type": "text"
+                },
+                {
+                  "key": "budget",
+                  "value": "1250",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/update-form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "update-form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/{userId}/update-form - User Not Found (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: non-existent user",
+                  "pm.test('P2: Status code is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "username",
+                  "value": "GhostUser",
+                  "type": "text"
+                },
+                {
+                  "key": "email",
+                  "value": "ghost@test.com",
+                  "type": "text"
+                },
+                {
+                  "key": "budget",
+                  "value": "500",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/update-form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "update-form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/{userId}/update-form - Duplicate Username (P3)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P3 - Invalid: duplicate username",
+                  "pm.test('P3: Status code is 400 for duplicate username', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});",
+                  "",
+                  "pm.test('P3: Error message mentions username', function () {",
+                  "    pm.expect(pm.response.text()).to.include('Username already in use');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {"key": "username", "value": "{{uniqueUsername2}}", "type": "text"},
+                {"key": "email", "value": "unique_update_email@test.com", "type": "text"},
+                {"key": "budget", "value": "500", "type": "text"}
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/update-form",
+              "host": ["{{baseUrl}}"],
+              "path": ["users", "{{testUserId}}", "update-form"]
+            }
+          }
+        },
+        {
+          "name": "POST /users/{userId}/update-form - Duplicate Email (P4)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P4 - Invalid: duplicate email",
+                  "pm.test('P4: Status code is 400 for duplicate email', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});",
+                  "",
+                  "pm.test('P4: Error message mentions email', function () {",
+                  "    pm.expect(pm.response.text()).to.include('email already in use');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {"key": "username", "value": "unique_update_username", "type": "text"},
+                {"key": "email", "value": "{{uniqueEmail2}}", "type": "text"},
+                {"key": "budget", "value": "500", "type": "text"}
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/update-form",
+              "host": ["{{baseUrl}}"],
+              "path": ["users", "{{testUserId}}", "update-form"]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "8. User Management - GET Forms",
+      "item": [
+        {
+          "name": "GET /users/create-form (P1: Valid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P1 - Valid: get create form",
+                  "pm.test('P1: Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});",
+                  "",
+                  "pm.test('P1: Response contains form', function () {",
+                  "    pm.expect(pm.response.text()).to.include('<form');",
+                  "    pm.expect(pm.response.text()).to.include('Create New User');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/users/create-form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "create-form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "GET /users/{userId}/edit-form - Existing User (P1: Valid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P1 - Valid: get edit form for existing user",
+                  "pm.test('P1: Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});",
+                  "",
+                  "pm.test('P1: Response contains edit form', function () {",
+                  "    pm.expect(pm.response.text()).to.include('<form');",
+                  "    pm.expect(pm.response.text()).to.include('Edit User');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/edit-form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "edit-form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "GET /users/{userId}/edit-form - Non-existent User (P2: Invalid)",
+          "event": [
+            {
               "listen": "test",
               "script": {
                 "exec": [
@@ -1005,15 +1590,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/edit-form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "edit-form"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "edit-form"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "8. Transaction Management - POST /users/{userId}/transactions",
+      "name": "9. Transaction Management - POST /users/{userId}/transactions",
       "item": [
         {
           "name": "POST Transaction - Valid (P1: All fields valid)",
@@ -1033,7 +1624,7 @@
                   "pm.test('P1: Transaction has ID', function () {",
                   "    const jsonData = pm.response.json();",
                   "    pm.expect(jsonData).to.have.property('transactionId');",
-                  "    pm.collectionVariables.set('testTransactionId', jsonData.transactionId);",
+                  "    pm.environment.set('testTransactionId', jsonData.transactionId);",
                   "});",
                   "",
                   "pm.test('P1: Transaction has timestamp', function () {",
@@ -1065,8 +1656,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1082,7 +1679,7 @@
                   "});",
                   "",
                   "const jsonData = pm.response.json();",
-                  "pm.collectionVariables.set('testTransactionId2', jsonData.transactionId);"
+                  "pm.environment.set('testTransactionId2', jsonData.transactionId);"
                 ],
                 "type": "text/javascript"
               }
@@ -1102,8 +1699,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1137,8 +1740,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1177,8 +1786,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "transactions"
+              ]
             }
           }
         },
@@ -1212,8 +1827,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1247,8 +1868,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1283,8 +1910,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1318,15 +1951,65 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST Transaction - Large Amount (P7: Boundary)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P7 - Boundary: large amount",
+                  "pm.test('P7: Status is 201', function () {",
+                  "    pm.response.to.have.status(201);",
+                  "});",
+                  "pm.test('P7: Large amount stored', function () {",
+                  "    pm.expect(pm.response.json().amount).to.be.above(999999);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"description\": \"Large purchase\", \"amount\": 9999999.99, \"category\": \"OTHER\"}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "9. Transaction Management - GET /users/{userId}/transactions",
+      "name": "10. Transaction Management - GET /users/{userId}/transactions",
       "item": [
         {
           "name": "GET Transactions - Valid User (P1: Valid)",
@@ -1363,8 +2046,14 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         },
@@ -1389,15 +2078,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "transactions"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "10. Transaction Management - GET /users/{userId}/transactions/{txId}",
+      "name": "11. Transaction Management - GET /users/{userId}/transactions/{txId}",
       "item": [
         {
           "name": "GET Single Transaction - Valid (P1: Valid)",
@@ -1426,8 +2121,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "{{testTransactionId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
             }
           }
         },
@@ -1457,8 +2159,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId2}}/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId2}}", "transactions", "{{testTransactionId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId2}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
             }
           }
         },
@@ -1483,15 +2192,22 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/00000000-0000-0000-0000-000000000000",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "00000000-0000-0000-0000-000000000000"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "00000000-0000-0000-0000-000000000000"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "11. Transaction Management - PUT /users/{userId}/transactions/{txId}",
+      "name": "12. Transaction Management - PUT /users/{userId}/transactions/{txId}",
       "item": [
         {
           "name": "PUT Transaction - Update Amount (P1: Valid)",
@@ -1528,8 +2244,15 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "{{testTransactionId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
             }
           }
         },
@@ -1562,19 +2285,110 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "transactions", "{{testTransactionId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
+            }
+          }
+        },
+        {
+          "name": "PUT Transaction - Wrong User (P3: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('P3: Status code is 404 for wrong user', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\n    \"amount\": 100\n}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId2}}/transactions/{{testTransactionId}}",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId2}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
+            }
+          }
+        },
+        {
+          "name": "PUT Transaction - Invalid Category (P5: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P5 - Invalid category",
+                  "pm.test('P5: Status indicates error', function () {",
+                  "    pm.expect(pm.response.code).to.be.oneOf([400, 500]);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "PUT",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"category\": \"INVALID\"}"
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/{{testTransactionId}}",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
             }
           }
         },
         {
-          "name": "PUT Transaction - Wrong User (P3: Invalid)",
+          "name": "PUT Transaction - Non-existent Transaction (P4: Invalid)",
           "event": [
             {
               "listen": "test",
               "script": {
                 "exec": [
-                  "pm.test('P3: Status code is 404 for wrong user', function () {",
+                  "// Equivalence Partition: P4 - Non-existent transaction",
+                  "pm.test('P4: Status is 404', function () {",
                   "    pm.response.to.have.status(404);",
                   "});"
                 ],
@@ -1592,19 +2406,26 @@
             ],
             "body": {
               "mode": "raw",
-              "raw": "{\n    \"amount\": 100\n}"
+              "raw": "{\"amount\": 100}"
             },
             "url": {
-              "raw": "{{baseUrl}}/users/{{testUserId2}}/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId2}}", "transactions", "{{testTransactionId}}"]
+              "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/00000000-0000-0000-0000-000000000000",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "00000000-0000-0000-0000-000000000000"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "12. Transaction Form Endpoints",
+      "name": "13. Transaction Form Endpoints",
       "item": [
         {
           "name": "GET /users/{userId}/transactions/create-form (P1: Valid)",
@@ -1631,8 +2452,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/create-form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "create-form"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "create-form"
+              ]
             }
           }
         },
@@ -1685,15 +2513,171 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "form"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "GET /users/{userId}/transactions/create-form - User Not Found (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: non-existent user",
+                  "pm.test('P2: Status code is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/transactions/create-form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "transactions",
+                "create-form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/{userId}/transactions/form - User Not Found (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: non-existent user",
+                  "pm.test('P2: Status code is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "description",
+                  "value": "Test",
+                  "type": "text"
+                },
+                {
+                  "key": "amount",
+                  "value": "10",
+                  "type": "text"
+                },
+                {
+                  "key": "category",
+                  "value": "FOOD",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/transactions/form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "transactions",
+                "form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/{userId}/transactions/form - Invalid Category (P3)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P3 - Invalid: invalid category",
+                  "pm.test('P3: Status code indicates error', function () {",
+                  "    pm.expect(pm.response.code).to.be.oneOf([400, 500]);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "description",
+                  "value": "Test",
+                  "type": "text"
+                },
+                {
+                  "key": "amount",
+                  "value": "10",
+                  "type": "text"
+                },
+                {
+                  "key": "category",
+                  "value": "INVALID_CAT",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "form"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "13. Budget Management - GET /users/{userId}/budget",
+      "name": "14. Budget Management - GET /users/{userId}/budget",
       "item": [
         {
           "name": "GET Budget Page (P1: Valid)",
@@ -1721,8 +2705,14 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "budget"
+              ]
             }
           }
         },
@@ -1746,15 +2736,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "budget"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "14. Budget Management - PUT /users/{userId}/budget",
+      "name": "15. Budget Management - PUT /users/{userId}/budget",
       "item": [
         {
           "name": "PUT Budget - Update (P1: Valid)",
@@ -1791,8 +2787,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "budget"
+              ]
             }
           }
         },
@@ -1830,8 +2832,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "budget"
+              ]
             }
           }
         },
@@ -1864,8 +2872,14 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "budget"
+              ]
             }
           }
         },
@@ -1898,15 +2912,21 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "budget"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "15. Budget Management - POST /users/{userId}/update-budget",
+      "name": "16. Budget Management - POST /users/{userId}/update-budget",
       "item": [
         {
           "name": "POST Update Budget Form (P1: Valid)",
@@ -1947,15 +2967,68 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/update-budget",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "update-budget"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "update-budget"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST Update Budget Form - User Not Found (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Non-existent user",
+                  "pm.test('P2: Status is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "budget",
+                  "value": "1000",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/update-budget",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "update-budget"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "16. Analytics - Weekly Summary",
+      "name": "17. Analytics - Weekly Summary",
       "item": [
         {
           "name": "GET Weekly Summary (P1: Valid)",
@@ -1984,8 +3057,14 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/weekly-summary",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "weekly-summary"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "weekly-summary"
+              ]
             }
           }
         },
@@ -2009,15 +3088,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/weekly-summary",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "weekly-summary"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "weekly-summary"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "17. Analytics - Monthly Summary",
+      "name": "18. Analytics - Monthly Summary",
       "item": [
         {
           "name": "GET Monthly Summary (P1: Valid)",
@@ -2044,8 +3129,14 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/monthly-summary",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "monthly-summary"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "monthly-summary"
+              ]
             }
           }
         },
@@ -2069,15 +3160,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/monthly-summary",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "monthly-summary"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "monthly-summary"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "18. Analytics - Budget Report",
+      "name": "19. Analytics - Budget Report",
       "item": [
         {
           "name": "GET Budget Report JSON (P1: Valid)",
@@ -2110,8 +3207,14 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/budget-report",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "budget-report"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "budget-report"
+              ]
             }
           }
         },
@@ -2135,15 +3238,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/budget-report",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000", "budget-report"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000",
+                "budget-report"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "19. Multiple Clients - Concurrent Operations",
+      "name": "20. Multiple Clients - Concurrent Operations",
       "item": [
         {
           "name": "Concurrent Test - Create Multiple Users Rapid",
@@ -2187,15 +3296,19 @@
             },
             "url": {
               "raw": "{{baseUrl}}/users",
-              "host": ["{{baseUrl}}"],
-              "path": ["users"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "20. Persistent Data - Verify Data Persists",
+      "name": "21. Persistent Data - Verify Data Persists",
       "item": [
         {
           "name": "Verify Test User Still Exists",
@@ -2224,8 +3337,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}"
+              ]
             }
           }
         },
@@ -2256,15 +3374,21 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions"
+              ]
             }
           }
         }
       ]
     },
     {
-      "name": "21. DELETE Operations - Transactions",
+      "name": "22. DELETE Operations - Transactions",
       "item": [
         {
           "name": "DELETE Transaction - Valid (P1: Valid)",
@@ -2291,8 +3415,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/{{testTransactionId2}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "{{testTransactionId2}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "{{testTransactionId2}}"
+              ]
             }
           }
         },
@@ -2316,8 +3447,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/transactions/{{testTransactionId2}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "transactions", "{{testTransactionId2}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "transactions",
+                "{{testTransactionId2}}"
+              ]
             }
           }
         },
@@ -2341,8 +3479,15 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId2}}/transactions/{{testTransactionId}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId2}}", "transactions", "{{testTransactionId}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId2}}",
+                "transactions",
+                "{{testTransactionId}}"
+              ]
             }
           }
         },
@@ -2371,14 +3516,45 @@
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}/deletetransaction/{{testTransactionId}}",
               "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId}}", "deletetransaction", "{{testTransactionId}}"]
+              "path": [
+                "users",
+                "{{testUserId}}",
+                "deletetransaction",
+                "{{testTransactionId}}"
+              ]
+            }
+          }
+        },
+        {
+          "name": "GET /users/{userId}/deletetransaction/{txId} - Invalid (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: non-existent or wrong user",
+                  "pm.test('P2: Status code is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000/deletetransaction/{{testTransactionId}}",
+              "host": ["{{baseUrl}}"],
+              "path": ["users", "00000000-0000-0000-0000-000000000000", "deletetransaction", "{{testTransactionId}}"]
             }
           }
         }
       ]
     },
     {
-      "name": "22. DELETE Operations - Users (Cleanup)",
+      "name": "23. DELETE Operations - Users (Cleanup)",
       "item": [
         {
           "name": "DELETE /users/{userId} - Delete Test User 2 (P1: Valid)",
@@ -2405,8 +3581,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId2}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId2}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId2}}"
+              ]
             }
           }
         },
@@ -2430,8 +3611,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId2}}",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "{{testUserId2}}"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "{{testUserId2}}"
+              ]
             }
           }
         },
@@ -2459,8 +3645,39 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/{{testUserId}}",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "deleteuser",
+                "{{testUserId}}"
+              ]
+            }
+          }
+        },
+        {
+          "name": "GET /deleteuser/{userId} - Not Found (P2)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: non-existent userId",
+                  "pm.test('P2: Status code is 404', function () {",
+                  "    pm.response.to.have.status(404);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/deleteuser/00000000-0000-0000-0000-000000000000",
               "host": ["{{baseUrl}}"],
-              "path": ["deleteuser", "{{testUserId}}"]
+              "path": ["deleteuser", "00000000-0000-0000-0000-000000000000"]
             }
           }
         },
@@ -2484,8 +3701,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/00000000-0000-0000-0000-000000000000",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "00000000-0000-0000-0000-000000000000"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "00000000-0000-0000-0000-000000000000"
+              ]
             }
           }
         },
@@ -2509,8 +3731,13 @@
             "header": [],
             "url": {
               "raw": "{{baseUrl}}/users/invalid-uuid",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "invalid-uuid"]
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "invalid-uuid"
+              ]
             }
           }
         }
diff --git a/src/main/java/dev/ase/teamproject/Application.java b/src/main/java/dev/ase/teamproject/Application.java
index ba0c45d..f19e9ac 100644
--- a/src/main/java/dev/ase/teamproject/Application.java
+++ b/src/main/java/dev/ase/teamproject/Application.java
@@ -8,15 +8,13 @@
  */
 @SpringBootApplication
 public final class Application {
-  /** Prevent instantiation of utility class. */
   private Application() {
-    // no-op
   }
 
   /**
-   * Application entry point.
+   * Launches the Spring Boot application.
    *
-   * @param args command line arguments
+   * @param args Command line arguments passed to the application.
    */
   public static void main(final String[] args) {
     SpringApplication.run(Application.class, args);
diff --git a/src/main/java/dev/ase/teamproject/controller/RouteController.java b/src/main/java/dev/ase/teamproject/controller/RouteController.java
index e58540b..517f59e 100644
--- a/src/main/java/dev/ase/teamproject/controller/RouteController.java
+++ b/src/main/java/dev/ase/teamproject/controller/RouteController.java
@@ -26,85 +26,46 @@
 import org.springframework.web.bind.annotation.RestController;
 
 /**
- * API routes for the application.
+ * REST controller providing API endpoints for user and transaction management.
+ * Supports both JSON and HTML form-based interactions for creating, reading,
+ * updating, and deleting users and transactions, as well as budget analytics.
  */
 @RestController
-@SuppressWarnings({
-    "PMD.CyclomaticComplexity", // Complexity due to many routes 
-    "PMD.TooManyMethods", // Many endpoints in one controller
-    "PMD.OnlyOneReturn", // Multiple return statements for clarity
-    "PMD.AvoidCatchingGenericException", // Catching RuntimeException for logging
-    "PMD.CommentSize", // Comments enhance understanding
-    "PMD.CognitiveComplexity" // Complexity due to branching for error handling
-})
 public class RouteController {
-
-  /** Class logger. */
   private static final Logger LOGGER = Logger.getLogger(RouteController.class.getName());
-
-  /** Common HTML literal. */
   private static final String HTML_OPEN = "<html><body>";
-
-  /** Common HTML literal. */
   private static final String HTML_CLOSE = "</body></html>";
-
-  /** Common HTML literal. */
   private static final String P_OPEN = "<p>";
-
-  /** Common HTML literal. */
   private static final String P_CLOSE = "</p>";
-
-  /** Common HTML literal. */
   private static final String H2_OPEN = "<h2>";
-
-  /** Common HTML literal. */
   private static final String H2_CLOSE = "</h2>";
-
-  /** Common HTML literal. */
   private static final String FMT_2F = "%.2f";
-
-  /** Common HTML literal. */
   private static final String USER_NF_PREFIX = "User ";
-
-  /** Common HTML literal. */
   private static final String TX_NF_PREFIX = "Transaction ";
-
-  /** Common HTML literal. */
   private static final String NF_SUFFIX = " not found";
-
-  /** Common HTML literal. */
   private static final String NF_FOR_USER = " not found for user ";
-
-  /** Common HTML literal. */
   private static final String FORM_CLOSE = "</form>";
-
-  /** Common HTML literal. */
   private static final String REQUIRED = " required><br><br>";
-
-  /** Common string literal. */
   private static final String GET_USERS = "GET /users/";
-
-  /** Common string literal. */
   private static final String POST_USERS = "POST /users/";
-
-  /** Common string literal. */
   private static final String USER_CR_FAIL = "User Creation Failed";
 
-  /** Service layer. */
   private final MockApiService mockApiService;
 
   /**
-   * Constructs the controller.
+   * Constructs a new {@code RouteController} with the specified service dependency.
    *
-   * @param mockApiService service dependency
+   * @param mockApiService The service layer handling business logic and data access.
    */
   public RouteController(final MockApiService mockApiService) {
     this.mockApiService = mockApiService;
   }
 
   /**
-   * Home page listing all users.
+   * Displays the home page with a list of all users in the system.
+   * Provides links to individual user detail pages.
    *
+   * @return An HTML response containing the user list or a message if no users exist.
    */
   @GetMapping({"/", "/index"})
   public ResponseEntity<String> index() {
@@ -144,9 +105,9 @@ public ResponseEntity<String> index() {
   // ---------------------------------------------------------------------------
 
   /**
-   * Returns all users.
+   * Retrieves all users in the system.
    *
-   * @return list of users
+   * @return A JSON list of all {@code User} objects.
    */
   @GetMapping("/users")
   public List<User> getAllUsers() {
@@ -157,10 +118,11 @@ public List<User> getAllUsers() {
   }
 
   /**
-   * Returns details of a user.
+   * Retrieves detailed information about a specific user.
    *
-   * @param userId user id
-   * @return user
+   * @param userId The unique identifier of the user.
+   * @return A JSON response containing the {@code User} object.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping("/users/{userId}")
   public ResponseEntity<User> getUser(@PathVariable final UUID userId) {
@@ -183,16 +145,19 @@ public ResponseEntity<User> getUser(@PathVariable final UUID userId) {
   }
 
   /**
-   * Creates a user via JSON.
+   * Creates a new user from a JSON request body. Validates that username and email
+   * are provided and checks for uniqueness constraints.
    *
-   * @param user user payload
-   * @return created user
+   * @param user The {@code User} object containing username, email, and budget.
+   * @return A JSON response with the created {@code User} object and HTTP 201 status.
+   * @throws RuntimeException if username or email is missing.
+   * @throws IllegalArgumentException if username or email already exists.
+   * @throws IllegalStateException if user creation fails.
    */
   @PostMapping(
       value = "/users",
       consumes = MediaType.APPLICATION_JSON_VALUE,
       produces = MediaType.APPLICATION_JSON_VALUE)
-  @SuppressWarnings("PMD.AvoidThrowingRawExceptionTypes")
   public ResponseEntity<User> createUserJson(@RequestBody final User user) {
     if (LOGGER.isLoggable(Level.INFO)) {
       LOGGER.info("POST /users called - Creating new user via JSON: " + user.getUsername());
@@ -238,12 +203,13 @@ public ResponseEntity<User> createUserJson(@RequestBody final User user) {
   }
 
   /**
-   * Creates a user via form; returns HTML.
+   * Creates a new user from HTML form data. Validates uniqueness of username
+   * and email before creation.
    *
-   * @param username username
-   * @param email email
-   * @param budget budget
-   * @return HTML confirmation
+   * @param username The username for the new user.
+   * @param email The email address for the new user.
+   * @param budget The initial budget for the new user.
+   * @return An HTML response confirming user creation or displaying an error message.
    */
   @PostMapping(
       value = "/users/form",
@@ -293,11 +259,15 @@ public ResponseEntity<String> createUserFromFormHtml(
   }
 
   /**
-   * Updates a user via JSON.
+   * Updates an existing user with new information from a JSON request body.
+   * Validates uniqueness of username and email if they are being changed.
+   * Fields that are not provided or are empty retain their existing values.
    *
-   * @param userId id
-   * @param userUpdates updates
-   * @return updated user
+   * @param userId The unique identifier of the user to update.
+   * @param userUpdates A {@code User} object containing the fields to update.
+   * @return A JSON response with the updated {@code User} object.
+   * @throws NoSuchElementException if the user is not found.
+   * @throws IllegalArgumentException if the new username or email already exists.
    */
   @PutMapping(
       value = "/users/{userId}",
@@ -344,9 +314,6 @@ public ResponseEntity<User> updateUserJson(
     if (userUpdates.getEmail() == null || userUpdates.getEmail().isEmpty()) {
       userUpdates.setEmail(existing.getEmail());
     }
-    userUpdates.setBudget(userUpdates.getBudget() == 0.0
-        ? existing.getBudget()
-        : userUpdates.getBudget());
 
     mockApiService.deleteUser(userId);
     final User saved = mockApiService.addUser(userUpdates);
@@ -358,13 +325,15 @@ public ResponseEntity<User> updateUserJson(
   }
 
   /**
-   * Updates a user via form; returns HTML.
+   * Updates an existing user from HTML form data. Validates uniqueness of username
+   * and email if they are being changed.
    *
-   * @param userId id
-   * @param username username
-   * @param email email
-   * @param budget budget
-   * @return HTML confirmation
+   * @param userId The unique identifier of the user to update.
+   * @param username The new username.
+   * @param email The new email address.
+   * @param budget The new budget amount.
+   * @return An HTML response confirming the update or displaying an error message.
+   * @throws NoSuchElementException if the user is not found.
    */
   @PostMapping(
       value = "/users/{userId}/update-form",
@@ -423,11 +392,60 @@ public ResponseEntity<String> updateUserFromFormHtml(
       return ResponseEntity.ok(html);
     }
   }
+  /**
+   * Deletes a transaction via a GET request for testing convenience.
+   * This endpoint should not be used in production as DELETE operations should use
+   * the DELETE HTTP method. Validates transaction ownership before deletion.
+   *
+   * @param userId The unique identifier of the user who owns the transaction.
+   * @param transactionId The unique identifier of the transaction to delete.
+   * @return ResponseEntity with plain text confirmation message (200 OK) or
+   *         error description (404 Not Found, 500 Internal Server Error).
+   */
+
+  @GetMapping("/users/{userId}/deletetransaction/{transactionId}")
+  public ResponseEntity<String> deleteTransactionViaGet(
+      @PathVariable final UUID userId,
+      @PathVariable final UUID transactionId) {
+    if (LOGGER.isLoggable(Level.INFO)) {
+      LOGGER.info("GET /users/" + userId + "/deletetransaction/"
+          + transactionId + " called - Deleting via GET.");
+    }
+    if (!mockApiService.getUser(userId).isPresent()) {
+      if (LOGGER.isLoggable(Level.WARNING)) {
+        LOGGER.warning("Cannot delete via GET - user not found: " + userId);
+      }
+      return ResponseEntity.status(HttpStatus.NOT_FOUND)
+          .body("Error: User " + userId + NF_SUFFIX);
+    }
+    final Optional<Transaction> txOpt = mockApiService.getTransaction(transactionId);
+    final boolean belongsToUser = txOpt.map(t -> t.getUserId().equals(userId)).orElse(false);
+    if (!belongsToUser) {
+      if (LOGGER.isLoggable(Level.WARNING)) {
+        LOGGER.warning("Cannot delete via GET - transaction not found: " + transactionId);
+      }
+      return ResponseEntity.status(HttpStatus.NOT_FOUND)
+          .body("Error: Transaction " + transactionId + " not found for user " + userId);
+    }
+    final boolean deleted = mockApiService.deleteTransaction(transactionId);
+    if (!deleted) {
+      if (LOGGER.isLoggable(Level.WARNING)) {
+        LOGGER.warning("Transaction deletion via GET failed: " + transactionId);
+      }
+      return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .body("Error: Failed to delete transaction " + transactionId);
+    }
+    if (LOGGER.isLoggable(Level.INFO)) {
+      LOGGER.info("Transaction deleted successfully via GET for user "
+          + userId + ": " + transactionId);
+    }
+    return ResponseEntity.ok("Transaction deleted successfully!");
+  }
 
   /**
-   * Shows user create form.
+   * Displays an HTML form for creating a new user.
    *
-   * @return HTML form
+   * @return An HTML page with a form for entering user details.
    */
   @GetMapping(value = "/users/create-form", produces = MediaType.TEXT_HTML_VALUE)
   public String showCreateUserForm() {
@@ -446,10 +464,12 @@ public String showCreateUserForm() {
   }
 
   /**
-   * Shows user edit form.
+   * Displays an HTML form for editing an existing user. The form is pre-populated
+   * with the user's current information.
    *
-   * @param userId id
-   * @return HTML form
+   * @param userId The unique identifier of the user to edit.
+   * @return An HTML page with a form for updating user details.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping(value = "/users/{userId}/edit-form", produces = MediaType.TEXT_HTML_VALUE)
   public String showEditUserForm(@PathVariable final UUID userId) {
@@ -483,10 +503,11 @@ public String showEditUserForm(@PathVariable final UUID userId) {
   }
 
   /**
-   * Deletes a user by ID via JSON.
+   * Deletes a user by their unique identifier via a DELETE request.
    *
-   * @param userId id
-   * @return deletion result
+   * @param userId The unique identifier of the user to delete.
+   * @return A JSON response confirming the deletion.
+   * @throws NoSuchElementException if the user is not found or already deleted.
    */
   @DeleteMapping("/users/{userId}")
   public ResponseEntity<Map<String, Object>> deleteUser(@PathVariable final UUID userId) {
@@ -507,10 +528,13 @@ public ResponseEntity<Map<String, Object>> deleteUser(@PathVariable final UUID u
   }
 
   /**
-   * Deletes a user via GET (testing).
+   * Deletes a user by their unique identifier via a GET request.
+   * This endpoint is provided for testing convenience but should not be used
+   * in production as DELETE operations should use the DELETE HTTP method.
    *
-   * @param userId id
-   * @return plain text result
+   * @param userId The unique identifier of the user to delete.
+   * @return A plain text confirmation message.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping("/deleteuser/{userId}")
   public String deleteUserViaGet(@PathVariable final UUID userId) {
@@ -535,10 +559,12 @@ public String deleteUserViaGet(@PathVariable final UUID userId) {
   // ---------------------------------------------------------------------------
 
   /**
-   * Lists transactions for a user.
+   * Retrieves all transactions for a specific user.
+   * Returns an empty list if the user has no transactions.
    *
-   * @param userId id
-   * @return list or error
+   * @param userId The unique identifier of the user whose transactions to retrieve.
+   * @return ResponseEntity containing a list of Transaction objects, or an error message
+   *         with NOT_FOUND status if the user does not exist.
    */
   @GetMapping("/users/{userId}/transactions")
   public ResponseEntity<?> getUserTransactions(@PathVariable final UUID userId) {
@@ -568,11 +594,14 @@ public ResponseEntity<?> getUserTransactions(@PathVariable final UUID userId) {
   }
 
   /**
-   * Gets a transaction for a user.
+   * Retrieves a specific transaction for a user by transaction ID.
+   * Validates that the transaction belongs to the specified user.
    *
-   * @param userId user id
-   * @param transactionId transaction id
-   * @return transaction
+   * @param userId The unique identifier of the user.
+   * @param transactionId The unique identifier of the transaction to retrieve.
+   * @return The requested Transaction object.
+   * @throws NoSuchElementException if the user is not found, or if the transaction
+   *         does not exist or does not belong to the specified user.
    */
   @GetMapping("/users/{userId}/transactions/{transactionId}")
   public ResponseEntity<Transaction> getTransaction(
@@ -597,11 +626,15 @@ public ResponseEntity<Transaction> getTransaction(
   }
 
   /**
-   * Creates a transaction via JSON.
+   * Creates a new transaction for a user using JSON input.
+   * The transaction is automatically associated with the specified user,
+   * overriding any userId present in the request body.
    *
-   * @param userId user id
-   * @param transaction transaction
-   * @return created transaction
+   * @param userId The unique identifier of the user for whom to create the transaction.
+   * @param transaction The transaction object containing details (description, amount, category).
+   *        The userId field will be overwritten with the path parameter value.
+   * @return The created Transaction object with HTTP status 201 (CREATED).
+   * @throws NoSuchElementException if the user is not found.
    */
   @PostMapping(
       value = "/users/{userId}/transactions",
@@ -638,13 +671,15 @@ public ResponseEntity<Transaction> createTransactionJson(
   }
 
   /**
-   * Creates a transaction via form; returns HTML.
+   * Creates a new transaction for a user using HTML form data.
+   * Returns an HTML page confirming the transaction creation with formatted details.
    *
-   * @param userId user id
-   * @param description description
-   * @param amount amount
-   * @param category category
-   * @return HTML confirmation
+   * @param userId The unique identifier of the user for whom to create the transaction.
+   * @param description A textual description of the transaction.
+   * @param amount The monetary amount of the transaction.
+   * @param category The category of the transaction (e.g., FOOD, TRANSPORTATION).
+   * @return ResponseEntity containing an HTML success page with HTTP status 201 (CREATED),
+   *         or an error message with appropriate status code if creation fails.
    */
   @PostMapping(value = "/users/{userId}/transactions/form",
       consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE,
@@ -695,12 +730,17 @@ public ResponseEntity<String> createTransactionFromFormHtml(
   }
 
   /**
-   * Updates a transaction via JSON.
+   * Updates an existing transaction for a user with partial data.
+   * Only the fields present in the updates map will be modified; other fields remain unchanged.
+   * Validates that the transaction belongs to the specified user before updating.
    *
-   * @param userId user id
-   * @param transactionId transaction id
-   * @param updates field map
-   * @return updated transaction
+   * @param userId The unique identifier of the user who owns the transaction.
+   * @param transactionId The unique identifier of the transaction to update.
+   * @param updates A map containing the fields to update (e.g., "description", "amount",
+   *                "category").
+   * @return The updated Transaction object.
+   * @throws NoSuchElementException if the user is not found, or if the transaction
+   *         does not exist or does not belong to the specified user.
    */
   @PutMapping(
       value = "/users/{userId}/transactions/{transactionId}",
@@ -732,7 +772,7 @@ public ResponseEntity<Transaction> updateTransactionJson(
           TX_NF_PREFIX + transactionId + NF_FOR_USER + userId);
     }
     try {
-      final Optional<Transaction> updated = 
+      final Optional<Transaction> updated =
           mockApiService.updateTransaction(transactionId, updates);
       if (LOGGER.isLoggable(Level.INFO)) {
         LOGGER.info("Transaction updated successfully: " + transactionId + " for user " + userId);
@@ -747,10 +787,12 @@ public ResponseEntity<Transaction> updateTransactionJson(
   }
 
   /**
-   * Shows transaction create form.
+   * Displays an HTML form for creating a new transaction.
+   * The form includes fields for description, amount, and a dropdown for category selection.
    *
-   * @param userId user id
-   * @return HTML form
+   * @param userId The unique identifier of the user for whom to display the form.
+   * @return An HTML page containing the transaction creation form.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping(
       value = "/users/{userId}/transactions/create-form",
@@ -792,11 +834,15 @@ public String showCreateTransactionForm(@PathVariable final UUID userId) {
   }
 
   /**
-   * Deletes a transaction via JSON.
+   * Deletes a specific transaction for a user.
+   * Validates that the transaction belongs to the specified user before deletion.
    *
-   * @param userId user id
-   * @param transactionId transaction id
-   * @return deletion result
+   * @param userId The unique identifier of the user who owns the transaction.
+   * @param transactionId The unique identifier of the transaction to delete.
+   * @return A map containing deletion confirmation with keys: "deleted" (boolean),
+   *         "userId" (UUID), and "transactionId" (UUID).
+   * @throws NoSuchElementException if the user is not found, or if the transaction
+   *         does not exist or does not belong to the specified user.
    */
   @DeleteMapping("/users/{userId}/transactions/{transactionId}")
   public ResponseEntity<Map<String, Object>> deleteTransaction(
@@ -838,63 +884,19 @@ public ResponseEntity<Map<String, Object>> deleteTransaction(
         "deleted", true, "userId", userId, "transactionId", transactionId));
   }
 
-  /**
-   * Deletes a transaction via GET (testing).
-   *
-   * @param userId user id
-   * @param transactionId transaction id
-   * @return plain text result
-   */
-  @GetMapping("/users/{userId}/deletetransaction/{transactionId}")
-  public String deleteTransactionViaGet(
-      @PathVariable final UUID userId,
-      @PathVariable final UUID transactionId) {
-
-    if (LOGGER.isLoggable(Level.INFO)) {
-      LOGGER.info("GET /users/" + userId + "/deletetransaction/" 
-          + transactionId + " called - Deleting via GET.");
-    }
-
-    if (!mockApiService.getUser(userId).isPresent()) {
-      if (LOGGER.isLoggable(Level.WARNING)) {
-        LOGGER.warning("Cannot delete via GET - user not found: " + userId);
-      }
-      return "Error: User " + userId + NF_SUFFIX;
-    }
-
-    final Optional<Transaction> txOpt = mockApiService.getTransaction(transactionId);
-    final boolean belongsToUser = txOpt.map(t -> t.getUserId().equals(userId)).orElse(false);
-    if (!belongsToUser) {
-      if (LOGGER.isLoggable(Level.WARNING)) {
-        LOGGER.warning("Cannot delete via GET - transaction not found: " + transactionId);
-      }
-      return "Error: Transaction " + transactionId + " not found for user " + userId;
-    }
-
-    final boolean deleted = mockApiService.deleteTransaction(transactionId);
-    if (!deleted) {
-      if (LOGGER.isLoggable(Level.WARNING)) {
-        LOGGER.warning("Transaction deletion via GET failed: " + transactionId);
-      }
-      return "Error: Failed to delete transaction " + transactionId;
-    }
-
-    if (LOGGER.isLoggable(Level.INFO)) {
-      LOGGER.info("Transaction deleted successfully via GET for user " 
-          + userId + ": " + transactionId);
-    }
-    return "Transaction deleted successfully!";
-  }
 
   // ---------------------------------------------------------------------------
   // Budget & Analytics
   // ---------------------------------------------------------------------------
 
   /**
-   * Budget page.
+   * Displays an HTML page for budget management showing current budget status,
+   * spending totals, and links to various financial reports.
+   * Includes a form for updating the user's budget.
    *
-   * @param userId user id
-   * @return HTML page
+   * @param userId The unique identifier of the user whose budget page to display.
+   * @return An HTML page containing budget information and management tools.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping(value = "/users/{userId}/budget", produces = MediaType.TEXT_HTML_VALUE)
   public String budgetManagement(@PathVariable final UUID userId) {
@@ -938,11 +940,14 @@ public String budgetManagement(@PathVariable final UUID userId) {
   }
 
   /**
-   * Updates budget via JSON.
+   * Updates a user's budget using JSON input.
+   * Accepts a map that may contain budget-related fields such as "budget" (total budget amount).
    *
-   * @param userId user id
-   * @param budgetUpdate map with fields
-   * @return budget report
+   * @param userId The unique identifier of the user whose budget to update.
+   * @param budgetUpdate A map containing budget fields to update.
+   * @return A map containing the updated budget report with keys such as "totalSpent",
+   *         "remaining", and other budget statistics.
+   * @throws NoSuchElementException if the user is not found.
    */
   @PutMapping(
       value = "/users/{userId}/budget",
@@ -970,11 +975,13 @@ public ResponseEntity<Map<String, Object>> updateBudgetJson(
   }
 
   /**
-   * Updates budget via form; returns HTML.
+   * Updates a user's budget using HTML form data.
+   * Returns an HTML confirmation page showing the new budget amount.
    *
-   * @param userId user id
-   * @param budget new budget
-   * @return HTML confirmation
+   * @param userId The unique identifier of the user whose budget to update.
+   * @param budget The new budget amount to set.
+   * @return ResponseEntity containing an HTML success page confirming the budget update.
+   * @throws NoSuchElementException if the user is not found.
    */
   @PostMapping(
       value = "/users/{userId}/update-budget",
@@ -1008,10 +1015,13 @@ public ResponseEntity<String> updateBudget(
   }
 
   /**
-   * Weekly summary.
+   * Generates a weekly summary of transactions for a user.
+   * Includes transactions from the last 7 days and calculates the weekly spending total.
    *
-   * @param userId user id
-   * @return JSON weekly summary
+   * @param userId The unique identifier of the user whose weekly summary to generate.
+   * @return A map containing keys: "username", "weeklyTotal" (double), "transactionCount" (int),
+   *         and "transactions" (list of Transaction objects).
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping(value = "/users/{userId}/weekly-summary", produces = MediaType.APPLICATION_JSON_VALUE)
   public Map<String, Object> weeklySummary(@PathVariable final UUID userId) {
@@ -1044,10 +1054,13 @@ public Map<String, Object> weeklySummary(@PathVariable final UUID userId) {
   }
 
   /**
-   * Monthly summary.
+   * Generates a monthly summary of transactions for a user.
+   * Provides aggregated spending data for the current month.
    *
-   * @param userId user id
-   * @return JSON monthly summary
+   * @param userId The unique identifier of the user whose monthly summary to generate.
+   * @return A map containing a "summary" key with monthly transaction data,
+   *         or an empty map if no summary is available.
+   * @throws NoSuchElementException if the user is not found.
    */
   @GetMapping(
       value = "/users/{userId}/monthly-summary",
@@ -1076,14 +1089,16 @@ public Map<String, Object> monthlySummary(@PathVariable final UUID userId) {
 
     return response;
   }
-  
+
   /**
-   * Budget report JSON.
+   * Retrieves a detailed budget report for a user in JSON format.
+   * Includes total budget, total spent, remaining budget, and other financial metrics.
    *
-   * @param userId user id
-   * @return JSON budget report
+   * @param userId The unique identifier of the user whose budget report to retrieve.
+   * @return A map containing budget statistics with keys such as "totalSpent", "remaining",
+   *         and other relevant financial data.
+   * @throws NoSuchElementException if the user is not found.
    */
-
   @GetMapping(
       value = "/users/{userId}/budget-report",
       produces = MediaType.APPLICATION_JSON_VALUE)
@@ -1109,27 +1124,29 @@ public ResponseEntity<Map<String, Object>> budgetReport(@PathVariable final UUID
   // ---------------------------------------------------------------------------
 
   /**
-   * 404 handler.
+   * Exception handler for resource not found errors.
+   * Returns a JSON error response with HTTP status 404 (NOT_FOUND).
    *
-   * @param exception exception
-   * @return JSON error
+   * @param exception The NoSuchElementException containing the error message.
+   * @return ResponseEntity containing a map with an "error" key and the exception message.
    */
   @ExceptionHandler(NoSuchElementException.class)
   public ResponseEntity<Map<String, String>> handleNotFound(
-        final NoSuchElementException exception) {
+      final NoSuchElementException exception) {
     return ResponseEntity.status(HttpStatus.NOT_FOUND)
         .body(Map.of("error", exception.getMessage()));
   }
 
   /**
-   * 400 handler.
+   * Exception handler for invalid request data or parameters.
+   * Returns a JSON error response with HTTP status 400 (BAD_REQUEST).
    *
-   * @param exception exception
-   * @return JSON error
+   * @param exception The IllegalArgumentException containing the error message.
+   * @return ResponseEntity containing a map with an "error" key and the exception message.
    */
   @ExceptionHandler(IllegalArgumentException.class)
   public ResponseEntity<Map<String, String>> handleBadRequest(
-        final IllegalArgumentException exception) {
+      final IllegalArgumentException exception) {
     return ResponseEntity.status(HttpStatus.BAD_REQUEST)
         .body(Map.of("error", exception.getMessage()));
   }
diff --git a/src/main/java/dev/ase/teamproject/filter/LoggerFilter.java b/src/main/java/dev/ase/teamproject/filter/LoggerFilter.java
index 9822820..7e5418d 100644
--- a/src/main/java/dev/ase/teamproject/filter/LoggerFilter.java
+++ b/src/main/java/dev/ase/teamproject/filter/LoggerFilter.java
@@ -12,28 +12,38 @@
 
 /**
  * Logs all incoming API requests with client IP, method, endpoint, and timestamp.
+ * The client IP is determined from the X-Forwarded-For header if available, otherwise
+ * from the remote address.
  */
 @Component
-@SuppressWarnings({
-    "PMD.SystemPrintln", // Using System.out for simplicity in this example
-})
 public class LoggerFilter implements Filter {
-  
-  /** {@inheritDoc} */
+
+  /**
+   * Logs the details of an incoming HTTP request and passes it along the filter chain.
+   * Extracts client IP from X-Forwarded-For header or falls back to remote address,
+   * then logs the IP, HTTP method, request URI, and current timestamp to standard output.
+   *
+   * @param request The incoming servlet request.
+   * @param response The servlet response.
+   * @param chain The filter chain to continue processing the request.
+   * @throws IOException if an I/O error occurs during filtering.
+   * @throws ServletException if a servlet error occurs during filtering.
+   */
   @Override
-  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
+  public void doFilter(final ServletRequest request, final ServletResponse response,
+                       final FilterChain chain)
       throws IOException, ServletException {
-    HttpServletRequest httpRequest = (HttpServletRequest) request;
-    
+    final HttpServletRequest httpRequest = (HttpServletRequest) request;
+
     String clientIp = httpRequest.getHeader("X-Forwarded-For");
     if (clientIp == null || clientIp.isEmpty()) {
       clientIp = request.getRemoteAddr();
     }
-    
+
     // Simple log format: IP | METHOD | ENDPOINT | TIMESTAMP
-    System.out.println("CLIENT_LOG: " + clientIp + " | " 
-        + httpRequest.getMethod() + " " 
-        + httpRequest.getRequestURI() + " | " 
+    System.out.println("CLIENT_LOG: " + clientIp + " | "
+        + httpRequest.getMethod() + " "
+        + httpRequest.getRequestURI() + " | "
         + Instant.now());
 
     chain.doFilter(request, response);
diff --git a/src/main/java/dev/ase/teamproject/model/Transaction.java b/src/main/java/dev/ase/teamproject/model/Transaction.java
index 2963b1f..9884d90 100644
--- a/src/main/java/dev/ase/teamproject/model/Transaction.java
+++ b/src/main/java/dev/ase/teamproject/model/Transaction.java
@@ -12,43 +12,20 @@
  *  income or a refund. The class supports both date-only (for summaries) and
  *  timestamped (for precise ordering).
  */
-@SuppressWarnings({
-    "PMD.DataClass", // Class primarily holds data
-    "PMD.OnlyOneReturn", // Multiple return statements for clarity
-    "PMD.CommentSize", // Comments enhance understanding
-    "PMD.CyclomaticComplexity", // Complexity justified for compareTo
-    "PMD.CognitiveComplexity", // Complexity justified for compareTo
-    "PMD.ConstructorCallsOverridableMethod" // Safe usage in constructor
-})
 public class Transaction implements Comparable<Transaction> {
-  /** The unique identifier for the transaction. */
   private UUID transactionId;
-
-  /** The unique identifier of the user who made the transaction. */
   private UUID userId;
-
-  /** A brief description of the transaction. */
-  private String description; 
-
-  /** The amount of the transaction (positive for expense, negative for income). */
+  private String description;
   private double amount;
-
-  /** The category of the transaction. */
   private String category;
-
-  /** The exact timestamp when the transaction occurred. */
   private LocalDateTime timestamp;
-
-  /** The calendar date of the transaction (without time). */
   private LocalDate date;
 
-  /** Default constructor for Transaction. */
   public Transaction() {
-    // no-op
   }
 
   /**
-   * Constructs a new {@code Transaction} with data. {@code transactionId}, 
+   * Constructs a new {@code Transaction} with data. {@code transactionId},
    * {@code timestamp}, and {@code date} are  regenerated by the database.
    *
    * @param userId The unique identifier of the user who made the transaction.
@@ -56,64 +33,62 @@ public Transaction() {
    * @param category The category of the transaction.
    * @param description A brief description of the transaction.
    */
-  public Transaction(final UUID userId, final double amount, 
-      final String category, final String description) {
+  public Transaction(final UUID userId, final double amount,
+                     final String category, final String description) {
     this.userId = userId;
     this.amount = amount;
     this.category = category;
     setDescription(description);
   }
 
-  /** Getter for the transaction ID. */
-  public UUID getTransactionId() { 
-    return transactionId; 
+  public UUID getTransactionId() {
+    return transactionId;
   }
 
-  /** Setter for the transaction ID. */
-  public void setTransactionId(final UUID userId) { 
-    this.transactionId = userId; 
+  public void setTransactionId(final UUID userId) {
+    this.transactionId = userId;
   }
 
-  /** Getter for the user ID associated with this transaction. */
-  public UUID getUserId() { 
-    return userId; 
+  public UUID getUserId() {
+    return userId;
   }
 
-  /** Setter for the user ID associated with this transaction. */
   public void setUserId(final UUID userId) {
-    this.userId = userId; 
+    this.userId = userId;
   }
 
-  /** Getter for the description of the transaction. */
   public String getDescription() {
-    return description; 
+    return description;
   }
 
-  /** Setter for the description of the transaction. */
+  /**
+   * Sets the description of the transaction. If the provided description
+   * is {@code null}, it defaults to an empty string. Leading and trailing
+   * whitespace is automatically trimmed.
+   *
+   * @param description A brief description of the transaction.
+   */
   public void setDescription(final String description) {
     this.description = (description == null) ? "" : description.trim();
   }
 
-  /** Getter for the amount of the transaction. */
-  public double getAmount() { 
-    return amount; 
+  public double getAmount() {
+    return amount;
   }
 
-  /** Setter for the amount of the transaction. */
-  public void setAmount(final double amount) { 
-    this.amount = amount; 
+  public void setAmount(final double amount) {
+    this.amount = amount;
   }
 
-  /** Getter for the exact timestamp of the transaction. */
-  public LocalDateTime getTimestamp() { 
-    return timestamp; 
+  public LocalDateTime getTimestamp() {
+    return timestamp;
   }
 
   /**
-   * Sets the exact timestamp for the transaction. If a timestamp is provided, 
+   * Sets the exact timestamp for the transaction. If a timestamp is provided,
    * the corresponding date field is updated to match.
    *
-   * @param timestamp The {@code LocalDateTime} value representing 
+   * @param timestamp The {@code LocalDateTime} value representing
    *                  when the transaction occurred.
    */
   public void setTimestamp(final LocalDateTime timestamp) {
@@ -123,9 +98,8 @@ public void setTimestamp(final LocalDateTime timestamp) {
     }
   }
 
-  /** Getter for the calendar date of the transaction. */
-  public LocalDate getDate() { 
-    return date; 
+  public LocalDate getDate() {
+    return date;
   }
 
   /**
@@ -144,14 +118,12 @@ public void setDate(final LocalDate date) {
     }
   }
 
-  /** Getter for the category of the transaction. */
-  public String getCategory() { 
-    return category; 
+  public String getCategory() {
+    return category;
   }
 
-  /** Setter for the category of the transaction. */
-  public void setCategory(final String category) { 
-    this.category = category; 
+  public void setCategory(final String category) {
+    this.category = category;
   }
 
   /**
@@ -173,7 +145,17 @@ public LocalDateTime effectiveInstant() {
     return null;
   }
 
-  /** Compares this transaction to another based on their effective instants. */
+  /**
+   * Compares this transaction to another based on their effective instants.
+   * Transactions are ordered primarily by their timestamp (or date if timestamp
+   * is unavailable). When timestamps are equal or both {@code null}, transactions
+   * are ordered by their unique identifier. Transactions with {@code null} instants
+   * are ordered before those with valid instants.
+   *
+   * @param other The transaction to compare against.
+   * @return a negative integer, zero, or a positive integer as this transaction
+   *         is less than, equal to, or greater than the specified transaction.
+   */
   @Override
   public int compareTo(final Transaction other) {
     if (other == null) {
@@ -181,7 +163,7 @@ public int compareTo(final Transaction other) {
     }
     final LocalDateTime thisDateTime = this.effectiveInstant();
     final LocalDateTime otherDateTime = other.effectiveInstant();
-    
+
     if (thisDateTime == null && otherDateTime == null) {
       final UUID thisUuid = this.transactionId;
       final UUID otherUuid = other.transactionId;
@@ -196,7 +178,7 @@ public int compareTo(final Transaction other) {
       }
       return thisUuid.compareTo(otherUuid);
     }
-    
+
     if (thisDateTime == null) {
       return -1;
     }
@@ -208,7 +190,7 @@ public int compareTo(final Transaction other) {
     if (cmp != 0) {
       return cmp;
     }
-    
+
     final UUID thisUuid = this.transactionId;
     final UUID otherUuid = other.transactionId;
     if (thisUuid == null && otherUuid == null) {
@@ -223,7 +205,14 @@ public int compareTo(final Transaction other) {
     return thisUuid.compareTo(otherUuid);
   }
 
-  /** Compares this transaction to another based on their effective instants. */
+  /**
+   * Indicates whether some other object is "equal to" this one.
+   * Two transactions are considered equal if they have the same transaction ID.
+   *
+   * @param other The reference object with which to compare.
+   * @return {@code true} if this transaction has the same ID as the other object;
+   *         {@code false} otherwise.
+   */
   @Override
   public boolean equals(final Object other) {
     if (this == other) {
@@ -236,22 +225,31 @@ public boolean equals(final Object other) {
     return Objects.equals(transactionId, transaction.transactionId);
   }
 
-  /** Returns a hash code for this transaction based on its ID. */
+  /**
+   * Returns a hash code value for this transaction based on its unique identifier.
+   *
+   * @return a hash code value for this transaction.
+   */
   @Override
-  public int hashCode() { 
-    return Objects.hash(transactionId); 
+  public int hashCode() {
+    return Objects.hash(transactionId);
   }
 
-  /** Returns a string representation of the transaction. */
+  /**
+   * Returns a string representation of the transaction, including its ID,
+   * description, amount, timestamp, date, and category.
+   *
+   * @return a string representation of this transaction.
+   */
   @Override
   public String toString() {
     return "Transaction{"
-            + "id=" + transactionId
-            + ", description='" + description + '\''
-            + ", amount=" + amount
-            + ", timestamp=" + timestamp
-            + ", date=" + date
-            + ", category='" + category + '\''
-            + '}';
+        + "id=" + transactionId
+        + ", description='" + description + '\''
+        + ", amount=" + amount
+        + ", timestamp=" + timestamp
+        + ", date=" + date
+        + ", category='" + category + '\''
+        + '}';
   }
 }
diff --git a/src/main/java/dev/ase/teamproject/model/User.java b/src/main/java/dev/ase/teamproject/model/User.java
index 9a3d9f0..89e79b2 100644
--- a/src/main/java/dev/ase/teamproject/model/User.java
+++ b/src/main/java/dev/ase/teamproject/model/User.java
@@ -4,33 +4,20 @@
 
 /**
  * This class defines the User model used in the application.
- * A user represents an individual with an account in the system. 
- * Each user has identifying information such as a unique ID, username, 
+ * A user represents an individual with an account in the system.
+ * Each user has identifying information such as a unique ID, username,
  * email address, and a budget. The User entity serves as the foundation
  * for tracking transactions, spending summaries, and budget analytics.
  */
-@SuppressWarnings({
-    "PMD.ShortClassName", // Commonly used class name
-    "PMD.DataClass" // Class primarily holds data
-})
 public class User {
-  /** The unique identifier for the user. */
   private UUID userId;
-
-  /** The display name of the user. */
   private String username;
-
-  /** The email address of the user. */
   private String email;
-
-  /** The total budget assigned to this user. */
   private double budget;
 
-  /** Default constructor for User. */
   public User() {
-    // no-op
   }
-  
+
   /**
    * Constructs a new {@code User} with specified username, email, and budget.
    * The unique {@code userId} is generated by the database.
@@ -51,7 +38,7 @@ public UUID getUserId() {
 
   public void setUserId(final UUID userId) {
     this.userId = userId;
-  }  
+  }
 
   public String getUsername() {
     return username;
diff --git a/src/main/java/dev/ase/teamproject/service/MockApiService.java b/src/main/java/dev/ase/teamproject/service/MockApiService.java
index dc42356..7bad3c1 100644
--- a/src/main/java/dev/ase/teamproject/service/MockApiService.java
+++ b/src/main/java/dev/ase/teamproject/service/MockApiService.java
@@ -18,24 +18,14 @@
 /**
  * This class defines the Mock API Service responsible for managing
  * interactions between the application and the PostgreSQL database.
- *  It provides CRUD operations for users and transactions, as well as
- *  analytics and budgeting functionalities.
- *  All methods in this class use the Spring JdbcTemplate for data access.
+ * It provides CRUD operations for users and transactions, as well as
+ * analytics and budgeting functionalities.
+ * All methods in this class use the Spring JdbcTemplate for data access.
  */
-@SuppressWarnings({
-    "PMD.TooManyMethods", // Service class with multiple operations
-    "PMD.OnlyOneReturn", // Multiple return statements for clarity
-    "PMD.AvoidCatchingGenericException", // Generic exception handling for DB ops
-    "PMD.CyclomaticComplexity", // Complex service methods for validations
-    "PMD.CognitiveComplexity" // Complex validation and DB interaction flows
-})
 @Service
 public class MockApiService {
-
-  /** The JdbcTemplate used for database interactions. */
   private final JdbcTemplate jdbcTemplate;
 
-  /** Maps SQL query results to {@code User} objects. */
   private final RowMapper<User> userRowMapper = (rs, rowNum) -> {
     final User user = new User();
     user.setUserId((UUID) rs.getObject("user_id"));
@@ -45,7 +35,6 @@ public class MockApiService {
     return user;
   };
 
-  /** Maps SQL query results to {@code Transaction} objects. */
   private final RowMapper<Transaction> txRowMapper = (rs, rowNum) -> {
     final Transaction transaction = new Transaction();
     try {
@@ -54,26 +43,23 @@ public class MockApiService {
       transaction.setDescription(rs.getString("description"));
       transaction.setAmount(rs.getDouble(AMOUNT));
       transaction.setCategory(rs.getString("category"));
-      
+
       // Handle potential null values for timestamps
       if (rs.getTimestamp("created_time") != null) {
         transaction.setTimestamp(rs.getTimestamp("created_time").toLocalDateTime());
       }
-      
+
       if (rs.getDate("created_date") != null) {
         transaction.setDate(rs.getDate("created_date").toLocalDate());
       }
-      
+
       return transaction;
     } catch (Exception e) {
       throw new IllegalStateException("Error mapping transaction row: " + e.getMessage(), e);
-    } 
+    }
   };
 
-  /** Common string literal. */
   private static final String USER_NOT_FOUND = "User not found";
-  
-  /** Common string literal. */
   private static final String AMOUNT = "amount";
 
   /**
@@ -99,7 +85,7 @@ public List<User> viewAllUsers() {
    * Retrieves a specific user by their unique identifier.
    *
    * @param userId The {@code UUID} of the user to retrieve.
-   * @return An {@code Optional} containing the {@code User} if found, 
+   * @return An {@code Optional} containing the {@code User} if found,
    *         or empty if not found.
    */
   public Optional<User> getUser(final UUID userId) {
@@ -113,24 +99,25 @@ public Optional<User> getUser(final UUID userId) {
   }
 
   /**
-   * Adds a new user to the database.
+   * Adds a new user to the database. If the user already has a {@code userId},
+   * it is used directly; otherwise, a new {@code UUID} is generated by the database.
    *
    * @param user The {@code User} object containing username, email, and budget.
-   * @return The created {@code User} object with a generated {@code UUID}.
+   * @return The created {@code User} object with its assigned {@code UUID}.
    */
   public User addUser(final User user) {
     if (user.getUserId() != null) {
       final String sql = "INSERT INTO users (user_id, username, email, budget) VALUES (?, ?, ?, ?)";
-      jdbcTemplate.update(sql, 
+      jdbcTemplate.update(sql,
           user.getUserId(),  // Use the provided UUID
-          user.getUsername(), 
-          user.getEmail(), 
+          user.getUsername(),
+          user.getEmail(),
           user.getBudget());
       return user;  // Return as-is
     } else {
-      final String sql = 
+      final String sql =
           "INSERT INTO users (username, email, budget) VALUES (?, ?, ?) RETURNING user_id";
-      final UUID generatedUserId = jdbcTemplate.queryForObject(sql, UUID.class, 
+      final UUID generatedUserId = jdbcTemplate.queryForObject(sql, UUID.class,
           user.getUsername(), user.getEmail(), user.getBudget());
       user.setUserId(generatedUserId);
       return user;
@@ -152,7 +139,7 @@ public boolean deleteUser(final UUID userId) {
   /**
    * Retrieves all transactions sorted by most recent creation time.
    *
-   * @return A {@code List} of {@code Transaction} objects 
+   * @return A {@code List} of {@code Transaction} objects
    *         sorted by {@code created_time}.
    */
   public List<Transaction> viewAllTransactions() {
@@ -179,10 +166,14 @@ public Optional<Transaction> getTransaction(final UUID transactionId) {
   }
 
   /**
-   * Creates a new transaction record in the database.
+   * Creates a new transaction record in the database. Validates that all required
+   * fields are present and valid before insertion. The database automatically
+   * generates the transaction ID, timestamp, and date.
    *
    * @param transaction The {@code Transaction} to insert.
-   * @return The created {@code Transaction}.
+   * @return The created {@code Transaction} with database-generated fields populated.
+   * @throws IllegalArgumentException if required fields are missing, invalid, or
+   *         if the user ID does not exist.
    * @throws IllegalStateException if the insert operation fails.
    */
   public Transaction addTransaction(final Transaction transaction) {
@@ -203,15 +194,15 @@ public Transaction addTransaction(final Transaction transaction) {
     }
 
     try {
-      final String sql = "INSERT INTO transactions (user_id, description, amount, category) " 
+      final String sql = "INSERT INTO transactions (user_id, description, amount, category) "
           + "VALUES (?, ?, ?, ?::transaction_category) "
           + "RETURNING transaction_id, created_time, created_date";
       final Transaction savedTransaction = jdbcTemplate.queryForObject(sql, (rs, rowNum) -> {
         transaction.setTransactionId(rs.getObject("transaction_id", UUID.class));
         transaction.setTimestamp(rs.getTimestamp("created_time").toLocalDateTime());
         transaction.setDate(rs.getDate("created_date").toLocalDate());
-        return transaction; 
-      }, 
+        return transaction;
+      },
           transaction.getUserId(),
           transaction.getDescription(),
           transaction.getAmount(),
@@ -221,10 +212,10 @@ public Transaction addTransaction(final Transaction transaction) {
       final String message = e.getMessage();
       if (message != null && message.contains("foreign key constraint")) {
         throw new IllegalArgumentException("Invalid user ID: user does not exist", e);
-      } else if (message != null && (message.contains("transaction_category") 
+      } else if (message != null && (message.contains("transaction_category")
           || message.contains("enum"))) {
         throw new IllegalArgumentException("Invalid category. Valid categories are: FOOD,"
-            + "TRANSPORTATION, ENTERTAINMENT, UTILITIES, SHOPPING," 
+            + "TRANSPORTATION, ENTERTAINMENT, UTILITIES, SHOPPING,"
             + "HEALTHCARE, TRAVEL, EDUCATION, OTHER", e);
       } else if (message != null && (message.contains("numeric") || message.contains(AMOUNT))) {
         throw new IllegalArgumentException("Invalid amount format: must be a valid number", e);
@@ -235,7 +226,8 @@ public Transaction addTransaction(final Transaction transaction) {
   }
 
   /**
-   * Retrieves all transactions associated with a specific user.
+   * Retrieves all transactions associated with a specific user, ordered by
+   * most recent first.
    *
    * @param userId The {@code UUID} of the user.
    * @return A {@code List} of the user's {@code Transaction} records.
@@ -251,22 +243,27 @@ public List<Transaction> getTransactionsByUser(final UUID userId) {
   }
 
   /**
-   * Updates an existing transaction record with new values.
+   * Updates an existing transaction record with new values. Validates all provided
+   * fields before applying changes. Only the fields present in the updates map
+   * will be modified.
    *
    * @param transactionId The {@code UUID} of the transaction to update.
-   * @param updates A {@code Map} containing the fields to modify and new values.
-   * @return An {@code Optional} of the updated {@code Transaction}, 
-   *         or empty if update fails.
+   * @param updates A {@code Map} containing the fields to modify and their new values.
+   *                Valid keys are "description", "amount", and "category".
+   * @return An {@code Optional} of the updated {@code Transaction}.
+   * @throws IllegalArgumentException if the transaction is not found, if no valid
+   *         fields are provided, or if any field value is invalid.
+   * @throws IllegalStateException if the update operation fails.
    */
   public Optional<Transaction> updateTransaction(
-        final UUID transactionId, final Map<String, Object> updates) {
+      final UUID transactionId, final Map<String, Object> updates) {
     final Optional<Transaction> existing = getTransaction(transactionId);
     if (!existing.isPresent()) {
       throw new IllegalArgumentException("Transaction not found with ID: " + transactionId);
     }
-    
+
     final Transaction transaction = existing.get();
-    
+
     // Validate and apply updates
     if (updates.containsKey("description")) {
       final Object description = updates.get("description");
@@ -280,7 +277,7 @@ public Optional<Transaction> updateTransaction(
         throw new IllegalArgumentException("Description must be a string");
       }
     }
-    
+
     if (updates.containsKey(AMOUNT)) {
       final Object amount = updates.get(AMOUNT);
       final double newAmount;
@@ -295,13 +292,13 @@ public Optional<Transaction> updateTransaction(
       } else {
         throw new IllegalArgumentException("Amount must be a number");
       }
-      
+
       if (newAmount <= 0) {
         throw new IllegalArgumentException("Amount must be greater than 0");
       }
       transaction.setAmount(newAmount);
     }
-    
+
     if (updates.containsKey("category")) {
       final Object category = updates.get("category");
       if (category instanceof String) {
@@ -311,7 +308,7 @@ public Optional<Transaction> updateTransaction(
         }
         // Validate category against known values
         final List<String> validCategories = Arrays.asList(
-            "FOOD", "TRANSPORTATION", "ENTERTAINMENT", "UTILITIES", 
+            "FOOD", "TRANSPORTATION", "ENTERTAINMENT", "UTILITIES",
             "SHOPPING", "HEALTHCARE", "TRAVEL", "EDUCATION", "OTHER"
         );
         if (!validCategories.contains(cat.toUpperCase(Locale.ROOT))) {
@@ -323,13 +320,13 @@ public Optional<Transaction> updateTransaction(
         throw new IllegalArgumentException("Category must be a string");
       }
     }
-    
+
     // Check if any valid updates were provided
     if (updates.isEmpty()) {
       throw new IllegalArgumentException("No valid fields provided for update");
     }
-    
-    final String sql = "UPDATE transactions SET description = ?, amount = ?, " 
+
+    final String sql = "UPDATE transactions SET description = ?, amount = ?, "
         + "category = ?::transaction_category WHERE transaction_id = ?";
     final int rowsAffected;
     try {
@@ -340,10 +337,10 @@ public Optional<Transaction> updateTransaction(
           transactionId);
     } catch (DataAccessException e) {
       final String message = e.getMessage();
-      if (message != null && (message.contains("transaction_category") 
+      if (message != null && (message.contains("transaction_category")
           || message.contains("enum"))) {
         throw new IllegalArgumentException("Invalid category. Valid categories are: "
-            + "FOOD, TRANSPORTATION, ENTERTAINMENT, UTILITIES, SHOPPING, " 
+            + "FOOD, TRANSPORTATION, ENTERTAINMENT, UTILITIES, SHOPPING, "
             + "HEALTHCARE, TRAVEL, EDUCATION, OTHER", e);
       }
       throw new IllegalStateException("Failed to update transaction: " + message, e);
@@ -368,10 +365,12 @@ public boolean deleteTransaction(final UUID transactionId) {
   }
 
   /**
-   * Generates a summary of a user's budget information.
+   * Generates a summary of a user's budget information, including total budget,
+   * total spent, and remaining balance.
    *
    * @param userId The {@code UUID} of the user.
-   * @return A formatted summary string with budget details and remaining balance.
+   * @return A formatted summary string with budget details, or "User not found"
+   *         if the user does not exist.
    */
   public String getBudgetsTextBlock(final UUID userId) {
     final Optional<User> userOpt = getUser(userId);
@@ -387,19 +386,21 @@ public String getBudgetsTextBlock(final UUID userId) {
     final double remaining = user.getBudget() - totalSpent;
     return String.format(
         "Budget Summary for %s:\n"
-        + "Total Budget: $%.2f\n"
-        + "Total Spent: $%.2f\n"
-        + "Remaining: $%.2f",
+            + "Total Budget: $%.2f\n"
+            + "Total Spent: $%.2f\n"
+            + "Remaining: $%.2f",
         user.getUsername(), user.getBudget(), totalSpent, remaining
     );
   }
 
   /**
    * Generates warning messages for users who are near or over their budget.
+   * A warning is issued if the user has exceeded their budget or has less than
+   * 10% remaining.
    *
    * @param userId The {@code UUID} of the user.
-   * @return A formatted string with warning messages, 
-   *         or an empty string if none apply.
+   * @return A formatted string with warning messages, an empty string if no warnings
+   *         apply, or "User not found" if the user does not exist.
    */
   public String getBudgetWarningsText(final UUID userId) {
     final Optional<User> userOpt = getUser(userId);
@@ -425,10 +426,13 @@ public String getBudgetWarningsText(final UUID userId) {
   }
 
   /**
-   * Generates a monthly spending summary with category breakdown.
+   * Generates a monthly spending summary with category breakdown for the current month.
+   * Includes total budget, amount spent, remaining balance, and spending broken down
+   * by category in descending order.
    *
    * @param userId The {@code UUID} of the user.
-   * @return A formatted multi-line string summarizing the user's monthly spending.
+   * @return A formatted multi-line string summarizing the user's monthly spending,
+   *         or "User not found" if the user does not exist.
    */
   public String getMonthlySummary(final UUID userId) {
     final Optional<User> userOpt = getUser(userId);
@@ -439,7 +443,7 @@ public String getMonthlySummary(final UUID userId) {
     final List<Transaction> transactions = getTransactionsByUser(userId);
     final LocalDate now = LocalDate.now();
     final List<Transaction> monthTransactions = transactions.stream()
-        .filter(t -> t.getDate() != null && t.getDate().getMonth() 
+        .filter(t -> t.getDate() != null && t.getDate().getMonth()
             == now.getMonth() && t.getDate().getYear() == now.getYear())
         .collect(Collectors.toList());
     final double totalSpent = monthTransactions.stream()
@@ -468,10 +472,13 @@ public String getMonthlySummary(final UUID userId) {
   }
 
   /**
-   * Generates a budget report containing analytics, totals, and warnings.
+   * Generates a comprehensive budget report containing analytics, totals, category
+   * breakdown, and warnings. The report includes budget status, spending by category,
+   * and whether the user is over budget or has warnings.
    *
    * @param userId The {@code UUID} of the user.
-   * @return A {@code Map} with budget metrics and summaries.
+   * @return A {@code Map} with budget metrics and summaries, or a map containing
+   *         an "error" key if the user is not found.
    */
   public Map<String, Object> getBudgetReport(final UUID userId) {
     final Optional<User> userOpt = getUser(userId);
@@ -506,11 +513,12 @@ public Map<String, Object> getBudgetReport(final UUID userId) {
   }
 
   /**
-   * Updates the user's budget with new settings or amounts.
+   * Updates the user's budget with a new value. The budget must be non-negative.
    *
    * @param userId The {@code UUID} of the user.
-   * @param updates A {@code Map} containing updated budget values.
-   * @throws IllegalArgumentException if the user is not found or budget is invalid.
+   * @param updates A {@code Map} containing a "budget" key with the new budget value.
+   * @throws IllegalArgumentException if the user is not found, if the budget value
+   *         is invalid or negative, or if the format is incorrect.
    */
   public void setBudgets(final UUID userId, final Map<String, Object> updates) {
     final Optional<User> userOpt = getUser(userId);
@@ -536,7 +544,8 @@ public void setBudgets(final UUID userId, final Map<String, Object> updates) {
   }
 
   /**
-   * Retrieves transactions created within the last seven days for a given user.
+   * Retrieves transactions created within the last seven days for a given user,
+   * ordered by most recent first.
    *
    * @param userId The {@code UUID} of the user.
    * @return A {@code List} of {@code Transaction} objects created in the past week.
@@ -550,13 +559,15 @@ public List<Transaction> weeklySummary(final UUID userId) {
 
   /**
    * Calculates the total spending for a user over the past seven days.
+   * Only positive transaction amounts are included in the total.
    *
    * @param userId The {@code UUID} of the user.
-   * @return The total spending amount for the last 7 days.
+   * @return The total spending amount for the last 7 days, or 0.0 if no transactions
+   *         exist or if an error occurs.
    */
   public double totalLast7Days(final UUID userId) {
     final LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
-    final String sql = "SELECT COALESCE(SUM(amount), 0) FROM transactions" 
+    final String sql = "SELECT COALESCE(SUM(amount), 0) FROM transactions"
         + " WHERE user_id = ? AND created_date >= ? AND amount > 0";
     try {
       final Double result = jdbcTemplate.queryForObject(sql, Double.class, userId, oneWeekAgo);
@@ -567,11 +578,15 @@ public double totalLast7Days(final UUID userId) {
   }
 
   /**
-   * Returns if username is already in database.
+   * Checks whether a username already exists in the database. Optionally excludes
+   * a specific user ID from the search, useful for update operations where a user
+   * is keeping their own username.
    *
-   * @param username to check for
-   * @param excludeUserId on id to exclude in search, set to null of none
-   * @return boolean that shows whether username is in use
+   * @param username The username to check for.
+   * @param excludeUserId The user ID to exclude from the search, or {@code null}
+   *                      to check against all users.
+   * @return {@code true} if the username exists (excluding the specified user if provided);
+   *         {@code false} otherwise.
    */
   public boolean isUsernameExists(final String username, final UUID excludeUserId) {
     if (excludeUserId == null) {
@@ -582,19 +597,23 @@ public boolean isUsernameExists(final String username, final UUID excludeUserId)
     } else {
       // Check against other users only
       final String sql = "SELECT COUNT(*) FROM users WHERE username = ? AND user_id != ?";
-      final Integer count = jdbcTemplate.queryForObject(sql, 
+      final Integer count = jdbcTemplate.queryForObject(sql,
           Integer.class, username, excludeUserId);
       return count != null && count > 0;
     }
   }
 
   /**
-  * Returns if email is already in database.
-  *
-  * @param email to check for
-  * @param excludeUserId on id to exclude in search, set to null of none
-  * @return boolean that shows whether email is in use
-  */
+   * Checks whether an email already exists in the database. Optionally excludes
+   * a specific user ID from the search, useful for update operations where a user
+   * is keeping their own email.
+   *
+   * @param email The email to check for.
+   * @param excludeUserId The user ID to exclude from the search, or {@code null}
+   *                      to check against all users.
+   * @return {@code true} if the email exists (excluding the specified user if provided);
+   *         {@code false} otherwise.
+   */
   public boolean isEmailExists(final String email, final UUID excludeUserId) {
     if (excludeUserId == null) {
       // Check against all users
diff --git a/src/main/resources/all-java.xml b/src/main/resources/all-java.xml
deleted file mode 100644
index ca7b007..0000000
--- a/src/main/resources/all-java.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ruleset name="All Java Rules"
-    xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
-  <description>Enable all standard PMD Java rules.</description>
-  <rule ref="category/java/bestpractices.xml"/>
-  <rule ref="category/java/codestyle.xml"/>
-  <rule ref="category/java/design.xml">
-    <exclude name="LoosePackageCoupling"/>
-  </rule>
-  <rule ref="category/java/documentation.xml"/>
-  <rule ref="category/java/errorprone.xml"/>
-  <rule ref="category/java/multithreading.xml"/>
-  <rule ref="category/java/performance.xml"/>
-  <rule ref="category/java/security.xml"/>
-</ruleset>
\ No newline at end of file
diff --git a/src/main/resources/custom-java-rules.xml b/src/main/resources/custom-java-rules.xml
new file mode 100644
index 0000000..75efbea
--- /dev/null
+++ b/src/main/resources/custom-java-rules.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="All Java Rules"
+         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
+    <description>Custom PMD Java Rules</description>
+
+    <rule ref="category/java/bestpractices.xml">
+        <exclude name="AvoidPrintStackTrace"/>
+        <exclude name="SystemPrintln"/>
+    </rule>
+
+    <rule ref="category/java/codestyle.xml">
+        <exclude name="OnlyOneReturn"/>
+        <exclude name="ShortClassName"/>
+        <exclude name="AtLeastOneConstructor"/>
+    </rule>
+
+    <rule ref="category/java/design.xml">
+        <exclude name="LoosePackageCoupling"/>
+        <exclude name="CognitiveComplexity"/>
+        <exclude name="CyclomaticComplexity"/>
+        <exclude name="DataClass"/>
+        <exclude name="TooManyMethods"/>
+        <exclude name="NcssCount"/>
+        <exclude name="AvoidCatchingGenericException"/>
+        <exclude name="AvoidThrowingRawExceptionTypes"/>
+        <exclude name="LawOfDemeter"/>
+        <exclude name="NPathComplexity"/>
+    </rule>
+
+    <rule ref="category/java/documentation.xml">
+        <exclude name="CommentSize"/>
+        <exclude name="CommentRequired"/>
+        <exclude name="UncommentedEmptyConstructor"/>
+    </rule>
+
+    <rule ref="category/java/errorprone.xml">
+        <exclude name="AvoidCatchingNPE"/>
+        <exclude name="ConstructorCallsOverridableMethod"/>
+    </rule>
+
+    <rule ref="category/java/multithreading.xml"/>
+
+    <rule ref="category/java/performance.xml"/>
+
+    <rule ref="category/java/security.xml"/>
+
+</ruleset>
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/MockApiServiceIntegrationTests.java b/src/test/java/dev/ase/teamproject/MockApiServiceIntegrationTests.java
index 04fe1a3..f1164b9 100644
--- a/src/test/java/dev/ase/teamproject/MockApiServiceIntegrationTests.java
+++ b/src/test/java/dev/ase/teamproject/MockApiServiceIntegrationTests.java
@@ -6,6 +6,7 @@
 import dev.ase.teamproject.model.Transaction;
 import dev.ase.teamproject.model.User;
 import dev.ase.teamproject.service.MockApiService;
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -17,12 +18,36 @@
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.test.context.ActiveProfiles;
 
-/** Integration testing for MockApiServices using a test database hosted on GCP. */
-
+/**
+ * Integration Tests for MockApiService.
+ *
+ * <p>These tests verify the integration between the MockApiService class and the
+ * external PostgreSQL database hosted on GCP. They exercise:
+ * <ul>
+ *   <li>Database CRUD operations for User and Transaction entities</li>
+ *   <li>Foreign key constraints between users and transactions tables</li>
+ *   <li>Database triggers for auto-generated fields (timestamps, dates, UUIDs)</li>
+ *   <li>PostgreSQL ENUM type handling for transaction categories</li>
+ *   <li>Database aggregate functions and queries (SUM, COUNT, date filtering)</li>
+ *   <li>Cascade delete operations</li>
+ * </ul>
+ *
+ * <h2>External Integration Points</h2>
+ * <ul>
+ *   <li>MockApiService ↔ PostgreSQL Database (via JdbcTemplate)</li>
+ *   <li>User table ↔ Transaction table (foreign key relationship)</li>
+ *   <li>Application code ↔ Database constraints and validations</li>
+ * </ul>
+ *
+ * <h2>Internal Integration Points</h2>
+ * <ul>
+ *   <li>MockApiService ↔ User model (data mapping via RowMapper)</li>
+ *   <li>MockApiService ↔ Transaction model (data mapping via RowMapper)</li>
+ *   <li>Service methods calling other service methods internally</li>
+ * </ul>
+ */
 @ActiveProfiles("test")
 @SpringBootTest
-// @TestPropertySource(locations = "classpath:application-test.properties")
-
 public class MockApiServiceIntegrationTests {
 
   @Autowired
@@ -33,8 +58,15 @@ public class MockApiServiceIntegrationTests {
 
   private UUID userId;
 
+  /**
+   * Sets up a clean database state before each test.
+   * Creates a base user for tests to use, ensuring isolation between test cases.
+   *
+   * <p><strong>Integration:</strong> Uses TRUNCATE CASCADE to test database
+   * cascade delete functionality.
+   */
   @BeforeEach
-  void setup() {
+  public void setup() {
     // Clean tables
     jdbcTemplate.execute("TRUNCATE TABLE users CASCADE");
 
@@ -47,26 +79,56 @@ void setup() {
     userId = saved.getUserId();
   }
 
-  // ---------------------
-  // USER TESTS
-  // ---------------------
+  // ===========================================================================
+  // USER CRUD OPERATIONS - Testing User table integration
+  // ===========================================================================
 
+  /**
+   * Tests retrieval of all users from the database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database SELECT query
+   */
   @Test
-  void testViewAllUsers() {
+  public void testViewAllUsers() {
     List<User> users = service.viewAllUsers();
     assertThat(users).hasSize(1);
     assertThat(users.get(0).getUsername()).isEqualTo("user");
   }
 
+  /**
+   * Tests retrieval of a specific user by UUID.
+   *
+   * <p><strong>External Integration:</strong> Service → Database SELECT with WHERE clause
+   */
   @Test
-  void testGetUser() {
+  public void testGetUser() {
     Optional<User> user = service.getUser(userId);
     assertThat(user).isPresent();
     assertThat(user.get().getUsername()).isEqualTo("user");
   }
 
+  /**
+   * Tests retrieval of non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service → Database returns empty result
+   */
+  @Test
+  public void testGetUser_notFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    Optional<User> user = service.getUser(fakeId);
+
+    assertThat(user).isEmpty();
+  }
+
+  /**
+   * Tests successful user creation with database-generated UUID.
+   *
+   * <p><strong>External Integration:</strong> Service → Database INSERT with RETURNING clause
+   * to retrieve auto-generated user_id
+   */
   @Test
-  void testAddUser_success() {
+  public void testAddUser_success() {
     User user = new User();
     user.setUsername("newUser");
     user.setEmail("test@email.com");
@@ -78,8 +140,14 @@ void testAddUser_success() {
     assertThat(service.getUser(saved.getUserId())).isPresent();
   }
 
+  /**
+   * Tests database unique constraint enforcement on username.
+   *
+   * <p><strong>External Integration:</strong> Service → Database unique constraint violation
+   * handling (users_username_key constraint)
+   */
   @Test
-  void testAddUser_fail() {
+  public void testAddUser_duplicateUsername_fail() {
     User duplicate = new User();
     duplicate.setUsername("user");
     duplicate.setEmail("test@email.com");
@@ -89,19 +157,117 @@ void testAddUser_fail() {
         .isInstanceOf(Exception.class);
   }
 
+  /**
+   * Tests database unique constraint enforcement on email.
+   *
+   * <p><strong>External Integration:</strong> Service → Database unique constraint violation
+   * handling (users_email_key constraint)
+   */
+  @Test
+  public void testAddUser_duplicateEmail_fail() {
+    User duplicate = new User();
+    duplicate.setUsername("differentUser");
+    duplicate.setEmail("user@email.com");  // Same email as setup user
+    duplicate.setBudget(10.0);
+
+    assertThatThrownBy(() -> service.addUser(duplicate))
+        .isInstanceOf(Exception.class);
+  }
+
+  /**
+   * Tests user deletion from database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database DELETE operation
+   * and verification that record no longer exists
+   */
   @Test
-  void testDeleteUser() {
+  public void testDeleteUser() {
     boolean deleted = service.deleteUser(userId);
     assertThat(deleted).isTrue();
     assertThat(service.getUser(userId)).isEmpty();
   }
 
-  // ---------------------
-  // TRANSACTION TESTS
-  // ---------------------
+  /**
+   * Tests deletion of non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service → Database DELETE returns 0 rows affected
+   */
+  @Test
+  public void testDeleteUser_notFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    boolean deleted = service.deleteUser(fakeId);
+
+    assertThat(deleted).isFalse();
+  }
+
+  // ===========================================================================
+  // TRANSACTION CRUD OPERATIONS - Testing Transaction table integration
+  // ===========================================================================
 
+  /**
+   * Tests retrieval of all transactions from the database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database SELECT query
+   * with ORDER BY clause
+   */
   @Test
-  void testAddTransaction_success() {
+  public void testViewAllTransactions() {
+    // Add transactions for test user
+    Transaction t1 = new Transaction(userId, 10.0, "FOOD", "first");
+    Transaction t2 = new Transaction(userId, 20.0, "OTHER", "second");
+    service.addTransaction(t1);
+    service.addTransaction(t2);
+
+    List<Transaction> all = service.viewAllTransactions();
+
+    assertThat(all).hasSizeGreaterThanOrEqualTo(2);
+    // Most recent should be first (ORDER BY created_time DESC)
+    assertThat(all.get(0).getDescription()).isEqualTo("second");
+  }
+
+  /**
+   * Tests retrieval of a specific transaction by ID.
+   *
+   * <p><strong>External Integration:</strong> Service → Database SELECT with WHERE clause
+   */
+  @Test
+  public void testGetTransaction_found() {
+    Transaction t = new Transaction(userId, 50.0, "FOOD", "specific transaction");
+    Transaction saved = service.addTransaction(t);
+
+    Optional<Transaction> found = service.getTransaction(saved.getTransactionId());
+
+    assertThat(found).isPresent();
+    assertThat(found.get().getDescription()).isEqualTo("specific transaction");
+  }
+
+  /**
+   * Tests retrieval of non-existent transaction.
+   *
+   * <p><strong>External Integration:</strong> Service → Database returns empty result
+   */
+  @Test
+  public void testGetTransaction_notFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    Optional<Transaction> found = service.getTransaction(fakeId);
+
+    assertThat(found).isEmpty();
+  }
+
+  /**
+   * Tests successful transaction creation with database-generated fields.
+   *
+   * <p><strong>External Integration:</strong>
+   * <ul>
+   *   <li>Service → Database INSERT with RETURNING clause</li>
+   *   <li>Database auto-generates: transaction_id, created_time, created_date</li>
+   *   <li>Tests PostgreSQL ENUM casting (::transaction_category)</li>
+   * </ul>
+   */
+  @Test
+  public void testAddTransaction_success() {
     Transaction t = new Transaction();
     t.setUserId(userId);
     t.setDescription("desc");
@@ -115,8 +281,14 @@ void testAddTransaction_success() {
     assertThat(saved.getTimestamp()).isNotNull();
   }
 
+  /**
+   * Tests application-level validation before database interaction.
+   *
+   * <p><strong>Internal Integration:</strong> Application validation layer preventing
+   * invalid data from reaching the database
+   */
   @Test
-  void testAddTransaction_negativeAmountInvalid() {
+  public void testAddTransaction_negativeAmountInvalid() {
     Transaction t = new Transaction();
     t.setUserId(userId);
     t.setDescription("desc");
@@ -128,8 +300,68 @@ void testAddTransaction_negativeAmountInvalid() {
         .hasMessageContaining("Amount must be greater than 0");
   }
 
+  /**
+   * Tests application-level validation for zero amount.
+   *
+   * <p><strong>Internal Integration:</strong> Application validation layer
+   */
   @Test
-  void testAddTransaction_categoryInvalid() {
+  public void testAddTransaction_zeroAmountInvalid() {
+    Transaction t = new Transaction();
+    t.setUserId(userId);
+    t.setDescription("desc");
+    t.setAmount(0.0);
+    t.setCategory("OTHER");
+
+    assertThatThrownBy(() -> service.addTransaction(t))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Amount must be greater than 0");
+  }
+
+  /**
+   * Tests application-level validation for null description.
+   *
+   * <p><strong>Internal Integration:</strong> Application validation layer
+   */
+  @Test
+  public void testAddTransaction_nullDescriptionInvalid() {
+    Transaction t = new Transaction();
+    t.setUserId(userId);
+    t.setDescription(null);
+    t.setAmount(10.0);
+    t.setCategory("OTHER");
+
+    assertThatThrownBy(() -> service.addTransaction(t))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Description is required");
+  }
+
+  /**
+   * Tests application-level validation for null category.
+   *
+   * <p><strong>Internal Integration:</strong> Application validation layer
+   */
+  @Test
+  public void testAddTransaction_nullCategoryInvalid() {
+    Transaction t = new Transaction();
+    t.setUserId(userId);
+    t.setDescription("desc");
+    t.setAmount(10.0);
+    t.setCategory(null);
+
+    assertThatThrownBy(() -> service.addTransaction(t))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Category is required");
+  }
+
+  /**
+   * Tests database ENUM constraint enforcement.
+   *
+   * <p><strong>External Integration:</strong> Application attempts invalid category,
+   * database ENUM type rejects it, application handles the error
+   */
+  @Test
+  public void testAddTransaction_categoryInvalid() {
     Transaction t = new Transaction();
     t.setUserId(userId);
     t.setDescription("desc");
@@ -141,8 +373,14 @@ void testAddTransaction_categoryInvalid() {
         .hasMessageContaining("Invalid category");
   }
 
+  /**
+   * Tests partial update of transaction record.
+   *
+   * <p><strong>External Integration:</strong> Service → Database UPDATE operation
+   * with selective field modification
+   */
   @Test
-  void testUpdateTransaction_success() {
+  public void testUpdateTransaction_success() {
     Transaction t = new Transaction(userId, 20.0, "OTHER", "desc");
     Transaction saved = service.addTransaction(t);
 
@@ -158,48 +396,591 @@ void testUpdateTransaction_success() {
     assertThat(updated.get().getDescription()).isEqualTo("updated");
   }
 
+  /**
+   * Tests update with category change.
+   *
+   * <p><strong>External Integration:</strong> Service → Database UPDATE with ENUM casting
+   */
+  @Test
+  public void testUpdateTransaction_categoryChange() {
+    Transaction t = new Transaction(userId, 20.0, "OTHER", "desc");
+    Transaction saved = service.addTransaction(t);
+
+    Map<String, Object> updates = Map.of("category", "FOOD");
+
+    Optional<Transaction> updated = service.updateTransaction(saved.getTransactionId(), updates);
+
+    assertThat(updated).isPresent();
+    assertThat(updated.get().getCategory()).isEqualTo("FOOD");
+  }
+
+  /**
+   * Tests update with invalid category.
+   *
+   * <p><strong>Internal Integration:</strong> Application validation rejects invalid category
+   */
+  @Test
+  public void testUpdateTransaction_invalidCategory() {
+    Transaction t = new Transaction(userId, 20.0, "OTHER", "desc");
+    Transaction saved = service.addTransaction(t);
+
+    Map<String, Object> updates = Map.of("category", "INVALID_CATEGORY");
+
+    assertThatThrownBy(() -> service.updateTransaction(saved.getTransactionId(), updates))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Invalid category");
+  }
+
+  /**
+   * Tests transaction deletion from database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database DELETE operation
+   */
   @Test
-  void testDeleteTransaction_success() {
+  public void testDeleteTransaction_success() {
     Transaction t = new Transaction(userId, 10.0, "OTHER", "desc");
     Transaction saved = service.addTransaction(t);
 
     boolean deleted = service.deleteTransaction(saved.getTransactionId());
     assertThat(deleted).isTrue();
+
+    // Verify actually deleted
+    assertThat(service.getTransaction(saved.getTransactionId())).isEmpty();
   }
 
-  // ---------------------
-  // ANALYTICS / REPORTS
-  // ---------------------
+  /**
+   * Tests deletion of non-existent transaction.
+   *
+   * <p><strong>External Integration:</strong> Service → Database DELETE returns 0 rows
+   */
+  @Test
+  public void testDeleteTransaction_notFound() {
+    UUID fakeId = UUID.randomUUID();
 
+    boolean deleted = service.deleteTransaction(fakeId);
+
+    assertThat(deleted).isFalse();
+  }
+
+  // ===========================================================================
+  // FOREIGN KEY RELATIONSHIP TESTS - Testing User-Transaction data sharing
+  // ===========================================================================
+
+  /**
+   * Tests that transactions cannot be created for non-existent users.
+   *
+   * <p><strong>External Integration:</strong> Database foreign key constraint enforcement
+   * between transactions.user_id and users.user_id
+   */
   @Test
-  void testGetBudgetsTextBlock_userFound() {
+  public void testAddTransaction_invalidUserId() {
+    UUID fakeUserId = UUID.randomUUID();
+    Transaction t = new Transaction(fakeUserId, 10.0, "OTHER", "desc");
+
+    assertThatThrownBy(() -> service.addTransaction(t))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Invalid user ID");
+  }
+
+  /**
+   * Tests cascade delete: deleting a user deletes their transactions.
+   *
+   * <p><strong>External Integration:</strong>
+   * <ul>
+   *   <li>User-Transaction foreign key with ON DELETE CASCADE</li>
+   *   <li>Database automatically removes child records</li>
+   *   <li>Service verifies cascaded deletion</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Transaction.userId references User.userId
+   */
+  @Test
+  public void testDeleteUser_cascadesTransactions() {
+    // Create transactions for user
+    Transaction t1 = new Transaction(userId, 10.0, "FOOD", "lunch");
+    Transaction t2 = new Transaction(userId, 20.0, "OTHER", "misc");
+    service.addTransaction(t1);
+    service.addTransaction(t2);
+
+    // Verify transactions exist
+    List<Transaction> before = service.getTransactionsByUser(userId);
+    assertThat(before).hasSize(2);
+
+    // Delete user
+    boolean deleted = service.deleteUser(userId);
+    assertThat(deleted).isTrue();
+
+    // Verify transactions were cascaded
+    List<Transaction> after = service.getTransactionsByUser(userId);
+    assertThat(after).isEmpty();
+  }
+
+  /**
+   * Tests retrieval of transactions filtered by user ID.
+   *
+   * <p><strong>External Integration:</strong> Service → Database query filtering
+   * by foreign key relationship
+   *
+   * <p><strong>Shared Data:</strong> Tests that transactions are correctly
+   * associated with their owning user via userId
+   */
+  @Test
+  public void testGetTransactionsByUser() {
+    // Create second user
+    User user2 = new User("user2", "user2@email.com", 200.0);
+    User savedUser2 = service.addUser(user2);
+
+    // Create transactions for both users
+    Transaction t1 = new Transaction(userId, 10.0, "FOOD", "user1-tx1");
+    Transaction t2 = new Transaction(userId, 15.0, "OTHER", "user1-tx2");
+    Transaction t3 = new Transaction(savedUser2.getUserId(), 30.0, "FOOD", "user2-tx1");
+
+    service.addTransaction(t1);
+    service.addTransaction(t2);
+    service.addTransaction(t3);
+
+    // Test user 1's transactions
+    List<Transaction> user1Txs = service.getTransactionsByUser(userId);
+    assertThat(user1Txs).hasSize(2);
+    assertThat(user1Txs).allMatch(tx -> tx.getUserId().equals(userId));
+
+    // Test user 2's transactions
+    List<Transaction> user2Txs = service.getTransactionsByUser(savedUser2.getUserId());
+    assertThat(user2Txs).hasSize(1);
+    assertThat(user2Txs.get(0).getDescription()).isEqualTo("user2-tx1");
+  }
+
+  // ===========================================================================
+  // ANALYTICS OPERATIONS - Testing complex database queries with aggregations
+  // ===========================================================================
+
+  /**
+   * Tests budget summary generation with SUM aggregation.
+   *
+   * <p><strong>Internal Integration:</strong>
+   * <ul>
+   *   <li>Service retrieves user from database</li>
+   *   <li>Service queries transactions with WHERE clause</li>
+   *   <li>Application calculates SUM</li>
+   *   <li>Combines data from both User and Transaction tables into summary</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Combines User.budget with Transaction.amount
+   */
+  @Test
+  public void testGetBudgetsTextBlock_userFound() {
     addSampleTransactions();
     String summary = service.getBudgetsTextBlock(userId);
     assertThat(summary).contains("Total Budget", "Total Spent", "Remaining");
   }
 
+  /**
+   * Tests error handling when querying non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service queries database for non-existent
+   * record and handles absence gracefully
+   */
   @Test
-  void testGetBudgetsTextBlock_userNotFound() {
+  public void testGetBudgetsTextBlock_userNotFound() {
     UUID fakeId = UUID.randomUUID();
     String summary = service.getBudgetsTextBlock(fakeId);
     assertThat(summary).contains("User not found");
   }
 
+  /**
+   * Tests budget warning generation for over-budget user.
+   *
+   * <p><strong>Internal Integration:</strong>
+   * <ul>
+   *   <li>Service retrieves user from database</li>
+   *   <li>Service retrieves transactions and calculates totals</li>
+   *   <li>Business logic generates warning messages</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Compares User.budget with sum of Transaction.amount
+   */
+  @Test
+  public void testGetBudgetWarningsText_overBudget() {
+    // Create transactions exceeding the 100.0 budget
+    Transaction t1 = new Transaction(userId, 80.0, "FOOD", "big expense");
+    Transaction t2 = new Transaction(userId, 50.0, "OTHER", "another expense");
+    service.addTransaction(t1);
+    service.addTransaction(t2);
+
+    String warnings = service.getBudgetWarningsText(userId);
+
+    assertThat(warnings).contains("OVER BUDGET");
+  }
+
+  /**
+   * Tests budget warning generation for near-budget user.
+   *
+   * <p><strong>Internal Integration:</strong> Business logic detects less than 10% remaining
+   *
+   * <p><strong>Shared Data:</strong> User.budget compared with Transaction totals
+   */
+  @Test
+  public void testGetBudgetWarningsText_nearBudget() {
+    // Spend 95 of 100 budget (5% remaining, which is < 10%)
+    Transaction t = new Transaction(userId, 95.0, "FOOD", "big expense");
+    service.addTransaction(t);
+
+    String warnings = service.getBudgetWarningsText(userId);
+
+    assertThat(warnings).contains("Budget warning");
+  }
+
+  /**
+   * Tests budget warning generation for healthy budget.
+   *
+   * <p><strong>Internal Integration:</strong> No warnings when budget is healthy
+   */
+  @Test
+  public void testGetBudgetWarningsText_healthy() {
+    // Spend only 10 of 100 budget (90% remaining)
+    Transaction t = new Transaction(userId, 10.0, "FOOD", "small expense");
+    service.addTransaction(t);
+
+    String warnings = service.getBudgetWarningsText(userId);
+
+    assertThat(warnings).isEmpty();
+  }
+
+  /**
+   * Tests budget warning for non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service handles missing user gracefully
+   */
+  @Test
+  public void testGetBudgetWarningsText_userNotFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    String warnings = service.getBudgetWarningsText(fakeId);
+
+    assertThat(warnings).contains("User not found");
+  }
+
+  /**
+   * Tests budget update operation.
+   *
+   * <p><strong>External Integration:</strong> Service → Database UPDATE operation
+   * with validation
+   */
   @Test
-  void testSetBudgets_success() {
+  public void testSetBudgets_success() {
     service.setBudgets(userId, Map.of("budget", 200.0));
     Optional<User> updated = service.getUser(userId);
     assertThat(updated).isPresent();
     assertThat(updated.get().getBudget()).isEqualTo(200.0);
   }
 
+  /**
+   * Tests budget validation before database update.
+   *
+   * <p><strong>Internal Integration:</strong> Application validates data before
+   * sending to database
+   */
   @Test
-  void testSetBudgets_invalidBudget() {
+  public void testSetBudgets_invalidBudget() {
     assertThatThrownBy(() -> service.setBudgets(userId, Map.of("budget", -10)))
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessageContaining("Budget cannot be negative");
   }
 
+  /**
+   * Tests budget update for non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service validates user exists before update
+   */
+  @Test
+  public void testSetBudgets_userNotFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    assertThatThrownBy(() -> service.setBudgets(fakeId, Map.of("budget", 100.0)))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("User not found");
+  }
+
+  /**
+   * Tests weekly summary with date-based filtering.
+   *
+   * <p><strong>External Integration:</strong>
+   * <ul>
+   *   <li>Service → Database query with date comparison (created_date >= ?)</li>
+   *   <li>Tests PostgreSQL date arithmetic</li>
+   *   <li>Verifies ORDER BY clause works correctly</li>
+   * </ul>
+   */
+  @Test
+  public void testWeeklySummary() {
+    addSampleTransactions();
+    List<Transaction> weekly = service.weeklySummary(userId);
+    assertThat(weekly).hasSize(3);
+  }
+
+  /**
+   * Tests weekly summary for user with no transactions.
+   *
+   * <p><strong>External Integration:</strong> Database returns empty result set
+   */
+  @Test
+  public void testWeeklySummary_noTransactions() {
+    List<Transaction> weekly = service.weeklySummary(userId);
+    assertThat(weekly).isEmpty();
+  }
+
+  /**
+   * Tests aggregate SUM calculation with date filtering.
+   *
+   * <p><strong>External Integration:</strong> Service → Database aggregate query
+   * (SUM with WHERE clause and date comparison)
+   */
+  @Test
+  public void testTotalLast7Days() {
+    addSampleTransactions();
+    double total = service.totalLast7Days(userId);
+    assertThat(total).isEqualTo(26.0); // 10 + 1 + 15
+  }
+
+  /**
+   * Tests total calculation when no transactions exist.
+   *
+   * <p><strong>External Integration:</strong> Database COALESCE returns 0 for null SUM
+   */
+  @Test
+  public void testTotalLast7Days_noTransactions() {
+    double total = service.totalLast7Days(userId);
+    assertThat(total).isEqualTo(0.0);
+  }
+
+  /**
+   * Tests monthly summary with date filtering and grouping.
+   *
+   * <p><strong>Internal Integration:</strong>
+   * <ul>
+   *   <li>Service queries transactions from database</li>
+   *   <li>Filters by current month/year</li>
+   *   <li>Groups by category (using Java streams)</li>
+   *   <li>Calculates totals per category</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Combines User.budget with grouped Transaction data
+   */
+  @Test
+  public void testGetMonthlySummary() {
+    addSampleTransactions();
+    String summary = service.getMonthlySummary(userId);
+    assertThat(summary)
+        .contains("Total Budget")
+        .contains("Total Spent")
+        .contains("Spending by Category");
+  }
+
+  /**
+   * Tests monthly summary for non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service handles missing user gracefully
+   */
+  @Test
+  public void testGetMonthlySummary_userNotFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    String summary = service.getMonthlySummary(fakeId);
+
+    assertThat(summary).contains("User not found");
+  }
+
+  /**
+   * Tests comprehensive budget report generation.
+   *
+   * <p><strong>Internal Integration:</strong>
+   * <ul>
+   *   <li>Retrieves user data from database</li>
+   *   <li>Retrieves all user transactions</li>
+   *   <li>Performs aggregations (SUM, GROUP BY category)</li>
+   *   <li>Combines multiple queries into single report</li>
+   *   <li>Applies business logic (warnings, thresholds)</li>
+   *   <li>Calls getBudgetWarningsText internally</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Comprehensive integration of User and Transaction data
+   */
+  @Test
+  public void testGetBudgetReport() {
+    addSampleTransactions();
+    Map<String, Object> report = service.getBudgetReport(userId);
+
+    assertThat(report).containsKeys(
+        "userId", "username", "totalBudget", "totalSpent",
+        "remaining", "categories", "isOverBudget", "warnings"
+    );
+    assertThat(report.get("totalSpent")).isEqualTo(26.0);
+  }
+
+  /**
+   * Tests budget report for non-existent user.
+   *
+   * <p><strong>External Integration:</strong> Service returns error map for missing user
+   */
+  @Test
+  public void testGetBudgetReport_userNotFound() {
+    UUID fakeId = UUID.randomUUID();
+
+    Map<String, Object> report = service.getBudgetReport(fakeId);
+
+    assertThat(report).containsKey("error");
+    assertThat(report.get("error")).isEqualTo("User not found");
+  }
+
+  /**
+   * Tests budget report with over-budget status.
+   *
+   * <p><strong>Internal Integration:</strong> Business logic correctly sets isOverBudget flag
+   *
+   * <p><strong>Shared Data:</strong> Compares User.budget (100) with Transaction totals (130)
+   */
+  @Test
+  public void testGetBudgetReport_overBudget() {
+    Transaction t1 = new Transaction(userId, 80.0, "FOOD", "big expense");
+    Transaction t2 = new Transaction(userId, 50.0, "OTHER", "another expense");
+    service.addTransaction(t1);
+    service.addTransaction(t2);
+
+    Map<String, Object> report = service.getBudgetReport(userId);
+
+    assertThat(report.get("totalSpent")).isEqualTo(130.0);
+    assertThat(report.get("remaining")).isEqualTo(-30.0);
+    assertThat(report.get("isOverBudget")).isEqualTo(true);
+    assertThat(report.get("hasWarnings")).isEqualTo(true);
+  }
+
+  // ===========================================================================
+  // UNIQUE CONSTRAINT VALIDATION - Testing database constraint checks
+  // ===========================================================================
+
+  /**
+   * Tests username uniqueness check against database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT query
+   * to check for existing username
+   */
+  @Test
+  public void testIsUsernameExists_existing() {
+    boolean exists = service.isUsernameExists("user", null);
+    assertThat(exists).isTrue();
+  }
+
+  /**
+   * Tests username check for non-existent username.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT returns 0
+   */
+  @Test
+  public void testIsUsernameExists_notExisting() {
+    boolean exists = service.isUsernameExists("nonexistent", null);
+    assertThat(exists).isFalse();
+  }
+
+  /**
+   * Tests username uniqueness check with exclusion.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT query
+   * with compound WHERE clause (username = ? AND user_id != ?)
+   */
+  @Test
+  public void testIsUsernameExists_excludingSelf() {
+    boolean exists = service.isUsernameExists("user", userId);
+    assertThat(exists).isFalse(); // Excludes self, so not considered duplicate
+  }
+
+  /**
+   * Tests email uniqueness check against database.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT query
+   * to check for existing email
+   */
+  @Test
+  public void testIsEmailExists_existing() {
+    boolean exists = service.isEmailExists("user@email.com", null);
+    assertThat(exists).isTrue();
+  }
+
+  /**
+   * Tests email check for non-existent email.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT returns 0
+   */
+  @Test
+  public void testIsEmailExists_notExisting() {
+    boolean exists = service.isEmailExists("nonexistent@email.com", null);
+    assertThat(exists).isFalse();
+  }
+
+  /**
+   * Tests email uniqueness check with exclusion.
+   *
+   * <p><strong>External Integration:</strong> Service → Database COUNT query
+   * with compound WHERE clause
+   */
+  @Test
+  public void testIsEmailExists_excludingSelf() {
+    boolean exists = service.isEmailExists("user@email.com", userId);
+    assertThat(exists).isFalse();
+  }
+
+  // ===========================================================================
+  // TIMESTAMP AND DATE HANDLING - Testing database triggers and defaults
+  // ===========================================================================
+
+  /**
+   * Tests that database automatically generates timestamps and dates.
+   *
+   * <p><strong>External Integration:</strong>
+   * <ul>
+   *   <li>Database trigger sets created_time to CURRENT_TIMESTAMP</li>
+   *   <li>Database trigger sets created_date to CURRENT_DATE</li>
+   *   <li>Service retrieves and maps these values correctly</li>
+   * </ul>
+   */
+  @Test
+  public void testTransactionTimestampGeneration() {
+    Transaction t = new Transaction(userId, 50.0, "FOOD", "test");
+
+    // Don't set timestamp or date manually
+    Transaction saved = service.addTransaction(t);
+
+    // Verify database populated these fields
+    assertThat(saved.getTimestamp()).isNotNull();
+    assertThat(saved.getDate()).isNotNull();
+    assertThat(saved.getDate()).isEqualTo(LocalDate.now());
+  }
+
+  /**
+   * Tests that transaction ID is generated by database.
+   *
+   * <p><strong>External Integration:</strong> Database generates UUID via gen_random_uuid()
+   */
+  @Test
+  public void testTransactionIdGeneration() {
+    Transaction t = new Transaction(userId, 25.0, "OTHER", "test id generation");
+
+    // Transaction ID should be null before save
+    assertThat(t.getTransactionId()).isNull();
+
+    Transaction saved = service.addTransaction(t);
+
+    // Database should have generated the ID
+    assertThat(saved.getTransactionId()).isNotNull();
+  }
+
+  // ===========================================================================
+  // Helper Methods
+  // ===========================================================================
+
+  /**
+   * Helper method to create sample transactions for testing.
+   * Reduces code duplication across tests.
+   */
   private void addSampleTransactions() {
     Transaction t1 = new Transaction(userId, 10.0, "OTHER", "desc1");
     Transaction t2 = new Transaction(userId, 1.0, "FOOD", "desc2");
@@ -208,4 +989,4 @@ private void addSampleTransactions() {
     service.addTransaction(t2);
     service.addTransaction(t3);
   }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/MockApiServiceTests.java b/src/test/java/dev/ase/teamproject/MockApiServiceTests.java
index d3b3f7f..aff5494 100644
--- a/src/test/java/dev/ase/teamproject/MockApiServiceTests.java
+++ b/src/test/java/dev/ase/teamproject/MockApiServiceTests.java
@@ -6,14 +6,13 @@
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.DynamicTest.dynamicTest;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyDouble;
 import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.endsWith;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -25,6 +24,7 @@
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -35,11 +35,183 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
 
 /**
- * This class contains the unit tests for the MockApiService class.
+ * Unit tests for the {@link MockApiService} class.
+ *
+ * <p>This test suite validates all public methods of the MockApiService,
+ * covering valid and invalid equivalence partitions including boundary values.
+ * Tests use Mockito to mock the JdbcTemplate dependency and share common setup
+ * through {@code @BeforeEach}.
+ *
+ * <h2>Equivalence Partitions by Method</h2>
+ *
+ * <h3>1. viewAllUsers()</h3>
+ * <ul>
+ *   <li>P1: (Valid) Multiple users exist - returns list of users</li>
+ *   <li>P2: (Valid/Boundary) No users exist - returns empty list</li>
+ *   <li>P3: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>2. getUser(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns Optional with user</li>
+ *   <li>P2: (Valid) User does not exist - returns empty Optional</li>
+ *   <li>P3: (Invalid) Database error - returns empty Optional</li>
+ * </ul>
+ *
+ * <h3>3. addUser(User)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User without userId - generates new UUID</li>
+ *   <li>P2: (Valid) User with existing userId - uses provided UUID</li>
+ *   <li>P3: (Invalid) Database returns null - user has null ID</li>
+ *   <li>P4: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>4. deleteUser(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns true</li>
+ *   <li>P2: (Valid) User does not exist - returns false</li>
+ *   <li>P3: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>5. viewAllTransactions()</h3>
+ * <ul>
+ *   <li>P1: (Valid) Transactions exist - returns list</li>
+ *   <li>P2: (Valid/Boundary) No transactions - returns empty list</li>
+ *   <li>P3: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>6. getTransaction(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Transaction exists - returns Optional with transaction</li>
+ *   <li>P2: (Valid) Transaction not found - returns empty Optional</li>
+ *   <li>P3: (Invalid) Database error - returns empty Optional</li>
+ * </ul>
+ *
+ * <h3>7. addTransaction(Transaction)</h3>
+ * <ul>
+ *   <li>P1: (Valid) All fields valid - returns saved transaction</li>
+ *   <li>P2: (Valid/Edge) DB returns null - returns original transaction</li>
+ *   <li>P3: (Invalid) Null userId - throws IllegalArgumentException</li>
+ *   <li>P4: (Invalid) Null description - throws IllegalArgumentException</li>
+ *   <li>P5: (Invalid) Blank description - throws IllegalArgumentException</li>
+ *   <li>P6: (Invalid) Amount zero - throws IllegalArgumentException</li>
+ *   <li>P7: (Invalid) Amount negative - throws IllegalArgumentException</li>
+ *   <li>P8: (Invalid) Null category - throws IllegalArgumentException</li>
+ *   <li>P9: (Invalid) Blank category - throws IllegalArgumentException</li>
+ *   <li>P10: (Invalid) Foreign key violation - throws IllegalArgumentException</li>
+ *   <li>P11: (Invalid) Invalid category enum - throws IllegalArgumentException</li>
+ *   <li>P12: (Invalid) General database error - throws IllegalStateException</li>
+ * </ul>
+ *
+ * <h3>8. getTransactionsByUser(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User has transactions - returns list</li>
+ *   <li>P2: (Valid/Boundary) User has no transactions - returns empty list</li>
+ *   <li>P3: (Invalid) Database error - throws IllegalStateException</li>
+ * </ul>
+ *
+ * <h3>9. updateTransaction(UUID, Map)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid updates - returns updated transaction</li>
+ *   <li>P2: (Valid) Amount as Number - updates correctly</li>
+ *   <li>P3: (Invalid) Transaction not found - throws IllegalArgumentException</li>
+ *   <li>P4: (Invalid) Empty updates map - throws IllegalArgumentException</li>
+ *   <li>P5: (Invalid) Description not string - throws IllegalArgumentException</li>
+ *   <li>P6: (Invalid) Blank description - throws IllegalArgumentException</li>
+ *   <li>P7: (Invalid) Amount not number/string - throws IllegalArgumentException</li>
+ *   <li>P8: (Invalid) Amount invalid string - throws IllegalArgumentException</li>
+ *   <li>P9: (Invalid) Amount zero or negative - throws IllegalArgumentException</li>
+ *   <li>P10: (Invalid) Category not string - throws IllegalArgumentException</li>
+ *   <li>P11: (Invalid) Blank category - throws IllegalArgumentException</li>
+ *   <li>P12: (Invalid) Invalid category value - throws IllegalArgumentException</li>
+ *   <li>P13: (Invalid) DB category enum error - throws IllegalArgumentException</li>
+ *   <li>P14: (Invalid) Update fails (0 rows) - throws IllegalStateException</li>
+ * </ul>
+ *
+ * <h3>10. deleteTransaction(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Transaction exists - returns true</li>
+ *   <li>P2: (Valid) Transaction not found - returns false</li>
+ *   <li>P3: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>11. getBudgetsTextBlock(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User found with transactions - returns summary</li>
+ *   <li>P2: (Valid) User found, no transactions - shows zero spent</li>
+ *   <li>P3: (Invalid) User not found - returns "User not found"</li>
+ * </ul>
+ *
+ * <h3>12. getBudgetWarningsText(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User near budget limit (&lt;10% remaining) - returns warning</li>
+ *   <li>P2: (Valid) User over budget - returns over budget warning</li>
+ *   <li>P3: (Valid) User has healthy budget (&gt;10% remaining) - returns empty</li>
+ *   <li>P4: (Invalid) User not found - returns "User not found"</li>
+ * </ul>
+ *
+ * <h3>13. getMonthlySummary(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User with current month transactions - returns summary</li>
+ *   <li>P2: (Valid/Edge) Transactions with null dates - ignored in summary</li>
+ *   <li>P3: (Invalid) User not found - returns "User not found"</li>
+ * </ul>
+ *
+ * <h3>14. getBudgetReport(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User found - returns complete report map</li>
+ *   <li>P2: (Valid) User over budget - report shows warnings</li>
+ *   <li>P3: (Invalid) User not found - returns error map</li>
+ * </ul>
+ *
+ * <h3>15. setBudgets(UUID, Map)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Budget as Number - updates successfully</li>
+ *   <li>P2: (Valid) Budget as String - parses and updates</li>
+ *   <li>P3: (Valid/Boundary) Budget is zero - updates successfully</li>
+ *   <li>P4: (Invalid) User not found - throws IllegalArgumentException</li>
+ *   <li>P5: (Invalid) Invalid budget format - throws IllegalArgumentException</li>
+ *   <li>P6: (Invalid) Negative budget - throws IllegalArgumentException</li>
+ *   <li>P7: (Valid/Edge) No budget key in map - no update performed</li>
+ * </ul>
+ *
+ * <h3>16. weeklySummary(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User has recent transactions - returns list</li>
+ *   <li>P2: (Valid/Boundary) No transactions in week - returns empty list</li>
+ *   <li>P3: (Invalid) Database error - throws exception</li>
+ * </ul>
+ *
+ * <h3>17. totalLast7Days(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Transactions exist - returns sum</li>
+ *   <li>P2: (Valid/Boundary) No transactions - returns 0.0</li>
+ *   <li>P3: (Valid/Edge) Database returns null - returns 0.0</li>
+ *   <li>P4: (Invalid) Database error - returns 0.0</li>
+ * </ul>
+ *
+ * <h3>18. isUsernameExists(String, UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Username exists (no exclusion) - returns true</li>
+ *   <li>P2: (Valid) Username does not exist - returns false</li>
+ *   <li>P3: (Valid) Username exists but excluded - returns false</li>
+ *   <li>P4: (Valid) Username exists for other user - returns true</li>
+ *   <li>P5: (Valid/Edge) Count is null - returns false</li>
+ * </ul>
+ *
+ * <h3>19. isEmailExists(String, UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Email exists (no exclusion) - returns true</li>
+ *   <li>P2: (Valid) Email does not exist - returns false</li>
+ *   <li>P3: (Valid) Email exists but excluded - returns false</li>
+ *   <li>P4: (Valid) Email exists for other user - returns true</li>
+ *   <li>P5: (Valid/Edge) Count is null - returns false</li>
+ * </ul>
  */
 public class MockApiServiceTests {
 
@@ -56,171 +228,244 @@ public class MockApiServiceTests {
 
   /**
    * Initializes mock objects and sets up test data before each test run.
+   * Creates a default user and transaction for use in tests.
    */
   @BeforeEach
   public void setUp() {
-    user = new User();
-    userId = user.getUserId();
-    transaction = new Transaction(
-      userId, 
-      10.0, 
-      "category", 
-      "description");
-    transactionId = transaction.getTransactionId();
     MockitoAnnotations.openMocks(this);
+    user = new User();
+    userId = UUID.randomUUID();
+    user.setUserId(userId);
+    transaction = new Transaction(userId, 10.0, "FOOD", "description");
+    transactionId = UUID.randomUUID();
+    transaction.setTransactionId(transactionId);
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // viewAllUsers
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
+  /**
+   * Tests viewAllUsers when multiple users exist.
+   *
+   * <p>Partition: P1 (Valid) - Multiple users exist.
+   */
   @Test
   public void viewAllUsers_twoUsersExist_returnsListOfTwo() {
     List<User> users = List.of(new User(), new User());
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any()))
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<User>>any()))
         .thenReturn(users);
-    List<User> test = service.viewAllUsers();
-    assertEquals(2, test.size());
+
+    List<User> result = service.viewAllUsers();
+
+    assertEquals(2, result.size());
   }
 
+  /**
+   * Tests viewAllUsers when no users exist.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No users exist.
+   */
   @Test
   public void viewAllUsers_noUsersExist_returnsEmptyList() {
-    List<User> users = List.of();
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any()))
-        .thenReturn(users);
-    List<User> test = service.viewAllUsers();
-    assertEquals(0, test.size());
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<User>>any()))
+        .thenReturn(List.of());
+
+    List<User> result = service.viewAllUsers();
+
+    assertEquals(0, result.size());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // getUser
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests getUser when user exists.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
+   */
   @Test
   public void getUser_userExists_returnsUser() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
         .thenReturn(user);
+
+    Optional<User> result = service.getUser(userId);
+
+    assertTrue(result.isPresent());
+    assertEquals(userId, result.get().getUserId());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests getUser when user does not exist.
+   *
+   * <p>Partition: P2 (Valid) - User does not exist.
+   */
   @Test
   public void getUser_userDoesNotExist_returnsEmptyOptional() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
         .thenReturn(null);
 
-    Optional<User> test = service.getUser(userId);
-    assertTrue(test.isEmpty());
+    Optional<User> result = service.getUser(userId);
+
+    assertTrue(result.isEmpty());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests getUser when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void getUser_invalid_throwsExceptionReturnsEmpty() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
+  public void getUser_databaseError_returnsEmptyOptional() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
         .thenThrow(new RuntimeException("DB error"));
+
     Optional<User> result = service.getUser(userId);
+
     assertFalse(result.isPresent());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // addUser
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+
+  /**
+   * Tests addUser with user that has no userId (generates new UUID).
+   *
+   * <p>Partition: P1 (Valid) - User without userId.
+   */
+  @Test
+  public void addUser_noUserId_returnsUserWithGeneratedId() {
+    User newUser = new User();
+    newUser.setUsername("testuser");
+    newUser.setEmail("test@example.com");
+    newUser.setBudget(100.0);
+    UUID generatedId = UUID.randomUUID();
+
+    when(jdbcTemplate.queryForObject(anyString(), eq(UUID.class), anyString(), anyString(),
+        anyDouble()))
+        .thenReturn(generatedId);
+
+    User result = service.addUser(newUser);
+
+    assertEquals(generatedId, result.getUserId());
+  }
 
-  /** Typical valid input. */
+  /**
+   * Tests addUser with user that already has a userId.
+   *
+   * <p>Partition: P2 (Valid) - User with existing userId.
+   */
   @Test
-  public void addUser_validInput_returnsUserWithGeneratedId() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      eq(UUID.class), 
-      anyString(), 
-      anyString(), 
-      anyDouble()))
-        .thenReturn(userId);
+  public void addUser_withExistingUserId_usesProvidedId() {
+    UUID existingId = UUID.randomUUID();
+    User newUser = new User();
+    newUser.setUserId(existingId);
+    newUser.setUsername("testuser");
+    newUser.setEmail("test@example.com");
+    newUser.setBudget(100.0);
+
+    when(jdbcTemplate.update(anyString(), eq(existingId), anyString(), anyString(), anyDouble()))
+        .thenReturn(1);
 
-    User test = service.addUser(user);
-    assertEquals(userId, test.getUserId());
+    User result = service.addUser(newUser);
+
+    assertEquals(existingId, result.getUserId());
+    verify(jdbcTemplate).update(anyString(), eq(existingId), anyString(), anyString(), anyDouble());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests addUser when database returns null UUID.
+   *
+   * <p>Partition: P3 (Invalid) - Database returns null.
+   */
   @Test
-  public void addUser_atypical_returnsUserWithNullId() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      eq(UUID.class),
-      anyString(), 
-      anyString(), 
-      anyDouble()))
+  public void addUser_databaseReturnsNull_userHasNullId() {
+    User newUser = new User();
+    when(jdbcTemplate.queryForObject(anyString(), eq(UUID.class), nullable(String.class),
+        nullable(String.class), anyDouble()))
         .thenReturn(null);
-    User test = service.addUser(user);
-    assertNull(test.getUserId());
+
+    User result = service.addUser(newUser);
+
+    assertNull(result.getUserId());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests addUser when database throws exception.
+   *
+   * <p>Partition: P4 (Invalid) - Database error.
+   */
   @Test
-  public void addUser_invalid_throwsException() {
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        eq(UUID.class),
-        nullable(String.class),
-        nullable(String.class),
-        anyDouble()
-    )).thenThrow(new RuntimeException("DB error"));
+  public void addUser_databaseError_throwsException() {
+    User newUser = new User();
+    when(jdbcTemplate.queryForObject(anyString(), eq(UUID.class), nullable(String.class),
+        nullable(String.class), anyDouble()))
+        .thenThrow(new RuntimeException("DB error"));
 
-    assertThrows(RuntimeException.class, () -> service.addUser(user));
+    assertThrows(RuntimeException.class, () -> service.addUser(newUser));
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // deleteUser
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests deleteUser when user exists.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
+   */
   @Test
   public void deleteUser_userExists_returnsTrue() {
-    when(jdbcTemplate.update(anyString(), eq(userId)))
-        .thenReturn(1);
+    when(jdbcTemplate.update(anyString(), eq(userId))).thenReturn(1);
+
     boolean result = service.deleteUser(userId);
+
     assertTrue(result);
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests deleteUser when user does not exist.
+   *
+   * <p>Partition: P2 (Valid) - User does not exist.
+   */
   @Test
   public void deleteUser_userDoesNotExist_returnsFalse() {
-    when(jdbcTemplate.update(anyString(), eq(userId)))
-        .thenReturn(0);
+    when(jdbcTemplate.update(anyString(), eq(userId))).thenReturn(0);
+
     boolean result = service.deleteUser(userId);
+
     assertFalse(result);
   }
 
-  /** Invalid input. */
+  /**
+   * Tests deleteUser when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void deleteUser_invalid_throwsRuntimeException() {
+  public void deleteUser_databaseError_throwsException() {
     when(jdbcTemplate.update(anyString(), eq(userId)))
         .thenThrow(new RuntimeException("DB error"));
-    assertThrows(RuntimeException.class, () -> {
-      service.deleteUser(userId);
-    });
+
+    assertThrows(RuntimeException.class, () -> service.deleteUser(userId));
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // viewAllTransactions
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests viewAllTransactions when transactions exist.
+   *
+   * <p>Partition: P1 (Valid) - Transactions exist.
+   */
   @Test
-  public void viewAllTransactions_typical_returnsTransactionList() {
+  public void viewAllTransactions_transactionsExist_returnsList() {
     Transaction t1 = new Transaction(userId, 50.0, "FOOD", "Lunch");
     Transaction t2 = new Transaction(userId, 120.0, "SHOPPING", "Shoes");
     List<Transaction> mockTransactions = List.of(t1, t2);
@@ -235,7 +480,11 @@ public void viewAllTransactions_typical_returnsTransactionList() {
     assertEquals("FOOD", result.get(0).getCategory());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests viewAllTransactions when no transactions exist.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions.
+   */
   @Test
   public void viewAllTransactions_noTransactions_returnsEmptyList() {
     when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any()))
@@ -247,28 +496,34 @@ public void viewAllTransactions_noTransactions_returnsEmptyList() {
     assertTrue(result.isEmpty());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests viewAllTransactions when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void viewAllTransactions_queryFails_throwsRuntimeException() {
+  public void viewAllTransactions_databaseError_throwsException() {
     when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any()))
         .thenThrow(new RuntimeException("Error"));
 
-    assertThrows(RuntimeException.class, () -> {
-      service.viewAllTransactions();
-    });
+    assertThrows(RuntimeException.class, () -> service.viewAllTransactions());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // getTransaction
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests getTransaction when transaction exists.
+   *
+   * <p>Partition: P1 (Valid) - Transaction exists.
+   */
   @Test
   public void getTransaction_transactionExists_returnsOptionalWithTransaction() {
-    Transaction transaction = new Transaction(userId, 45.0, "FOOD", "Dinner");
-    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers
-        .<RowMapper<Transaction>>any(), eq(transactionId)))
-        .thenReturn(transaction);
+    Transaction tx = new Transaction(userId, 45.0, "FOOD", "Dinner");
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId)))
+        .thenReturn(tx);
 
     Optional<Transaction> result = service.getTransaction(transactionId);
 
@@ -277,100 +532,57 @@ public void getTransaction_transactionExists_returnsOptionalWithTransaction() {
     assertEquals(45.0, result.get().getAmount());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests getTransaction when transaction not found.
+   *
+   * <p>Partition: P2 (Valid) - Transaction not found.
+   */
   @Test
   public void getTransaction_transactionNotFound_returnsEmptyOptional() {
-    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers
-        .<RowMapper<Transaction>>any(), eq(transactionId)))
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId)))
         .thenReturn(null);
 
     Optional<Transaction> result = service.getTransaction(transactionId);
+
     assertFalse(result.isPresent());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests getTransaction when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void getTransaction_queryFails_returnsEmptyOptional() {
-    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers
-        .<RowMapper<Transaction>>any(), eq(transactionId)))
+  public void getTransaction_databaseError_returnsEmptyOptional() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId)))
         .thenThrow(new RuntimeException("Error"));
 
     Optional<Transaction> result = service.getTransaction(transactionId);
-    assertFalse(result.isPresent());
-  }
-
-
-  // ---------------------------------------------------------------------------
-  // getTransactionsByUser
-  // ---------------------------------------------------------------------------
-
-  /** Typical valid input. */
-  @Test
-  public void getTransactionsByUser_typical_returnsTransactionList() {
-    Transaction t1 = new Transaction(userId, 25.0, "category1", "desc1");
-    Transaction t2 = new Transaction(userId, 10.0, "category2", "desc2");
-    List<Transaction> transactions = List.of(t1, t2);
-
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId)))
-        .thenReturn(transactions);
-
-    List<Transaction> test = service.getTransactionsByUser(userId);
-    assertEquals(2, test.size());
-    assertEquals("category1", test.get(0).getCategory());
-  }
-
-  /** Atypical valid input. */
-  @Test
-  public void getTransactionsByUser_atypical_returnsEmptyList() {
-    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<User>>any(), eq(userId)))
-        .thenReturn(List.of());
-
-    List<Transaction> result = service.getTransactionsByUser(userId);
-    assertTrue(result.isEmpty());
-  }
-
-  /** Invalid input. */
-  @Test
-  public void getTransactionsByUser_queryFails_throwsRuntimeException() {
-    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<User>>any(), eq(userId)))
-        .thenThrow(new RuntimeException("Error"));
-    RuntimeException exception = assertThrows(RuntimeException.class, () -> {
-      service.getTransactionsByUser(userId);
-    });
-    
-    assertTrue(exception.getMessage().contains("Failed to get transactions: "));
-    assertTrue(exception.getMessage().contains("Error"));
 
+    assertFalse(result.isPresent());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // addTransaction
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests addTransaction with all valid fields.
+   *
+   * <p>Partition: P1 (Valid) - All fields valid.
+   */
   @Test
   public void addTransaction_validTransaction_returnsSavedTransaction() {
     UUID validUserId = UUID.randomUUID();
-    Transaction tx = new Transaction(
-        validUserId,
-        10.0,
-        "FOOD",              // valid category
-        "description"
-    );
+    Transaction tx = new Transaction(validUserId, 10.0, "FOOD", "description");
     UUID txId = UUID.randomUUID();
     LocalDateTime createdTime = LocalDateTime.of(2025, 10, 23, 12, 0);
     LocalDate createdDate = LocalDate.of(2025, 10, 23);
-  
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(tx.getUserId()),
-        eq(tx.getDescription()),
-        eq(tx.getAmount()),
-        eq(tx.getCategory())))
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(tx.getUserId()), eq(tx.getDescription()), eq(tx.getAmount()), eq(tx.getCategory())))
         .thenAnswer(invocation -> {
           var rs = mock(java.sql.ResultSet.class);
           when(rs.getObject("transaction_id", UUID.class)).thenReturn(txId);
@@ -379,606 +591,1052 @@ public void addTransaction_validTransaction_returnsSavedTransaction() {
           var rowMapper = invocation.getArgument(1);
           return ((RowMapper<Transaction>) rowMapper).mapRow(rs, 0);
         });
-  
+
     Transaction result = service.addTransaction(tx);
-  
+
     assertNotNull(result);
-    assertEquals(tx.getUserId(), result.getUserId());
-    assertEquals(tx.getDescription(), result.getDescription());
-    assertEquals(tx.getAmount(), result.getAmount());
-    assertEquals(tx.getCategory(), result.getCategory());
     assertEquals(txId, result.getTransactionId());
     assertEquals(createdTime, result.getTimestamp());
     assertEquals(createdDate, result.getDate());
   }
-  
 
-  /** Atypical valid input. */
+  /**
+   * Tests addTransaction when database returns null.
+   *
+   * <p>Partition: P2 (Valid/Edge) - DB returns null.
+   */
   @Test
-  public void addTransaction_atypical_returnsTransactionEvenIfNoRowsAffected() {
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        any(),
-        any(),
-        any(),
-        any()))
-        .thenReturn(null);
-  
-    // Use a valid userId and valid category so implementation passes validation
+  public void addTransaction_databaseReturnsNull_returnsOriginalTransaction() {
     UUID validUserId = UUID.randomUUID();
-    Transaction t = new Transaction(validUserId, 75.0, "TRANSPORTATION", "subway");
-  
-    Transaction result = service.addTransaction(t);
-  
-    // Implementation returns a fallback Transaction, not null
+    Transaction tx = new Transaction(validUserId, 75.0, "TRANSPORTATION", "subway");
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        any(), any(), any(), any()))
+        .thenReturn(null);
+
+    Transaction result = service.addTransaction(tx);
+
     assertNotNull(result);
     assertEquals(75.0, result.getAmount());
     assertEquals("TRANSPORTATION", result.getCategory());
-    assertEquals("subway", result.getDescription());
     assertNull(result.getTransactionId());
-    assertNull(result.getTimestamp());
-    assertNull(result.getDate());
-  }  
+  }
 
-  /** Invalid input. */
+  /**
+   * Tests addTransaction with null userId.
+   *
+   * <p>Partition: P3 (Invalid) - Null userId.
+   */
   @Test
-  public void addTransaction_failedTransaction_throwsRuntimeException() {
-    UUID validUserId = UUID.randomUUID();
-    Transaction tx = new Transaction(validUserId, 10.0, "FOOD", "description");
-  
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(tx.getUserId()),
-        eq(tx.getDescription()),
-        eq(tx.getAmount()),
-        eq(tx.getCategory())
-    )).thenThrow(new RuntimeException("DB insert error"));
-  
-    RuntimeException exception = assertThrows(RuntimeException.class, () -> {
-      service.addTransaction(tx);
-    });
-  
-    // Match the actual behavior
-    assertEquals("Failed to create transaction: DB insert error", exception.getMessage());
-    // Optional: check that original error is preserved as cause if your impl does that
-    // assertTrue(exception.getCause().getMessage().contains("DB insert error"));
-  }
-  
-  
-  // ---------------------------------------------------------------------------
-  // updateTransaction
-  // ---------------------------------------------------------------------------
+  public void addTransaction_nullUserId_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction(null, 10.0, "FOOD", "description");
 
-  /** Typical valid input. */
-  @Test
-  public void updateTransaction_validUpdates_returnsUpdatedTransaction() {
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenReturn(transaction);
-  
-    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId)))
-        .thenReturn(1);
-  
-    Transaction updatedTransaction = new Transaction();
-    updatedTransaction.setDescription("new description");
-    updatedTransaction.setAmount(7.0);
-    updatedTransaction.setCategory("OTHER");   // valid category
-  
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenReturn(updatedTransaction);
-    
-    Map<String, Object> updates = Map.of(
-        "description", "new description", 
-        "amount", "7.0", 
-        "category", "OTHER");    // valid
-  
-    Optional<Transaction> test = service.updateTransaction(transactionId, updates);
-  
-    assertTrue(test.isPresent());
-    assertEquals("new description", test.get().getDescription());
-    assertEquals(7.0, test.get().getAmount());
-    assertEquals("OTHER", test.get().getCategory());
-  }
-  
-  @Test
-  public void updateTransaction_amountIsNumeric_returnsUpdatedTransaction() {
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenReturn(transaction);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId)))
-        .thenReturn(1);
+    assertEquals("User ID is required", exception.getMessage());
+  }
 
-    Transaction updatedTransaction = new Transaction();
-    updatedTransaction.setAmount(7.0);
+  /**
+   * Tests addTransaction with null description.
+   *
+   * <p>Partition: P4 (Invalid) - Null description.
+   */
+  @Test
+  public void addTransaction_nullDescription_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction();
+    tx.setUserId(UUID.randomUUID());
+    tx.setAmount(10.0);
+    tx.setCategory("FOOD");
+    tx.setDescription(null);
 
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenReturn(updatedTransaction);
-    
-    Map<String, Object> updates = Map.of("amount", 7);
-    Optional<Transaction> test = service.updateTransaction(transactionId, updates);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    assertTrue(test.isPresent());
-    assertEquals(7.0, test.get().getAmount());
+    assertEquals("Description is required", exception.getMessage());
   }
 
-  /** Atypical valid input. */
-  @Test
-  public void updateTransaction_transactionNotFound_returnsEmptyOptional() {
-    Map<String, Object> updates = Map.of("key1", "key2");
-  
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenThrow(new RuntimeException("DB error"));
-  
-    IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> {
-      service.updateTransaction(transactionId, updates);
-    });
-  
-    assertTrue(ex.getMessage().contains("Transaction not found with ID"));
-  }
-  
-  /** Invalid input. */
+  /**
+   * Tests addTransaction with blank description.
+   *
+   * <p>Partition: P5 (Invalid) - Blank description.
+   */
   @Test
-  public void updateTransaction_updateFails_returnsEmptyOptional() {
-    Map<String, Object> updates = Map.of(
-        "description", "new description",
-        "amount", "7.0",
-        "category", "OTHER"   // valid category so we hit the "no rows" path
-    );
-  
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(transactionId))).thenReturn(transaction);
-  
-    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId)))
-        .thenReturn(0); // simulate no rows affected
-  
-    IllegalStateException ex = assertThrows(
-        IllegalStateException.class,
-        () -> service.updateTransaction(transactionId, updates)
-    );
-  
-    assertTrue(ex.getMessage().contains("Failed to update transaction"));
-  }
-  
-
-  // ---------------------------------------------------------------------------
-  // deleteTransaction
-  // ---------------------------------------------------------------------------
+  public void addTransaction_blankDescription_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction(UUID.randomUUID(), 10.0, "FOOD", "   ");
 
-  /** Typical valid input. */
-  @Test
-  public void deleteTransaction_transactionExists_returnsTrue() {
-    when(jdbcTemplate.update(anyString(), eq(transactionId)))
-        .thenReturn(1);
-    boolean test = service.deleteTransaction(transactionId);
-    assertTrue(test);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
+
+    assertEquals("Description is required", exception.getMessage());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests addTransaction with zero amount.
+   *
+   * <p>Partition: P6 (Invalid) - Amount zero.
+   */
   @Test
-  public void deleteTransaction_transactionDoesNotExist_returnsFalse() {
-    when(jdbcTemplate.update(anyString(), eq(transactionId)))
-        .thenReturn(0);
-    boolean test = service.deleteTransaction(transactionId);
-    assertFalse(test);
+  public void addTransaction_zeroAmount_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction(UUID.randomUUID(), 0.0, "FOOD", "description");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
+
+    assertEquals("Amount must be greater than 0", exception.getMessage());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests addTransaction with negative amount.
+   *
+   * <p>Partition: P7 (Invalid) - Amount negative.
+   */
   @Test
-  public void deleteTransaction_invalid_throwsRuntimeException() {
-    when(jdbcTemplate.update(anyString(), eq(transactionId)))
-        .thenThrow(new RuntimeException("DB error"));
-    assertThrows(RuntimeException.class, () -> service.deleteTransaction(transactionId));
-  }
+  public void addTransaction_negativeAmount_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction(UUID.randomUUID(), -10.0, "FOOD", "description");
 
-  // ---------------------------------------------------------------------------
-  // getBudgetsTextBlock
-  // ---------------------------------------------------------------------------
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
+
+    assertEquals("Amount must be greater than 0", exception.getMessage());
+  }
 
-  /** Typical valid input. */
+  /**
+   * Tests addTransaction with null category.
+   *
+   * <p>Partition: P8 (Invalid) - Null category.
+   */
   @Test
-  public void getBudgetsTextBlock_userFound_returnsBudgetSummaryText() {
-    user.setUsername("User");
-    List<Transaction> transactions = List.of(
-        new Transaction(userId, 1.0, "category", "description"),
-        new Transaction(userId, 2.0, "category2", "description2"));
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenReturn(user);
+  public void addTransaction_nullCategory_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction();
+    tx.setUserId(UUID.randomUUID());
+    tx.setAmount(10.0);
+    tx.setDescription("description");
+    tx.setCategory(null);
 
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId)))
-        .thenReturn(transactions);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    String test = service.getBudgetsTextBlock(userId);
-    assertTrue(test.contains("User"));
-    assertTrue(test.contains("3.0"));
-  }
-
-  /** Atypical valid input. */
-  @Test
-  public void getBudgetsTextBlock_atypical_noTransactionsShowsZeroSpent() {
-    UUID testId = UUID.randomUUID();
-    User testUser = new User();
-    testUser.setUserId(testId);
-    testUser.setUsername("username");
-    testUser.setBudget(10.00);
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)
-    )).thenReturn(user);
-    when(jdbcTemplate.query(
-      anyString(),
-      ArgumentMatchers.<RowMapper<Transaction>>any(),
-      eq(userId)
-    )).thenReturn(Collections.emptyList());
-
-    String test = service.getBudgetsTextBlock(userId);
-    System.out.println("DEBUG: " + test);
-    assertTrue(test.contains("Total Spent: $0.00"));
-  }
-
-  /** Invalid input. */
-  @Test
-  public void getBudgetsTextBlock_userNotFound_returnsUserNotFoundMessage() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenThrow(new RuntimeException());
-    String test = service.getBudgetsTextBlock(userId);
-    assertEquals("User not found", test);
+    assertEquals("Category is required", exception.getMessage());
   }
 
-  // ---------------------------------------------------------------------------
-  // getBudgetWarningsText
-  // ---------------------------------------------------------------------------
-
-  /** Typical valid input. */
+  /**
+   * Tests addTransaction with blank category.
+   *
+   * <p>Partition: P9 (Invalid) - Blank category.
+   */
   @Test
-  public void getBudgetWarningsText_userNearBudgetLimit_returnsWarningMessage() {
-    user.setBudget(10.0);
-
-    List<Transaction> transactions = List.of(
-        new Transaction(userId, 9.5, "category", "description"));
+  public void addTransaction_blankCategory_throwsIllegalArgumentException() {
+    Transaction tx = new Transaction(UUID.randomUUID(), 10.0, "   ", "description");
 
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenReturn(user);
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(),
-      eq(userId)))
-        .thenReturn(transactions);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    String test = service.getBudgetWarningsText(userId);
-    assertTrue(test.contains("Budget warning: Only"));
-    assertTrue(test.contains("0.5"));
+    assertEquals("Category is required", exception.getMessage());
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests addTransaction when foreign key constraint is violated.
+   *
+   * <p>Partition: P10 (Invalid) - Foreign key violation.
+   */
   @Test
-  public void getBudgetWarningsText_userOverBudget_returnsOverBudgetWarning() {
-    user.setBudget(5.0);
+  public void addTransaction_foreignKeyViolation_throwsIllegalArgumentException() {
+    UUID validUserId = UUID.randomUUID();
+    Transaction tx = new Transaction(validUserId, 10.0, "FOOD", "description");
 
-    List<Transaction> transactions = List.of(
-        transaction);
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        any(), any(), any(), any()))
+        .thenThrow(new RuntimeException("foreign key constraint violation"));
 
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenReturn(user);
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId)))
-        .thenReturn(transactions);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    String test = service.getBudgetWarningsText(userId);
-    assertTrue(test.contains("OVER BUDGET! You have exceeded your budget by $"));
-    assertTrue(test.contains("5.0"));
+    assertTrue(exception.getMessage().contains("Invalid user ID"));
   }
 
-  /** Invalid input. */
+  /**
+   * Tests addTransaction when invalid category enum is used.
+   *
+   * <p>Partition: P11 (Invalid) - Invalid category enum.
+   */
   @Test
-  public void getBudgetWarningsText_userNotFound_returnsUserNotFoundMessage() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenThrow(new RuntimeException());
-    String test = service.getBudgetWarningsText(userId);
-    assertEquals("User not found", test);
-  }
-
-  // ---------------------------------------------------------------------------
-  // getMonthlySummary
-  // ---------------------------------------------------------------------------
+  public void addTransaction_invalidCategoryEnum_throwsIllegalArgumentException() {
+    UUID validUserId = UUID.randomUUID();
+    Transaction tx = new Transaction(validUserId, 10.0, "INVALID_CATEGORY", "description");
 
-  /** Typical valid input. */
-  @Test
-  public void getMonthlySummary_typical_returnsFormattedSummary() {
-    user.setBudget(500);
-    LocalDate now = LocalDate.now();
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        any(), any(), any(), any()))
+        .thenThrow(new RuntimeException("transaction_category enum error"));
 
-    Transaction t1 = new Transaction(userId, 100.0, "c1", "d1");
-    t1.setDate(now);
-    Transaction t2 = new Transaction(userId, 50.0, "c2", "d2");
-    t2.setDate(now);
-    Transaction t3 = new Transaction(userId, 200.0, "c3", "d3");
-    t3.setDate(now.minusMonths(1));
-    List<Transaction> transactions = List.of(t1, t2, t3);
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.addTransaction(tx));
 
-    when(jdbcTemplate.queryForObject(
-        anyString(),
-        ArgumentMatchers.<RowMapper<User>>any(),
-        eq(userId)
-    )).thenReturn(user);
+    assertTrue(exception.getMessage().contains("Invalid category"));
+  }
 
-    when(jdbcTemplate.query(
-        anyString(),
-        ArgumentMatchers.<RowMapper<Transaction>>any(),
-        eq(userId)
-    )).thenReturn(transactions);
+  /**
+   * Tests addTransaction when general database error occurs.
+   *
+   * <p>Partition: P12 (Invalid) - General database error.
+   */
+  @Test
+  public void addTransaction_generalDatabaseError_throwsIllegalStateException() {
+    UUID validUserId = UUID.randomUUID();
+    Transaction tx = new Transaction(validUserId, 10.0, "FOOD", "description");
 
-    String summary = service.getMonthlySummary(userId);
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        any(), any(), any(), any()))
+        .thenThrow(new RuntimeException("Connection timeout"));
 
-    assertTrue(summary.contains("Total Spent: $150.00"));
-    assertTrue(summary.contains("Remaining: $350.00"));
-    assertTrue(summary.contains("- c1: $100.00"));
-    assertTrue(summary.contains("- c2: $50.00"));
-    assertFalse(summary.contains("c3"));
+    IllegalStateException exception = assertThrows(IllegalStateException.class,
+        () -> service.addTransaction(tx));
 
+    assertTrue(exception.getMessage().contains("Failed to create transaction"));
   }
 
-  /** Atypical valid input. */
-  @Test
-  public void getMonthlySummary_invalid_nullDatesIgnoredInSummary() {
-    user.setBudget(500);
-    LocalDate now = LocalDate.now();
+  // ===========================================================================
+  // getTransactionsByUser
+  // ===========================================================================
 
-    Transaction t1 = new Transaction(userId, 100.0, "c1", "d1");
-    Transaction t2 = new Transaction(userId, 50.0, "c2", "d2");
-    Transaction t3 = new Transaction(userId, 200.0, "c3", "d3");
-    List<Transaction> transactions = List.of(t1, t2, t3);
+  /**
+   * Tests getTransactionsByUser when user has transactions.
+   *
+   * <p>Partition: P1 (Valid) - User has transactions.
+   */
+  @Test
+  public void getTransactionsByUser_hasTransactions_returnsList() {
+    Transaction t1 = new Transaction(userId, 25.0, "FOOD", "desc1");
+    Transaction t2 = new Transaction(userId, 10.0, "SHOPPING", "desc2");
+    List<Transaction> transactions = List.of(t1, t2);
 
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)
-    )).thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
 
-    when(jdbcTemplate.query(
-      anyString(),
-      ArgumentMatchers.<RowMapper<Transaction>>any(),
-      eq(userId)
-    )).thenReturn(transactions);
+    List<Transaction> result = service.getTransactionsByUser(userId);
 
-    String summary = service.getMonthlySummary(userId);
-    assertTrue(summary.contains("Total Spent: $0.00"));
-    assertTrue(summary.contains("Remaining: $500.00"));
+    assertEquals(2, result.size());
+    assertEquals("FOOD", result.get(0).getCategory());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests getTransactionsByUser when user has no transactions.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions.
+   */
   @Test
-  public void getMonthlySummary_userNotFound_returnsUserNotFoundMessage() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenThrow(new RuntimeException());
-    String test = service.getMonthlySummary(userId);
-    assertEquals("User not found", test);
-  }
+  public void getTransactionsByUser_noTransactions_returnsEmptyList() {
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(List.of());
 
-  // ---------------------------------------------------------------------------
-  // getBudgetReport
-  // ---------------------------------------------------------------------------
+    List<Transaction> result = service.getTransactionsByUser(userId);
 
-  /** Typical valid input. */
-  @Test
-  public void getBudgetReport_userFound_returnsValidReport() {
-    user.setUsername("User");
-    user.setEmail("email");
-    user.setBudget(100.0);
-    UUID userId = UUID.randomUUID();
-    user.setUserId(userId);
-    List<Transaction> transactions = List.of(
-        new Transaction(userId, 1.0, "category", "description"),
-        new Transaction(userId, 2.0, "category2", "description2"));
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenReturn((user));
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId)))
-        .thenReturn((transactions));
-
-    Map<String, Object> test = service.getBudgetReport(userId);
-
-    assertEquals(userId, test.get("userId"));
-    assertEquals("User", test.get("username"));
-    assertEquals(100.0, test.get("totalBudget"));
-    assertEquals(3.0, test.get("totalSpent"));
-    assertEquals(97.0, test.get("remaining"));
-    assertEquals(false, test.get("isOverBudget"));
-    assertEquals("", test.get("warnings"));
-    assertEquals(false, test.get("hasWarnings"));
-
-    Map<String, Double> categories = Map.of(
-        "category", 1.0,
-        "category2", 2.0);
-
-    assertEquals(categories, test.get("categories"));
-  }
-
-  /** Atypical valid input. */
-  @Test
-  public void getBudgetReport_overBudget() {
-    user.setUsername("User");
-    user.setEmail("email");
-    user.setBudget(1.0);
-    UUID userId = UUID.randomUUID();
-    user.setUserId(userId);
-    List<Transaction> transactions = List.of(
-        new Transaction(userId, 1.0, "category", "description"),
-        new Transaction(userId, 2.0, "category2", "description2"));
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)))
-        .thenReturn(user);
-  
-    when(jdbcTemplate.query(
-      anyString(),
-      ArgumentMatchers.<RowMapper<Transaction>>any(),
-      eq(userId)))
-        .thenReturn(transactions);
-    
-    Map<String, Object> test = service.getBudgetReport(userId);
-    assertEquals(true, test.get("isOverBudget"));
-    assertEquals("OVER BUDGET! You have exceeded your budget by $2.00\n", test.get("warnings"));
-    assertEquals(true, test.get("hasWarnings"));
+    assertTrue(result.isEmpty());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests getTransactionsByUser when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void getBudgetReport_userNotFound_returnsErrorMap() {
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
-        .thenThrow(new RuntimeException());
-    Map<String, Object> test = service.getBudgetReport(userId);
-    assertEquals(Map.of("error", "User not found"), test);
-  }
-
-  // ---------------------------------------------------------------------------
-  // setBudgets
-  // ---------------------------------------------------------------------------
+  public void getTransactionsByUser_databaseError_throwsIllegalStateException() {
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException("Error"));
 
-  /** Typical valid input. */
-  @Test
-  public void setBudgets_validUpdate() {
-    Map<String, Object> updates = Map.of("budget", 20.0);
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)))
-        .thenReturn(user);
-    
-    service.setBudgets(userId, updates);
+    IllegalStateException exception = assertThrows(IllegalStateException.class,
+        () -> service.getTransactionsByUser(userId));
 
-    verify(jdbcTemplate).update("UPDATE users SET budget = ? WHERE user_id = ?", 20.0, userId);
+    assertTrue(exception.getMessage().contains("Failed to get transactions"));
   }
 
+  // ===========================================================================
+  // updateTransaction
+  // ===========================================================================
 
-  /** Atypical valid input. */
+  /**
+   * Tests updateTransaction with valid string updates.
+   *
+   * <p>Partition: P1 (Valid) - Valid updates.
+   */
   @Test
-  public void setBudgets_acceptsString() {
-    Map<String, Object> updates = Map.of("budget", "20.0");
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)))
-        .thenReturn(user);
-    
-    service.setBudgets(userId, updates);
+  public void updateTransaction_validUpdates_returnsUpdatedTransaction() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId))).thenReturn(1);
 
-    verify(jdbcTemplate).update("UPDATE users SET budget = ? WHERE user_id = ?", 20.0, userId);
-  }
+    Transaction updatedTransaction = new Transaction();
+    updatedTransaction.setDescription("new description");
+    updatedTransaction.setAmount(7.0);
+    updatedTransaction.setCategory("OTHER");
 
-  /** Invalid input. */
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(updatedTransaction);
 
+    Map<String, Object> updates = Map.of(
+        "description", "new description",
+        "amount", "7.0",
+        "category", "OTHER");
+
+    Optional<Transaction> result = service.updateTransaction(transactionId, updates);
+
+    assertTrue(result.isPresent());
+    assertEquals("new description", result.get().getDescription());
+  }
+
+  /**
+   * Tests updateTransaction with amount as Number type.
+   *
+   * <p>Partition: P2 (Valid) - Amount as Number.
+   */
+  @Test
+  public void updateTransaction_amountAsNumber_updatesCorrectly() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId))).thenReturn(1);
+
+    Transaction updatedTransaction = new Transaction();
+    updatedTransaction.setAmount(7.0);
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(updatedTransaction);
+
+    Map<String, Object> updates = Map.of("amount", 7);
+
+    Optional<Transaction> result = service.updateTransaction(transactionId, updates);
+
+    assertTrue(result.isPresent());
+    assertEquals(7.0, result.get().getAmount());
+  }
+
+  /**
+   * Tests updateTransaction when transaction not found.
+   *
+   * <p>Partition: P3 (Invalid) - Transaction not found.
+   */
+  @Test
+  public void updateTransaction_transactionNotFound_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenThrow(new RuntimeException("Not found"));
+
+    Map<String, Object> updates = Map.of("description", "test");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertTrue(exception.getMessage().contains("Transaction not found"));
+  }
+
+  /**
+   * Tests updateTransaction with empty updates map.
+   *
+   * <p>Partition: P4 (Invalid) - Empty updates map.
+   */
+  @Test
+  public void updateTransaction_emptyUpdates_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of();
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertTrue(exception.getMessage().contains("No valid fields provided"));
+  }
+
+  /**
+   * Tests updateTransaction when description is not a string.
+   *
+   * <p>Partition: P5 (Invalid) - Description not string.
+   */
+  @Test
+  public void updateTransaction_descriptionNotString_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("description", 123);
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Description must be a string", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when description is blank.
+   *
+   * <p>Partition: P6 (Invalid) - Blank description.
+   */
+  @Test
+  public void updateTransaction_blankDescription_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("description", "   ");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Description cannot be empty", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when amount is invalid type.
+   *
+   * <p>Partition: P7 (Invalid) - Amount not number/string.
+   */
+  @Test
+  public void updateTransaction_amountInvalidType_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("amount", true);
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Amount must be a number", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when amount string is invalid.
+   *
+   * <p>Partition: P8 (Invalid) - Amount invalid string.
+   */
+  @Test
+  public void updateTransaction_amountInvalidString_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("amount", "not-a-number");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Amount must be a valid number", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when amount is zero.
+   *
+   * <p>Partition: P9 (Invalid) - Amount zero or negative.
+   */
+  @Test
+  public void updateTransaction_amountZero_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("amount", 0);
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Amount must be greater than 0", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when category is not a string.
+   *
+   * <p>Partition: P10 (Invalid) - Category not string.
+   */
+  @Test
+  public void updateTransaction_categoryNotString_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("category", 123);
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Category must be a string", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when category is blank.
+   *
+   * <p>Partition: P11 (Invalid) - Blank category.
+   */
+  @Test
+  public void updateTransaction_blankCategory_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("category", "   ");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertEquals("Category cannot be empty", exception.getMessage());
+  }
+
+  /**
+   * Tests updateTransaction when category value is invalid.
+   *
+   * <p>Partition: P12 (Invalid) - Invalid category value.
+   */
+  @Test
+  public void updateTransaction_invalidCategoryValue_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    Map<String, Object> updates = Map.of("category", "INVALID_CATEGORY");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertTrue(exception.getMessage().contains("Invalid category"));
+  }
+
+  /**
+   * Tests updateTransaction when database throws category enum error.
+   *
+   * <p>Partition: P13 (Invalid) - DB category enum error.
+   */
+  @Test
+  public void updateTransaction_dbCategoryEnumError_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+
+    DataAccessException dae = mock(DataAccessException.class);
+    when(dae.getMessage()).thenReturn("transaction_category enum error");
+    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId))).thenThrow(dae);
+
+    Map<String, Object> updates = Map.of("category", "FOOD");
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertTrue(exception.getMessage().contains("Invalid category"));
+  }
+
+  /**
+   * Tests updateTransaction when update affects zero rows.
+   *
+   * <p>Partition: P14 (Invalid) - Update fails (0 rows).
+   */
+  @Test
+  public void updateTransaction_zeroRowsAffected_throwsIllegalStateException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(transactionId))).thenReturn(transaction);
+    when(jdbcTemplate.update(anyString(), any(), any(), any(), eq(transactionId))).thenReturn(0);
+
+    Map<String, Object> updates = Map.of("description", "new desc", "category", "OTHER");
+
+    IllegalStateException exception = assertThrows(IllegalStateException.class,
+        () -> service.updateTransaction(transactionId, updates));
+
+    assertTrue(exception.getMessage().contains("Failed to update transaction"));
+  }
+
+  // ===========================================================================
+  // deleteTransaction
+  // ===========================================================================
+
+  /**
+   * Tests deleteTransaction when transaction exists.
+   *
+   * <p>Partition: P1 (Valid) - Transaction exists.
+   */
+  @Test
+  public void deleteTransaction_transactionExists_returnsTrue() {
+    when(jdbcTemplate.update(anyString(), eq(transactionId))).thenReturn(1);
+
+    boolean result = service.deleteTransaction(transactionId);
+
+    assertTrue(result);
+  }
+
+  /**
+   * Tests deleteTransaction when transaction does not exist.
+   *
+   * <p>Partition: P2 (Valid) - Transaction not found.
+   */
+  @Test
+  public void deleteTransaction_transactionNotFound_returnsFalse() {
+    when(jdbcTemplate.update(anyString(), eq(transactionId))).thenReturn(0);
+
+    boolean result = service.deleteTransaction(transactionId);
+
+    assertFalse(result);
+  }
+
+  /**
+   * Tests deleteTransaction when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
+  @Test
+  public void deleteTransaction_databaseError_throwsException() {
+    when(jdbcTemplate.update(anyString(), eq(transactionId)))
+        .thenThrow(new RuntimeException("DB error"));
+
+    assertThrows(RuntimeException.class, () -> service.deleteTransaction(transactionId));
+  }
+
+  // ===========================================================================
+  // getBudgetsTextBlock
+  // ===========================================================================
+
+  /**
+   * Tests getBudgetsTextBlock when user found with transactions.
+   *
+   * <p>Partition: P1 (Valid) - User found with transactions.
+   */
+  @Test
+  public void getBudgetsTextBlock_userWithTransactions_returnsSummary() {
+    user.setUsername("TestUser");
+    user.setBudget(100.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 30.0, "FOOD", "desc1"),
+        new Transaction(userId, 20.0, "SHOPPING", "desc2"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    String result = service.getBudgetsTextBlock(userId);
+
+    assertTrue(result.contains("TestUser"));
+    assertTrue(result.contains("Total Spent: $50.00"));
+    assertTrue(result.contains("Remaining: $50.00"));
+  }
+
+  /**
+   * Tests getBudgetsTextBlock when user has no transactions.
+   *
+   * <p>Partition: P2 (Valid) - User found, no transactions.
+   */
+  @Test
+  public void getBudgetsTextBlock_noTransactions_showsZeroSpent() {
+    user.setUsername("TestUser");
+    user.setBudget(100.0);
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(Collections.emptyList());
+
+    String result = service.getBudgetsTextBlock(userId);
+
+    assertTrue(result.contains("Total Spent: $0.00"));
+  }
+
+  /**
+   * Tests getBudgetsTextBlock when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
+   */
+  @Test
+  public void getBudgetsTextBlock_userNotFound_returnsUserNotFound() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException());
+
+    String result = service.getBudgetsTextBlock(userId);
+
+    assertEquals("User not found", result);
+  }
+
+  // ===========================================================================
+  // getBudgetWarningsText
+  // ===========================================================================
+
+  /**
+   * Tests getBudgetWarningsText when user is near budget limit.
+   *
+   * <p>Partition: P1 (Valid) - Less than 10% remaining.
+   */
+  @Test
+  public void getBudgetWarningsText_nearLimit_returnsWarning() {
+    user.setBudget(100.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 95.0, "FOOD", "desc"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    String result = service.getBudgetWarningsText(userId);
+
+    assertTrue(result.contains("Budget warning"));
+    assertTrue(result.contains("less than 10%"));
+  }
+
+  /**
+   * Tests getBudgetWarningsText when user is over budget.
+   *
+   * <p>Partition: P2 (Valid) - Over budget.
+   */
+  @Test
+  public void getBudgetWarningsText_overBudget_returnsOverBudgetWarning() {
+    user.setBudget(50.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 75.0, "FOOD", "desc"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    String result = service.getBudgetWarningsText(userId);
+
+    assertTrue(result.contains("OVER BUDGET"));
+  }
+
+  /**
+   * Tests getBudgetWarningsText when user has healthy budget.
+   *
+   * <p>Partition: P3 (Valid) - More than 10% remaining.
+   */
+  @Test
+  public void getBudgetWarningsText_healthyBudget_returnsEmpty() {
+    user.setBudget(100.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 50.0, "FOOD", "desc"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    String result = service.getBudgetWarningsText(userId);
+
+    assertEquals("", result);
+  }
+
+  /**
+   * Tests getBudgetWarningsText when user not found.
+   *
+   * <p>Partition: P4 (Invalid) - User not found.
+   */
+  @Test
+  public void getBudgetWarningsText_userNotFound_returnsUserNotFound() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException());
+
+    String result = service.getBudgetWarningsText(userId);
+
+    assertEquals("User not found", result);
+  }
+
+  // ===========================================================================
+  // getMonthlySummary
+  // ===========================================================================
+
+  /**
+   * Tests getMonthlySummary with current month transactions.
+   *
+   * <p>Partition: P1 (Valid) - User with current month transactions.
+   */
+  @Test
+  public void getMonthlySummary_currentMonthTransactions_returnsSummary() {
+    user.setBudget(500.0);
+    LocalDate now = LocalDate.now();
+
+    Transaction t1 = new Transaction(userId, 100.0, "FOOD", "d1");
+    t1.setDate(now);
+    Transaction t2 = new Transaction(userId, 50.0, "SHOPPING", "d2");
+    t2.setDate(now);
+    Transaction t3 = new Transaction(userId, 200.0, "TRAVEL", "d3");
+    t3.setDate(now.minusMonths(1));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(List.of(t1, t2, t3));
+
+    String result = service.getMonthlySummary(userId);
+
+    assertTrue(result.contains("Total Spent: $150.00"));
+    assertTrue(result.contains("Remaining: $350.00"));
+    assertFalse(result.contains("TRAVEL"));
+  }
+
+  /**
+   * Tests getMonthlySummary when transactions have null dates.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Transactions with null dates.
+   */
+  @Test
+  public void getMonthlySummary_nullDates_ignoredInSummary() {
+    user.setBudget(500.0);
+
+    Transaction t1 = new Transaction(userId, 100.0, "FOOD", "d1");
+    Transaction t2 = new Transaction(userId, 50.0, "SHOPPING", "d2");
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(List.of(t1, t2));
+
+    String result = service.getMonthlySummary(userId);
+
+    assertTrue(result.contains("Total Spent: $0.00"));
+  }
+
+  /**
+   * Tests getMonthlySummary when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
+   */
+  @Test
+  public void getMonthlySummary_userNotFound_returnsUserNotFound() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException());
+
+    String result = service.getMonthlySummary(userId);
+
+    assertEquals("User not found", result);
+  }
+
+  // ===========================================================================
+  // getBudgetReport
+  // ===========================================================================
+
+  /**
+   * Tests getBudgetReport when user found.
+   *
+   * <p>Partition: P1 (Valid) - User found.
+   */
+  @Test
+  public void getBudgetReport_userFound_returnsCompleteReport() {
+    user.setUsername("TestUser");
+    user.setEmail("test@example.com");
+    user.setBudget(100.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 30.0, "FOOD", "desc1"),
+        new Transaction(userId, 20.0, "SHOPPING", "desc2"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    Map<String, Object> result = service.getBudgetReport(userId);
+
+    assertEquals(userId, result.get("userId"));
+    assertEquals("TestUser", result.get("username"));
+    assertEquals(100.0, result.get("totalBudget"));
+    assertEquals(50.0, result.get("totalSpent"));
+    assertEquals(50.0, result.get("remaining"));
+    assertEquals(false, result.get("isOverBudget"));
+  }
+
+  /**
+   * Tests getBudgetReport when user is over budget.
+   *
+   * <p>Partition: P2 (Valid) - User over budget.
+   */
+  @Test
+  public void getBudgetReport_overBudget_showsWarnings() {
+    user.setUsername("TestUser");
+    user.setBudget(50.0);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 75.0, "FOOD", "desc"));
+
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId)))
+        .thenReturn(transactions);
+
+    Map<String, Object> result = service.getBudgetReport(userId);
+
+    assertEquals(true, result.get("isOverBudget"));
+    assertEquals(true, result.get("hasWarnings"));
+    assertTrue(((String) result.get("warnings")).contains("OVER BUDGET"));
+  }
+
+  /**
+   * Tests getBudgetReport when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
+   */
+  @Test
+  public void getBudgetReport_userNotFound_returnsErrorMap() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException());
+
+    Map<String, Object> result = service.getBudgetReport(userId);
+
+    assertEquals(Map.of("error", "User not found"), result);
+  }
+
+  // ===========================================================================
+  // setBudgets
+  // ===========================================================================
+
+  /**
+   * Tests setBudgets with budget as Number.
+   *
+   * <p>Partition: P1 (Valid) - Budget as Number.
+   */
+  @Test
+  public void setBudgets_budgetAsNumber_updatesSuccessfully() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+
+    Map<String, Object> updates = Map.of("budget", 200.0);
+    service.setBudgets(userId, updates);
+
+    verify(jdbcTemplate).update("UPDATE users SET budget = ? WHERE user_id = ?", 200.0, userId);
+  }
+
+  /**
+   * Tests setBudgets with budget as String.
+   *
+   * <p>Partition: P2 (Valid) - Budget as String.
+   */
+  @Test
+  public void setBudgets_budgetAsString_parsesAndUpdates() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+
+    Map<String, Object> updates = Map.of("budget", "150.50");
+    service.setBudgets(userId, updates);
+
+    verify(jdbcTemplate).update("UPDATE users SET budget = ? WHERE user_id = ?", 150.50, userId);
+  }
+
+  /**
+   * Tests setBudgets with zero budget.
+   *
+   * <p>Partition: P3 (Valid/Boundary) - Budget is zero.
+   */
+  @Test
+  public void setBudgets_zeroBudget_updatesSuccessfully() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+
+    Map<String, Object> updates = Map.of("budget", 0.0);
+    service.setBudgets(userId, updates);
+
+    verify(jdbcTemplate).update("UPDATE users SET budget = ? WHERE user_id = ?", 0.0, userId);
+  }
+
+  /**
+   * Tests setBudgets when user not found.
+   *
+   * <p>Partition: P4 (Invalid) - User not found.
+   */
   @Test
   public void setBudgets_userNotFound_throwsIllegalArgumentException() {
-    Map<String, Object> updates = Map.of("test1", "test2");
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(),
-      eq(userId)))
-        .thenThrow(new IllegalArgumentException("User not found"));
-    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
-      service.setBudgets(userId, updates);
-    });
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenThrow(new RuntimeException());
+
+    Map<String, Object> updates = Map.of("budget", 100.0);
 
-    assertTrue(exception.getMessage().contains("User not found"));
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.setBudgets(userId, updates));
+
+    assertEquals("User not found", exception.getMessage());
   }
 
+  /**
+   * Tests setBudgets with invalid budget format.
+   *
+   * <p>Partition: P5 (Invalid) - Invalid budget format.
+   */
   @Test
   public void setBudgets_invalidFormat_throwsIllegalArgumentException() {
-    Map<String, Object> updates = Map.of("budget", true);
-    user.setBudget(100.0);
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
         .thenReturn(user);
-    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
-      service.setBudgets(userId, updates);
-    });
 
-    assertTrue(exception.getMessage().contains("Invalid budget format"));
+    Map<String, Object> updates = Map.of("budget", true);
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.setBudgets(userId, updates));
+
+    assertEquals("Invalid budget format", exception.getMessage());
   }
 
+  /**
+   * Tests setBudgets with negative budget.
+   *
+   * <p>Partition: P6 (Invalid) - Negative budget.
+   */
   @Test
   public void setBudgets_negativeBudget_throwsIllegalArgumentException() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
+        .thenReturn(user);
+
     Map<String, Object> updates = Map.of("budget", -100.0);
-    user.setBudget(100.0);
-    when(jdbcTemplate.queryForObject(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<User>>any(), 
-      eq(userId)))
+
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> service.setBudgets(userId, updates));
+
+    assertEquals("Budget cannot be negative", exception.getMessage());
+  }
+
+  /**
+   * Tests setBudgets when no budget key in map.
+   *
+   * <p>Partition: P7 (Valid/Edge) - No budget key.
+   */
+  @Test
+  public void setBudgets_noBudgetKey_noUpdatePerformed() {
+    when(jdbcTemplate.queryForObject(anyString(), ArgumentMatchers.<RowMapper<User>>any(),
+        eq(userId)))
         .thenReturn(user);
-    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
-      service.setBudgets(userId, updates);
-    });
 
-    assertTrue(exception.getMessage().contains("Budget cannot be negative"));
+    Map<String, Object> updates = Map.of("other", "value");
+    service.setBudgets(userId, updates);
+
+    verify(jdbcTemplate, never()).update(eq("UPDATE users SET budget = ? WHERE user_id = ?"),
+        any(), any());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // weeklySummary
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests weeklySummary with recent transactions.
+   *
+   * <p>Partition: P1 (Valid) - User has recent transactions.
+   */
   @Test
-  public void weeklySummary_returnsTransactions() {
+  public void weeklySummary_hasRecentTransactions_returnsList() {
     LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
-
     List<Transaction> expected = List.of(
-      new Transaction(userId, 100.0, "c1", "d1"),
-      new Transaction(userId, 50.0, "c2", "d2")
-    );
-
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId), 
-      eq(oneWeekAgo)))
+        new Transaction(userId, 100.0, "FOOD", "d1"),
+        new Transaction(userId, 50.0, "SHOPPING", "d2"));
+
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId), eq(oneWeekAgo)))
         .thenReturn(expected);
 
     List<Transaction> result = service.weeklySummary(userId);
@@ -986,16 +1644,17 @@ public void weeklySummary_returnsTransactions() {
     assertEquals(expected, result);
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests weeklySummary with no transactions in week.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions in week.
+   */
   @Test
-  public void weeklySummary_atypical_noTransactions_returnsEmptyList() {
+  public void weeklySummary_noTransactionsInWeek_returnsEmptyList() {
     LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
 
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId), 
-      eq(oneWeekAgo)))
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        eq(userId), eq(oneWeekAgo)))
         .thenReturn(Collections.emptyList());
 
     List<Transaction> result = service.weeklySummary(userId);
@@ -1004,74 +1663,255 @@ public void weeklySummary_atypical_noTransactions_returnsEmptyList() {
     assertTrue(result.isEmpty());
   }
 
-  /** Invalid input. */
+  /**
+   * Tests weeklySummary when database throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Database error.
+   */
   @Test
-  public void weeklySummary_invalidInput_throwsException() {
-    UUID userId = null;
-    
-    when(jdbcTemplate.query(
-      anyString(), 
-      ArgumentMatchers.<RowMapper<Transaction>>any(), 
-      eq(userId), 
-      any()))
+  public void weeklySummary_databaseError_throwsException() {
+    when(jdbcTemplate.query(anyString(), ArgumentMatchers.<RowMapper<Transaction>>any(),
+        any(), any()))
         .thenThrow(new IllegalArgumentException("DB Error"));
 
     assertThrows(IllegalArgumentException.class, () -> service.weeklySummary(userId));
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // totalLast7Days
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
-  /** Typical valid input. */
+  /**
+   * Tests totalLast7Days when transactions exist.
+   *
+   * <p>Partition: P1 (Valid) - Transactions exist.
+   */
   @Test
-  public void totalLast7Days_returnsSum() {
+  public void totalLast7Days_hasTransactions_returnsSum() {
     LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
 
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      eq(Double.class),
-      eq(userId),
-      eq(oneWeekAgo)
-    )).thenReturn(150.0);
+    when(jdbcTemplate.queryForObject(anyString(), eq(Double.class), eq(userId), eq(oneWeekAgo)))
+        .thenReturn(150.0);
 
     double result = service.totalLast7Days(userId);
 
     assertEquals(150.0, result);
   }
 
-  /** Atypical valid input. */
+  /**
+   * Tests totalLast7Days when no transactions exist.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions.
+   */
   @Test
   public void totalLast7Days_noTransactions_returnsZero() {
     LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
 
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      eq(Double.class),
-      eq(userId),
-      eq(oneWeekAgo)
-    )).thenReturn(0.0);
+    when(jdbcTemplate.queryForObject(anyString(), eq(Double.class), eq(userId), eq(oneWeekAgo)))
+        .thenReturn(0.0);
+
+    double result = service.totalLast7Days(userId);
+
+    assertEquals(0.0, result);
+  }
+
+  /**
+   * Tests totalLast7Days when database returns null.
+   *
+   * <p>Partition: P3 (Valid/Edge) - Database returns null.
+   */
+  @Test
+  public void totalLast7Days_databaseReturnsNull_returnsZero() {
+    LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
+
+    when(jdbcTemplate.queryForObject(anyString(), eq(Double.class), eq(userId), eq(oneWeekAgo)))
+        .thenReturn(null);
 
     double result = service.totalLast7Days(userId);
 
     assertEquals(0.0, result);
   }
 
-  /** Invalid input. */
+  /**
+   * Tests totalLast7Days when database throws exception.
+   *
+   * <p>Partition: P4 (Invalid) - Database error.
+   */
   @Test
-  public void totalLast7Days_invalidInput_returnsZero() {
+  public void totalLast7Days_databaseError_returnsZero() {
     LocalDate oneWeekAgo = LocalDate.now().minusDays(7);
 
-    when(jdbcTemplate.queryForObject(
-      anyString(),
-      eq(Double.class),
-      eq(userId),
-      eq(oneWeekAgo)
-    )).thenThrow(new RuntimeException("DB Error"));
+    when(jdbcTemplate.queryForObject(anyString(), eq(Double.class), eq(userId), eq(oneWeekAgo)))
+        .thenThrow(new RuntimeException("DB Error"));
 
     double result = service.totalLast7Days(userId);
 
     assertEquals(0.0, result);
   }
 
-}
+  // ===========================================================================
+  // isUsernameExists
+  // ===========================================================================
+
+  /**
+   * Tests isUsernameExists when username exists (no exclusion).
+   *
+   * <p>Partition: P1 (Valid) - Username exists.
+   */
+  @Test
+  public void isUsernameExists_exists_returnsTrue() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("testuser")))
+        .thenReturn(1);
+
+    boolean result = service.isUsernameExists("testuser", null);
+
+    assertTrue(result);
+  }
+
+  /**
+   * Tests isUsernameExists when username does not exist.
+   *
+   * <p>Partition: P2 (Valid) - Username does not exist.
+   */
+  @Test
+  public void isUsernameExists_notExists_returnsFalse() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("testuser")))
+        .thenReturn(0);
+
+    boolean result = service.isUsernameExists("testuser", null);
+
+    assertFalse(result);
+  }
+
+  /**
+   * Tests isUsernameExists when username exists but excluded.
+   *
+   * <p>Partition: P3 (Valid) - Username exists but excluded.
+   */
+  @Test
+  public void isUsernameExists_existsButExcluded_returnsFalse() {
+    UUID excludeId = UUID.randomUUID();
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("testuser"),
+        eq(excludeId)))
+        .thenReturn(0);
+
+    boolean result = service.isUsernameExists("testuser", excludeId);
+
+    assertFalse(result);
+  }
+
+  /**
+   * Tests isUsernameExists when username exists for other user.
+   *
+   * <p>Partition: P4 (Valid) - Username exists for other user.
+   */
+  @Test
+  public void isUsernameExists_existsForOtherUser_returnsTrue() {
+    UUID excludeId = UUID.randomUUID();
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("testuser"),
+        eq(excludeId)))
+        .thenReturn(1);
+
+    boolean result = service.isUsernameExists("testuser", excludeId);
+
+    assertTrue(result);
+  }
+
+  /**
+   * Tests isUsernameExists when count is null.
+   *
+   * <p>Partition: P5 (Valid/Edge) - Count is null.
+   */
+  @Test
+  public void isUsernameExists_countNull_returnsFalse() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("testuser")))
+        .thenReturn(null);
+
+    boolean result = service.isUsernameExists("testuser", null);
+
+    assertFalse(result);
+  }
+
+  // ===========================================================================
+  // isEmailExists
+  // ===========================================================================
+
+  /**
+   * Tests isEmailExists when email exists (no exclusion).
+   *
+   * <p>Partition: P1 (Valid) - Email exists.
+   */
+  @Test
+  public void isEmailExists_exists_returnsTrue() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("test@example.com")))
+        .thenReturn(1);
+
+    boolean result = service.isEmailExists("test@example.com", null);
+
+    assertTrue(result);
+  }
+
+  /**
+   * Tests isEmailExists when email does not exist.
+   *
+   * <p>Partition: P2 (Valid) - Email does not exist.
+   */
+  @Test
+  public void isEmailExists_notExists_returnsFalse() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("test@example.com")))
+        .thenReturn(0);
+
+    boolean result = service.isEmailExists("test@example.com", null);
+
+    assertFalse(result);
+  }
+
+  /**
+   * Tests isEmailExists when email exists but excluded.
+   *
+   * <p>Partition: P3 (Valid) - Email exists but excluded.
+   */
+  @Test
+  public void isEmailExists_existsButExcluded_returnsFalse() {
+    UUID excludeId = UUID.randomUUID();
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("test@example.com"),
+        eq(excludeId)))
+        .thenReturn(0);
+
+    boolean result = service.isEmailExists("test@example.com", excludeId);
+
+    assertFalse(result);
+  }
+
+  /**
+   * Tests isEmailExists when email exists for other user.
+   *
+   * <p>Partition: P4 (Valid) - Email exists for other user.
+   */
+  @Test
+  public void isEmailExists_existsForOtherUser_returnsTrue() {
+    UUID excludeId = UUID.randomUUID();
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("test@example.com"),
+        eq(excludeId)))
+        .thenReturn(1);
+
+    boolean result = service.isEmailExists("test@example.com", excludeId);
+
+    assertTrue(result);
+  }
+
+  /**
+   * Tests isEmailExists when count is null.
+   *
+   * <p>Partition: P5 (Valid/Edge) - Count is null.
+   */
+  @Test
+  public void isEmailExists_countNull_returnsFalse() {
+    when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), eq("test@example.com")))
+        .thenReturn(null);
+
+    boolean result = service.isEmailExists("test@example.com", null);
+
+    assertFalse(result);
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/RouteControllerIntegrationTests.java b/src/test/java/dev/ase/teamproject/RouteControllerIntegrationTests.java
index a343ccb..aa5e335 100644
--- a/src/test/java/dev/ase/teamproject/RouteControllerIntegrationTests.java
+++ b/src/test/java/dev/ase/teamproject/RouteControllerIntegrationTests.java
@@ -1,11 +1,10 @@
 package dev.ase.teamproject;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
+import static org.hamcrest.Matchers.notNullValue;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
@@ -18,291 +17,913 @@
 import dev.ase.teamproject.model.Transaction;
 import dev.ase.teamproject.model.User;
 import dev.ase.teamproject.service.MockApiService;
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.UUID;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
 import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.http.MediaType;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ActiveProfiles;
 import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.MvcResult;
 
 /**
- * Integration Tests (API Tests) for the RouteController.
+ * Integration Tests for the RouteController.
  *
- * <p>This test suite uses @SpringBootTest and MockMvc to test the full
- * HTTP request-response cycle, including request mapping, JSON serialization,
- * and exception handling at the web layer.
+ * <p>This test suite provides comprehensive integration testing at multiple levels:
  *
- * <p>It fulfills the "API Testing" and "Integration Testing" criteria by testing
- * the integration between the Web Layer (RouteController) and the
- * Service Layer (MockApiService).
+ * <h2>Internal Integration Tests</h2>
+ *
+ * <p>These tests exercise the complete request-response cycle through all layers:
+ * <ul>
+ *   <li><strong>HTTP Layer:</strong> Request parsing, URL mapping,content negotiation</li>
+ *   <li><strong>Controller Layer:</strong> RouteController request handling
+ *   and response building</li>
+ *   <li><strong>Service Layer:</strong> MockApiService business logic and validation</li>
+ *   <li><strong>Data Access Layer:</strong> JdbcTemplate database operations</li>
+ *   <li><strong>External Resource:</strong> PostgreSQL database on GCP</li>
+ * </ul>
+ *
+ * <h2>Integration Points Tested</h2>
+ * <ul>
+ *   <li>RouteController ↔ MockApiService (internal integration via dependency injection)</li>
+ *   <li>MockApiService ↔ JdbcTemplate ↔ PostgreSQL (external integration with database)</li>
+ *   <li>Spring MVC ↔ Jackson ObjectMapper (JSON serialization/deserialization)</li>
+ *   <li>Exception handlers ↔ HTTP response codes</li>
+ *   <li>Request validation ↔ Database constraints</li>
+ * </ul>
+ *
+ * <h2>Data Flow Tested</h2>
+ * <pre>
+ * HTTP Request → MockMvc → DispatcherServlet → RouteController
+ *     → MockApiService → JdbcTemplate → PostgreSQL Database
+ *     → Response flows back through all layers
+ * </pre>
+ *
+ * <h2>Shared Data Integration</h2>
+ * <ul>
+ *   <li>User and Transaction entities share userId (foreign key relationship)</li>
+ *   <li>Budget calculations integrate user.budget with transaction.amount</li>
+ *   <li>Weekly/Monthly summaries integrate date filtering with aggregations</li>
+ * </ul>
  */
 @SpringBootTest
 @AutoConfigureMockMvc
+@ActiveProfiles("test")
 public class RouteControllerIntegrationTests {
 
   /**
-   * Used to send simulated HTTP requests to the controller.
+   * MockMvc instance for simulating HTTP requests to the controller.
+   * Integrates with Spring's DispatcherServlet for full request processing.
    */
   @Autowired
   private MockMvc mockMvc;
 
   /**
-   * Used to serialize Java objects into JSON strings for POST/PUT bodies.
+   * ObjectMapper for JSON serialization/deserialization.
+   * Tests integration between Java objects and JSON payloads.
    */
   @Autowired
   private ObjectMapper objectMapper;
 
   /**
-   * Replaces the real MockApiService bean in the application context
-   * with a Mockito mock, allowing us to control its behavior.
+   * The real MockApiService bean (not mocked).
+   * Tests actual integration between controller and service layers.
    */
-  @MockBean
+  @Autowired
   private MockApiService mockApiService;
 
-  // ---------------------------------------------------------------------------
-  // User Endpoint Tests
-  // ---------------------------------------------------------------------------
+  /**
+   * JdbcTemplate for direct database setup/cleanup.
+   * Ensures test isolation by managing database state.
+   */
+  @Autowired
+  private JdbcTemplate jdbcTemplate;
+
+  /**
+   * UUID of the test user created in setUp.
+   * Shared across tests to verify data relationships.
+   */
+  private UUID testUserId;
+
+  /**
+   * Sets up a clean database state before each test.
+   * Creates a base user for tests requiring existing data.
+   *
+   * <p><strong>Integration:</strong> Direct database manipulation via JdbcTemplate
+   * to ensure consistent starting state for integration tests.
+   */
+  @BeforeEach
+  public void setUp() {
+    // Clean database to ensure test isolation
+    jdbcTemplate.execute("TRUNCATE TABLE users CASCADE");
+
+    // Create a test user via the service (tests service-DB integration)
+    User testUser = new User("IntegrationTestUser", "integration@test.com", 1000.0);
+    User saved = mockApiService.addUser(testUser);
+    testUserId = saved.getUserId();
+  }
+
+  // ===========================================================================
+  // USER ENDPOINT INTEGRATION TESTS
+  // Tests: HTTP → Controller → Service → Database → Response
+  // ===========================================================================
 
   /**
-   * Tests GET /users
-   * Partition: P1 (Valid) - Users exist.
+   * Tests integration for GET /users endpoint.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>HTTP GET request → RouteController.getAllUsers()</li>
+   *   <li>RouteController → MockApiService.viewAllUsers()</li>
+   *   <li>MockApiService → JdbcTemplate → PostgreSQL SELECT query</li>
+   *   <li>Database results → User objects → JSON serialization</li>
+   * </ul>
    */
   @Test
-  public void getAllUsers_usersExist_returns200OkAndUserList() throws Exception {
-    // Arrange
-    User user1 = new User("Alice", "alice@example.com", 100);
-    User user2 = new User("Bob", "bob@example.com", 200);
-    when(mockApiService.viewAllUsers()).thenReturn(List.of(user1, user2));
+  public void getAllUsers_returnsUsersFromDatabase() throws Exception {
+    // Add another user to verify multiple records
+    User user2 = new User("SecondUser", "second@test.com", 500.0);
+    mockApiService.addUser(user2);
 
-    // Act & Assert
     mockMvc.perform(get("/users"))
         .andExpect(status().isOk())
         .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-        .andExpect(jsonPath("$", hasSize(2))) // $ is the root (the list)
-        .andExpect(jsonPath("$[0].username", is("Alice")))
-        .andExpect(jsonPath("$[1].username", is("Bob")));
+        .andExpect(jsonPath("$", hasSize(2)))
+        .andExpect(jsonPath("$[0].username").exists())
+        .andExpect(jsonPath("$[1].username").exists());
   }
 
   /**
-   * Tests GET /users/{userId}
-   * Partition: P1 (Valid) - User exists.
+   * Tests integration for GET /users/{userId} endpoint.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Path variable extraction from URL</li>
+   *   <li>RouteController → MockApiService.getUser(UUID)</li>
+   *   <li>MockApiService → Database SELECT WHERE user_id = ?</li>
+   *   <li>User entity mapping and JSON response</li>
+   * </ul>
    */
   @Test
-  public void getUser_existingUser_returns200OkAndUser() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 100);
-    user.setUserId(userId);
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-
-    // Act & Assert
-    mockMvc.perform(get("/users/{userId}", userId))
+  public void getUser_returnsUserFromDatabase() throws Exception {
+    mockMvc.perform(get("/users/{userId}", testUserId))
         .andExpect(status().isOk())
         .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-        .andExpect(jsonPath("$.username", is("Alice")))
-        .andExpect(jsonPath("$.email", is("alice@example.com")))
-        .andExpect(jsonPath("$.userId", is(userId.toString())));
+        .andExpect(jsonPath("$.userId", is(testUserId.toString())))
+        .andExpect(jsonPath("$.username", is("IntegrationTestUser")))
+        .andExpect(jsonPath("$.email", is("integration@test.com")))
+        .andExpect(jsonPath("$.budget", is(1000.0)));
   }
 
   /**
-   * Tests GET /users/{userId}
-   * Partition: P3 (Invalid) - User does not exist.
-   * This also tests the @ExceptionHandler(NoSuchElementException.class)
+   * Tests integration for GET /users/{userId} with non-existent user.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Database returns empty result</li>
+   *   <li>Service returns Optional.empty()</li>
+   *   <li>Controller throws NoSuchElementException</li>
+   *   <li>@ExceptionHandler converts to 404 response</li>
+   * </ul>
    */
   @Test
-  public void getUser_nonexistentUser_returns404NotFound() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+  public void getUser_nonExistent_returns404() throws Exception {
+    UUID nonExistentId = UUID.randomUUID();
 
-    // Act & Assert
-    mockMvc.perform(get("/users/{userId}", userId))
+    mockMvc.perform(get("/users/{userId}", nonExistentId))
         .andExpect(status().isNotFound())
-        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-        .andExpect(jsonPath("$.error", is("User " + userId + " not found")));
+        .andExpect(jsonPath("$.error", is("User " + nonExistentId + " not found")));
   }
 
   /**
-   * Tests POST /users (JSON)
-   * Partition: P1 (Valid) - Valid user payload.
+   * Tests integration for POST /users (JSON) endpoint.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>JSON request body deserialization to User object</li>
+   *   <li>RouteController validation (null checks)</li>
+   *   <li>MockApiService → Database INSERT with RETURNING</li>
+   *   <li>Database generates UUID, returns to application</li>
+   *   <li>User object serialized to JSON response</li>
+   * </ul>
    */
   @Test
-  public void createUserJson_validUser_returns201Created() throws Exception {
-    // Arrange
-    User userToCreate = new User("NewUser", "new@example.com", 500);
-    
-    // This is what the service will "save" and return
-    User savedUser = new User("NewUser", "new@example.com", 500);
-    savedUser.setUserId(UUID.randomUUID());
-
-    // We use any() because the user object sent to addUser won't have the ID yet
-    when(mockApiService.addUser(any(User.class))).thenReturn(savedUser);
-
-    // Act & Assert
-    mockMvc.perform(post("/users")
-        .contentType(MediaType.APPLICATION_JSON)
-        .content(objectMapper.writeValueAsString(userToCreate)))
+  public void createUserJson_persistsToDatabase() throws Exception {
+    User newUser = new User("NewIntegrationUser", "newuser@test.com", 750.0);
+
+    MvcResult result = mockMvc.perform(post("/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(newUser)))
         .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.username", is("NewUser")))
-        .andExpect(jsonPath("$.userId", is(savedUser.getUserId().toString())));
+        .andExpect(jsonPath("$.username", is("NewIntegrationUser")))
+        .andExpect(jsonPath("$.userId", notNullValue()))
+        .andReturn();
+
+    // Verify data actually persisted to database
+    String response = result.getResponse().getContentAsString();
+    User createdUser = objectMapper.readValue(response, User.class);
+
+    // Query database directly to verify persistence
+    mockMvc.perform(get("/users/{userId}", createdUser.getUserId()))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.username", is("NewIntegrationUser")));
   }
 
   /**
-   * Tests POST /users (JSON)
-   * Partition: P5 (Invalid) - Duplicate email.
-   * This also tests the @ExceptionHandler(IllegalArgumentException.class)
+   * Tests integration for POST /users with duplicate email.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Database unique constraint on email column</li>
+   *   <li>DataIntegrityViolationException thrown by JdbcTemplate</li>
+   *   <li>Controller catches and converts to IllegalArgumentException</li>
+   *   <li>@ExceptionHandler returns 400 response</li>
+   * </ul>
    */
   @Test
-  public void createUserJson_duplicateEmail_returns400BadRequest() throws Exception {
-    // Arrange
-    User userToCreate = new User("NewUser", "taken@example.com", 500);
-    
-    // Mock the service to throw the exception the controller expects
-    when(mockApiService.addUser(any(User.class)))
-        .thenThrow(new IllegalArgumentException("Email already exists: taken@example.com"));
-
-    // Act & Assert
+  public void createUserJson_duplicateEmail_returns400() throws Exception {
+    User duplicateEmailUser = new User("DifferentName", "integration@test.com", 500.0);
+
     mockMvc.perform(post("/users")
-        .contentType(MediaType.APPLICATION_JSON)
-        .content(objectMapper.writeValueAsString(userToCreate)))
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(duplicateEmailUser)))
         .andExpect(status().isBadRequest())
-        .andExpect(jsonPath("$.error", is("Email already exists: taken@example.com")));
+        .andExpect(jsonPath("$.error", containsString("Email already exists")));
   }
 
   /**
-   * Tests POST /users/form (HTML)
-   * Partition: P1 (Valid) - Valid form data.
+   * Tests integration for POST /users with duplicate username.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Database unique constraint on username column</li>
+   *   <li>DataIntegrityViolationException propagation</li>
+   *   <li>Error message extraction and formatting</li>
+   * </ul>
    */
   @Test
-  public void createUserFromFormHtml_validForm_returns201CreatedHtml() throws Exception {
-    // Arrange
-    User savedUser = new User("FormUser", "form@example.com", 300);
-    savedUser.setUserId(UUID.randomUUID());
+  public void createUserJson_duplicateUsername_returns400() throws Exception {
+    User duplicateUsernameUser = new User("IntegrationTestUser", "different@test.com", 500.0);
 
-    when(mockApiService.isUsernameExists("FormUser", null)).thenReturn(false);
-    when(mockApiService.isEmailExists("form@example.com", null)).thenReturn(false);
-    when(mockApiService.addUser(any(User.class))).thenReturn(savedUser);
+    mockMvc.perform(post("/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(duplicateUsernameUser)))
+        .andExpect(status().isBadRequest())
+        .andExpect(jsonPath("$.error", containsString("Username already exists")));
+  }
 
-    // Act & Assert
+  /**
+   * Tests integration for POST /users/form (HTML form submission).
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Form URL-encoded content type handling</li>
+   *   <li>@RequestParam binding to method parameters</li>
+   *   <li>Service uniqueness checks before insert</li>
+   *   <li>HTML response generation with user data</li>
+   * </ul>
+   */
+  @Test
+  public void createUserFromForm_persistsAndReturnsHtml() throws Exception {
     mockMvc.perform(post("/users/form")
-        .contentType(MediaType.APPLICATION_FORM_URLENCODED)
-        .param("username", "FormUser")
-        .param("email", "form@example.com")
-        .param("budget", "300"))
+            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
+            .param("username", "FormCreatedUser")
+            .param("email", "formuser@test.com")
+            .param("budget", "600.0"))
         .andExpect(status().isCreated())
         .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
-        .andExpect(content().string(containsString("User Created Successfully!")))
-        .andExpect(content().string(containsString("FormUser")));
+        .andExpect(content().string(containsString("User Created Successfully")))
+        .andExpect(content().string(containsString("FormCreatedUser")));
+
+    // Verify persisted to database via API
+    mockMvc.perform(get("/users"))
+        .andExpect(jsonPath("$[?(@.username == 'FormCreatedUser')]").exists());
   }
 
   /**
-   * Tests DELETE /users/{userId}
-   * Partition: P1 (Valid) - User exists.
+   * Tests integration for PUT /users/{userId} (JSON update).
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Path variable and request body combined</li>
+   *   <li>Service retrieves existing user from DB</li>
+   *   <li>Uniqueness validation against other users</li>
+   *   <li>Delete-then-insert update strategy</li>
+   *   <li>Updated data persisted and returned</li>
+   * </ul>
    */
   @Test
-  public void deleteUser_existingUser_returns200Ok() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.deleteUser(userId)).thenReturn(true);
+  public void updateUserJson_updatesDatabase() throws Exception {
+    User updates = new User("UpdatedUsername", "updated@test.com", 1500.0);
 
-    // Act & Assert
-    mockMvc.perform(delete("/users/{userId}", userId))
+    mockMvc.perform(put("/users/{userId}", testUserId)
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(updates)))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.username", is("UpdatedUsername")))
+        .andExpect(jsonPath("$.email", is("updated@test.com")))
+        .andExpect(jsonPath("$.budget", is(1500.0)));
+
+    // Verify update persisted
+    mockMvc.perform(get("/users/{userId}", testUserId))
+        .andExpect(jsonPath("$.username", is("UpdatedUsername")));
+  }
+
+  /**
+   * Tests integration for DELETE /users/{userId}.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>RouteController → MockApiService.deleteUser()</li>
+   *   <li>Database DELETE operation</li>
+   *   <li>Cascade delete of related transactions</li>
+   *   <li>Confirmation response generation</li>
+   * </ul>
+   */
+  @Test
+  public void deleteUser_removesFromDatabase() throws Exception {
+    mockMvc.perform(delete("/users/{userId}", testUserId))
         .andExpect(status().isOk())
         .andExpect(jsonPath("$.deleted", is(true)))
-        .andExpect(jsonPath("$.userId", is(userId.toString())));
+        .andExpect(jsonPath("$.userId", is(testUserId.toString())));
+
+    // Verify actually deleted from database
+    mockMvc.perform(get("/users/{userId}", testUserId))
+        .andExpect(status().isNotFound());
+  }
+
+  // ===========================================================================
+  // TRANSACTION ENDPOINT INTEGRATION TESTS
+  // Tests: HTTP → Controller → Service → Database with User relationship
+  // ===========================================================================
+
+  /**
+   * Tests integration for POST /users/{userId}/transactions.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Transaction linked to User via foreign key (userId)</li>
+   *   <li>Service validates user exists before insert</li>
+   *   <li>Database generates transaction_id, timestamp, date</li>
+   *   <li>PostgreSQL ENUM type handling for category</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Transaction.userId references User.userId
+   */
+  @Test
+  public void createTransaction_persistsWithUserRelationship() throws Exception {
+    Transaction newTx = new Transaction(testUserId, 150.0, "FOOD", "Grocery shopping");
+
+    MvcResult result = mockMvc.perform(post("/users/{userId}/transactions", testUserId)
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(newTx)))
+        .andExpect(status().isCreated())
+        .andExpect(jsonPath("$.description", is("Grocery shopping")))
+        .andExpect(jsonPath("$.amount", is(150.0)))
+        .andExpect(jsonPath("$.category", is("FOOD")))
+        .andExpect(jsonPath("$.transactionId", notNullValue()))
+        .andExpect(jsonPath("$.userId", is(testUserId.toString())))
+        .andReturn();
+
+    // Verify transaction retrievable via user's transactions endpoint
+    mockMvc.perform(get("/users/{userId}/transactions", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$", hasSize(1)))
+        .andExpect(jsonPath("$[0].description", is("Grocery shopping")));
   }
 
   /**
-   * Tests DELETE /users/{userId}
-   * Partition: P2 (Invalid) - User does not exist.
+   * Tests integration for GET /users/{userId}/transactions.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>User existence validation</li>
+   *   <li>Database query filtered by user_id foreign key</li>
+   *   <li>Multiple transactions returned as JSON array</li>
+   * </ul>
    */
   @Test
-  public void deleteUser_nonExistentUser_returns404NotFound() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.deleteUser(userId)).thenReturn(false); // Service reports delete failed
+  public void getUserTransactions_returnsUserSpecificTransactions() throws Exception {
+    // Create transactions for test user
+    Transaction tx1 = new Transaction(testUserId, 50.0, "FOOD", "Lunch");
+    Transaction tx2 = new Transaction(testUserId, 100.0, "SHOPPING", "Clothes");
+    mockApiService.addTransaction(tx1);
+    mockApiService.addTransaction(tx2);
+
+    // Create another user with transactions (should not appear)
+    User otherUser = new User("OtherUser", "other@test.com", 500.0);
+    User savedOther = mockApiService.addUser(otherUser);
+    Transaction otherTx = new Transaction(savedOther.getUserId(), 200.0, "OTHER", "Other expense");
+    mockApiService.addTransaction(otherTx);
+
+    // Verify only test user's transactions returned
+    mockMvc.perform(get("/users/{userId}/transactions", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$", hasSize(2)))
+        .andExpect(jsonPath("$[*].userId",
+            org.hamcrest.Matchers.everyItem(is(testUserId.toString()))));
+  }
+
+  /**
+   * Tests integration for GET /users/{userId}/transactions/{transactionId}.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>User existence validation</li>
+   *   <li>Transaction existence validation</li>
+   *   <li>Transaction ownership validation (userId match)</li>
+   *   <li>Single transaction retrieval by ID</li>
+   * </ul>
+   */
+  @Test
+  public void getTransaction_returnsSpecificTransaction() throws Exception {
+    // Create a transaction
+    Transaction tx = new Transaction(testUserId, 75.0, "ENTERTAINMENT", "Movie tickets");
+    Transaction saved = mockApiService.addTransaction(tx);
+
+    mockMvc.perform(get("/users/{userId}/transactions/{transactionId}",
+            testUserId, saved.getTransactionId()))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.transactionId", is(saved.getTransactionId().toString())))
+        .andExpect(jsonPath("$.description", is("Movie tickets")))
+        .andExpect(jsonPath("$.amount", is(75.0)));
+  }
 
-    // Act & Assert
-    mockMvc.perform(delete("/users/{userId}", userId))
+  /**
+   * Tests integration for transaction ownership validation.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Transaction exists but belongs to different user</li>
+   *   <li>Controller validates userId matches transaction.userId</li>
+   *   <li>Returns 404 even though transaction exists (security)</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Tests foreign key relationship enforcement
+   */
+  @Test
+  public void getTransaction_wrongUser_returns404() throws Exception {
+    // Create transaction for test user
+    Transaction tx = new Transaction(testUserId, 50.0, "FOOD", "Snacks");
+    Transaction saved = mockApiService.addTransaction(tx);
+
+    // Create another user
+    User otherUser = new User("OtherUser", "other@test.com", 500.0);
+    User savedOther = mockApiService.addUser(otherUser);
+
+    // Try to access transaction via wrong user's endpoint
+    mockMvc.perform(get("/users/{userId}/transactions/{transactionId}",
+            savedOther.getUserId(), saved.getTransactionId()))
         .andExpect(status().isNotFound())
-        .andExpect(jsonPath("$.error", is("User " + userId + " not found")));
+        .andExpect(jsonPath("$.error", containsString("not found for user")));
   }
 
-  // ---------------------------------------------------------------------------
-  // Transaction Endpoint Tests
-  // ---------------------------------------------------------------------------
+  /**
+   * Tests integration for PUT /users/{userId}/transactions/{transactionId}.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Partial update via Map payload</li>
+   *   <li>Service validates user and transaction exist</li>
+   *   <li>Database UPDATE operation</li>
+   *   <li>Updated transaction returned</li>
+   * </ul>
+   */
+  @Test
+  public void updateTransaction_updatesDatabase() throws Exception {
+    // Create a transaction
+    Transaction tx = new Transaction(testUserId, 100.0, "SHOPPING", "Initial description");
+    Transaction saved = mockApiService.addTransaction(tx);
+
+    // Update amount and description
+    Map<String, Object> updates = Map.of(
+        "amount", 150.0,
+        "description", "Updated description"
+    );
+
+    mockMvc.perform(put("/users/{userId}/transactions/{transactionId}",
+            testUserId, saved.getTransactionId())
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(updates)))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.amount", is(150.0)))
+        .andExpect(jsonPath("$.description", is("Updated description")));
+
+    // Verify update persisted
+    mockMvc.perform(get("/users/{userId}/transactions/{transactionId}",
+            testUserId, saved.getTransactionId()))
+        .andExpect(jsonPath("$.amount", is(150.0)))
+        .andExpect(jsonPath("$.description", is("Updated description")));
+  }
 
   /**
-   * Tests GET /users/{userId}/transactions
-   * Partition: P1 (Valid) - User exists, transactions returned.
+   * Tests integration for DELETE /users/{userId}/transactions/{transactionId}.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Ownership validation before delete</li>
+   *   <li>Database DELETE operation</li>
+   *   <li>Confirmation response</li>
+   *   <li>Subsequent retrieval returns 404</li>
+   * </ul>
    */
   @Test
-  public void getUserTransactions_existingUser_returns200OkAndTransactions() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    Transaction t1 = new Transaction(userId, 50.0, "Food", "Lunch");
-    Transaction t2 = new Transaction(userId, 120.0, "Shopping", "Clothes");
-    t1.setTransactionId(UUID.randomUUID());
-    t2.setTransactionId(UUID.randomUUID());
-    
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(new User())); // User exists
-    when(mockApiService.getTransactionsByUser(userId)).thenReturn(List.of(t1, t2));
-
-    // Act & Assert
-    mockMvc.perform(get("/users/{userId}/transactions", userId))
+  public void deleteTransaction_removesFromDatabase() throws Exception {
+    // Create a transaction
+    Transaction tx = new Transaction(testUserId, 50.0, "OTHER", "To be deleted");
+    Transaction saved = mockApiService.addTransaction(tx);
+
+    // Delete the transaction
+    mockMvc.perform(delete("/users/{userId}/transactions/{transactionId}",
+            testUserId, saved.getTransactionId()))
         .andExpect(status().isOk())
-        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-        .andExpect(jsonPath("$", hasSize(2)))
-        .andExpect(jsonPath("$[0].description", is("Lunch")))
-        .andExpect(jsonPath("$[1].description", is("Clothes")));
+        .andExpect(jsonPath("$.deleted", is(true)));
+
+    // Verify actually deleted
+    mockMvc.perform(get("/users/{userId}/transactions/{transactionId}",
+            testUserId, saved.getTransactionId()))
+        .andExpect(status().isNotFound());
   }
 
   /**
-   * Tests POST /users/{userId}/transactions
-   * Partition: P1 (Valid) - Valid user and transaction.
+   * Tests cascade delete: deleting user removes their transactions.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>User-Transaction foreign key with ON DELETE CASCADE</li>
+   *   <li>Database cascades delete to child records</li>
+   *   <li>Full-stack verification via API</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Tests referential integrity between tables
    */
   @Test
-  public void createTransactionJson_valid_returns201Created() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    Transaction savedTx = new Transaction(userId, 75.0, "Food", "Dinner");
-    savedTx.setTransactionId(UUID.randomUUID());
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(new User())); // User exists
-    when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(savedTx);
-
-    Transaction txToCreate = new Transaction(userId, 75.0, "Food", "Dinner");
-    // Act & Assert
-    mockMvc.perform(post("/users/{userId}/transactions", userId)
-        .contentType(MediaType.APPLICATION_JSON)
-        .content(objectMapper.writeValueAsString(txToCreate)))
-        .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.description", is("Dinner")))
-        .andExpect(jsonPath("$.transactionId", is(savedTx.getTransactionId().toString())));
+  public void deleteUser_cascadesTransactionDeletion() throws Exception {
+    // Create transactions for user
+    Transaction tx1 = new Transaction(testUserId, 50.0, "FOOD", "Lunch");
+    Transaction tx2 = new Transaction(testUserId, 100.0, "SHOPPING", "Clothes");
+    Transaction savedTx1 = mockApiService.addTransaction(tx1);
+    Transaction savedTx2 = mockApiService.addTransaction(tx2);
+
+    // Verify transactions exist
+    mockMvc.perform(get("/users/{userId}/transactions", testUserId))
+        .andExpect(jsonPath("$", hasSize(2)));
+
+    // Delete user
+    mockMvc.perform(delete("/users/{userId}", testUserId))
+        .andExpect(status().isOk());
+
+    // Verify user deleted
+    mockMvc.perform(get("/users/{userId}", testUserId))
+        .andExpect(status().isNotFound());
+
+    // Create new user to query transactions endpoint
+    User newUser = new User("NewUser", "new@test.com", 500.0);
+    User savedNew = mockApiService.addUser(newUser);
+
+    // Transactions should be gone (cascade delete)
+    // Attempting to get deleted transactions returns 404
+    mockMvc.perform(get("/users/{userId}/transactions/{transactionId}",
+            savedNew.getUserId(), savedTx1.getTransactionId()))
+        .andExpect(status().isNotFound());
+  }
+
+  // ===========================================================================
+  // BUDGET & ANALYTICS INTEGRATION TESTS
+  // Tests: Aggregation queries spanning User and Transaction tables
+  // ===========================================================================
+
+  /**
+   * Tests integration for GET /users/{userId}/budget-report.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>User data retrieval (budget amount)</li>
+   *   <li>Transaction aggregation (SUM by category)</li>
+   *   <li>Business logic calculations (remaining, warnings)</li>
+   *   <li>Complex JSON response structure</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Combines User.budget with Transaction.amount
+   */
+  @Test
+  public void getBudgetReport_aggregatesUserAndTransactionData() throws Exception {
+    // Create transactions for the test user
+    Transaction tx1 = new Transaction(testUserId, 200.0, "FOOD", "Groceries");
+    Transaction tx2 = new Transaction(testUserId, 300.0, "SHOPPING", "Electronics");
+    Transaction tx3 = new Transaction(testUserId, 100.0, "FOOD", "Dining out");
+    mockApiService.addTransaction(tx1);
+    mockApiService.addTransaction(tx2);
+    mockApiService.addTransaction(tx3);
+
+    mockMvc.perform(get("/users/{userId}/budget-report", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.userId", is(testUserId.toString())))
+        .andExpect(jsonPath("$.username", is("IntegrationTestUser")))
+        .andExpect(jsonPath("$.totalBudget", is(1000.0)))
+        .andExpect(jsonPath("$.totalSpent", is(600.0)))  // 200 + 300 + 100
+        .andExpect(jsonPath("$.remaining", is(400.0)))   // 1000 - 600
+        .andExpect(jsonPath("$.isOverBudget", is(false)))
+        .andExpect(jsonPath("$.categories.FOOD", is(300.0)))  // 200 + 100
+        .andExpect(jsonPath("$.categories.SHOPPING", is(300.0)));
   }
 
   /**
-   * Tests POST /users/{userId}/transactions
-   * Partition: (Invalid) - User does not exist.
+   * Tests integration for PUT /users/{userId}/budget.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Budget update via JSON payload</li>
+   *   <li>Service validates user exists</li>
+   *   <li>Database UPDATE on users table</li>
+   *   <li>Returns updated budget report</li>
+   * </ul>
    */
   @Test
-  public void createTransactionJson_userNotFound_returns404NotFound() throws Exception {
-    // Arrange
-    UUID userId = UUID.randomUUID();
-    Transaction txToCreate = new Transaction(userId, 75.0, "Food", "Dinner");
+  public void updateBudgetJson_updatesDatabaseAndReturnsReport() throws Exception {
+    Map<String, Object> budgetUpdate = Map.of("budget", 2000.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty()); // User does NOT exist
+    mockMvc.perform(put("/users/{userId}/budget", testUserId)
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(budgetUpdate)))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.totalBudget", is(2000.0)));
+
+    // Verify budget actually updated in database
+    mockMvc.perform(get("/users/{userId}", testUserId))
+        .andExpect(jsonPath("$.budget", is(2000.0)));
+  }
+
+  /**
+   * Tests integration for GET /users/{userId}/weekly-summary.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Date-based filtering (transactions from last 7 days)</li>
+   *   <li>Database query with date comparison</li>
+   *   <li>Aggregation of filtered results</li>
+   *   <li>Summary statistics calculation</li>
+   * </ul>
+   */
+  @Test
+  public void getWeeklySummary_filtersAndAggregates() throws Exception {
+    // Create transactions (will have today's date from DB trigger)
+    Transaction tx1 = new Transaction(testUserId, 50.0, "FOOD", "Recent lunch");
+    Transaction tx2 = new Transaction(testUserId, 75.0, "OTHER", "Recent expense");
+    mockApiService.addTransaction(tx1);
+    mockApiService.addTransaction(tx2);
+
+    mockMvc.perform(get("/users/{userId}/weekly-summary", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.username", is("IntegrationTestUser")))
+        .andExpect(jsonPath("$.weeklyTotal", is(125.0)))  // 50 + 75
+        .andExpect(jsonPath("$.transactionCount", is(2)))
+        .andExpect(jsonPath("$.transactions", hasSize(2)));
+  }
+
+  /**
+   * Tests integration for GET /users/{userId}/monthly-summary.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Monthly date filtering</li>
+   *   <li>Category-based grouping</li>
+   *   <li>String report generation</li>
+   * </ul>
+   */
+  @Test
+  public void getMonthlySummary_generatesReport() throws Exception {
+    // Create transactions
+    Transaction tx1 = new Transaction(testUserId, 100.0, "FOOD", "Groceries");
+    Transaction tx2 = new Transaction(testUserId, 50.0, "FOOD", "Snacks");
+    mockApiService.addTransaction(tx1);
+    mockApiService.addTransaction(tx2);
+
+    mockMvc.perform(get("/users/{userId}/monthly-summary", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.summary", containsString("Total Budget")))
+        .andExpect(jsonPath("$.summary", containsString("Total Spent")))
+        .andExpect(jsonPath("$.summary", containsString("FOOD")));
+  }
+
+  /**
+   * Tests budget over-spending detection across layers.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Transactions exceed user's budget</li>
+   *   <li>Service calculates negative remaining</li>
+   *   <li>isOverBudget flag set correctly</li>
+   *   <li>Warnings generated based on business rules</li>
+   * </ul>
+   *
+   * <p><strong>Shared Data:</strong> Budget comparison requires both User and Transaction data
+   */
+  @Test
+  public void getBudgetReport_detectsOverBudget() throws Exception {
+    // Create transactions that exceed budget (1000)
+    Transaction tx1 = new Transaction(testUserId, 600.0, "SHOPPING", "Big purchase");
+    Transaction tx2 = new Transaction(testUserId, 500.0, "OTHER", "Another expense");
+    mockApiService.addTransaction(tx1);
+    mockApiService.addTransaction(tx2);
+
+    mockMvc.perform(get("/users/{userId}/budget-report", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(jsonPath("$.totalSpent", is(1100.0)))
+        .andExpect(jsonPath("$.remaining", is(-100.0)))
+        .andExpect(jsonPath("$.isOverBudget", is(true)))
+        .andExpect(jsonPath("$.hasWarnings", is(true)));
+  }
+
+  // ===========================================================================
+  // HTML ENDPOINT INTEGRATION TESTS
+  // Tests: Form submissions and HTML response generation
+  // ===========================================================================
+
+  /**
+   * Tests integration for GET / (index page).
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Fetches all users from database</li>
+   *   <li>Generates HTML with user links</li>
+   *   <li>Content-Type negotiation (TEXT_HTML)</li>
+   * </ul>
+   */
+  @Test
+  public void indexPage_displaysUsersFromDatabase() throws Exception {
+    mockMvc.perform(get("/"))
+        .andExpect(status().isOk())
+        .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
+        .andExpect(content().string(containsString("Welcome to the Personal Finance Tracker")))
+        .andExpect(content().string(containsString("IntegrationTestUser")))
+        .andExpect(content().string(containsString("integration@test.com")));
+  }
+
+  /**
+   * Tests integration for GET /users/{userId}/budget (HTML page).
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>User lookup from database</li>
+   *   <li>Budget report generation</li>
+   *   <li>Weekly spending calculation</li>
+   *   <li>HTML page rendering with data</li>
+   * </ul>
+   */
+  @Test
+  public void budgetManagementPage_displaysUserBudgetData() throws Exception {
+    // Add some transactions
+    Transaction tx = new Transaction(testUserId, 250.0, "FOOD", "Weekly groceries");
+    mockApiService.addTransaction(tx);
+
+    mockMvc.perform(get("/users/{userId}/budget", testUserId))
+        .andExpect(status().isOk())
+        .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
+        .andExpect(content().string(containsString("Budget Management")))
+        .andExpect(content().string(containsString("IntegrationTestUser")));
+  }
+
+  /**
+   * Tests integration for POST /users/{userId}/update-budget (HTML form).
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Form parameter extraction</li>
+   *   <li>User lookup and validation</li>
+   *   <li>Budget update in database</li>
+   *   <li>HTML success response</li>
+   * </ul>
+   */
+  @Test
+  public void updateBudgetForm_updatesAndReturnsHtml() throws Exception {
+    mockMvc.perform(post("/users/{userId}/update-budget", testUserId)
+            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
+            .param("budget", "1500.0"))
+        .andExpect(status().isOk())
+        .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
+        .andExpect(content().string(containsString("Budget Updated Successfully")))
+        .andExpect(content().string(containsString("1500.00")));
+
+    // Verify update persisted
+    mockMvc.perform(get("/users/{userId}", testUserId))
+        .andExpect(jsonPath("$.budget", is(1500.0)));
+  }
+
+  /**
+   * Tests integration for transaction form submission.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Form data to Transaction object conversion</li>
+   *   <li>User existence validation</li>
+   *   <li>Database INSERT with form data</li>
+   *   <li>HTML confirmation page</li>
+   * </ul>
+   */
+  @Test
+  public void createTransactionForm_persistsAndReturnsHtml() throws Exception {
+    mockMvc.perform(post("/users/{userId}/transactions/form", testUserId)
+            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
+            .param("description", "Form-created transaction")
+            .param("amount", "99.99")
+            .param("category", "OTHER"))
+        .andExpect(status().isCreated())
+        .andExpect(content().contentTypeCompatibleWith(MediaType.TEXT_HTML))
+        .andExpect(content().string(containsString("Transaction Created Successfully")));
+
+    // Verify persisted
+    mockMvc.perform(get("/users/{userId}/transactions", testUserId))
+        .andExpect(jsonPath("$[0].description", is("Form-created transaction")))
+        .andExpect(jsonPath("$[0].amount", is(99.99)));
+  }
+
+  // ===========================================================================
+  // EXCEPTION HANDLER INTEGRATION TESTS
+  // Tests: Exception propagation through all layers
+  // ===========================================================================
 
-    // Act & Assert
-    mockMvc.perform(post("/users/{userId}/transactions", userId)
-        .contentType(MediaType.APPLICATION_JSON)
-        .content(objectMapper.writeValueAsString(txToCreate)))
+  /**
+   * Tests NoSuchElementException handling.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Database returns no results</li>
+   *   <li>Service returns Optional.empty()</li>
+   *   <li>Controller throws NoSuchElementException</li>
+   *   <li>@ExceptionHandler intercepts and formats response</li>
+   *   <li>HTTP 404 status with JSON error body</li>
+   * </ul>
+   */
+  @Test
+  public void exceptionHandler_notFound_returns404Json() throws Exception {
+    UUID nonExistentId = UUID.randomUUID();
+
+    mockMvc.perform(get("/users/{userId}/budget-report", nonExistentId))
         .andExpect(status().isNotFound())
-        .andExpect(jsonPath("$.error", is("User " + userId + " not found")));
+        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+        .andExpect(jsonPath("$.error", containsString("not found")));
+  }
+
+  /**
+   * Tests IllegalArgumentException handling.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Invalid data sent to controller</li>
+   *   <li>Controller validates and throws IllegalArgumentException</li>
+   *   <li>@ExceptionHandler intercepts and formats response</li>
+   *   <li>HTTP 400 status with JSON error body</li>
+   * </ul>
+   */
+  @Test
+  public void exceptionHandler_internal_badRequest_returns400Json() throws Exception {
+    // Null username triggers validation error in controller
+    User invalidUser = new User(null, "valid@email.com", 100.0);
+
+    mockMvc.perform(post("/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(invalidUser)))
+        .andExpect(status().isBadRequest())
+        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+        .andExpect(jsonPath("$.error").exists());
+  }
+
+  // ===========================================================================
+  // CONCURRENT ACCESS INTEGRATION TESTS
+  // Tests: Database handles concurrent operations correctly
+  // ===========================================================================
+
+  /**
+   * Tests that unique constraints are enforced under concurrent-like conditions.
+   *
+   * <p><strong>Integration Points:</strong>
+   * <ul>
+   *   <li>Multiple requests attempting same operation</li>
+   *   <li>Database unique constraint enforcement</li>
+   *   <li>Proper error responses for violations</li>
+   * </ul>
+   */
+  @Test
+  public void uniqueConstraint_enforcedAcrossRequests() throws Exception {
+    // First request succeeds
+    User user1 = new User("UniqueUser", "unique@test.com", 100.0);
+    mockMvc.perform(post("/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(user1)))
+        .andExpect(status().isCreated());
+
+    // Second request with same username fails
+    User user2 = new User("UniqueUser", "different@test.com", 200.0);
+    mockMvc.perform(post("/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content(objectMapper.writeValueAsString(user2)))
+        .andExpect(status().isBadRequest())
+        .andExpect(jsonPath("$.error", containsString("Username already exists")));
   }
 }
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/RouteControllerTests.java b/src/test/java/dev/ase/teamproject/RouteControllerTests.java
index d1466d9..6c7649b 100644
--- a/src/test/java/dev/ase/teamproject/RouteControllerTests.java
+++ b/src/test/java/dev/ase/teamproject/RouteControllerTests.java
@@ -8,8 +8,8 @@
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyMap;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -40,1209 +40,284 @@
 import org.springframework.http.ResponseEntity;
 
 /**
- * Test Plan / Equivalence Partitions for RouteController
+ * Unit tests for the {@link RouteController} class.
  *
- * <p>Endpoints:
+ * <p>This test suite validates all public endpoints in the RouteController,
+ * covering valid and invalid equivalence partitions including boundary values.
+ * Tests use Mockito to mock the MockApiService dependency and share common setup
+ * through {@code @BeforeEach} and {@code @AfterEach}.
  *
- * <p>1. GET /index 
- * - P1: users list non-empty -> HTML with user entries
- *   - Covered by: index_usersExist_returnsHtmlListOfUsers 
- * - P2: users list empty -> HTML with "No users found" 
- *   - Covered by: index_noUsers_returnsNoUsersMessage 
- * - P3: service throws RuntimeException -> controller propagates RuntimeException
- *   - Covered by: index_serviceThrowsException_throwsRuntimeException
+ * <h2>Equivalence Partitions by Endpoint</h2>
  *
- * <p>2. GET /users/{userId}
- * - P1: userId exists -> 200 OK, User in body
- *   - Covered by: getUser_existingUser_returnsUserWith200 
- * - P2: userId exists, minimal fields -> 200 OK, minimal user 
- *   - Covered by: getUser_minimalUserFields_returnsUserWith200 
- * - P3: userId does not exist -> NoSuchElementException 
- *   - Covered by: getUser_nonexistentUser_throwsNoSuchElementException
+ * <h3>1. GET / or /index</h3>
+ * <ul>
+ *   <li>P1: (Valid) Users exist - returns HTML with user list</li>
+ *   <li>P2: (Valid/Boundary) No users - returns "No users found" message</li>
+ *   <li>P3: (Invalid) Service throws exception - propagates RuntimeException</li>
+ *   <li>P4: (Edge) Logger disabled - still returns correct HTML</li>
+ * </ul>
  *
- * <p>3. POST /users (JSON)
- * - Input User:
- *   - username: { non-null, null }
- *   - email: { non-null, null }
- *   - DB constraints: { unique OK, duplicate email, duplicate username, other violation }
- * - P1: valid user, service OK -> 201 CREATED, user returned
- *   - Covered by: createUserJson_validUser_returnsCreatedUserWith201
- * - P2: valid user, service RuntimeException -> wrapped RuntimeException
- *   - Covered by: createUserJson_serviceThrowsException_throwsRuntimeException
- * - P3: username == null -> IllegalArgumentException("Username field is required")
- *   - Covered by: createUserJson_missingUsername_throwsIllegalArgumentException
- * - P4: email == null -> IllegalArgumentException("Email field is required")
- *   - Covered by: createUserJson_missingEmail_throwsIllegalArgumentException
- * - P5: DataIntegrityViolation: duplicate email -> 
- *         IllegalArgumentException("Email already exists: ...")
- *   - Covered by: createUserJson_duplicateEmail_throwsIllegalArgumentException
- * - P6: DataIntegrityViolation: duplicate username -> 
- *         IllegalArgumentException("Username already exists: ...")
- *   - Covered by: createUserJson_duplicateUsername_throwsIllegalArgumentException
- * - P7: DataIntegrityViolation: other DB constraint -> 
- *         IllegalArgumentException("Data integrity violation")
- *   - Covered by: createUserJson_genericDataIntegrityViolation_throwsIllegalArgumentException
+ * <h3>2. GET /users</h3>
+ * <ul>
+ *   <li>P1: (Valid) Returns list of users from service</li>
+ *   <li>P2: (Edge) Logger disabled - still returns list</li>
+ * </ul>
  *
- * <p>4. POST /users/form (HTML)
- * - P1: new username/email, OK -> 201 CREATED HTML success
- *   - Covered by: createUserFromFormHtml_validForm_returnsHtmlSuccessWith201
- * - P2: budget == 0 boundary -> 201 CREATED HTML with $0.00
- *   - Covered by: createUserFromFormHtml_zeroBudget_returnsHtmlSuccessWith201
- * - P3: duplicate username -> 400 BAD_REQUEST, "Username already in use"
- *   - Covered by: createUserFromFormHtml_duplicateUsername_returns400
- * - P4: duplicate email -> 400 BAD_REQUEST, "User email already in use"
- *   - Covered by: createUserFromFormHtml_duplicateEmail_returns400
- * - P5: service throws RuntimeException -> propagated RuntimeException
- *   - Covered by: createUserFromFormHtml_serviceThrowsException_throwsRuntimeException
+ * <h3>3. GET /users/{userId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns 200 OK with user</li>
+ *   <li>P2: (Valid/Edge) User with minimal fields - returns 200 OK</li>
+ *   <li>P3: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
  *
- * <p>5. PUT /users/{userId} (JSON)
- * - P1: user exists, all fields updated -> 200 OK with updated user
- *   - Covered by: updateUserJson_existingUser_returnsUpdatedUserWith200
- * - P2: user exists, budget boundary 0.0 -> 200 OK, 0 budget allowed
- *   - Covered by: updateUserJson_zeroBudget_returnsUpdatedUserWith200
- * - P3: userId not found -> NoSuchElementException
- *   - Covered by: updateUserJson_userNotFound_throwsNoSuchElementException
- * - P4: duplicate username (isUsernameExists) -> IllegalArgumentException
- *   - Covered by: updateUserJson_duplicateUsername_throwsIllegalArgumentException
- * - P5: duplicate email (isEmailExists) -> IllegalArgumentException
- *   - Covered by: updateUserJson_duplicateEmail_throwsIllegalArgumentException
+ * <h3>4. POST /users (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid user - returns 201 CREATED</li>
+ *   <li>P2: (Valid/Edge) Empty email string - returns 201 CREATED</li>
+ *   <li>P3: (Invalid) Null username - throws RuntimeException with cause</li>
+ *   <li>P4: (Invalid) Null email - throws RuntimeException with cause</li>
+ *   <li>P5: (Invalid) Duplicate email - throws IllegalArgumentException</li>
+ *   <li>P6: (Invalid) Duplicate username - throws IllegalArgumentException</li>
+ *   <li>P7: (Invalid) Generic data integrity violation - throws IllegalArgumentException</li>
+ *   <li>P8: (Invalid) Service throws exception - throws IllegalStateException</li>
+ *   <li>P9: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
  *
- * <p>6. Other endpoints (summaries, budgets, transactions)
- * - /users/{userId}/transactions (list, get, create, update, delete)
- *   - Typical input partitions: valid userId, valid transaction payload
- *   - Atypical input partitions: boundary amounts, empty lists, edge dates
- *   - Invalid input partitions: non-existent userId, malformed payload, negative amounts
- *   - Each case is covered by corresponding tests using the
- *     "Typical / Atypical / Invalid input" naming pattern.
- * - /users/{userId}/budget, /weekly-summary, /monthly-summary, /budget-report
- *   - Typical: valid user, normal data ranges
- *   - Atypical: zero / boundary budgets, empty histories, edge date ranges
- *   - Invalid: user not found, inconsistent or malformed parameters
- *   - Each equivalence partition is covered by dedicated tests following the
- *     same naming convention.
+ * <h3>5. POST /users/form (HTML)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid form data - returns 201 CREATED HTML</li>
+ *   <li>P2: (Valid/Boundary) Zero budget - returns 201 CREATED with $0.00</li>
+ *   <li>P3: (Invalid) Duplicate username - returns 400 BAD_REQUEST</li>
+ *   <li>P4: (Invalid) Duplicate email - returns 400 BAD_REQUEST</li>
+ *   <li>P5: (Invalid) Service throws exception - propagates exception</li>
+ *   <li>P6: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
  *
- * <p>Exception Handlers:
- * - handleNotFound: maps NoSuchElementException -> 404 with {"error": msg}
- *   - Covered by: handleNotFound_returns404WithErrorMessage
- * - handleBadRequest: maps IllegalArgumentException -> 400 with {"error": msg}
- *   - Covered by: handleBadRequest_returns400WithErrorMessage
- */
-@ExtendWith(MockitoExtension.class)
-public class RouteControllerTests {
-
-  /**
-   * A mock implementation of the service layer.
-   */
-  @Mock
-  private MockApiService mockApiService;
-
-  /**
-   * The instance of the controller under test, with mocks injected.
-   */
-  @InjectMocks
-  private RouteController routeController;
-
-  /**
-   * Set up logic before each test (if any).
-   */
-  @BeforeEach
-  public void setUp() {
-    // Initialization code, if needed
-  }
-
-  /**
-   * Tear down logic after each test (if any).
-   */
-  @AfterEach
-  public void tearDown() {
-    // Cleanup code, if needed
-  }
-
-  /**
-   * Helper method to temporarily set the log level for the controller's
-   * logger. Returns the original level so it can be restored.
-   *
-   * @param level The new level (e.g., Level.OFF)
-   * @return The original Level
-   */
-  private Level setLogLevel(Level level) {
-    Logger logger = Logger.getLogger(RouteController.class.getName());
-    Level original = logger.getLevel();
-    logger.setLevel(level);
-    return original;
-  }
-
-  /**
-   * Tests GET /index with the logger disabled to cover the 'isLoggable'
-   * branch.
-   */
-  @Test
-  public void index_loggerOff_stillReturnsHtml() {
-    Logger logger = Logger.getLogger(RouteController.class.getName());
-    Level original = logger.getLevel();
-    try {
-      logger.setLevel(Level.OFF); // isLoggable(Level.INFO) -> false
-
-      when(mockApiService.viewAllUsers()).thenReturn(List.of());
-      ResponseEntity<String> response = routeController.index();
-
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      logger.setLevel(original);  // restore
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // New Tests for Logger Branch Coverage (Level.OFF)
-  // These tests ensure all `if (LOGGER.isLoggable(...))` branches are covered
-  // by running scenarios with the logger level set to OFF.
-  // ---------------------------------------------------------------------------
-  /**
-   * Tests GET /users with the logger disabled.
-   */
-  @Test
-  public void getAllUsers_loggerOff_stillReturnsList() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      List<User> users = List.of(new User("Alice", "a@a.com", 100));
-      when(mockApiService.viewAllUsers()).thenReturn(users);
-      List<User> result = routeController.getAllUsers();
-      assertEquals(users, result);
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId} (happy path) with the logger disabled.
-   */
-  @Test
-  public void getUser_loggerOff_existingUser_returnsUserWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1200.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      ResponseEntity<User> response = routeController.getUser(userId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-      assertEquals(user, response.getBody());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId} (not found path) with the logger disabled.
-   */
-  @Test
-  public void getUser_loggerOff_nonexistentUser_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.getUser(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users (happy path) with the logger disabled.
-   */
-  @Test
-  public void createUserJson_loggerOff_validUser_returnsCreatedUserWith201() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      User user = new User("Alice", "alice@example.com", 1500.0);
-      when(mockApiService.addUser(user)).thenReturn(user);
-      ResponseEntity<User> response = routeController.createUserJson(user);
-      assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users (duplicate email path) with the logger disabled.
-   */
-  @Test
-  public void createUserJson_loggerOff_duplicateEmail_throwsIllegalArgumentException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      DataIntegrityViolationException ex = new DataIntegrityViolationException(
-          "constraint violation", new RuntimeException("users_email_key"));
-      when(mockApiService.addUser(user)).thenThrow(ex);
-      assertThrows(IllegalArgumentException.class, () -> routeController.createUserJson(user));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users (generic exception path) with the logger disabled.
-   */
-  @Test
-  public void createUserJson_loggerOff_serviceThrowsException_throwsRuntimeException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      User user = new User("Charlie", "charlie@example.com", 800.0);
-      when(mockApiService.addUser(user)).thenThrow(new RuntimeException("Database error"));
-      assertThrows(RuntimeException.class, () -> routeController.createUserJson(user));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/form (happy path) with the logger disabled.
-   */
-  @Test
-  public void createUserFromFormHtml_loggerOff_validForm_returnsHtmlSuccessWith201() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      User saved = new User("Alice", "alice@example.com", 1500.0);
-      when(mockApiService.addUser(any(User.class))).thenReturn(saved);
-      ResponseEntity<String> response = routeController.createUserFromFormHtml(
-          "Alice", "alice@example.com", 1500.0);
-      assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/form (duplicate username path) with the logger
-   * disabled.
-   */
-  @Test
-  public void createUserFromFormHtml_loggerOff_duplicateUsername_returns400() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      when(mockApiService.isUsernameExists("Alice", null)).thenReturn(true);
-      ResponseEntity<String> response = routeController.createUserFromFormHtml(
-          "Alice", "alice@example.com", 500.0);
-      assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId} (happy path) with the logger disabled.
-   */
-  @Test
-  public void updateUserJson_loggerOff_existingUser_returnsUpdatedUserWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User existingUser = new User("Alice", "old@example.com", 1000.0);
-      User updatedUser = new User("Alice", "new@example.com", 1200.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-      when(mockApiService.addUser(updatedUser)).thenReturn(updatedUser);
-      ResponseEntity<User> response =
-          routeController.updateUserJson(userId, updatedUser);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId} (not found path) with the logger disabled.
-   */
-  @Test
-  public void updateUserJson_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User updatedUser = new User("Eve", "eve@example.com", 900.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateUserJson(userId, updatedUser));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/update-form (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void updateUserFromFormHtml_loggerOff_existingUser_returnsHtmlSuccessWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User existingUser = new User("Alice", "alice@example.com", 1000.0);
-      User savedUser = new User("Alice", "alice_new@example.com", 1200.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-      when(mockApiService.addUser(any(User.class))).thenReturn(savedUser);
-      ResponseEntity<String> response = routeController.updateUserFromFormHtml(
-          userId, "Alice", "alice_new@example.com", 1200.0);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/update-form (not found path) with the logger
-   * disabled.
-   */
-  @Test
-  public void updateUserFromFormHtml_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateUserFromFormHtml(
-              userId, "Eve", "eve@example.com", 100.0));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/create-form with the logger disabled.
-   */
-  @Test
-  public void showCreateUserForm_loggerOff_returnsExpectedHtmlForm() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      String html = routeController.showCreateUserForm();
-      assertTrue(html.contains("<h2>Create New User</h2>"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/edit-form (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void showEditUserForm_loggerOff_existingUser_returnsPopulatedFormHtml() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      String html = routeController.showEditUserForm(userId);
-      assertTrue(html.contains("<h2>Edit User</h2>"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/edit-form (not found path) with the logger
-   * disabled.
-   */
-  @Test
-  public void showEditUserForm_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.showEditUserForm(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId} (happy path) with the logger disabled.
-   */
-  @Test
-  public void deleteUser_loggerOff_existingUser_returnsConfirmationMapWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.deleteUser(userId)).thenReturn(true);
-      ResponseEntity<Map<String, Object>> response = routeController.deleteUser(userId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId} (not found path) with the logger disabled.
-   */
-  @Test
-  public void deleteUser_loggerOff_alreadyDeletedUser_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.deleteUser(userId)).thenReturn(false);
-      assertThrows(NoSuchElementException.class, () -> routeController.deleteUser(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /deleteuser/{userId} (happy path) with the logger disabled.
-   */
-  @Test
-  public void deleteUserViaGet_loggerOff_existingUser_returnsSuccessMessage() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.deleteUser(userId)).thenReturn(true);
-      String result = routeController.deleteUserViaGet(userId);
-      assertEquals("User deleted successfully", result);
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /deleteuser/{userId} (not found path) with the logger disabled.
-   */
-  @Test
-  public void deleteUserViaGet_loggerOff_alreadyDeletedUser_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.deleteUser(userId)).thenReturn(false);
-      assertThrows(NoSuchElementException.class, () -> routeController.deleteUserViaGet(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void getUserTransactions_loggerOff_existingUser_returnsTransactionsWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransactionsByUser(userId)).thenReturn(new ArrayList<>());
-      ResponseEntity<?> response = routeController.getUserTransactions(userId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions (user not found path) with the
-   * logger disabled.
-   */
-  @Test
-  public void getUserTransactions_loggerOff_userDoesNotExist_returns404Error() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      ResponseEntity<?> response = routeController.getUserTransactions(userId);
-      assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions (service error path) with the
-   * logger disabled.
-   */
-  @Test
-  public void getUserTransactions_loggerOff_serviceThrowsException_returns500Error() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Carol", "carol@example.com", 700.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransactionsByUser(userId))
-          .thenThrow(new RuntimeException("Database error"));
-      ResponseEntity<?> response = routeController.getUserTransactions(userId);
-      assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions/{txId} (happy path) with the
-   * logger disabled.
-   */
-  @Test
-  public void getTransaction_loggerOff_existingUserAndTransaction_returnsTransactionWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      Transaction tx = new Transaction(userId, 50.0, "Food", "Lunch");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      ResponseEntity<Transaction> response =
-          routeController.getTransaction(userId, transactionId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions/{txId} (user not found path) with
-   * the logger disabled.
-   */
-  @Test
-  public void getTransaction_loggerOff_userDoesNotExist_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.getTransaction(userId, transactionId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void
-      createTransactionJson_loggerOff_validUserAndTransaction_returnsCreatedTransactionWith201() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      Transaction transaction = new Transaction(userId, 75.0, "Food", "Lunch");
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.addTransaction(transaction)).thenReturn(transaction);
-      ResponseEntity<Transaction> response =
-          routeController.createTransactionJson(userId, transaction);
-      assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions (user not found path) with the
-   * logger disabled.
-   */
-  @Test
-  public void createTransactionJson_loggerOff_userDoesNotExist_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      Transaction transaction = new Transaction(userId, 100.0, "Travel", "Trip");
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.createTransactionJson(userId, transaction));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions (service error path) with the
-   * logger disabled.
-   */
-  @Test
-  public void createTransactionJson_loggerOff_serviceThrows_propagatesException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      Transaction tx = new Transaction();
-      when(mockApiService.getUser(userId))
-          .thenReturn(Optional.of(new User("u", "u@x.com", 100)));
-      when(mockApiService.addTransaction(any(Transaction.class)))
-          .thenThrow(new RuntimeException("DB insert broke"));
-      assertThrows(RuntimeException.class,
-          () -> routeController.createTransactionJson(userId, tx));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions/form (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void createTransactionFromFormHtml_loggerOff_validUser_returnsHtmlSuccessWith201() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      Transaction saved = new Transaction(userId, 120.0, "Shopping", "Clothes");
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(saved);
-      ResponseEntity<String> response = routeController.createTransactionFromFormHtml(
-          userId, "Clothes", 120.0, "Shopping");
-      assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions/form (user not found path) with
-   * the logger disabled.
-   */
-  @Test
-  public void createTransactionFromFormHtml_loggerOff_userDoesNotExist_returns404Error() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      ResponseEntity<String> response = routeController.createTransactionFromFormHtml(
-          userId, "Test", 40.0, "Misc");
-      assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/transactions/form (service error path) with
-   * the logger disabled.
-   */
-  @Test
-  public void createTransactionFromFormHtml_loggerOff_serviceThrowsException_returns500Error() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Carol", "carol@example.com", 700.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.addTransaction(any(Transaction.class)))
-          .thenThrow(new RuntimeException("Database error"));
-      ResponseEntity<String> response = routeController.createTransactionFromFormHtml(
-          userId, "Groceries", 45.0, "Food");
-      assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId}/transactions/{txId} (happy path) with the
-   * logger disabled.
-   */
-  @Test
-  public void
-      updateTransactionJson_loggerOff_validUserAndTransaction_returnsUpdatedTransactionWith200() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      Transaction existing = new Transaction(userId, 100.0, "Food", "Lunch");
-      existing.setTransactionId(transactionId);
-      Transaction updatedTx = new Transaction(userId, 120.0, "Food", "Dinner");
-      updatedTx.setTransactionId(transactionId);
-      Map<String, Object> updates = Map.of("amount", 120.0);
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(existing));
-      when(mockApiService.updateTransaction(transactionId, updates))
-          .thenReturn(Optional.of(updatedTx));
-      ResponseEntity<Transaction> response =
-          routeController.updateTransactionJson(userId, transactionId, updates);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId}/transactions/{txId} (user not found path) with
-   * the logger disabled.
-   */
-  @Test
-  public void updateTransactionJson_loggerOff_userDoesNotExist_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      Map<String, Object> updates = new HashMap<>();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateTransactionJson(userId, transactionId, updates));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId}/transactions/{txId} (tx not found path) with
-   * the logger disabled.
-   */
-  @Test
-  public void updateTransactionJson_loggerOff_transactionMissing_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Dave", "dave@example.com", 400.0);
-      Map<String, Object> updates = new HashMap<>();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateTransactionJson(userId, transactionId, updates));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions/create-form (happy path) with the
-   * logger disabled.
-   */
-  @Test
-  public void showCreateTransactionForm_loggerOff_validUser_returnsHtmlForm() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      String html = routeController.showCreateTransactionForm(userId);
-      assertTrue(html.contains("Create New Transaction"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/transactions/create-form (user not found path)
-   * with the logger disabled.
-   */
-  @Test
-  public void showCreateTransactionForm_loggerOff_userDoesNotExist_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.showCreateTransactionForm(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId}/transactions/{txId} (happy path) with the
-   * logger disabled.
-   */
-  @Test
-  public void deleteTransaction_loggerOff_validUserAndTransaction_returns200AndConfirmationMap() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      Transaction tx = new Transaction(userId, 50.0, "Food", "Lunch");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      when(mockApiService.deleteTransaction(transactionId)).thenReturn(true);
-      ResponseEntity<Map<String, Object>> response =
-          routeController.deleteTransaction(userId, transactionId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId}/transactions/{txId} (user not found path)
-   * with the logger disabled.
-   */
-  @Test
-  public void deleteTransaction_loggerOff_userDoesNotExist_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.deleteTransaction(userId, transactionId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId}/transactions/{txId} (tx mismatch path) with
-   * the logger disabled.
-   */
-  @Test
-  public void
-      deleteTransaction_loggerOff_transactionToDifferentUser_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID otherUserId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Carol", "carol@example.com", 800.0);
-      Transaction tx = new Transaction(otherUserId, 75.0, "Travel", "Bus");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.deleteTransaction(userId, transactionId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests DELETE /users/{userId}/transactions/{txId} (delete fails path) with
-   * the logger disabled.
-   */
-  @Test
-  public void deleteTransaction_loggerOff_deleteFails_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Bob", "bob@example.com", 500.0);
-      Transaction tx = new Transaction(userId, 25.0, "Misc", "Test");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      when(mockApiService.deleteTransaction(transactionId)).thenReturn(false);
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.deleteTransaction(userId, transactionId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/deletetransaction/{txId} (happy path) with the
-   * logger disabled.
-   */
-  @Test
-  public void deleteTransactionViaGet_loggerOff_validUserAndTransaction_returnsSuccessMessage() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.0);
-      Transaction tx = new Transaction(userId, 60.0, "Food", "Dinner");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      when(mockApiService.deleteTransaction(transactionId)).thenReturn(true);
-      String result = routeController.deleteTransactionViaGet(userId, transactionId);
-      assertTrue(result.contains("Transaction deleted successfully"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/deletetransaction/{txId} (user not found path)
-   * with the logger disabled.
-   */
-  @Test
-  public void deleteTransactionViaGet_loggerOff_userDoesNotExist_returnsUserNotFoundError() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      String result = routeController.deleteTransactionViaGet(userId, transactionId);
-      assertTrue(result.contains("Error: User " + userId + " not found"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/deletetransaction/{txId} (tx mismatch path)
-   * with the logger disabled.
-   */
-  @Test
-  public void deleteTxViaGet_loggerOff_txToDiffUser_returnsTxNotFoundError() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID otherUserId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Carol", "carol@example.com", 700.0);
-      Transaction tx = new Transaction(otherUserId, 30.0, "Travel", "Train");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      String result = routeController.deleteTransactionViaGet(userId, transactionId);
-      assertTrue(result.contains(
-          "Error: Transaction " + transactionId + " not found for user " + userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/deletetransaction/{txId} (delete fails path)
-   * with the logger disabled.
-   */
-  @Test
-  public void deleteTransactionViaGet_loggerOff_deleteFails_returnsErrorMessage() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      UUID transactionId = UUID.randomUUID();
-      User user = new User("Bob", "bob@example.com", 500.0);
-      Transaction tx = new Transaction(userId, 40.0, "Misc", "Test");
-      tx.setTransactionId(transactionId);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-      when(mockApiService.deleteTransaction(transactionId)).thenReturn(false);
-      String result = routeController.deleteTransactionViaGet(userId, transactionId);
-      assertTrue(result.contains("Error: Failed to delete transaction"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/budget (happy path) with the logger disabled.
-   */
-  @Test
-  public void budgetManagement_loggerOff_userFoundWithWeeklySpending_returnsHtml() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "a@a.com", 1000.00);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getBudgetReport(userId))
-          .thenReturn(Map.of("totalSpent", 200.0, "remaining", 800.0));
-      when(mockApiService.totalLast7Days(userId)).thenReturn(150.00);
-      String html = routeController.budgetManagement(userId);
-      assertTrue(html.contains("Budget Management - Alice"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests GET /users/{userId}/budget (user not found path) with the logger
-   * disabled.
-   */
-  @Test
-  public void budgetManagement_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.budgetManagement(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId}/budget (happy path) with the logger disabled.
-   */
-  @Test
-  public void updateBudgetJson_loggerOff_validUser_returnsUpdatedBudgetReport() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1500.00);
-      Map<String, Object> budgetUpdate = Map.of("budget", 2000.00);
-      Map<String, Object> updatedReport =
-          Map.of("totalSpent", 500.00, "remaining", 1500.00);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      doNothing().when(mockApiService).setBudgets(userId, budgetUpdate);
-      when(mockApiService.getBudgetReport(userId)).thenReturn(updatedReport);
-      ResponseEntity<Map<String, Object>> response =
-          routeController.updateBudgetJson(userId, budgetUpdate);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests PUT /users/{userId}/budget (user not found path) with the logger
-   * disabled.
-   */
-  @Test
-  public void updateBudgetJson_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      Map<String, Object> budgetUpdate = Map.of("budget", 1000.00);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateBudgetJson(userId, budgetUpdate));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/update-budget (happy path) with the logger
-   * disabled.
-   */
-  @Test
-  public void updateBudget_loggerOff_validUser_returnsHtmlConfirmation() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1000.00);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      doNothing().when(mockApiService).setBudgets(userId, Map.of("budget", 1200.00));
-      ResponseEntity<String> response = routeController.updateBudget(userId, 1200.00);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
-
-  /**
-   * Tests POST /users/{userId}/update-budget (user not found path) with the
-   * logger disabled.
-   */
-  @Test
-  public void updateBudget_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class,
-          () -> routeController.updateBudget(userId, 1500.00));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
+ * <h3>6. PUT /users/{userId} (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists, all fields updated - returns 200 OK</li>
+ *   <li>P2: (Valid/Boundary) Zero budget - returns 200 OK</li>
+ *   <li>P3: (Valid/Edge) Null/empty fields use existing values</li>
+ *   <li>P4: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P5: (Invalid) Duplicate username - throws IllegalArgumentException</li>
+ *   <li>P6: (Invalid) Duplicate email - throws IllegalArgumentException</li>
+ *   <li>P7: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>7. POST /users/{userId}/update-form (HTML)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns 200 OK HTML</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Invalid) Duplicate username - returns 400 BAD_REQUEST</li>
+ *   <li>P4: (Invalid) Duplicate email - returns 400 BAD_REQUEST</li>
+ *   <li>P5: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>8. GET /users/create-form</h3>
+ * <ul>
+ *   <li>P1: (Valid) Returns HTML form</li>
+ *   <li>P2: (Edge) Logger disabled - still returns form</li>
+ * </ul>
+ *
+ * <h3>9. GET /users/{userId}/edit-form</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns populated form</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>10. DELETE /users/{userId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns 200 OK with confirmation</li>
+ *   <li>P2: (Invalid) User not found/delete fails - throws NoSuchElementException</li>
+ *   <li>P3: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>11. GET /deleteuser/{userId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns success message</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>12. GET /users/{userId}/transactions</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists with transactions - returns 200 OK list</li>
+ *   <li>P2: (Valid/Boundary) User exists, no transactions - returns empty list</li>
+ *   <li>P3: (Invalid) User not found - returns 404 NOT_FOUND</li>
+ *   <li>P4: (Invalid) Service throws exception - returns 500 INTERNAL_SERVER_ERROR</li>
+ *   <li>P5: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>13. GET /users/{userId}/transactions/{transactionId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) User and transaction exist, belongs to user - returns 200 OK</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Invalid) Transaction not found - throws NoSuchElementException</li>
+ *   <li>P4: (Invalid) Transaction belongs to different user - throws NoSuchElementException</li>
+ *   <li>P5: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>14. POST /users/{userId}/transactions (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid transaction - returns 201 CREATED</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Invalid) Service throws exception - propagates exception</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>15. POST /users/{userId}/transactions/form (HTML)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid form data - returns 201 CREATED HTML</li>
+ *   <li>P2: (Invalid) User not found - returns 404 NOT_FOUND</li>
+ *   <li>P3: (Invalid) Service throws exception - returns 500 INTERNAL_SERVER_ERROR</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>16. PUT /users/{userId}/transactions/{transactionId} (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid update - returns 200 OK with updated transaction</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Invalid) Transaction not found - throws NoSuchElementException</li>
+ *   <li>P4: (Invalid) Transaction belongs to different user - throws NoSuchElementException</li>
+ *   <li>P5: (Invalid) Update returns empty - throws NoSuchElementException</li>
+ *   <li>P6: (Invalid) Service throws exception - propagates exception</li>
+ *   <li>P7: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>17. GET /users/{userId}/transactions/create-form</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns HTML form</li>
+ *   <li>P2: (Valid/Edge) Minimal user - returns HTML form</li>
+ *   <li>P3: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>18. DELETE /users/{userId}/transactions/{transactionId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid deletion - returns 200 OK with confirmation</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Invalid) Transaction not found - throws NoSuchElementException</li>
+ *   <li>P4: (Invalid) Transaction belongs to different user - throws NoSuchElementException</li>
+ *   <li>P5: (Invalid) Delete returns false - throws NoSuchElementException</li>
+ *   <li>P6: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>19. GET /users/{userId}/deletetransaction/{transactionId}</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid deletion - returns success message</li>
+ *   <li>P2: (Invalid) User not found - returns error message</li>
+ *   <li>P3: (Invalid) Transaction not found or wrong user - returns error message</li>
+ *   <li>P4: (Invalid) Delete fails - returns error message</li>
+ *   <li>P5: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>20. GET /users/{userId}/budget (HTML)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns budget management HTML</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>21. PUT /users/{userId}/budget (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid budget update - returns 200 OK with report</li>
+ *   <li>P2: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P3: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>22. POST /users/{userId}/update-budget (HTML form)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Valid budget - returns 200 OK HTML</li>
+ *   <li>P2: (Valid/Boundary) Zero budget - returns 200 OK</li>
+ *   <li>P3: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>23. GET /users/{userId}/weekly-summary (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User with transactions - returns summary map</li>
+ *   <li>P2: (Valid/Boundary) User with no transactions - returns empty summary</li>
+ *   <li>P3: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>24. GET /users/{userId}/monthly-summary (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns summary map</li>
+ *   <li>P2: (Valid/Edge) Service returns null summary - map has no "summary" key</li>
+ *   <li>P3: (Valid/Edge) Service returns empty summary - map has empty string</li>
+ *   <li>P4: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P5: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>25. GET /users/{userId}/budget-report (JSON)</h3>
+ * <ul>
+ *   <li>P1: (Valid) User exists - returns 200 OK with report</li>
+ *   <li>P2: (Valid/Edge) Empty report - returns 200 OK with empty map</li>
+ *   <li>P3: (Invalid) User not found - throws NoSuchElementException</li>
+ *   <li>P4: (Edge) Logger disabled - behavior unchanged</li>
+ * </ul>
+ *
+ * <h3>26. Exception Handlers</h3>
+ * <ul>
+ *   <li>handleNotFound: NoSuchElementException -> 404 NOT_FOUND with error message</li>
+ *   <li>handleBadRequest: IllegalArgumentException -> 400 BAD_REQUEST with error message</li>
+ * </ul>
+ */
+@ExtendWith(MockitoExtension.class)
+public class RouteControllerTests {
 
   /**
-   * Tests GET /users/{userId}/weekly-summary (happy path) with the logger
-   * disabled.
+   * A mock implementation of the service layer.
    */
-  @Test
-  public void weeklySummary_loggerOff_withTransactions_rendersTable() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "a@a.com", 100);
-      Transaction t = new Transaction(userId, 10, "FOOD", "Lunch");
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.weeklySummary(userId)).thenReturn(List.of(t));
-      when(mockApiService.totalLast7Days(userId)).thenReturn(10.0);
-      Map<String, Object> summary = routeController.weeklySummary(userId);
-      assertEquals("Alice", summary.get("username"));
-      assertEquals(10.0, (Double) summary.get("weeklyTotal"));
-      assertEquals(1, summary.get("transactionCount"));
-      assertEquals(1, ((List<?>) summary.get("transactions")).size());
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
+  @Mock
+  private MockApiService mockApiService;
 
   /**
-   * Tests GET /users/{userId}/weekly-summary (user not found path) with the
-   * logger disabled.
+   * The instance of the controller under test, with mocks injected.
    */
-  @Test
-  public void weeklySummary_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.weeklySummary(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
+  @InjectMocks
+  private RouteController routeController;
 
   /**
-   * Tests GET /users/{userId}/monthly-summary (happy path) with the logger
-   * disabled.
+   * Set up logic before each test.
    */
-  @Test
-  public void monthlySummary_loggerOff_validUser_returnsHtmlWithSummaryText() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Charlie", "charlie@example.com", 1200.0);
-      String mockSummary = "Total spent this month: $400";
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getMonthlySummary(userId)).thenReturn(mockSummary);
-      Map<String, Object> response = routeController.monthlySummary(userId);
-      assertEquals(mockSummary, response.get("summary"));
-    } finally {
-      setLogLevel(originalLevel);
-    }
+  @BeforeEach
+  public void setUp() {
+    // Initialization code, if needed
   }
 
   /**
-   * Tests GET /users/{userId}/monthly-summary (user not found path) with the
-   * logger disabled.
+   * Tear down logic after each test.
    */
-  @Test
-  public void monthlySummary_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.monthlySummary(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
+  @AfterEach
+  public void tearDown() {
+    // Cleanup code, if needed
   }
 
   /**
-   * Tests GET /users/{userId}/budget-report (happy path) with the logger
-   * disabled.
+   * Helper method to temporarily set the log level for the controller's logger.
+   *
+   * @param level The new level (e.g., Level.OFF)
+   * @return The original Level so it can be restored
    */
-  @Test
-  public void budgetReport_loggerOff_validUser_returnsJsonBudgetReport() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      User user = new User("Alice", "alice@example.com", 1500.00);
-      Map<String, Object> report = Map.of("totalSpent", 500.00, "remaining", 1000.00);
-      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-      when(mockApiService.getBudgetReport(userId)).thenReturn(report);
-      ResponseEntity<Map<String, Object>> response = routeController.budgetReport(userId);
-      assertEquals(HttpStatus.OK, response.getStatusCode());
-    } finally {
-      setLogLevel(originalLevel);
-    }
+  private Level setLogLevel(Level level) {
+    Logger logger = Logger.getLogger(RouteController.class.getName());
+    Level original = logger.getLevel();
+    logger.setLevel(level);
+    return original;
   }
 
-  /**
-   * Tests GET /users/{userId}/budget-report (user not found path) with the
-   * logger disabled.
-   */
-  @Test
-  public void budgetReport_loggerOff_userNotFound_throwsNoSuchElementException() {
-    Level originalLevel = setLogLevel(Level.OFF);
-    try {
-      UUID userId = UUID.randomUUID();
-      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
-      assertThrows(NoSuchElementException.class, () -> routeController.budgetReport(userId));
-    } finally {
-      setLogLevel(originalLevel);
-    }
-  }
+  // ===========================================================================
+  // Tests for index (GET / or /index)
+  // ===========================================================================
 
-  // ---------------------------------------------------------------------------
-  // Tests for index
-  // ---------------------------------------------------------------------------
   /**
-   * Tests GET /index when users exist in the database. Expects HTML list.
+   * Tests GET /index when users exist in the database.
+   *
+   * <p>Partition: P1 (Valid) - Users exist.
    */
   @Test
   public void index_usersExist_returnsHtmlListOfUsers() {
@@ -1261,7 +336,9 @@ public void index_usersExist_returnsHtmlListOfUsers() {
   }
 
   /**
-   * Tests GET /index when no users exist. Expects "No users found" message.
+   * Tests GET /index when no users exist.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No users.
    */
   @Test
   public void index_noUsers_returnsNoUsersMessage() {
@@ -1274,8 +351,9 @@ public void index_noUsers_returnsNoUsersMessage() {
   }
 
   /**
-   * Tests that GET /index propagates RuntimeExceptions from the service
-   * layer.
+   * Tests GET /index when service throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Service throws exception.
    */
   @Test
   public void index_serviceThrowsException_throwsRuntimeException() {
@@ -1286,17 +364,37 @@ public void index_serviceThrowsException_throwsRuntimeException() {
     assertEquals("Database unavailable", thrown.getMessage());
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for getAllUsers (trivial)
-  // ---------------------------------------------------------------------------
   /**
-   * Tests GET /users returns the complete list of users from the service.
+   * Tests GET /index with logger disabled for branch coverage.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
+   */
+  @Test
+  public void index_loggerOff_stillReturnsHtml() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      when(mockApiService.viewAllUsers()).thenReturn(List.of());
+      ResponseEntity<String> response = routeController.index();
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for getAllUsers (GET /users)
+  // ===========================================================================
+
+  /**
+   * Tests GET /users returns the complete list from service.
+   *
+   * <p>Partition: P1 (Valid) - Returns list of users.
    */
   @Test
   public void getAllUsers_validCall_returnsListFromService() {
-    List<User> users = new ArrayList<>();
-    users.add(new User("Alice", "alice@example.com", 1000.0));
-    users.add(new User("Bob", "bob@example.com", 800.0));
+    List<User> users = List.of(
+        new User("Alice", "alice@example.com", 1000.0),
+        new User("Bob", "bob@example.com", 800.0));
     when(mockApiService.viewAllUsers()).thenReturn(users);
 
     List<User> result = routeController.getAllUsers();
@@ -1304,11 +402,32 @@ public void getAllUsers_validCall_returnsListFromService() {
     assertEquals(users, result);
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for getUser
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET /users/{userId} for an existing user.
+   * Tests GET /users with logger disabled.
+   *
+   * <p>Partition: P2 (Edge) - Logger disabled.
+   */
+  @Test
+  public void getAllUsers_loggerOff_stillReturnsList() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      List<User> users = List.of(new User("Alice", "a@a.com", 100));
+      when(mockApiService.viewAllUsers()).thenReturn(users);
+      List<User> result = routeController.getAllUsers();
+      assertEquals(users, result);
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for getUser (GET /users/{userId})
+  // ===========================================================================
+
+  /**
+   * Tests GET /users/{userId} for an existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
   public void getUser_existingUser_returnsUserWith200() {
@@ -1323,8 +442,9 @@ public void getUser_existingUser_returnsUserWith200() {
   }
 
   /**
-   * (Atypical valid input) Tests GET /users/{userId} for a user with
-   * minimal/empty fields.
+   * Tests GET /users/{userId} for a user with minimal fields.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Minimal fields.
    */
   @Test
   public void getUser_minimalUserFields_returnsUserWith200() {
@@ -1335,12 +455,13 @@ public void getUser_minimalUserFields_returnsUserWith200() {
     ResponseEntity<User> response = routeController.getUser(userId);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(user, response.getBody());
     assertEquals("X", response.getBody().getUsername());
   }
 
   /**
-   * (Invalid input) Tests GET /users/{userId} for a non-existent user ID.
+   * Tests GET /users/{userId} for a non-existent user.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
   public void getUser_nonexistentUser_throwsNoSuchElementException() {
@@ -1349,17 +470,55 @@ public void getUser_nonexistentUser_throwsNoSuchElementException() {
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.getUser(userId)
-    );
+        () -> routeController.getUser(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for createUserJson
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests POST /users with a valid JSON payload.
+   * Tests GET /users/{userId} with logger disabled (existing user path).
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
+   */
+  @Test
+  public void getUser_loggerOff_existingUser_returnsUserWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1200.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      ResponseEntity<User> response = routeController.getUser(userId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  /**
+   * Tests GET /users/{userId} with logger disabled (not found path).
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled, not found.
+   */
+  @Test
+  public void getUser_loggerOff_nonexistentUser_throwsNoSuchElementException() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+      assertThrows(NoSuchElementException.class, () -> routeController.getUser(userId));
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for createUserJson (POST /users)
+  // ===========================================================================
+
+  /**
+   * Tests POST /users with a valid user.
+   *
+   * <p>Partition: P1 (Valid) - Valid user.
    */
   @Test
   public void createUserJson_validUser_returnsCreatedUserWith201() {
@@ -1373,555 +532,582 @@ public void createUserJson_validUser_returnsCreatedUserWith201() {
   }
 
   /**
-   * (Atypical valid input) Tests POST /users with an empty string for email,
-   * which is distinct from a null email.
+   * Tests POST /users with empty email string (not null).
+   *
+   * <p>Partition: P2 (Valid/Edge) - Empty email string.
    */
   @Test
-  public void createUserJson_missingEmail_returnsCreatedUserWith201() {
+  public void createUserJson_emptyEmailString_returnsCreatedUserWith201() {
     User user = new User("Bob", "", 1000.0);
     when(mockApiService.addUser(user)).thenReturn(user);
 
     ResponseEntity<User> response = routeController.createUserJson(user);
 
     assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    assertEquals(user, response.getBody());
-  }
-
-  /**
-   * (Invalid input) Tests POST /users when the service layer throws a generic
-   * exception.
-   */
-  @Test
-  public void createUserJson_serviceThrowsException_throwsRuntimeException() {
-    User user = new User("Charlie", "charlie@example.com", 800.0);
-    when(mockApiService.addUser(user)).thenThrow(new RuntimeException("Database error"));
-
-    RuntimeException thrown = assertThrows(
-        RuntimeException.class,
-        () -> routeController.createUserJson(user)
-    );
-
-    // Match the controller behavior: it wraps with "Failed to create user"
-    assertEquals("Failed to create user", thrown.getMessage());
   }
 
   /**
-   * (Invalid input) Tests POST /users when the 'username' field is null.
+   * Tests POST /users with null username.
+   *
+   * <p>Partition: P3 (Invalid) - Null username.
    */
   @Test
-  public void createUserJson_missingUsername_throwsRuntimeException() {
+  public void createUserJson_nullUsername_throwsRuntimeException() {
     User user = new User(null, "alice@example.com", 1000.0);
 
     RuntimeException ex = assertThrows(
         RuntimeException.class,
-        () -> routeController.createUserJson(user)
-    );
+        () -> routeController.createUserJson(user));
 
-    // Outer exception message from controller
     assertEquals("Failed to create user", ex.getMessage());
-
-    // Inner cause is the real validation error
     assertTrue(ex.getCause() instanceof IllegalArgumentException);
     assertEquals("Username field is required", ex.getCause().getMessage());
   }
 
   /**
-   * (Invalid input) Tests POST /users when the 'email' field is null.
+   * Tests POST /users with null email.
+   *
+   * <p>Partition: P4 (Invalid) - Null email.
    */
   @Test
-  public void createUserJson_missingEmail_throwsRuntimeException() {
+  public void createUserJson_nullEmail_throwsRuntimeException() {
     User user = new User("Alice", null, 1000.0);
 
     RuntimeException ex = assertThrows(
         RuntimeException.class,
-        () -> routeController.createUserJson(user)
-    );
+        () -> routeController.createUserJson(user));
 
-    // Outer exception message from controller
     assertEquals("Failed to create user", ex.getMessage());
-
-    // Inner cause is the real validation error
     assertTrue(ex.getCause() instanceof IllegalArgumentException);
     assertEquals("Email field is required", ex.getCause().getMessage());
   }
 
   /**
-   * (Invalid input) Tests POST /users when a duplicate email violation
-   * occurs.
+   * Tests POST /users with duplicate email.
+   *
+   * <p>Partition: P5 (Invalid) - Duplicate email.
    */
   @Test
   public void createUserJson_duplicateEmail_throwsIllegalArgumentException() {
     User user = new User("Alice", "alice@example.com", 1000.0);
-    DataIntegrityViolationException ex
-        = new DataIntegrityViolationException(
-            "constraint violation",
-            new RuntimeException("users_email_key")
-        );
-
+    DataIntegrityViolationException ex = new DataIntegrityViolationException(
+        "constraint violation", new RuntimeException("users_email_key"));
     when(mockApiService.addUser(user)).thenThrow(ex);
 
     IllegalArgumentException thrown = assertThrows(
         IllegalArgumentException.class,
-        () -> routeController.createUserJson(user)
-    );
+        () -> routeController.createUserJson(user));
 
     assertEquals("Email already exists: alice@example.com", thrown.getMessage());
   }
 
   /**
-   * (Invalid input) Tests POST /users when a duplicate username violation
-   * occurs.
+   * Tests POST /users with duplicate username.
+   *
+   * <p>Partition: P6 (Invalid) - Duplicate username.
    */
   @Test
   public void createUserJson_duplicateUsername_throwsIllegalArgumentException() {
     User user = new User("Alice", "alice@example.com", 1000.0);
-    DataIntegrityViolationException ex
-        = new DataIntegrityViolationException(
-            "constraint violation",
-            new RuntimeException("users_username_key")
-        );
-
+    DataIntegrityViolationException ex = new DataIntegrityViolationException(
+        "constraint violation", new RuntimeException("users_username_key"));
+    when(mockApiService.addUser(user)).thenThrow(ex);
+
+    IllegalArgumentException thrown = assertThrows(
+        IllegalArgumentException.class,
+        () -> routeController.createUserJson(user));
+
+    assertEquals("Username already exists: Alice", thrown.getMessage());
+  }
+
+  /**
+   * Tests POST /users with generic data integrity violation.
+   *
+   * <p>Partition: P7 (Invalid) - Generic data integrity violation.
+   */
+  @Test
+  public void createUserJson_genericDataIntegrityViolation_throwsIllegalArgumentException() {
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    DataIntegrityViolationException ex = new DataIntegrityViolationException(
+        "constraint violation", new RuntimeException("some_other_constraint"));
     when(mockApiService.addUser(user)).thenThrow(ex);
 
     IllegalArgumentException thrown = assertThrows(
         IllegalArgumentException.class,
-        () -> routeController.createUserJson(user)
-    );
+        () -> routeController.createUserJson(user));
 
-    assertEquals("Username already exists: Alice", thrown.getMessage());
+    assertEquals("Data integrity violation", thrown.getMessage());
   }
 
   /**
-   * (Invalid input) Tests POST /users for a generic, non-specific data
-   * integrity violation.
+   * Tests POST /users when service throws generic exception.
+   *
+   * <p>Partition: P8 (Invalid) - Service throws exception.
    */
   @Test
-  public void createUserJson_genericDataIntegrityViolation_throwsIllegalArgumentException() {
-    User user = new User("Alice", "alice@example.com", 1000.0);
-    DataIntegrityViolationException ex
-        = new DataIntegrityViolationException(
-            "constraint violation",
-            new RuntimeException("some_other_constraint")
-        );
+  public void createUserJson_serviceThrowsException_throwsIllegalStateException() {
+    User user = new User("Charlie", "charlie@example.com", 800.0);
+    when(mockApiService.addUser(user)).thenThrow(new RuntimeException("Database error"));
 
-    when(mockApiService.addUser(user)).thenThrow(ex);
+    RuntimeException thrown = assertThrows(
+        RuntimeException.class,
+        () -> routeController.createUserJson(user));
 
-    IllegalArgumentException thrown = assertThrows(
-        IllegalArgumentException.class,
-        () -> routeController.createUserJson(user)
-    );
+    assertEquals("Failed to create user", thrown.getMessage());
+  }
 
-    assertEquals("Data integrity violation", thrown.getMessage());
+  /**
+   * Tests POST /users with logger disabled.
+   *
+   * <p>Partition: P9 (Edge) - Logger disabled.
+   */
+  @Test
+  public void createUserJson_loggerOff_validUser_returnsCreatedUserWith201() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      User user = new User("Alice", "alice@example.com", 1500.0);
+      when(mockApiService.addUser(user)).thenReturn(user);
+      ResponseEntity<User> response = routeController.createUserJson(user);
+      assertEquals(HttpStatus.CREATED, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  /**
+   * Tests POST /users with logger disabled (duplicate email path).
+   *
+   * <p>Partition: P9 (Edge) - Logger disabled, duplicate email.
+   */
+  @Test
+  public void createUserJson_loggerOff_duplicateEmail_throwsIllegalArgumentException() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      DataIntegrityViolationException ex = new DataIntegrityViolationException(
+          "constraint violation", new RuntimeException("users_email_key"));
+      when(mockApiService.addUser(user)).thenThrow(ex);
+      assertThrows(IllegalArgumentException.class, () -> routeController.createUserJson(user));
+    } finally {
+      setLogLevel(original);
+    }
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for createUserFromFormHtml
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // Tests for createUserFromFormHtml (POST /users/form)
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests POST /users/form with valid, unique data.
+   * Tests POST /users/form with valid form data.
+   *
+   * <p>Partition: P1 (Valid) - Valid form data.
    */
   @Test
   public void createUserFromFormHtml_validForm_returnsHtmlSuccessWith201() {
     User saved = new User("Alice", "alice@example.com", 1500.0);
     when(mockApiService.addUser(any(User.class))).thenReturn(saved);
 
-    ResponseEntity<String> response
-        = routeController.createUserFromFormHtml("Alice", "alice@example.com", 1500.0);
+    ResponseEntity<String> response =
+        routeController.createUserFromFormHtml("Alice", "alice@example.com", 1500.0);
 
     assertEquals(HttpStatus.CREATED, response.getStatusCode());
     assertTrue(response.getBody().contains("User Created Successfully"));
-    assertTrue(response.getBody().contains("Alice"));
   }
 
   /**
-   * (Atypical valid input) Tests POST /users/form with a 0.0 budget.
+   * Tests POST /users/form with zero budget.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - Zero budget.
    */
   @Test
   public void createUserFromFormHtml_zeroBudget_returnsHtmlSuccessWith201() {
     User saved = new User("Bob", "bob@example.com", 0.0);
     when(mockApiService.addUser(any(User.class))).thenReturn(saved);
 
-    ResponseEntity<String> response
-        = routeController.createUserFromFormHtml("Bob", "bob@example.com", 0.0);
+    ResponseEntity<String> response =
+        routeController.createUserFromFormHtml("Bob", "bob@example.com", 0.0);
 
     assertEquals(HttpStatus.CREATED, response.getStatusCode());
     assertTrue(response.getBody().contains("$0.00"));
   }
 
   /**
-   * (Invalid input) Tests POST /users/form when the service throws an
-   * exception.
-   */
-  @Test
-  public void createUserFromFormHtml_serviceThrowsException_throwsRuntimeException() {
-    when(mockApiService.addUser(any(User.class)))
-        .thenThrow(new RuntimeException("Save failed"));
-
-    RuntimeException thrown = assertThrows(
-        RuntimeException.class,
-        () -> routeController.createUserFromFormHtml("Eve", "eve@example.com", 100.0)
-    );
-
-    assertEquals("Save failed", thrown.getMessage());
-  }
-
-  /**
-   * (Invalid input) Tests POST /users/form with a duplicate username.
+   * Tests POST /users/form with duplicate username.
+   *
+   * <p>Partition: P3 (Invalid) - Duplicate username.
    */
   @Test
   public void createUserFromFormHtml_duplicateUsername_returns400() {
     when(mockApiService.isUsernameExists("Alice", null)).thenReturn(true);
 
-    ResponseEntity<String> response
-        = routeController.createUserFromFormHtml("Alice", "alice@example.com", 500.0);
+    ResponseEntity<String> response =
+        routeController.createUserFromFormHtml("Alice", "alice@example.com", 500.0);
 
     assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
     assertTrue(response.getBody().contains("Username already in use"));
   }
 
   /**
-   * (Invalid input) Tests POST /users/form with a duplicate email.
+   * Tests POST /users/form with duplicate email.
+   *
+   * <p>Partition: P4 (Invalid) - Duplicate email.
    */
   @Test
   public void createUserFromFormHtml_duplicateEmail_returns400() {
     when(mockApiService.isUsernameExists("Alice", null)).thenReturn(false);
     when(mockApiService.isEmailExists("alice@example.com", null)).thenReturn(true);
 
-    ResponseEntity<String> response
-        = routeController.createUserFromFormHtml("Alice", "alice@example.com", 500.0);
+    ResponseEntity<String> response =
+        routeController.createUserFromFormHtml("Alice", "alice@example.com", 500.0);
 
     assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
     assertTrue(response.getBody().contains("User email already in use"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for updateUserJson
-  // ---------------------------------------------------------------------------
   /**
-   * Tests PUT /users/{userId} fallback logic: empty username string should
-   * use existing username.
+   * Tests POST /users/form when service throws exception.
+   *
+   * <p>Partition: P5 (Invalid) - Service throws exception.
    */
   @Test
-  public void updateUserJson_emptyUsername_fallsBackToExisting() {
-    UUID userId = UUID.randomUUID();
-    User existing = new User("originalName", "orig@x.com", 100);
-
-    User updates = new User("", "new@x.com", 150);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
-    when(mockApiService.isUsernameExists("", userId)).thenReturn(false);
-    when(mockApiService.isEmailExists("new@x.com", userId)).thenReturn(false);
-    when(mockApiService.addUser(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
+  public void createUserFromFormHtml_serviceThrowsException_throwsRuntimeException() {
+    when(mockApiService.addUser(any(User.class))).thenThrow(new RuntimeException("Save failed"));
 
-    User result = routeController.updateUserJson(userId, updates).getBody();
+    RuntimeException thrown = assertThrows(
+        RuntimeException.class,
+        () -> routeController.createUserFromFormHtml("Eve", "eve@example.com", 100.0));
 
-    assertEquals("originalName", result.getUsername());
+    assertEquals("Save failed", thrown.getMessage());
   }
 
   /**
-   * Tests PUT /users/{userId} fallback logic: empty email string should use
-   * existing email.
+   * Tests POST /users/form with logger disabled.
+   *
+   * <p>Partition: P6 (Edge) - Logger disabled.
    */
   @Test
-  public void updateUserJson_emptyEmail_fallsBackToExisting() {
-    UUID userId = UUID.randomUUID();
-    User existing = new User("oldName", "old@x.com", 100);
-
-    User updates = new User("newName", "", 200);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
-    when(mockApiService.isUsernameExists("newName", userId)).thenReturn(false);
-    when(mockApiService.isEmailExists("", userId)).thenReturn(false);
-
-    when(mockApiService.addUser(any(User.class)))
-        .thenAnswer(inv -> inv.getArgument(0));
-
-    User updated = routeController.updateUserJson(userId, updates).getBody();
-
-    assertEquals("old@x.com", updated.getEmail());
+  public void createUserFromFormHtml_loggerOff_validForm_returnsHtmlSuccessWith201() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      User saved = new User("Alice", "alice@example.com", 1500.0);
+      when(mockApiService.addUser(any(User.class))).thenReturn(saved);
+      ResponseEntity<String> response =
+          routeController.createUserFromFormHtml("Alice", "alice@example.com", 1500.0);
+      assertEquals(HttpStatus.CREATED, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for updateUserJson (PUT /users/{userId})
+  // ===========================================================================
+
   /**
-   * Tests PUT /users/{userId} fallback logic: empty strings and 0.0 budget
-   * should use all existing data.
+   * Tests PUT /users/{userId} with valid update.
+   *
+   * <p>Partition: P1 (Valid) - User exists, all fields updated.
    */
   @Test
-  public void updateUserJson_allFieldsEmpty_fallbacksToExisting() {
+  public void updateUserJson_existingUser_returnsUpdatedUserWith200() {
     UUID userId = UUID.randomUUID();
-    User existing = new User("oldName", "old@x.com", 100);
-
-    User updates = new User("", "", 0.0);
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User updated = new User("AliceNew", "alice_new@example.com", 1200.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
-    when(mockApiService.isUsernameExists("", userId)).thenReturn(false);
-    when(mockApiService.isEmailExists("", userId)).thenReturn(false);
-    when(mockApiService.addUser(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
+    when(mockApiService.deleteUser(userId)).thenReturn(true);
+    when(mockApiService.addUser(any(User.class))).thenReturn(updated);
 
-    User out = routeController.updateUserJson(userId, updates).getBody();
+    ResponseEntity<User> response = routeController.updateUserJson(userId, updated);
 
-    assertEquals("oldName", out.getUsername());
-    assertEquals("old@x.com", out.getEmail());
-    assertEquals(100.0, out.getBudget());
+    assertEquals(HttpStatus.OK, response.getStatusCode());
   }
 
   /**
-   * (Typical valid input) Tests PUT /users/{userId} with a valid update
-   * payload.
+   * Tests PUT /users/{userId} with zero budget boundary.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - Zero budget.
    */
   @Test
-  public void updateUserJson_existingUser_returnsUpdatedUserWith200() {
+  public void updateUserJson_zeroBudget_returnsUpdatedUserWith200() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Alice", "old@example.com", 1000.0);
-    User updatedUser = new User("Alice", "new@example.com", 1200.0);
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User updated = new User("Alice", "alice@example.com", 0.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-    when(mockApiService.addUser(updatedUser)).thenReturn(updatedUser);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+    when(mockApiService.deleteUser(userId)).thenReturn(true);
+    when(mockApiService.addUser(any(User.class))).thenReturn(updated);
 
-    ResponseEntity<User> response = routeController.updateUserJson(userId, updatedUser);
+    ResponseEntity<User> response = routeController.updateUserJson(userId, updated);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(updatedUser, response.getBody());
-    verify(mockApiService, times(1)).deleteUser(userId);
-    verify(mockApiService, times(1)).addUser(updatedUser);
   }
 
   /**
-   * (Atypical valid input) Tests PUT /users/{userId} with a 0.0 budget.
+   * Tests PUT /users/{userId} with null/empty fields (uses existing values).
+   *
+   * <p>Partition: P3 (Valid/Edge) - Null/empty fields.
    */
   @Test
-  public void updateUserJson_zeroBudget_returnsUpdatedUserWith200() {
+  public void updateUserJson_nullFields_usesExistingValues() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Bob", "bob@example.com", 800.0);
-    User updatedUser = new User("Bob", "bob@example.com", 0.0);
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User updates = new User(null, null, 0.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-    when(mockApiService.addUser(updatedUser)).thenReturn(updatedUser);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+    when(mockApiService.deleteUser(userId)).thenReturn(true);
+    when(mockApiService.addUser(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
 
-    ResponseEntity<User> response = routeController.updateUserJson(userId, updatedUser);
+    ResponseEntity<User> response = routeController.updateUserJson(userId, updates);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(updatedUser, response.getBody());
-    assertEquals(userId, response.getBody().getUserId());
+    assertEquals("Alice", response.getBody().getUsername());
   }
 
   /**
-   * (Invalid input) Tests PUT /users/{userId} for a non-existent user ID.
+   * Tests PUT /users/{userId} when user not found.
+   *
+   * <p>Partition: P4 (Invalid) - User not found.
    */
   @Test
   public void updateUserJson_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    User updatedUser = new User("Eve", "eve@example.com", 900.0);
-
+    User updates = new User("Eve", "eve@example.com", 900.0);
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateUserJson(userId, updatedUser)
-    );
+        () -> routeController.updateUserJson(userId, updates));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests PUT /users/{userId} with a duplicate username.
+   * Tests PUT /users/{userId} with duplicate username.
+   *
+   * <p>Partition: P5 (Invalid) - Duplicate username.
    */
   @Test
   public void updateUserJson_duplicateUsername_throwsIllegalArgumentException() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Alice", "alice@example.com", 1000.0);
-    User updates = new User("NewName", "alice_new@example.com", 1500.0);
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User updates = new User("TakenName", "alice@example.com", 1000.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-    when(mockApiService.isUsernameExists("NewName", userId)).thenReturn(true);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+    when(mockApiService.isUsernameExists("TakenName", userId)).thenReturn(true);
 
-    IllegalArgumentException ex = assertThrows(
+    IllegalArgumentException thrown = assertThrows(
         IllegalArgumentException.class,
-        () -> routeController.updateUserJson(userId, updates)
-    );
+        () -> routeController.updateUserJson(userId, updates));
 
-    assertEquals("Username already exists: NewName", ex.getMessage());
+    assertTrue(thrown.getMessage().contains("Username already exists"));
   }
 
   /**
-   * (Invalid input) Tests PUT /users/{userId} with a duplicate email.
+   * Tests PUT /users/{userId} with duplicate email.
+   *
+   * <p>Partition: P6 (Invalid) - Duplicate email.
    */
   @Test
   public void updateUserJson_duplicateEmail_throwsIllegalArgumentException() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Alice", "alice@example.com", 1000.0);
-    User updates = new User("Alice", "new@example.com", 1500.0);
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User updates = new User("Alice", "taken@example.com", 1000.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
     when(mockApiService.isUsernameExists("Alice", userId)).thenReturn(false);
-    when(mockApiService.isEmailExists("new@example.com", userId)).thenReturn(true);
+    when(mockApiService.isEmailExists("taken@example.com", userId)).thenReturn(true);
 
-    IllegalArgumentException ex = assertThrows(
+    IllegalArgumentException thrown = assertThrows(
         IllegalArgumentException.class,
-        () -> routeController.updateUserJson(userId, updates)
-    );
+        () -> routeController.updateUserJson(userId, updates));
 
-    assertEquals("Email already exists: new@example.com", ex.getMessage());
+    assertTrue(thrown.getMessage().contains("Email already exists"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for updateUserFromFormHtml
-  // ---------------------------------------------------------------------------
   /**
-   * (Invalid input) Tests POST /users/{userId}/update-form with a duplicate
-   * email.
+   * Tests PUT /users/{userId} with logger disabled.
+   *
+   * <p>Partition: P7 (Edge) - Logger disabled.
    */
   @Test
-  public void updateUserFromFormHtml_duplicateEmail_returns400() {
-    UUID userId = UUID.randomUUID();
-
-    when(mockApiService.isUsernameExists("Alice", userId)).thenReturn(false);
-    when(mockApiService.isEmailExists("alice@x.com", userId)).thenReturn(true);
-
-    ResponseEntity<String> response
-        = routeController.updateUserFromFormHtml(userId, "Alice", "alice@x.com", 500);
-
-    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
-    assertTrue(response.getBody().contains("User email already in use"));
+  public void updateUserJson_loggerOff_existingUser_returnsUpdatedUserWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User existing = new User("Alice", "alice@example.com", 1000.0);
+      User updated = new User("Alice", "new@example.com", 1200.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+      when(mockApiService.addUser(any(User.class))).thenReturn(updated);
+      ResponseEntity<User> response = routeController.updateUserJson(userId, updated);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for updateUserFromFormHtml (POST /users/{userId}/update-form)
+  // ===========================================================================
+
   /**
-   * (Invalid input) Tests POST /users/{userId}/update-form with a duplicate
-   * username.
+   * Tests POST /users/{userId}/update-form with valid data.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
-  public void updateUserFromFormHtml_duplicateUsername_returns400() {
+  public void updateUserFromFormHtml_validData_returnsHtmlSuccessWith200() {
     UUID userId = UUID.randomUUID();
+    User existing = new User("Alice", "alice@example.com", 1000.0);
+    User saved = new User("Alice", "alice_new@example.com", 1200.0);
 
-    when(mockApiService.isUsernameExists("Alice", userId)).thenReturn(true);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+    when(mockApiService.deleteUser(userId)).thenReturn(true);
+    when(mockApiService.addUser(any(User.class))).thenReturn(saved);
 
-    ResponseEntity<String> response
-        = routeController.updateUserFromFormHtml(userId, "Alice", "alice@x.com", 500);
+    ResponseEntity<String> response =
+        routeController.updateUserFromFormHtml(userId, "Alice", "alice_new@example.com", 1200.0);
 
-    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
-    assertTrue(response.getBody().contains("Username already in use"));
+    assertEquals(HttpStatus.OK, response.getStatusCode());
+    assertTrue(response.getBody().contains("User Updated Successfully"));
   }
 
   /**
-   * (Typical valid input) Tests POST /users/{userId}/update-form for an
-   * existing user.
+   * Tests POST /users/{userId}/update-form when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void updateUserFromFormHtml_existingUser_returnsHtmlSuccessWith200() {
+  public void updateUserFromFormHtml_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Alice", "alice@example.com", 1000.0);
-    User savedUser = new User("Alice", "alice_new@example.com", 1200.0);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-    when(mockApiService.addUser(any(User.class))).thenReturn(savedUser);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
-    ResponseEntity<String> response
-        = routeController.updateUserFromFormHtml(userId, "Alice", "alice_new@example.com", 1200.0);
+    NoSuchElementException thrown = assertThrows(
+        NoSuchElementException.class,
+        () -> routeController.updateUserFromFormHtml(userId, "Eve", "eve@example.com", 100.0));
 
-    assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertTrue(response.getBody().contains("User Updated Successfully!"));
-    assertTrue(response.getBody().contains("alice_new@example.com"));
-    verify(mockApiService, times(1)).deleteUser(userId);
-    verify(mockApiService, times(1)).addUser(any(User.class));
+    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Atypical valid input) Tests POST /users/{userId}/update-form with a 0.0
-   * budget.
+   * Tests POST /users/{userId}/update-form with duplicate username.
+   *
+   * <p>Partition: P3 (Invalid) - Duplicate username.
    */
   @Test
-  public void updateUserFromFormHtml_zeroBudget_returnsHtmlWithZeroBudget() {
+  public void updateUserFromFormHtml_duplicateUsername_returns400() {
     UUID userId = UUID.randomUUID();
-    User existingUser = new User("Bob", "bob@example.com", 500.0);
-    User savedUser = new User("Bob", "bob@example.com", 0.0);
+    when(mockApiService.isUsernameExists("TakenName", userId)).thenReturn(true);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(existingUser));
-    when(mockApiService.addUser(any(User.class))).thenReturn(savedUser);
+    ResponseEntity<String> response =
+        routeController.updateUserFromFormHtml(userId, "TakenName", "new@example.com", 100.0);
 
-    ResponseEntity<String> response
-        = routeController.updateUserFromFormHtml(userId, "Bob", "bob@example.com", 0.0);
-
-    assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertTrue(response.getBody().contains("$0.00"));
+    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    assertTrue(response.getBody().contains("Username already in use"));
   }
 
   /**
-   * (Invalid input) Tests POST /users/{userId}/update-form for a non-existent
-   * user.
+   * Tests POST /users/{userId}/update-form with duplicate email.
+   *
+   * <p>Partition: P4 (Invalid) - Duplicate email.
    */
   @Test
-  public void updateUserFromFormHtml_userNotFound_throwsNoSuchElementException() {
+  public void updateUserFromFormHtml_duplicateEmail_returns400() {
     UUID userId = UUID.randomUUID();
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+    when(mockApiService.isUsernameExists("NewName", userId)).thenReturn(false);
+    when(mockApiService.isEmailExists("taken@example.com", userId)).thenReturn(true);
 
-    NoSuchElementException thrown = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.updateUserFromFormHtml(userId, "Eve", "eve@example.com", 100.0)
-    );
+    ResponseEntity<String> response =
+        routeController.updateUserFromFormHtml(userId, "NewName", "taken@example.com", 100.0);
 
-    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
+    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    assertTrue(response.getBody().contains("User email already in use"));
+  }
+
+  /**
+   * Tests POST /users/{userId}/update-form with logger disabled.
+   *
+   * <p>Partition: P5 (Edge) - Logger disabled.
+   */
+  @Test
+  public void updateUserFromFormHtml_loggerOff_existingUser_returnsHtmlSuccessWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User existing = new User("Alice", "alice@example.com", 1000.0);
+      User saved = new User("Alice", "alice_new@example.com", 1200.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(existing));
+      when(mockApiService.addUser(any(User.class))).thenReturn(saved);
+      ResponseEntity<String> response =
+          routeController.updateUserFromFormHtml(userId, "Alice", "alice_new@example.com", 1200.0);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for showCreateUserForm (trivial)
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // Tests for showCreateUserForm (GET /users/create-form)
+  // ===========================================================================
+
   /**
-   * Tests GET /users/create-form returns the correct HTML form.
+   * Tests GET /users/create-form returns HTML form.
+   *
+   * <p>Partition: P1 (Valid) - Returns HTML form.
    */
   @Test
-  public void showCreateUserForm_returnsExpectedHtmlForm() {
+  public void showCreateUserForm_returnsHtmlForm() {
     String html = routeController.showCreateUserForm();
 
     assertTrue(html.contains("<h2>Create New User</h2>"));
-    assertTrue(html.contains("action='/users/form'"));
-    assertTrue(html.contains("Username:"));
-    assertTrue(html.contains("Email:"));
-    assertTrue(html.contains("Budget:"));
+    assertTrue(html.contains("<form"));
+    assertTrue(html.contains("name='username'"));
+    assertTrue(html.contains("name='email'"));
+    assertTrue(html.contains("name='budget'"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for showEditUserForm
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET /users/{userId}/edit-form populates the
-   * form correctly.
+   * Tests GET /users/create-form with logger disabled.
+   *
+   * <p>Partition: P2 (Edge) - Logger disabled.
    */
   @Test
-  public void showEditUserForm_existingUser_returnsPopulatedFormHtml() {
-    UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1000.0);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-
-    String html = routeController.showEditUserForm(userId);
-
-    assertTrue(html.contains("<h2>Edit User</h2>"));
-    assertTrue(html.contains("Alice"));
-    assertTrue(html.contains("alice@example.com"));
-    assertTrue(html.contains(String.valueOf(user.getBudget())));
-    assertTrue(html.contains("/users/" + userId + "/update-form"));
+  public void showCreateUserForm_loggerOff_returnsExpectedHtmlForm() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      String html = routeController.showCreateUserForm();
+      assertTrue(html.contains("<h2>Create New User</h2>"));
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for showEditUserForm (GET /users/{userId}/edit-form)
+  // ===========================================================================
+
   /**
-   * (Atypical valid input) Tests GET /users/{userId}/edit-form with empty
-   * user fields.
+   * Tests GET /users/{userId}/edit-form for existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
-  public void showEditUserForm_userWithEmptyFields_returnsValidFormHtml() {
+  public void showEditUserForm_existingUser_returnsPopulatedFormHtml() {
     UUID userId = UUID.randomUUID();
-    User user = new User("", "", 0.0);
-
+    User user = new User("Alice", "alice@example.com", 1000.0);
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
 
     String html = routeController.showEditUserForm(userId);
 
     assertTrue(html.contains("<h2>Edit User</h2>"));
-    assertTrue(html.contains("value=''")); // empty username/email fields
-    assertTrue(html.contains("value='0.0'")); // zero budget still rendered
+    assertTrue(html.contains("Alice"));
+    assertTrue(html.contains("alice@example.com"));
   }
 
   /**
-   * (Invalid input) Tests GET /users/{userId}/edit-form for a non-existent
-   * user.
+   * Tests GET /users/{userId}/edit-form when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
   public void showEditUserForm_userNotFound_throwsNoSuchElementException() {
@@ -1930,17 +1116,38 @@ public void showEditUserForm_userNotFound_throwsNoSuchElementException() {
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.showEditUserForm(userId)
-    );
+        () -> routeController.showEditUserForm(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for deleteUser
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests DELETE /users/{userId} for an existing user.
+   * Tests GET /users/{userId}/edit-form with logger disabled.
+   *
+   * <p>Partition: P3 (Edge) - Logger disabled.
+   */
+  @Test
+  public void showEditUserForm_loggerOff_existingUser_returnsPopulatedFormHtml() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      String html = routeController.showEditUserForm(userId);
+      assertTrue(html.contains("<h2>Edit User</h2>"));
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for deleteUser (DELETE /users/{userId})
+  // ===========================================================================
+
+  /**
+   * Tests DELETE /users/{userId} for existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
   public void deleteUser_existingUser_returnsConfirmationMapWith200() {
@@ -1955,45 +1162,48 @@ public void deleteUser_existingUser_returnsConfirmationMapWith200() {
   }
 
   /**
-   * (Atypical valid input) Tests DELETE /users/{userId} when the user is
-   * already deleted.
+   * Tests DELETE /users/{userId} when delete fails.
+   *
+   * <p>Partition: P2 (Invalid) - Delete fails.
    */
   @Test
-  public void deleteUser_alreadyDeletedUser_throwsNoSuchElementException() {
+  public void deleteUser_deleteFails_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
     when(mockApiService.deleteUser(userId)).thenReturn(false);
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.deleteUser(userId)
-    );
+        () -> routeController.deleteUser(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests DELETE /users/{userId} when the service throws an
-   * exception.
+   * Tests DELETE /users/{userId} with logger disabled.
+   *
+   * <p>Partition: P3 (Edge) - Logger disabled.
    */
   @Test
-  public void deleteUser_serviceThrowsRuntimeException_propagatesException() {
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.deleteUser(userId)).thenThrow(new RuntimeException("Database failure"));
-
-    RuntimeException thrown = assertThrows(
-        RuntimeException.class,
-        () -> routeController.deleteUser(userId)
-    );
-
-    assertEquals("Database failure", thrown.getMessage());
+  public void deleteUser_loggerOff_existingUser_returnsConfirmationMapWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      when(mockApiService.deleteUser(userId)).thenReturn(true);
+      ResponseEntity<Map<String, Object>> response = routeController.deleteUser(userId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for deleteUserViaGet
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // Tests for deleteUserViaGet (GET /deleteuser/{userId})
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests GET /deleteuser/{userId} for an existing
-   * user.
+   * Tests GET /deleteuser/{userId} for existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
   public void deleteUserViaGet_existingUser_returnsSuccessMessage() {
@@ -2006,72 +1216,56 @@ public void deleteUserViaGet_existingUser_returnsSuccessMessage() {
   }
 
   /**
-   * (Atypical valid input) Tests GET /deleteuser/{userId} when the user is
-   * already deleted.
-   */
-  @Test
-  public void deleteUserViaGet_alreadyDeletedUser_throwsNoSuchElementException() {
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.deleteUser(userId)).thenReturn(false);
-
-    NoSuchElementException thrown = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.deleteUserViaGet(userId)
-    );
-
-    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
-  }
-
-  /**
-   * (Invalid input) Tests GET /deleteuser/{userId} when the service throws an
-   * exception.
-   */
-  @Test
-  public void deleteUserViaGet_serviceThrowsRuntimeException_propagatesException() {
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.deleteUser(userId)).thenThrow(new RuntimeException("Internal DB error"));
-
-    RuntimeException thrown = assertThrows(
-        RuntimeException.class,
-        () -> routeController.deleteUserViaGet(userId)
-    );
-
-    assertEquals("Internal DB error", thrown.getMessage());
-  }
-
-  // ---------------------------------------------------------------------------
-  // Tests for getUserTransactions
-  // ---------------------------------------------------------------------------
-  /**
-   * (Invalid input) Tests GET /users/{userId}/transactions when the service
-   * throws an exception.
+   * Tests GET /deleteuser/{userId} when delete fails.
+   *
+   * <p>Partition: P2 (Invalid) - Delete fails.
    */
   @Test
-  public void getUserTransactions_serviceThrows_returns500() {
+  public void deleteUserViaGet_deleteFails_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Test", "t@e.com", 10);
+    when(mockApiService.deleteUser(userId)).thenReturn(false);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransactionsByUser(userId))
-        .thenThrow(new RuntimeException("DB exploded"));
+    NoSuchElementException thrown = assertThrows(
+        NoSuchElementException.class,
+        () -> routeController.deleteUserViaGet(userId));
 
-    ResponseEntity<?> response = routeController.getUserTransactions(userId);
+    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
+  }
 
-    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    assertTrue(response.getBody().toString().contains("DB exploded"));
+  /**
+   * Tests GET /deleteuser/{userId} with logger disabled.
+   *
+   * <p>Partition: P3 (Edge) - Logger disabled.
+   */
+  @Test
+  public void deleteUserViaGet_loggerOff_existingUser_returnsSuccessMessage() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      when(mockApiService.deleteUser(userId)).thenReturn(true);
+      String result = routeController.deleteUserViaGet(userId);
+      assertEquals("User deleted successfully", result);
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for getUserTransactions (GET /users/{userId}/transactions)
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests GET /users/{userId}/transactions for a user
-   * with transactions.
+   * Tests GET /users/{userId}/transactions for user with transactions.
+   *
+   * <p>Partition: P1 (Valid) - User exists with transactions.
    */
   @Test
-  public void getUserTransactions_existingUser_returnsTransactionsWith200() {
+  public void getUserTransactions_userWithTransactions_returnsList() {
     UUID userId = UUID.randomUUID();
     User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction t1 = new Transaction(userId, 50.0, "Food", "Lunch");
-    Transaction t2 = new Transaction(userId, 120.0, "Shopping", "Clothes");
-    List<Transaction> transactions = List.of(t1, t2);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 50.0, "FOOD", "Lunch"),
+        new Transaction(userId, 100.0, "SHOPPING", "Shoes"));
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.getTransactionsByUser(userId)).thenReturn(transactions);
@@ -2079,17 +1273,18 @@ public void getUserTransactions_existingUser_returnsTransactionsWith200() {
     ResponseEntity<?> response = routeController.getUserTransactions(userId);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(transactions, response.getBody());
+    assertEquals(2, ((List<?>) response.getBody()).size());
   }
 
   /**
-   * (Atypical valid input) Tests GET /users/{userId}/transactions for a user
-   * with no transactions.
+   * Tests GET /users/{userId}/transactions for user with no transactions.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions.
    */
   @Test
-  public void getUserTransactions_existingUserNoTransactions_returnsEmptyListWith200() {
+  public void getUserTransactions_noTransactions_returnsEmptyList() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 500.0);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.getTransactionsByUser(userId)).thenReturn(new ArrayList<>());
@@ -2101,28 +1296,29 @@ public void getUserTransactions_existingUserNoTransactions_returnsEmptyListWith2
   }
 
   /**
-   * (Invalid input) Tests GET /users/{userId}/transactions for a non-existent
-   * user.
+   * Tests GET /users/{userId}/transactions when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
-  public void getUserTransactions_userDoesNotExist_returns404Error() {
+  public void getUserTransactions_userNotFound_returns404() {
     UUID userId = UUID.randomUUID();
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     ResponseEntity<?> response = routeController.getUserTransactions(userId);
 
     assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    assertTrue(response.getBody().toString().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests GET /users/{userId}/transactions when the service
-   * throws an exception.
+   * Tests GET /users/{userId}/transactions when service throws exception.
+   *
+   * <p>Partition: P4 (Invalid) - Service throws exception.
    */
   @Test
-  public void getUserTransactions_serviceThrowsException_returns500Error() {
+  public void getUserTransactions_serviceThrowsException_returns500() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Carol", "carol@example.com", 700.0);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.getTransactionsByUser(userId))
@@ -2131,452 +1327,497 @@ public void getUserTransactions_serviceThrowsException_returns500Error() {
     ResponseEntity<?> response = routeController.getUserTransactions(userId);
 
     assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    assertTrue(response.getBody().toString().contains("Database error"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for getTransaction
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET /users/{userId}/transactions/{txId} for a
-   * valid, matching transaction.
+   * Tests GET /users/{userId}/transactions with logger disabled.
+   *
+   * <p>Partition: P5 (Edge) - Logger disabled.
    */
   @Test
-  public void getTransaction_existingUserAndTransaction_returnsTransactionWith200() {
-    UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction tx = new Transaction(userId, 50.0, "Food", "Lunch");
-    tx.setTransactionId(transactionId);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-
-    ResponseEntity<Transaction> response = routeController.getTransaction(userId, transactionId);
-
-    assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(tx, response.getBody());
-    assertEquals(transactionId, response.getBody().getTransactionId());
-    assertEquals(userId, response.getBody().getUserId());
+  public void getUserTransactions_loggerOff_existingUser_returnsTransactionsWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getTransactionsByUser(userId)).thenReturn(new ArrayList<>());
+      ResponseEntity<?> response = routeController.getUserTransactions(userId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for getTransaction (GET /users/{userId}/transactions/{transactionId})
+  // ===========================================================================
+
   /**
-   * (Atypical valid input) Tests GET .../{txId} where the transaction exists
-   * but belongs to another user.
+   * Tests GET .../transactions/{txId} for valid user and transaction.
+   *
+   * <p>Partition: P1 (Valid) - User and transaction exist, transaction belongs to user.
    */
   @Test
-  public void getTransaction_transactionBelongsToDifferentUser_throwsNoSuchElementException() {
+  public void getTransaction_validUserAndTransaction_returnsTransactionWith200() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    UUID otherUserId = UUID.randomUUID();
-
-    User user = new User("Bob", "bob@example.com", 800.0);
-    Transaction tx = new Transaction(otherUserId, 30.0, "Misc", "Other user’s purchase");
-    tx.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
 
-    NoSuchElementException thrown = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.getTransaction(userId, transactionId)
-    );
+    ResponseEntity<Transaction> response = routeController.getTransaction(userId, txId);
 
-    assertTrue(thrown.getMessage().contains("Transaction "
-        + transactionId + " not found for user " + userId));
+    assertEquals(HttpStatus.OK, response.getStatusCode());
+    assertEquals(tx, response.getBody());
   }
 
   /**
-   * (Invalid input) Tests GET .../{txId} for a non-existent user.
+   * Tests GET .../transactions/{txId} when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void getTransaction_userDoesNotExist_throwsNoSuchElementException() {
+  public void getTransaction_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
+    UUID txId = UUID.randomUUID();
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.getTransaction(userId, transactionId)
-    );
+        () -> routeController.getTransaction(userId, txId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests GET .../{txId} for a non-existent transaction.
+   * Tests GET .../transactions/{txId} when transaction not found.
+   *
+   * <p>Partition: P3 (Invalid) - Transaction not found.
    */
   @Test
-  public void getTransaction_transactionMissing_throwsNoSuchElementException() {
+  public void getTransaction_transactionNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    User user = new User("Carol", "carol@example.com", 1200.0);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.empty());
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.getTransaction(userId, transactionId)
-    );
+        () -> routeController.getTransaction(userId, txId));
 
-    assertTrue(thrown.getMessage().contains("Transaction " + transactionId + " not found"));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for createTransactionJson
-  // ---------------------------------------------------------------------------
   /**
-   * (Invalid input) Tests POST .../transactions when the service layer throws
-   * an exception.
+   * Tests GET .../transactions/{txId} when transaction belongs to different user.
+   *
+   * <p>Partition: P4 (Invalid) - Transaction belongs to different user.
    */
   @Test
-  public void createTransactionJson_serviceThrows_propagatesException() {
+  public void getTransaction_transactionBelongsToDifferentUser_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    Transaction tx = new Transaction();
-
-    when(mockApiService.getUser(userId))
-        .thenReturn(Optional.of(new User("u", "u@x.com", 100)));
+    UUID otherUserId = UUID.randomUUID();
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(otherUserId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
-    when(mockApiService.addTransaction(any(Transaction.class)))
-        .thenThrow(new RuntimeException("DB insert broke"));
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
 
-    RuntimeException ex = assertThrows(RuntimeException.class, ()
-        -> routeController.createTransactionJson(userId, tx)
-    );
+    NoSuchElementException thrown = assertThrows(
+        NoSuchElementException.class,
+        () -> routeController.getTransaction(userId, txId));
 
-    assertTrue(ex.getMessage().contains("DB insert broke"));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found for user"));
   }
 
   /**
-   * (Invalid input) Tests POST .../transactions/form when the service layer
-   * throws an exception.
+   * Tests GET .../transactions/{txId} with logger disabled.
+   *
+   * <p>Partition: P5 (Edge) - Logger disabled.
    */
   @Test
-  public void createTransactionFromFormHtml_serviceThrows_returns500() {
-    UUID userId = UUID.randomUUID();
-
-    when(mockApiService.getUser(userId))
-        .thenReturn(Optional.of(new User("A", "a@a.com", 100)));
-
-    when(mockApiService.addTransaction(any(Transaction.class)))
-        .thenThrow(new RuntimeException("exploded"));
-
-    ResponseEntity<String> response = routeController.createTransactionFromFormHtml(
-        userId, "movie", 12.50, "ENTERTAINMENT"
-    );
-
-    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    assertTrue(response.getBody().contains("exploded"));
+  public void getTransaction_loggerOff_existingUserAndTransaction_returnsTransactionWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      UUID txId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+      tx.setTransactionId(txId);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+      ResponseEntity<Transaction> response = routeController.getTransaction(userId, txId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
-  /**
-   * (Typical valid input) Tests POST .../transactions with a valid JSON
-   * payload.
-   */
-  @Test
-  public void createTransactionJson_validUserAndTransaction_returnsCreatedTransactionWith201() {
-    UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction transaction = new Transaction(userId, 75.0, "Food", "Lunch");
-    Transaction saved = new Transaction(userId, 75.0, "Food", "Lunch");
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.addTransaction(transaction)).thenReturn(saved);
-
-    ResponseEntity<Transaction> response
-        = routeController.createTransactionJson(userId, transaction);
-
-    assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    assertEquals(saved, response.getBody());
-    assertEquals(userId, response.getBody().getUserId());
-  }
+  // ===========================================================================
+  // Tests for createTransactionJson (POST /users/{userId}/transactions)
+  // ===========================================================================
 
   /**
-   * (Atypical valid input) Tests POST .../transactions with a 0.0 amount.
+   * Tests POST .../transactions with valid transaction.
+   *
+   * <p>Partition: P1 (Valid) - Valid transaction.
    */
   @Test
-  public void createTransactionJson_zeroAmount_returnsCreatedTransactionWith201() {
+  public void createTransactionJson_validTransaction_returnsCreatedWith201() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 500.0);
-    Transaction transaction = new Transaction(userId, 0.0, "Misc", "Zero transaction");
-    Transaction saved = new Transaction(userId, 0.0, "Misc", "Zero transaction");
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    UUID txId = UUID.randomUUID();
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.addTransaction(transaction)).thenReturn(saved);
+    when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(tx);
 
-    ResponseEntity<Transaction> response
-        = routeController.createTransactionJson(userId, transaction);
+    ResponseEntity<Transaction> response = routeController.createTransactionJson(userId, tx);
 
     assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    assertEquals(saved, response.getBody());
-    assertEquals(0.0, response.getBody().getAmount());
+    assertEquals(txId, response.getBody().getTransactionId());
   }
 
   /**
-   * (Invalid input) Tests POST .../transactions for a non-existent user.
+   * Tests POST .../transactions when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void createTransactionJson_userDoesNotExist_throwsNoSuchElementException() {
+  public void createTransactionJson_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    Transaction transaction = new Transaction(userId, 100.0, "Travel", "Trip");
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.createTransactionJson(userId, transaction)
-    );
+        () -> routeController.createTransactionJson(userId, tx));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for createTransactionFromFormHtml
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests POST .../transactions/form with valid data.
+   * Tests POST .../transactions when service throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Service throws exception.
    */
   @Test
-  public void createTransactionFromFormHtml_validUser_returnsHtmlSuccessWith201() {
+  public void createTransactionJson_serviceThrowsException_propagatesException() {
     UUID userId = UUID.randomUUID();
     User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction saved = new Transaction(userId, 120.0, "Shopping", "Clothes");
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(saved);
+    when(mockApiService.addTransaction(any(Transaction.class)))
+        .thenThrow(new IllegalArgumentException("Invalid category"));
 
-    ResponseEntity<String> response
-        = routeController.createTransactionFromFormHtml(userId, "Clothes", 120.0, "Shopping");
+    IllegalArgumentException thrown = assertThrows(
+        IllegalArgumentException.class,
+        () -> routeController.createTransactionJson(userId, tx));
 
-    assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    assertTrue(response.getBody().contains("Transaction Created Successfully"));
-    assertTrue(response.getBody().contains("Clothes"));
-    assertTrue(response.getBody().contains("Shopping"));
+    assertEquals("Invalid category", thrown.getMessage());
+  }
+
+  /**
+   * Tests POST .../transactions with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
+   */
+  @Test
+  public void createTransactionJson_loggerOff_validTransaction_returnsCreatedWith201() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(tx);
+      ResponseEntity<Transaction> response = routeController.createTransactionJson(userId, tx);
+      assertEquals(HttpStatus.CREATED, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for createTransactionFromFormHtml (POST /users/{userId}/transactions/form)
+  // ===========================================================================
+
   /**
-   * (Atypical valid input) Tests POST .../transactions/form with a negative
-   * amount (e.g., a refund).
+   * Tests POST .../transactions/form with valid form data.
+   *
+   * <p>Partition: P1 (Valid) - Valid form data.
    */
   @Test
-  public void createTransactionFromFormHtml_negativeAmount_returnsHtmlSuccessWith201() {
+  public void createTransactionFromFormHtml_validForm_returnsCreatedWith201() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 800.0);
-    Transaction saved = new Transaction(userId, -50.0, "Refund", "Reversal");
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction saved = new Transaction(userId, 50.0, "FOOD", "Lunch");
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(saved);
 
-    ResponseEntity<String> response
-        = routeController.createTransactionFromFormHtml(userId, "Reversal", -50.0, "Refund");
+    ResponseEntity<String> response =
+        routeController.createTransactionFromFormHtml(userId, "Lunch", 50.0, "FOOD");
 
     assertEquals(HttpStatus.CREATED, response.getStatusCode());
-    assertTrue(response.getBody().contains("Reversal"));
-    assertTrue(response.getBody().contains("Refund"));
+    assertTrue(response.getBody().contains("Transaction Created Successfully"));
   }
 
   /**
-   * (Invalid input) Tests POST .../transactions/form for a non-existent user.
+   * Tests POST .../transactions/form when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void createTransactionFromFormHtml_userDoesNotExist_returns404Error() {
+  public void createTransactionFromFormHtml_userNotFound_returns404() {
     UUID userId = UUID.randomUUID();
+
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
-    ResponseEntity<String> response
-        = routeController.createTransactionFromFormHtml(userId, "Test", 40.0, "Misc");
+    ResponseEntity<String> response =
+        routeController.createTransactionFromFormHtml(userId, "Lunch", 50.0, "FOOD");
 
     assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    assertTrue(response.getBody().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests POST .../transactions/form when the service throws
-   * an exception.
+   * Tests POST .../transactions/form when service throws exception.
+   *
+   * <p>Partition: P3 (Invalid) - Service throws exception.
    */
   @Test
-  public void createTransactionFromFormHtml_serviceThrowsException_returns500Error() {
+  public void createTransactionFromFormHtml_serviceThrowsException_returns500() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Carol", "carol@example.com", 700.0);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.addTransaction(any(Transaction.class)))
         .thenThrow(new RuntimeException("Database error"));
 
-    ResponseEntity<String> response
-        = routeController.createTransactionFromFormHtml(userId, "Groceries", 45.0, "Food");
+    ResponseEntity<String> response =
+        routeController.createTransactionFromFormHtml(userId, "Lunch", 50.0, "FOOD");
 
     assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
-    assertTrue(response.getBody().contains("Error creating transaction"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for updateTransactionJson
-  // ---------------------------------------------------------------------------
   /**
-   * (Invalid input) Tests PUT .../{txId} when the service update call fails
-   * (returns empty).
+   * Tests POST .../transactions/form with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
    */
   @Test
-  public void updateTransactionJson_updateFails_throwsException() {
-    UUID userId = UUID.randomUUID();
-    UUID txId = UUID.randomUUID();
-
-    User user = new User("A", "a@b.com", 100);
-    Transaction tx = new Transaction(userId, 5, "FOOD", "xx");
-    tx.setTransactionId(txId);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
-
-    when(mockApiService.updateTransaction(eq(txId), anyMap()))
-        .thenReturn(Optional.empty());
-
-    assertThrows(NoSuchElementException.class,
-        () -> routeController.updateTransactionJson(userId, txId, Map.of("amount", 9)));
+  public void createTransactionFromFormHtml_loggerOff_validForm_returnsCreatedWith201() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction saved = new Transaction(userId, 50.0, "FOOD", "Lunch");
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.addTransaction(any(Transaction.class))).thenReturn(saved);
+      ResponseEntity<String> response =
+          routeController.createTransactionFromFormHtml(userId, "Lunch", 50.0, "FOOD");
+      assertEquals(HttpStatus.CREATED, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for updateTransactionJson (PUT /users/{userId}/transactions/{txId})
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests PUT .../{txId} with a valid update payload.
+   * Tests PUT .../transactions/{txId} with valid update.
+   *
+   * <p>Partition: P1 (Valid) - Valid update.
    */
   @Test
-  public void updateTransactionJson_validUserAndTransaction_returnsUpdatedTransactionWith200() {
+  public void updateTransactionJson_validUpdate_returnsUpdatedTransactionWith200() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    Transaction existing = new Transaction(userId, 100.0, "Food", "Lunch");
-    existing.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction existing = new Transaction(userId, 100.0, "FOOD", "Lunch");
+    existing.setTransactionId(txId);
+    Transaction updated = new Transaction(userId, 120.0, "FOOD", "Dinner");
+    updated.setTransactionId(txId);
 
-    Transaction updatedTx = new Transaction(userId, 120.0, "Food", "Dinner");
-    updatedTx.setTransactionId(transactionId);
+    Map<String, Object> updates = Map.of("amount", 120.0, "description", "Dinner");
 
-    Map<String, Object> updates = new HashMap<>();
-    updates.put("amount", 120.0);
-    updates.put("description", "Dinner");
-    User user = new User("Alice", "alice@example.com", 1000.0);
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(existing));
-    when(mockApiService.updateTransaction(transactionId, updates))
-        .thenReturn(Optional.of(updatedTx));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(existing));
+    when(mockApiService.updateTransaction(txId, updates)).thenReturn(Optional.of(updated));
 
-    ResponseEntity<Transaction> response
-        = routeController.updateTransactionJson(userId, transactionId, updates);
+    ResponseEntity<Transaction> response =
+        routeController.updateTransactionJson(userId, txId, updates);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(updatedTx, response.getBody());
     assertEquals(120.0, response.getBody().getAmount());
-    assertEquals("Dinner", response.getBody().getDescription());
   }
 
   /**
-   * (Atypical valid input) Tests PUT .../{txId} when the service reports the
-   * update failed.
+   * Tests PUT .../transactions/{txId} when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void updateTransactionJson_updateFails_throwsNoSuchElementException() {
+  public void updateTransactionJson_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 800.0);
-    Transaction existing = new Transaction(userId, 200.0, "Travel", "Bus");
-    existing.setTransactionId(transactionId);
-
-    Map<String, Object> updates = new HashMap<>();
-    updates.put("amount", 220.0);
+    UUID txId = UUID.randomUUID();
+    Map<String, Object> updates = Map.of("amount", 100.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(existing));
-    when(mockApiService.updateTransaction(transactionId, updates)).thenReturn(Optional.empty());
+    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateTransactionJson(userId, transactionId, updates)
-    );
+        () -> routeController.updateTransactionJson(userId, txId, updates));
 
-    // Just check the type; don't over-constrain the message
-    assertNotNull(thrown.getMessage());
+    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests PUT .../{txId} for a non-existent user.
+   * Tests PUT .../transactions/{txId} when transaction not found.
+   *
+   * <p>Partition: P3 (Invalid) - Transaction not found.
    */
   @Test
-  public void updateTransactionJson_userDoesNotExist_throwsNoSuchElementException() {
+  public void updateTransactionJson_transactionNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    Map<String, Object> updates = new HashMap<>();
-    updates.put("amount", 90.0);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Map<String, Object> updates = Map.of("amount", 100.0);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateTransactionJson(userId, transactionId, updates)
-    );
+        () -> routeController.updateTransactionJson(userId, txId, updates));
 
-    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests PUT .../{txId} for a transaction belonging to
-   * another user.
+   * Tests PUT .../transactions/{txId} when transaction belongs to different user.
+   *
+   * <p>Partition: P4 (Invalid) - Transaction belongs to different user.
    */
   @Test
-  public void updateTransactionJson_transactionToDifferentUser_throwsNoSuchElementException() {
+  public void
+      updateTransactionJson_transactionBelongsToDifferentUser_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
     UUID otherUserId = UUID.randomUUID();
-
-    User user = new User("Carol", "carol@example.com", 700.0);
-    Transaction tx = new Transaction(otherUserId, 50.0, "Misc", "Not yours");
-    tx.setTransactionId(transactionId);
-
-    Map<String, Object> updates = new HashMap<>();
-    updates.put("description", "Changed");
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(otherUserId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
+    Map<String, Object> updates = Map.of("amount", 100.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateTransactionJson(userId, transactionId, updates)
-    );
+        () -> routeController.updateTransactionJson(userId, txId, updates));
 
-    assertTrue(thrown.getMessage().contains("Transaction "
-        + transactionId + " not found for user " + userId));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found for user"));
   }
 
   /**
-   * (Invalid input) Tests PUT .../{txId} for a non-existent transaction.
+   * Tests PUT .../transactions/{txId} when update returns empty.
+   *
+   * <p>Partition: P5 (Invalid) - Update returns empty.
    */
   @Test
-  public void updateTransactionJson_transactionMissing_throwsNoSuchElementException() {
+  public void updateTransactionJson_updateReturnsEmpty_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-    User user = new User("Dave", "dave@example.com", 400.0);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction existing = new Transaction(userId, 100.0, "FOOD", "Lunch");
+    existing.setTransactionId(txId);
+    Map<String, Object> updates = Map.of("amount", 120.0);
+
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(existing));
+    when(mockApiService.updateTransaction(txId, updates)).thenReturn(Optional.empty());
 
-    Map<String, Object> updates = new HashMap<>();
-    updates.put("category", "Updated");
+    assertThrows(NoSuchElementException.class,
+        () -> routeController.updateTransactionJson(userId, txId, updates));
+  }
+
+  /**
+   * Tests PUT .../transactions/{txId} when service throws exception.
+   *
+   * <p>Partition: P6 (Invalid) - Service throws exception.
+   */
+  @Test
+  public void updateTransactionJson_serviceThrowsException_propagatesException() {
+    UUID userId = UUID.randomUUID();
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction existing = new Transaction(userId, 100.0, "FOOD", "Lunch");
+    existing.setTransactionId(txId);
+    Map<String, Object> updates = Map.of("category", "INVALID");
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.empty());
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(existing));
+    when(mockApiService.updateTransaction(txId, updates))
+        .thenThrow(new IllegalArgumentException("Invalid category"));
 
-    NoSuchElementException thrown = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.updateTransactionJson(userId, transactionId, updates)
-    );
+    IllegalArgumentException thrown = assertThrows(
+        IllegalArgumentException.class,
+        () -> routeController.updateTransactionJson(userId, txId, updates));
+
+    assertEquals("Invalid category", thrown.getMessage());
+  }
 
-    assertTrue(thrown.getMessage().contains("Transaction "
-        + transactionId + " not found for user " + userId));
+  /**
+   * Tests PUT .../transactions/{txId} with logger disabled.
+   *
+   * <p>Partition: P7 (Edge) - Logger disabled.
+   */
+  @Test
+  public void updateTransactionJson_loggerOff_validUpdate_returnsUpdatedTransactionWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      UUID txId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction existing = new Transaction(userId, 100.0, "FOOD", "Lunch");
+      existing.setTransactionId(txId);
+      Transaction updated = new Transaction(userId, 120.0, "FOOD", "Dinner");
+      updated.setTransactionId(txId);
+      Map<String, Object> updates = Map.of("amount", 120.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(existing));
+      when(mockApiService.updateTransaction(txId, updates)).thenReturn(Optional.of(updated));
+      ResponseEntity<Transaction> response =
+          routeController.updateTransactionJson(userId, txId, updates);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for showCreateTransactionForm
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // Tests for showCreateTransactionForm (GET /users/{userId}/transactions/create-form)
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests GET .../transactions/create-form returns the
-   * correct HTML.
+   * Tests GET .../transactions/create-form for existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
   public void showCreateTransactionForm_validUser_returnsHtmlForm() {
@@ -2587,21 +1828,17 @@ public void showCreateTransactionForm_validUser_returnsHtmlForm() {
 
     String html = routeController.showCreateTransactionForm(userId);
 
-    assertNotNull(html);
-    assertTrue(html.contains("<form"));
     assertTrue(html.contains("Create New Transaction"));
-    assertTrue(html.contains("/users/" + userId + "/transactions/form"));
-    assertTrue(html.contains("Description:"));
-    assertTrue(html.contains("Category:"));
-    assertTrue(html.contains("value='FOOD'"));
+    assertTrue(html.contains("<form"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../transactions/create-form for a
-   * minimal user.
+   * Tests GET .../transactions/create-form for minimal user.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Minimal user.
    */
   @Test
-  public void showCreateTransactionForm_atypicalUser_returnsHtmlForm() {
+  public void showCreateTransactionForm_minimalUser_returnsHtmlForm() {
     UUID userId = UUID.randomUUID();
     User user = new User("X", "", 0.0);
 
@@ -2609,489 +1846,455 @@ public void showCreateTransactionForm_atypicalUser_returnsHtmlForm() {
 
     String html = routeController.showCreateTransactionForm(userId);
 
-    assertNotNull(html);
     assertTrue(html.contains("Create New Transaction"));
-    assertTrue(html.contains("<select name='category'"));
-    assertTrue(html.contains("<input type='submit' value='Create Transaction'"));
   }
 
   /**
-   * (Invalid input) Tests GET .../transactions/create-form for a non-existent
-   * user.
+   * Tests GET .../transactions/create-form when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
-  public void showCreateTransactionForm_userDoesNotExist_throwsNoSuchElementException() {
+  public void showCreateTransactionForm_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.showCreateTransactionForm(userId)
-    );
+        () -> routeController.showCreateTransactionForm(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for deleteTransaction
-  // ---------------------------------------------------------------------------
-  /**
-   * (Invalid input) Tests DELETE .../{txId} where the transaction belongs to
-   * another user.
-   */
-  @Test
-  public void deleteTransaction_transactionBelongsToOtherUser_throws() {
-    UUID userId = UUID.randomUUID();
-    UUID otherId = UUID.randomUUID();
-    UUID txId = UUID.randomUUID();
-
-    Transaction tx = new Transaction(otherId, 50, "FOOD", "desc");
-    tx.setTransactionId(txId);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(new User("u", "e", 10)));
-    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
-
-    assertThrows(NoSuchElementException.class,
-        () -> routeController.deleteTransaction(userId, txId));
-  }
-
   /**
-   * (Invalid input) Tests DELETE .../{txId} when the service reports the
-   * delete failed.
+   * Tests GET .../transactions/create-form with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
    */
   @Test
-  public void deleteTransaction_deleteFails_throwsNoSuchElementException_alt() {
-    UUID userId = UUID.randomUUID();
-    UUID txId = UUID.randomUUID();
-
-    User user = new User("X", "x@x.com", 100);
-
-    Transaction tx = new Transaction(userId, 10, "FOOD", "Test");
-    tx.setTransactionId(txId);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
-    when(mockApiService.deleteTransaction(txId)).thenReturn(false);
-
-    NoSuchElementException ex = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.deleteTransaction(userId, txId)
-    );
-
-    assertTrue(ex.getMessage().contains("Transaction " + txId + " not found"));
+  public void showCreateTransactionForm_loggerOff_validUser_returnsHtmlForm() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      String html = routeController.showCreateTransactionForm(userId);
+      assertTrue(html.contains("Create New Transaction"));
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for deleteTransaction (DELETE /users/{userId}/transactions/{txId})
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests DELETE .../{txId} for a valid, matching
-   * transaction.
+   * Tests DELETE .../transactions/{txId} for valid deletion.
+   *
+   * <p>Partition: P1 (Valid) - Valid deletion.
    */
   @Test
-  public void deleteTransaction_validUserAndTransaction_returns200AndConfirmationMap() {
+  public void deleteTransaction_validDeletion_returnsConfirmationWith200() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
+    UUID txId = UUID.randomUUID();
     User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction tx = new Transaction(userId, 50.0, "Food", "Lunch");
-    tx.setTransactionId(transactionId);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-    when(mockApiService.deleteTransaction(transactionId)).thenReturn(true);
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+    when(mockApiService.deleteTransaction(txId)).thenReturn(true);
 
-    ResponseEntity<Map<String, Object>> response
-        = routeController.deleteTransaction(userId, transactionId);
+    ResponseEntity<Map<String, Object>> response = routeController.deleteTransaction(userId, txId);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
     assertTrue((Boolean) response.getBody().get("deleted"));
-    assertEquals(userId, response.getBody().get("userId"));
-    assertEquals(transactionId, response.getBody().get("transactionId"));
   }
 
   /**
-   * (Atypical valid input) Tests DELETE .../{txId} when the service reports
-   * the delete failed.
+   * Tests DELETE .../transactions/{txId} when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void deleteTransaction_deleteFails_throwsNoSuchElementException() {
+  public void deleteTransaction_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    User user = new User("Bob", "bob@example.com", 500.0);
-    Transaction tx = new Transaction(userId, 25.0, "Misc", "Test");
-    tx.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-    when(mockApiService.deleteTransaction(transactionId)).thenReturn(false);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.deleteTransaction(userId, transactionId)
-    );
+        () -> routeController.deleteTransaction(userId, txId));
 
-    assertTrue(thrown.getMessage().contains("Transaction " + transactionId + " not found"));
+    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests DELETE .../{txId} for a non-existent user.
+   * Tests DELETE .../transactions/{txId} when transaction belongs to different user.
+   *
+   * <p>Partition: P4 (Invalid) - Transaction belongs to different user.
    */
   @Test
-  public void deleteTransaction_userDoesNotExist_throwsNoSuchElementException() {
+  public void deleteTransaction_transactionBelongsToDifferentUser_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
+    UUID otherUserId = UUID.randomUUID();
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(otherUserId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.deleteTransaction(userId, transactionId)
-    );
+        () -> routeController.deleteTransaction(userId, txId));
 
-    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found for user"));
   }
 
   /**
-   * (Invalid input) Tests DELETE .../{txId} for a transaction belonging to
-   * another user.
+   * Tests DELETE .../transactions/{txId} when delete returns false.
+   *
+   * <p>Partition: P5 (Invalid) - Delete returns false.
    */
   @Test
-  public void deleteTransaction_transactionToDifferentUser_throwsNoSuchElementException() {
+  public void deleteTransaction_deleteFails_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    UUID otherUserId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    User user = new User("Carol", "carol@example.com", 800.0);
-    Transaction tx = new Transaction(otherUserId, 75.0, "Travel", "Bus");
-    tx.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+    when(mockApiService.deleteTransaction(txId)).thenReturn(false);
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.deleteTransaction(userId, transactionId)
-    );
+        () -> routeController.deleteTransaction(userId, txId));
 
-    assertTrue(thrown.getMessage().contains("Transaction "
-        + transactionId + " not found for user " + userId));
+    assertTrue(thrown.getMessage().contains("Transaction " + txId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for deleteTransactionViaGet
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET .../deletetransaction/{txId} for a valid,
-   * matching transaction.
+   * Tests DELETE .../transactions/{txId} with logger disabled.
+   *
+   * <p>Partition: P6 (Edge) - Logger disabled.
    */
   @Test
-  public void deleteTransactionViaGet_validUserAndTransaction_returnsSuccessMessage() {
-    UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    User user = new User("Alice", "alice@example.com", 1000.0);
-    Transaction tx = new Transaction(userId, 60.0, "Food", "Dinner");
-    tx.setTransactionId(transactionId);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-    when(mockApiService.deleteTransaction(transactionId)).thenReturn(true);
-
-    String result = routeController.deleteTransactionViaGet(userId, transactionId);
-
-    assertTrue(result.contains("Transaction deleted successfully"));
+  public void deleteTransaction_loggerOff_validDeletion_returnsConfirmationWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      UUID txId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+      tx.setTransactionId(txId);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+      when(mockApiService.deleteTransaction(txId)).thenReturn(true);
+      ResponseEntity<Map<String, Object>> response =
+          routeController.deleteTransaction(userId, txId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for deleteTransactionViaGet (GET /users/{userId}/deletetransaction/{txId})
+  // ===========================================================================
+
   /**
-   * (Atypical valid input) Tests GET .../deletetransaction/{txId} when the
-   * service reports the delete failed.
+   * Tests GET .../deletetransaction/{txId} for valid deletion.
+   *
+   * <p>Partition: P1 (Valid) - Valid deletion.
    */
   @Test
-  public void deleteTransactionViaGet_deleteFails_returnsErrorMessage() {
+  public void deleteTransactionViaGet_validDeletion_returnsSuccessMessage() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    User user = new User("Bob", "bob@example.com", 500.0);
-    Transaction tx = new Transaction(userId, 40.0, "Misc", "Test");
-    tx.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-    when(mockApiService.deleteTransaction(transactionId)).thenReturn(false);
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+    when(mockApiService.deleteTransaction(txId)).thenReturn(true);
 
-    String result = routeController.deleteTransactionViaGet(userId, transactionId);
+    ResponseEntity<String> result = routeController.deleteTransactionViaGet(userId, txId);
 
-    assertTrue(result.contains("Error: Failed to delete transaction"));
+    assertEquals(HttpStatus.OK, result.getStatusCode());
+    assertEquals("Transaction deleted successfully!", result.getBody());
   }
 
   /**
-   * (Invalid input) Tests GET .../deletetransaction/{txId} for a non-existent
-   * user.
+   * Tests GET .../deletetransaction/{txId} when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void deleteTransactionViaGet_userDoesNotExist_returnsUserNotFoundError() {
+  public void deleteTransactionViaGet_userNotFound_returns404() {
     UUID userId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
+    UUID txId = UUID.randomUUID();
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
-    String result = routeController.deleteTransactionViaGet(userId, transactionId);
+    ResponseEntity<String> result = routeController.deleteTransactionViaGet(userId, txId);
 
-    assertTrue(result.contains("Error: User " + userId + " not found"));
+    assertEquals(HttpStatus.NOT_FOUND, result.getStatusCode());
+    assertTrue(result.getBody().contains("Error: User " + userId + " not found"));
   }
 
   /**
-   * (Invalid input) Tests GET .../deletetransaction/{txId} for a transaction
-   * belonging to another user.
+   * Tests GET .../deletetransaction/{txId} when transaction not found or wrong user.
+   *
+   * <p>Partition: P3 (Invalid) - Transaction not found or wrong user.
    */
   @Test
-  public void deleteTransactionViaGet_transactionToDifferentUser_returnsTransactionNotFoundError() {
+  public void deleteTransactionViaGet_transactionNotFound_returns404() {
     UUID userId = UUID.randomUUID();
-    UUID otherUserId = UUID.randomUUID();
-    UUID transactionId = UUID.randomUUID();
-
-    User user = new User("Carol", "carol@example.com", 700.0);
-    Transaction tx = new Transaction(otherUserId, 30.0, "Travel", "Train");
-    tx.setTransactionId(transactionId);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getTransaction(transactionId)).thenReturn(Optional.of(tx));
-
-    String result = routeController.deleteTransactionViaGet(userId, transactionId);
-
-    assertTrue(result.contains("Error: Transaction "
-        + transactionId + " not found for user " + userId));
-  }
-
-  // ---------------------------------------------------------------------------
-  // Tests for budgetManagement
-  // ---------------------------------------------------------------------------
-  /**
-   * (Invalid input) Tests GET .../budget for a non-existent user.
-   */
-  @Test
-  public void budgetManagement_userNotFound_throwsNoSuchElementException() {
-    UUID userId = UUID.randomUUID();
-    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.empty());
 
-    NoSuchElementException thrown = assertThrows(
-        NoSuchElementException.class,
-        () -> routeController.budgetManagement(userId)
-    );
+    ResponseEntity<String> result = routeController.deleteTransactionViaGet(userId, txId);
 
-    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
+    assertEquals(HttpStatus.NOT_FOUND, result.getStatusCode());
+    assertTrue(result.getBody().contains("Error: Transaction " + txId + " not found"));
   }
 
   /**
-   * (Typical valid input) Tests GET .../budget for a user with spending.
+   * Tests GET .../deletetransaction/{txId} when delete fails.
+   *
+   * <p>Partition: P4 (Invalid) - Delete fails.
    */
   @Test
-  public void budgetManagement_userFoundWithWeeklySpending_returnsHtml() {
+  public void deleteTransactionViaGet_deleteFails_returns500() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "a@a.com", 1000.00);
+    UUID txId = UUID.randomUUID();
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+    tx.setTransactionId(txId);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getBudgetReport(userId)).thenReturn(
-        Map.of("totalSpent", 200.0, "remaining", 800.0)
-    );
-    when(mockApiService.totalLast7Days(userId)).thenReturn(150.00);
+    when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+    when(mockApiService.deleteTransaction(txId)).thenReturn(false);
 
-    String html = routeController.budgetManagement(userId);
+    ResponseEntity<String> result = routeController.deleteTransactionViaGet(userId, txId);
 
-    assertTrue(html.contains("Budget Management - Alice"));
-    assertTrue(html.contains("$150.00"));
-    assertTrue(html.contains("$200.0"));
-    assertTrue(html.contains("$800.0"));
+    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, result.getStatusCode());
+    assertTrue(result.getBody().contains("Error: Failed to delete transaction"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../budget for a user with zero budget
-   * and spending.
+   * Tests GET .../deletetransaction/{txId} with logger disabled.
+   *
+   * <p>Partition: P5 (Edge) - Logger disabled.
    */
   @Test
-  public void budgetManagement_zeroSpendingAllFields_returnsHtml() {
-    UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 0.0);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getBudgetReport(userId)).thenReturn(
-        Map.of("totalSpent", 0.0, "remaining", 0.0)
-    );
-    when(mockApiService.totalLast7Days(userId)).thenReturn(0.0);
-
-    String html = routeController.budgetManagement(userId);
-
-    assertTrue(html.contains("$0.00"));
-    assertTrue(html.contains("$0.0"));
+  public void deleteTransactionViaGet_loggerOff_validDeletion_returnsSuccessMessage() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      UUID txId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Transaction tx = new Transaction(userId, 50.0, "FOOD", "Lunch");
+      tx.setTransactionId(txId);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getTransaction(txId)).thenReturn(Optional.of(tx));
+      when(mockApiService.deleteTransaction(txId)).thenReturn(true);
+      ResponseEntity<String> result = routeController.deleteTransactionViaGet(userId, txId);
+      assertEquals(HttpStatus.OK, result.getStatusCode());
+      assertEquals("Transaction deleted successfully!", result.getBody());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for budgetManagement (GET /users/{userId}/budget)
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests GET .../budget for a user with a budget.
+   * Tests GET /users/{userId}/budget for existing user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
-  public void budgetManagement_validUser_returnsBudgetHtmlDashboard() {
+  public void budgetManagement_validUser_returnsBudgetPageHtml() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1500.00);
-
-    Map<String, Object> budgetReport = new HashMap<>();
-    budgetReport.put("totalSpent", 600.00);
-    budgetReport.put("remaining", 900.00);
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Map<String, Object> report = Map.of("totalSpent", 500.0, "remaining", 500.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getBudgetReport(userId)).thenReturn(budgetReport);
-    when(mockApiService.totalLast7Days(userId)).thenReturn(200.00);
+    when(mockApiService.getBudgetReport(userId)).thenReturn(report);
+    when(mockApiService.totalLast7Days(userId)).thenReturn(100.0);
 
     String html = routeController.budgetManagement(userId);
 
-    assertNotNull(html);
-    assertTrue(html.contains("<h1>Budget Management - Alice</h1>"));
-    assertTrue(html.contains("<p><strong>Total Budget:</strong> $1500.00</p>"));
-    assertTrue(html.contains("<p><strong>Total Spent:</strong> $600.0</p>"));
-    assertTrue(html.contains("<p><strong>Remaining:</strong> $900.0</p>"));
-    assertTrue(html.contains("<p><strong>Weekly Spending:</strong> $200.00</p>"));
-    assertTrue(html.contains("/users/" + userId + "/budget-report"));
+    assertTrue(html.contains("Budget Management"));
+    assertTrue(html.contains("Alice"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../budget for a user with a zero
-   * budget.
+   * Tests GET /users/{userId}/budget when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
-  public void budgetManagement_userWithZeroBudget_returnsHtmlWithZeros() {
+  public void budgetManagement_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 0.00);
 
-    Map<String, Object> budgetReport = new HashMap<>();
-    budgetReport.put("totalSpent", 0.00);
-    budgetReport.put("remaining", 0.00);
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getBudgetReport(userId)).thenReturn(budgetReport);
-    when(mockApiService.totalLast7Days(userId)).thenReturn(0.00);
+    when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
-    String html = routeController.budgetManagement(userId);
+    NoSuchElementException thrown = assertThrows(
+        NoSuchElementException.class,
+        () -> routeController.budgetManagement(userId));
 
-    assertNotNull(html);
-    assertTrue(html.contains("<h1>Budget Management - Bob</h1>"));
-    assertTrue(html.contains("<p><strong>Total Budget:</strong> $0.00</p>"));
-    assertTrue(html.contains("<p><strong>Total Spent:</strong> $0.0</p>"));
-    assertTrue(html.contains("<p><strong>Remaining:</strong> $0.0</p>"));
-    assertTrue(html.contains("<p><strong>Weekly Spending:</strong> $0.00</p>"));
+    assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for updateBudgetJson
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests PUT .../budget with a valid JSON update.
+   * Tests GET /users/{userId}/budget with logger disabled.
+   *
+   * <p>Partition: P3 (Edge) - Logger disabled.
    */
   @Test
-  public void updateBudgetJson_validUser_returnsUpdatedBudgetReport() {
-    Map<String, Object> budgetUpdate = new HashMap<>();
-    budgetUpdate.put("budget", 2000.00);
-
-    Map<String, Object> updatedReport = new HashMap<>();
-    updatedReport.put("totalSpent", 500.00);
-    updatedReport.put("remaining", 1500.00);
-    UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1500.00);
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    doNothing().when(mockApiService).setBudgets(userId, budgetUpdate);
-    when(mockApiService.getBudgetReport(userId)).thenReturn(updatedReport);
-
-    ResponseEntity<Map<String, Object>> response
-        = routeController.updateBudgetJson(userId, budgetUpdate);
-
-    assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(updatedReport, response.getBody());
-    verify(mockApiService).setBudgets(userId, budgetUpdate);
+  public void budgetManagement_loggerOff_validUser_returnsBudgetPageHtml() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Map<String, Object> report = Map.of("totalSpent", 500.0, "remaining", 500.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getBudgetReport(userId)).thenReturn(report);
+      when(mockApiService.totalLast7Days(userId)).thenReturn(100.0);
+      String html = routeController.budgetManagement(userId);
+      assertTrue(html.contains("Budget Management"));
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for updateBudgetJson (PUT /users/{userId}/budget)
+  // ===========================================================================
+
   /**
-   * (Atypical valid input) Tests PUT .../budget setting the budget to zero.
+   * Tests PUT /users/{userId}/budget with valid update.
+   *
+   * <p>Partition: P1 (Valid) - Valid budget update.
    */
   @Test
-  public void updateBudgetJson_zeroBudget_returnsUpdatedBudgetReport() {
+  public void updateBudgetJson_validUpdate_returnsReportWith200() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 0.00);
-
-    Map<String, Object> budgetUpdate = Map.of("budget", 0.00);
-    Map<String, Object> report = Map.of("totalSpent", 0.00, "remaining", 0.00);
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Map<String, Object> budgetUpdate = Map.of("budget", 1500.0);
+    Map<String, Object> report = Map.of("totalBudget", 1500.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    doNothing().when(mockApiService).setBudgets(userId, budgetUpdate);
     when(mockApiService.getBudgetReport(userId)).thenReturn(report);
 
-    ResponseEntity<Map<String, Object>> response
-        = routeController.updateBudgetJson(userId, budgetUpdate);
+    ResponseEntity<Map<String, Object>> response =
+        routeController.updateBudgetJson(userId, budgetUpdate);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(report, response.getBody());
-    verify(mockApiService).setBudgets(userId, budgetUpdate);
   }
 
   /**
-   * (Invalid input) Tests PUT .../budget for a non-existent user.
+   * Tests PUT /users/{userId}/budget when user not found.
+   *
+   * <p>Partition: P2 (Invalid) - User not found.
    */
   @Test
   public void updateBudgetJson_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
-    Map<String, Object> budgetUpdate = Map.of("budget", 1000.00);
+    Map<String, Object> budgetUpdate = Map.of("budget", 1500.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateBudgetJson(userId, budgetUpdate)
-    );
+        () -> routeController.updateBudgetJson(userId, budgetUpdate));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for updateBudget
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests POST .../update-budget with valid form data.
+   * Tests PUT /users/{userId}/budget with logger disabled.
+   *
+   * <p>Partition: P3 (Edge) - Logger disabled.
+   */
+  @Test
+  public void updateBudgetJson_loggerOff_validUpdate_returnsReportWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Map<String, Object> budgetUpdate = Map.of("budget", 1500.0);
+      Map<String, Object> report = Map.of("totalBudget", 1500.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getBudgetReport(userId)).thenReturn(report);
+      ResponseEntity<Map<String, Object>> response =
+          routeController.updateBudgetJson(userId, budgetUpdate);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for updateBudget (POST /users/{userId}/update-budget)
+  // ===========================================================================
+
+  /**
+   * Tests POST /users/{userId}/update-budget with valid budget.
+   *
+   * <p>Partition: P1 (Valid) - Valid budget.
    */
   @Test
-  public void updateBudget_validUser_returnsHtmlConfirmation() {
+  public void updateBudget_validBudget_returnsHtmlSuccessWith200() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1000.00);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    doNothing().when(mockApiService).setBudgets(userId, Map.of("budget", 1200.00));
 
-    ResponseEntity<String> response = routeController.updateBudget(userId, 1200.00);
+    ResponseEntity<String> response = routeController.updateBudget(userId, 1500.0);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertTrue(response.getBody().contains("Budget Updated Successfully!"));
-    assertTrue(response.getBody().contains("$1200.00"));
-    verify(mockApiService).setBudgets(userId, Map.of("budget", 1200.00));
+    assertTrue(response.getBody().contains("Budget Updated Successfully"));
+    assertTrue(response.getBody().contains("$1500.00"));
   }
 
   /**
-   * (Atypical valid input) Tests POST .../update-budget setting the budget to
-   * zero.
+   * Tests POST /users/{userId}/update-budget with zero budget.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - Zero budget.
    */
   @Test
-  public void updateBudget_zeroBudget_returnsHtmlWithZero() {
+  public void updateBudget_zeroBudget_returnsHtmlSuccessWith200() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 500.00);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    doNothing().when(mockApiService).setBudgets(userId, Map.of("budget", 0.00));
 
-    ResponseEntity<String> response = routeController.updateBudget(userId, 0.00);
+    ResponseEntity<String> response = routeController.updateBudget(userId, 0.0);
 
     assertEquals(HttpStatus.OK, response.getStatusCode());
     assertTrue(response.getBody().contains("$0.00"));
-    assertTrue(response.getBody().contains("Budget Updated Successfully!"));
-    verify(mockApiService).setBudgets(userId, Map.of("budget", 0.00));
   }
 
   /**
-   * (Invalid input) Tests POST .../update-budget for a non-existent user.
+   * Tests POST /users/{userId}/update-budget when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
   public void updateBudget_userNotFound_throwsNoSuchElementException() {
@@ -3101,76 +2304,66 @@ public void updateBudget_userNotFound_throwsNoSuchElementException() {
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.updateBudget(userId, 1500.00)
-    );
+        () -> routeController.updateBudget(userId, 1500.0));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for weeklySummary
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET .../weekly-summary for a user with
-   * transactions.
+   * Tests POST /users/{userId}/update-budget with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
    */
   @Test
-  public void weeklySummary_withTransactions_rendersTable() {
-    UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "a@a.com", 100);
-
-    Transaction t = new Transaction(userId, 10, "FOOD", "Lunch");
-
-    when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.weeklySummary(userId)).thenReturn(List.of(t));
-    when(mockApiService.totalLast7Days(userId)).thenReturn(10.0);
-
-    Map<String, Object> summary = routeController.weeklySummary(userId);
-
-    assertEquals("Alice", summary.get("username"));
-    assertEquals(10.0, (Double) summary.get("weeklyTotal"));
-    assertEquals(1, summary.get("transactionCount"));
-    List<?> transactions = (List<?>) summary.get("transactions");
-    assertEquals(1, transactions.size());
-    assertTrue(transactions.contains(t));
+  public void updateBudget_loggerOff_validBudget_returnsHtmlSuccessWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      ResponseEntity<String> response = routeController.updateBudget(userId, 1500.0);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
   }
 
+  // ===========================================================================
+  // Tests for weeklySummary (GET /users/{userId}/weekly-summary)
+  // ===========================================================================
+
   /**
-   * (Typical valid input) Tests GET .../weekly-summary with multiple
-   * transactions.
+   * Tests GET /users/{userId}/weekly-summary for user with transactions.
+   *
+   * <p>Partition: P1 (Valid) - User with transactions.
    */
   @Test
-  public void weeklySummary_validUser_returnsHtmlWithTransactionsAndTotal() {
+  public void weeklySummary_userWithTransactions_returnsSummaryMap() {
     UUID userId = UUID.randomUUID();
     User user = new User("Alice", "alice@example.com", 1000.0);
-
-    Transaction tx1 = new Transaction(userId, 50.0, "FOOD", "Lunch");
-    Transaction tx2 = new Transaction(userId, 30.0, "TRANSPORTATION", "Subway pass");
-    List<Transaction> transactions = List.of(tx1, tx2);
+    List<Transaction> transactions = List.of(
+        new Transaction(userId, 50.0, "FOOD", "Lunch"));
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.weeklySummary(userId)).thenReturn(transactions);
-    when(mockApiService.totalLast7Days(userId)).thenReturn(80.0);
+    when(mockApiService.totalLast7Days(userId)).thenReturn(50.0);
 
     Map<String, Object> summary = routeController.weeklySummary(userId);
 
-    assertNotNull(summary);
     assertEquals("Alice", summary.get("username"));
-    assertEquals(80.0, (Double) summary.get("weeklyTotal"));
-    assertEquals(2, summary.get("transactionCount"));
-    List<?> responseTx = (List<?>) summary.get("transactions");
-    assertEquals(2, responseTx.size());
-    assertTrue(responseTx.containsAll(List.of(tx1, tx2)));
+    assertEquals(50.0, summary.get("weeklyTotal"));
+    assertEquals(1, summary.get("transactionCount"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../weekly-summary for a user with no
-   * transactions.
+   * Tests GET /users/{userId}/weekly-summary for user with no transactions.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - No transactions.
    */
   @Test
-  public void weeklySummary_noTransactions_returnsNoTransactionsMessage() {
+  public void weeklySummary_noTransactions_returnsEmptySummary() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 500.0);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.weeklySummary(userId)).thenReturn(new ArrayList<>());
@@ -3178,172 +2371,237 @@ public void weeklySummary_noTransactions_returnsNoTransactionsMessage() {
 
     Map<String, Object> summary = routeController.weeklySummary(userId);
 
-    assertNotNull(summary);
-    assertEquals("Bob", summary.get("username"));
-    assertEquals(0.0, (Double) summary.get("weeklyTotal"));
+    assertEquals(0.0, summary.get("weeklyTotal"));
     assertEquals(0, summary.get("transactionCount"));
-    assertTrue(((List<?>) summary.get("transactions")).isEmpty());
   }
 
   /**
-   * (Invalid input) Tests GET .../weekly-summary for a non-existent user.
+   * Tests GET /users/{userId}/weekly-summary when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
   public void weeklySummary_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
+
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.weeklySummary(userId)
-    );
+        () -> routeController.weeklySummary(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for monthlySummary
-  // ---------------------------------------------------------------------------
   /**
-   * (Atypical valid input) Tests GET .../monthly-summary when the service
-   * returns null.
+   * Tests GET /users/{userId}/weekly-summary with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
+   */
+  @Test
+  public void weeklySummary_loggerOff_userWithTransactions_returnsSummaryMap() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.weeklySummary(userId)).thenReturn(new ArrayList<>());
+      when(mockApiService.totalLast7Days(userId)).thenReturn(0.0);
+      Map<String, Object> summary = routeController.weeklySummary(userId);
+      assertNotNull(summary);
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for monthlySummary (GET /users/{userId}/monthly-summary)
+  // ===========================================================================
+
+  /**
+   * Tests GET /users/{userId}/monthly-summary for valid user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
    */
   @Test
-  public void monthlySummary_nullSummary_returnsEmptyPreBlock() {
+  public void monthlySummary_validUser_returnsSummaryMap() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Dana", "d@d.com", 1000);
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    String mockSummary = "Total spent this month: $400";
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getMonthlySummary(userId)).thenReturn(null);
+    when(mockApiService.getMonthlySummary(userId)).thenReturn(mockSummary);
 
     Map<String, Object> response = routeController.monthlySummary(userId);
 
-    assertNull(response.get("summary"));
+    assertEquals(mockSummary, response.get("summary"));
   }
 
   /**
-   * (Typical valid input) Tests GET .../monthly-summary for a valid user.
+   * Tests GET /users/{userId}/monthly-summary when service returns null.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Service returns null summary.
    */
   @Test
-  public void monthlySummary_validUser_returnsHtmlWithSummaryText() {
+  public void monthlySummary_nullSummary_returnsMapWithoutSummaryKey() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Charlie", "charlie@example.com", 1200.0);
-    String mockSummary = "Total spent this month: $400\nRemaining: $800";
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getMonthlySummary(userId)).thenReturn(mockSummary);
+    when(mockApiService.getMonthlySummary(userId)).thenReturn(null);
 
     Map<String, Object> response = routeController.monthlySummary(userId);
 
-    assertNotNull(response);
-    assertEquals(mockSummary, response.get("summary"));
+    assertNull(response.get("summary"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../monthly-summary when the service
-   * returns an empty string.
+   * Tests GET /users/{userId}/monthly-summary when service returns empty string.
+   *
+   * <p>Partition: P3 (Valid/Edge) - Service returns empty summary.
    */
   @Test
-  public void monthlySummary_emptySummary_returnsHtmlWithEmptyPreBlock() {
+  public void monthlySummary_emptySummary_returnsMapWithEmptyString() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Dana", "dana@example.com", 1000.0);
+    User user = new User("Alice", "alice@example.com", 1000.0);
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.getMonthlySummary(userId)).thenReturn("");
 
     Map<String, Object> response = routeController.monthlySummary(userId);
 
-    assertNotNull(response);
     assertEquals("", response.get("summary"));
   }
 
   /**
-   * (Invalid input) Tests GET .../monthly-summary for a non-existent user.
+   * Tests GET /users/{userId}/monthly-summary when user not found.
+   *
+   * <p>Partition: P4 (Invalid) - User not found.
    */
   @Test
   public void monthlySummary_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
+
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.monthlySummary(userId)
-    );
+        () -> routeController.monthlySummary(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for budgetReport
-  // ---------------------------------------------------------------------------
   /**
-   * (Typical valid input) Tests GET .../budget-report for a valid user.
+   * Tests GET /users/{userId}/monthly-summary with logger disabled.
+   *
+   * <p>Partition: P5 (Edge) - Logger disabled.
    */
   @Test
-  public void budgetReport_validUser_returnsJsonBudgetReport() {
-    Map<String, Object> report = new HashMap<>();
-    report.put("totalSpent", 500.00);
-    report.put("remaining", 1000.00);
-    report.put("budget", 1500.00);
+  public void monthlySummary_loggerOff_validUser_returnsSummaryMap() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getMonthlySummary(userId)).thenReturn("Summary");
+      Map<String, Object> response = routeController.monthlySummary(userId);
+      assertNotNull(response);
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for budgetReport (GET /users/{userId}/budget-report)
+  // ===========================================================================
+
+  /**
+   * Tests GET /users/{userId}/budget-report for valid user.
+   *
+   * <p>Partition: P1 (Valid) - User exists.
+   */
+  @Test
+  public void budgetReport_validUser_returnsReportWith200() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Alice", "alice@example.com", 1500.00);
+    User user = new User("Alice", "alice@example.com", 1000.0);
+    Map<String, Object> report = Map.of("totalSpent", 500.0, "remaining", 500.0);
+
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
     when(mockApiService.getBudgetReport(userId)).thenReturn(report);
 
     ResponseEntity<Map<String, Object>> response = routeController.budgetReport(userId);
 
-    assertNotNull(response);
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertEquals(report, response.getBody());
-    assertTrue(response.getBody().containsKey("totalSpent"));
-    assertEquals(500.00, response.getBody().get("totalSpent"));
+    assertEquals(500.0, response.getBody().get("totalSpent"));
   }
 
   /**
-   * (Atypical valid input) Tests GET .../budget-report for a user with an
-   * empty report.
+   * Tests GET /users/{userId}/budget-report with empty report.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Empty report.
    */
   @Test
-  public void budgetReport_emptyReport_returnsHttp200WithEmptyJson() {
+  public void budgetReport_emptyReport_returnsReportWith200() {
     UUID userId = UUID.randomUUID();
-    User user = new User("Bob", "bob@example.com", 0.0);
-
-    Map<String, Object> emptyReport = new HashMap<>();
-    emptyReport.put("totalSpent", 0.0);
-    emptyReport.put("remaining", 0.0);
+    User user = new User("Alice", "alice@example.com", 0.0);
+    Map<String, Object> report = new HashMap<>();
 
     when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
-    when(mockApiService.getBudgetReport(userId)).thenReturn(emptyReport);
+    when(mockApiService.getBudgetReport(userId)).thenReturn(report);
 
     ResponseEntity<Map<String, Object>> response = routeController.budgetReport(userId);
 
-    assertNotNull(response);
     assertEquals(HttpStatus.OK, response.getStatusCode());
-    assertTrue(response.getBody().containsKey("remaining"));
-    assertEquals(0.0, response.getBody().get("remaining"));
+    assertTrue(response.getBody().isEmpty());
   }
 
   /**
-   * (Invalid input) Tests GET .../budget-report for a non-existent user.
+   * Tests GET /users/{userId}/budget-report when user not found.
+   *
+   * <p>Partition: P3 (Invalid) - User not found.
    */
   @Test
   public void budgetReport_userNotFound_throwsNoSuchElementException() {
     UUID userId = UUID.randomUUID();
+
     when(mockApiService.getUser(userId)).thenReturn(Optional.empty());
 
     NoSuchElementException thrown = assertThrows(
         NoSuchElementException.class,
-        () -> routeController.budgetReport(userId)
-    );
+        () -> routeController.budgetReport(userId));
 
     assertTrue(thrown.getMessage().contains("User " + userId + " not found"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for handleNotFound
-  // ---------------------------------------------------------------------------
   /**
-   * Tests the @ExceptionHandler for NoSuchElementException.
+   * Tests GET /users/{userId}/budget-report with logger disabled.
+   *
+   * <p>Partition: P4 (Edge) - Logger disabled.
+   */
+  @Test
+  public void budgetReport_loggerOff_validUser_returnsReportWith200() {
+    Level original = setLogLevel(Level.OFF);
+    try {
+      UUID userId = UUID.randomUUID();
+      User user = new User("Alice", "alice@example.com", 1000.0);
+      Map<String, Object> report = Map.of("totalSpent", 500.0);
+      when(mockApiService.getUser(userId)).thenReturn(Optional.of(user));
+      when(mockApiService.getBudgetReport(userId)).thenReturn(report);
+      ResponseEntity<Map<String, Object>> response = routeController.budgetReport(userId);
+      assertEquals(HttpStatus.OK, response.getStatusCode());
+    } finally {
+      setLogLevel(original);
+    }
+  }
+
+  // ===========================================================================
+  // Tests for Exception Handlers
+  // ===========================================================================
+
+  /**
+   * Tests the exception handler for NoSuchElementException.
+   *
+   * <p>Partition: handleNotFound maps to 404 NOT_FOUND.
    */
   @Test
   public void handleNotFound_returns404WithErrorMessage() {
@@ -3351,17 +2609,14 @@ public void handleNotFound_returns404WithErrorMessage() {
 
     ResponseEntity<Map<String, String>> response = routeController.handleNotFound(ex);
 
-    assertNotNull(response);
     assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    assertTrue(response.getBody().containsKey("error"));
     assertEquals("User not found", response.getBody().get("error"));
   }
 
-  // ---------------------------------------------------------------------------
-  // Tests for handleBadRequest
-  // ---------------------------------------------------------------------------
   /**
-   * Tests the @ExceptionHandler for IllegalArgumentException.
+   * Tests the exception handler for IllegalArgumentException.
+   *
+   * <p>Partition: handleBadRequest maps to 400 BAD_REQUEST.
    */
   @Test
   public void handleBadRequest_returns400WithErrorMessage() {
@@ -3369,9 +2624,7 @@ public void handleBadRequest_returns400WithErrorMessage() {
 
     ResponseEntity<Map<String, String>> response = routeController.handleBadRequest(ex);
 
-    assertNotNull(response);
     assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
-    assertTrue(response.getBody().containsKey("error"));
     assertEquals("Invalid budget amount", response.getBody().get("error"));
   }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/TransactionUnitTests.java b/src/test/java/dev/ase/teamproject/TransactionUnitTests.java
index 1710f5f..e6c9adc 100644
--- a/src/test/java/dev/ase/teamproject/TransactionUnitTests.java
+++ b/src/test/java/dev/ase/teamproject/TransactionUnitTests.java
@@ -1,6 +1,7 @@
 package dev.ase.teamproject;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -15,138 +16,213 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * Test Plan / Equivalence Partitions for Transaction (POJO / Data Class)
+ * Unit tests for the {@link Transaction} model class.
  *
- * <p>Class Under Test: dev.ase.teamproject.model.Transaction
+ * <p>This test suite validates all public methods of the Transaction POJO,
+ * covering valid and invalid equivalence partitions including boundary values
+ * where applicable. Tests are organized by method and share common setup
+ * through {@code @BeforeEach}.
  *
- * <p>This plan covers the unit tests for the Transaction model. Since this is a
- * data class, testing focuses on constructors, getter/setter pairs, and
- * the branch logic within business methods (like compareTo, equals, etc.).
+ * <h2>Equivalence Partitions by Method</h2>
  *
- * <p>1. Transaction() (Default Constructor)
- * - P1: (Valid) Call constructor.
- * - Expects: All fields null or 0.0.
- * - Covered by: constructor_defaultConstructor_initializesNullOrZeroFields
+ * <h3>1. Transaction() - Default Constructor</h3>
+ * <ul>
+ *   <li>P1: (Valid) Instantiation - All fields should be null or 0.0</li>
+ *   <li>Covered by: {@link #constructor_defaultConstructor_initializesNullOrZeroFields}</li>
+ * </ul>
  *
- * <p>2. Transaction(userId, amount, category, description) (Parameterized)
- * - P1: (Valid) Call with valid data.
- * - Expects: Fields are set, description is handled by setDescription.
- * - Covered by: constructor_parameterizedConstructor_setsProvidedValues
+ * <h3>2. Transaction(userId, amount, category, description) - Parameterized Constructor</h3>
+ * <ul>
+ *   <li>P1: (Valid) All parameters provided with typical values</li>
+ *   <li>Covered by: {@link #constructor_parameterizedConstructor_setsProvidedValues}</li>
+ * </ul>
  *
- * <p>3. setDescription(String description)
- * - P1: (Valid) Normal string.
- * - Covered by: setDescription_validString_descriptionIsUpdated
- * - P2: (Valid, Boundary) Empty string "".
- * - Covered by: setDescription_emptyString_descriptionIsEmpty
- * - P3: (Valid, Branch) String with whitespace only (triggers trim()).
- * - Covered by: setDescription_withWhitespaceOnly_setsEmptyString
- * - P4: (Invalid, Branch) null input (triggers null check).
- * - Covered by: setDescription_withNull_setsEmptyString
+ * <h3>3. setTransactionId(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Non-null UUID</li>
+ *   <li>Covered by: {@link #setTransactionId_validId_transactionIdIsSet}</li>
+ *   <li>P2: (Invalid/Boundary) Null UUID</li>
+ *   <li>Covered by: {@link #setTransactionId_nullId_transactionIdIsNull}</li>
+ * </ul>
  *
- * <p>4. setTimestamp(LocalDateTime timestamp)
- * - P1: (Valid, Branch) timestamp != null.
- * - Expects: this.timestamp and this.date are set.
- * - Covered by: setTimestamp_validDateTime_timestampStoredCorrectly
- * - P2: (Invalid, Branch) timestamp == null.
- * - Expects: this.timestamp is set to null, this.date is unchanged.
- * - Covered by: setTimestamp_withNull_setsTimestampToNull_leavesDateUnchanged
+ * <h3>4. setUserId(UUID)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Non-null UUID</li>
+ *   <li>Covered by: {@link #setUserId_validId_userIdIsUpdated}</li>
+ *   <li>P2: (Invalid/Boundary) Null UUID</li>
+ *   <li>Covered by: {@link #setUserId_nullId_userIdIsNull}</li>
+ * </ul>
  *
- * <p>5. setDate(LocalDate date)
- * - P1: (Valid, Branch) date != null && this.timestamp == null.
- * - Expects: date is set, timestamp is set to date.atStartOfDay().
- * - Covered by: setDate_validDateTimestampNull_returnsDateStartOfDay
- * - P2: (Valid, Branch) date != null && this.timestamp != null.
- * - Expects: date is set, timestamp is unchanged.
- * - Covered by: setDate_withExistingTimestamp_keepsOriginalTimestamp
- * - P3: (Invalid, Branch) date == null.
- * - Expects: date is set to null (timestamp remains).
- * - Covered by: setDate_nullDate_dateIsNull
+ * <h3>5. setDescription(String)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Normal non-empty string</li>
+ *   <li>Covered by: {@link #setDescription_validString_descriptionIsUpdated}</li>
+ *   <li>P2: (Valid/Boundary) Empty string ""</li>
+ *   <li>Covered by: {@link #setDescription_emptyString_descriptionIsEmpty}</li>
+ *   <li>P3: (Valid/Edge) String with leading/trailing whitespace - triggers trim()</li>
+ *   <li>Covered by: {@link #setDescription_withLeadingTrailingWhitespace_trimsWhitespace}</li>
+ *   <li>P4: (Valid/Edge) Whitespace-only string - triggers trim() to empty</li>
+ *   <li>Covered by: {@link #setDescription_withWhitespaceOnly_setsEmptyString}</li>
+ *   <li>P5: (Invalid) Null input - triggers null-check branch</li>
+ *   <li>Covered by: {@link #setDescription_withNull_setsEmptyString}</li>
+ * </ul>
  *
- * <p>6. effectiveInstant()
- * - P1: (Branch) timestamp != null.
- * - Covered by: effectiveInstant_withTimestamp_returnsSameTimestamp
- * - P2: (Branch) timestamp == null && date != null.
- * - Covered by: effectiveInstant_withDateOnly_returnsDateStartOfDay
- * - P3: (Branch) timestamp == null && date == null.
- * - Covered by: effectiveInstant_bothTimestampAndDateNull_returnsNull
+ * <h3>6. setAmount(double)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Positive amount (expense)</li>
+ *   <li>Covered by: {@link #setAmount_positiveValue_amountIsUpdated}</li>
+ *   <li>P2: (Valid) Negative amount (income/refund)</li>
+ *   <li>Covered by: {@link #setAmount_negativeValue_amountIsUpdated}</li>
+ *   <li>P3: (Valid/Boundary) Zero amount</li>
+ *   <li>Covered by: {@link #setAmount_zeroValue_amountIsZero}</li>
+ *   <li>P4: (Valid/Boundary) Very large positive value</li>
+ *   <li>Covered by: {@link #setAmount_largePositiveValue_amountIsUpdated}</li>
+ *   <li>P5: (Valid/Boundary) Very large negative value</li>
+ *   <li>Covered by: {@link #setAmount_largeNegativeValue_amountIsUpdated}</li>
+ *   <li>P6: (Invalid/Boundary) Double.MAX_VALUE</li>
+ *   <li>Covered by: {@link #setAmount_maxDoubleValue_amountIsUpdated}</li>
+ *   <li>P7: (Invalid/Boundary) Double.MIN_VALUE (smallest positive)</li>
+ *   <li>Covered by: {@link #setAmount_minDoubleValue_amountIsUpdated}</li>
+ *   <li>P8: (Invalid/Edge) Double.NaN</li>
+ *   <li>Covered by: {@link #setAmount_nanValue_amountIsNan}</li>
+ *   <li>P9: (Invalid/Edge) Double.POSITIVE_INFINITY</li>
+ *   <li>Covered by: {@link #setAmount_positiveInfinity_amountIsInfinity}</li>
+ *   <li>P10: (Invalid/Edge) Double.NEGATIVE_INFINITY</li>
+ *   <li>Covered by: {@link #setAmount_negativeInfinity_amountIsNegativeInfinity}</li>
+ * </ul>
  *
- * <p>7. compareTo(Transaction other)
- * - P1: (Invalid) other == null.
- * - Covered by: compareTo_nullOther_returnsPositive
- * - P2: (Branch) Different non-null instants (cmp != 0).
- * - Covered by: compareTo_differentTimestamps_ordersByTime
- * - P3: (Branch) Same non-null instants (cmp == 0) -> fallback to ID compare.
- * - Covered by: compareTo_sameTimestamp_ordersById
- * - P4: (Branch) this.instant == null, other.instant != null.
- * - Covered by: compareTo_oneEffectiveInstantNull_returnsCorrectOrder
- * - P5: (Branch) this.instant != null, other.instant == null.
- * - Covered by: compareTo_oneEffectiveInstantNull_returnsCorrectOrder (reverse)
- * - P6: (Branch) Both instants null -> fallback to ID compare.
- * - Covered by: compareTo_bothEffectiveInstantNull_compareById
- * - P7: (Sub-Branch) Both instants null, both IDs null.
- * - Covered by: compareTo_bothNullIds_returnsZero
- * - P8: (Sub-Branch) Both instants null, one ID null.
- * - Covered by: compareTo_noTime_oneNullId_ordersNullFirst
- * - P9: (Sub-Branch) Same instant, one ID null.
- * - Covered by: compareTo_sameTime_oneNullId_ordersNullFirst
+ * <h3>7. setCategory(String)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Normal non-empty string</li>
+ *   <li>Covered by: {@link #setCategory_validString_categoryIsUpdated}</li>
+ *   <li>P2: (Valid/Boundary) Empty string</li>
+ *   <li>Covered by: {@link #setCategory_emptyString_categoryIsEmpty}</li>
+ *   <li>P3: (Invalid) Null input</li>
+ *   <li>Covered by: {@link #setCategory_nullValue_categoryIsNull}</li>
+ * </ul>
  *
- * <p>8. equals(Object other)
- * - P1: (Branch) this == other.
- * - Covered by: equals_sameObject_returnsTrue
- * - P2: (Branch) other == null.
- * - Covered by: equals_null_returnsFalse
- * - P3: (Branch) !(other instanceof Transaction).
- * - Covered by: equals_differentClass_returnsFalse
- * - P4: (Branch) Same class, Objects.equals(id1, id2) (different, non-null).
- * - Covered by: equals_differentIds_returnsFalse
- * - P5: (Branch) Same class, Objects.equals(id1, id2) (same, non-null).
- * - Covered by: equals_sameId_returnsTrue
- * - P6: (Branch) Same class, Objects.equals(null, null).
- * - Covered by: equals_bothNullId_returnsTrue
- * - P7: (Branch) Same class, Objects.equals(id, null).
- * - Covered by: equals_oneNullId_returnsFalse
- * - P8: (Branch) Same class, Objects.equals(null, id).
- * - Covered by: equals_oneNullId_returnsFalse_reverse
+ * <h3>8. setTimestamp(LocalDateTime)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Non-null timestamp - also updates date field</li>
+ *   <li>Covered by: {@link #setTimestamp_validDateTime_timestampStoredCorrectly}</li>
+ *   <li>P2: (Valid/Edge) Setting timestamp twice - date updates to latest</li>
+ *   <li>Covered by: {@link #setTimestamp_settingTwice_updatesDateToLatest}</li>
+ *   <li>P3: (Invalid) Null timestamp - timestamp becomes null, date unchanged</li>
+ *   <li>Covered by: {@link #setTimestamp_withNull_setsTimestampToNull_leavesDateUnchanged}</li>
+ * </ul>
  *
- * <p>9. hashCode()
- * - P1: (Branch) transactionId != null.
- * - Covered by: hashCode_withId_returnsIdHash
- * - P2: (Branch) transactionId == null.
- * - Covered by: hashCode_withNullId_returnsZeroHash
+ * <h3>9. setDate(LocalDate)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Date set when timestamp is null - auto-sets timestamp to start of day</li>
+ *   <li>Covered by: {@link #setDate_validDateTimestampNull_returnsDateStartOfDay}</li>
+ *   <li>P2: (Valid) Date set when timestamp exists - timestamp unchanged</li>
+ *   <li>Covered by: {@link #setDate_withExistingTimestamp_keepsOriginalTimestamp}</li>
+ *   <li>P3: (Invalid) Null date - date becomes null, timestamp unchanged</li>
+ *   <li>Covered by: {@link #setDate_nullDate_dateIsNull}</li>
+ * </ul>
  *
- * <p>10. toString()
- * - P1: (Valid) Call on a populated object.
- * - Covered by: toString_containsAllFields
+ * <h3>10. effectiveInstant()</h3>
+ * <ul>
+ *   <li>P1: (Valid) Timestamp exists - returns timestamp</li>
+ *   <li>Covered by: {@link #effectiveInstant_withTimestamp_returnsSameTimestamp}</li>
+ *   <li>P2: (Valid) Timestamp null, date exists - returns date.atStartOfDay()</li>
+ *   <li>Covered by: {@link #effectiveInstant_withDateOnly_returnsDateStartOfDay}</li>
+ *   <li>P3: (Invalid) Both timestamp and date null - returns null</li>
+ *   <li>Covered by: {@link #effectiveInstant_bothTimestampAndDateNull_returnsNull}</li>
+ * </ul>
+ *
+ * <h3>11. compareTo(Transaction)</h3>
+ * <ul>
+ *   <li>P1: (Invalid) Other is null - returns positive</li>
+ *   <li>Covered by: {@link #compareTo_nullOther_returnsPositive}</li>
+ *   <li>P2: (Valid) Different non-null instants - orders by time</li>
+ *   <li>Covered by: {@link #compareTo_differentTimestamps_ordersByTime}</li>
+ *   <li>P3: (Valid) Same non-null instants - fallback to ID comparison</li>
+ *   <li>Covered by: {@link #compareTo_sameTimestamp_ordersById}</li>
+ *   <li>P4: (Edge) This instant null, other instant non-null - this comes first</li>
+ *   <li>Covered by: {@link #compareTo_oneEffectiveInstantNull_returnsCorrectOrder}</li>
+ *   <li>P5: (Edge) This instant non-null, other instant null - other comes first</li>
+ *   <li>Covered by: {@link #compareTo_oneEffectiveInstantNull_returnsCorrectOrder}</li>
+ *   <li>P6: (Edge) Both instants null - fallback to ID comparison</li>
+ *   <li>Covered by: {@link #compareTo_bothEffectiveInstantNull_compareById}</li>
+ *   <li>P7: (Edge) Both instants null, both IDs null - returns zero</li>
+ *   <li>Covered by: {@link #compareTo_bothNullIds_returnsZero}</li>
+ *   <li>P8: (Edge) Both instants null, one ID null - null ID comes first</li>
+ *   <li>Covered by: {@link #compareTo_noTime_oneNullId_ordersNullFirst}</li>
+ *   <li>P9: (Edge) Same instant, one ID null - null ID comes first</li>
+ *   <li>Covered by: {@link #compareTo_sameTime_oneNullId_ordersNullFirst}</li>
+ *   <li>P10: (Edge) Same instant, both IDs null - returns zero</li>
+ *   <li>Covered by: {@link #compareTo_sameTime_bothNullId_returnsZero}</li>
+ * </ul>
+ *
+ * <h3>12. equals(Object)</h3>
+ * <ul>
+ *   <li>P1: (Valid) Same object reference - returns true</li>
+ *   <li>Covered by: {@link #equals_sameObject_returnsTrue}</li>
+ *   <li>P2: (Invalid) Other is null - returns false</li>
+ *   <li>Covered by: {@link #equals_null_returnsFalse}</li>
+ *   <li>P3: (Invalid) Other is different class - returns false</li>
+ *   <li>Covered by: {@link #equals_differentClass_returnsFalse}</li>
+ *   <li>P4: (Valid) Same class, same non-null IDs - returns true</li>
+ *   <li>Covered by: {@link #equals_sameId_returnsTrue}</li>
+ *   <li>P5: (Valid) Same class, different non-null IDs - returns false</li>
+ *   <li>Covered by: {@link #equals_differentIds_returnsFalse}</li>
+ *   <li>P6: (Edge) Same class, both IDs null - returns true</li>
+ *   <li>Covered by: {@link #equals_bothNullId_returnsTrue}</li>
+ *   <li>P7: (Edge) Same class, this ID non-null, other ID null - returns false</li>
+ *   <li>Covered by: {@link #equals_oneNullId_returnsFalse}</li>
+ *   <li>P8: (Edge) Same class, this ID null, other ID non-null - returns false</li>
+ *   <li>Covered by: {@link #equals_oneNullId_returnsFalse_reverse}</li>
+ * </ul>
+ *
+ * <h3>13. hashCode()</h3>
+ * <ul>
+ *   <li>P1: (Valid) Non-null transactionId - returns hash of ID</li>
+ *   <li>Covered by: {@link #hashCode_withId_returnsIdHash}</li>
+ *   <li>P2: (Edge) Null transactionId - returns hash of null (0)</li>
+ *   <li>Covered by: {@link #hashCode_withNullId_returnsZeroHash}</li>
+ *   <li>P3: (Contract) Equal objects have equal hash codes</li>
+ *   <li>Covered by: {@link #hashCode_equalObjects_haveSameHashCode}</li>
+ * </ul>
+ *
+ * <h3>14. toString()</h3>
+ * <ul>
+ *   <li>P1: (Valid) Populated object - contains all field values</li>
+ *   <li>Covered by: {@link #toString_containsAllFields}</li>
+ *   <li>P2: (Edge) Default object - contains null/default values</li>
+ *   <li>Covered by: {@link #toString_defaultObject_containsNullValues}</li>
+ * </ul>
  */
-
 public class TransactionUnitTests {
 
-  private Transaction transaction;  
+  private Transaction transaction;
   private UUID userId;
 
   /**
    * Sets up a fresh Transaction object before each test.
+   * Initializes with typical valid values for most tests.
    */
   @BeforeEach
   public void setUp() {
     userId = UUID.randomUUID();
-    transaction = new Transaction(userId, 10, "Category", "Description");
+    transaction = new Transaction(userId, 10.0, "Category", "Description");
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // Constructors
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * Tests the default constructor to ensure all fields are initialized
-   * to their default (null or 0.0) values.
+   * Tests the default constructor initializes all fields to null or 0.0.
+   *
+   * <p>Partition: P1 (Valid) - Default constructor instantiation.
    */
   @Test
   public void constructor_defaultConstructor_initializesNullOrZeroFields() {
     Transaction t = new Transaction();
     assertNull(t.getTransactionId());
     assertNull(t.getUserId());
-    assertNull(t.getDescription()); // <-- FIX: Was assertEquals("", t.getDescription())
+    assertNull(t.getDescription());
     assertEquals(0.0, t.getAmount());
     assertNull(t.getCategory());
     assertNull(t.getTimestamp());
@@ -154,8 +230,9 @@ public void constructor_defaultConstructor_initializesNullOrZeroFields() {
   }
 
   /**
-   * Tests the parameterized constructor to ensure all provided
-   * values are set correctly.
+   * Tests the parameterized constructor sets all provided values correctly.
+   *
+   * <p>Partition: P1 (Valid) - All parameters provided with typical values.
    */
   @Test
   public void constructor_parameterizedConstructor_setsProvidedValues() {
@@ -167,69 +244,103 @@ public void constructor_parameterizedConstructor_setsProvidedValues() {
     assertEquals("Test Description", t.getDescription());
   }
 
-
-  // ---------------------------------------------------------------------------
-  // getTransactionId, setTransactionId
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // getTransactionId / setTransactionId
+  // ===========================================================================
 
   /**
-   * Tests the setter and getter for transactionId.
+   * Tests setting a valid non-null transaction ID.
+   *
+   * <p>Partition: P1 (Valid) - Non-null UUID.
    */
   @Test
   public void setTransactionId_validId_transactionIdIsSet() {
     UUID expectedTransactionId = UUID.randomUUID();
     transaction.setTransactionId(expectedTransactionId);
-    UUID transactionId = transaction.getTransactionId();
-    assertEquals(expectedTransactionId, transactionId);
+    assertEquals(expectedTransactionId, transaction.getTransactionId());
+  }
+
+  /**
+   * Tests setting a null transaction ID.
+   *
+   * <p>Partition: P2 (Invalid/Boundary) - Null UUID.
+   */
+  @Test
+  public void setTransactionId_nullId_transactionIdIsNull() {
+    transaction.setTransactionId(UUID.randomUUID());
+    assertNotNull(transaction.getTransactionId());
+    transaction.setTransactionId(null);
+    assertNull(transaction.getTransactionId());
   }
 
-  // ---------------------------------------------------------------------------
-  // getUserId, setUserId
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // getUserId / setUserId
+  // ===========================================================================
 
   /**
    * Tests that the parameterized constructor correctly sets the userId.
+   *
+   * <p>Partition: P1 (Valid) - Non-null UUID via constructor.
    */
   @Test
   public void getUserId_afterConstruction_returnsNonNullUserId() {
     assertNotNull(transaction.getUserId());
+    assertEquals(userId, transaction.getUserId());
   }
 
   /**
-   * Tests the setter and getter for userId.
+   * Tests setting a valid non-null user ID.
+   *
+   * <p>Partition: P1 (Valid) - Non-null UUID.
    */
   @Test
   public void setUserId_validId_userIdIsUpdated() {
     UUID expectedUserId = UUID.randomUUID();
     transaction.setUserId(expectedUserId);
-    UUID userId = transaction.getUserId();
-    assertEquals(expectedUserId, userId);
-    
+    assertEquals(expectedUserId, transaction.getUserId());
   }
 
-  // ---------------------------------------------------------------------------
-  // getDescription, setDescription
-  // ---------------------------------------------------------------------------
+  /**
+   * Tests setting a null user ID.
+   *
+   * <p>Partition: P2 (Invalid/Boundary) - Null UUID.
+   */
+  @Test
+  public void setUserId_nullId_userIdIsNull() {
+    assertNotNull(transaction.getUserId());
+    transaction.setUserId(null);
+    assertNull(transaction.getUserId());
+  }
+
+  // ===========================================================================
+  // getDescription / setDescription
+  // ===========================================================================
 
   /**
    * Tests that the parameterized constructor correctly sets the description.
+   *
+   * <p>Partition: P1 (Valid) - Normal non-empty string via constructor.
    */
   @Test
   public void getDescription_afterConstruction_returnsProvidedDescription() {
-    assertEquals(transaction.getDescription(), "Description");
+    assertEquals("Description", transaction.getDescription());
   }
 
   /**
-   * (Typical valid input) Tests setting a standard string.
-   */  
+   * Tests setting a typical valid string description.
+   *
+   * <p>Partition: P1 (Valid) - Normal non-empty string.
+   */
   @Test
   public void setDescription_validString_descriptionIsUpdated() {
     transaction.setDescription("New Description");
-    assertEquals(transaction.getDescription(), "New Description");
+    assertEquals("New Description", transaction.getDescription());
   }
 
   /**
-   * (Typical valid input) Tests setting an empty string.
+   * Tests setting an empty string description.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - Empty string "".
    */
   @Test
   public void setDescription_emptyString_descriptionIsEmpty() {
@@ -238,7 +349,20 @@ public void setDescription_emptyString_descriptionIsEmpty() {
   }
 
   /**
-   * (Atypical valid input) Tests the trim() branch of the setter.
+   * Tests that leading and trailing whitespace is trimmed.
+   *
+   * <p>Partition: P3 (Valid/Edge) - String with leading/trailing whitespace.
+   */
+  @Test
+  public void setDescription_withLeadingTrailingWhitespace_trimsWhitespace() {
+    transaction.setDescription("  Trimmed Description  ");
+    assertEquals("Trimmed Description", transaction.getDescription());
+  }
+
+  /**
+   * Tests that whitespace-only string results in empty string after trim.
+   *
+   * <p>Partition: P4 (Valid/Edge) - Whitespace-only string.
    */
   @Test
   public void setDescription_withWhitespaceOnly_setsEmptyString() {
@@ -247,7 +371,9 @@ public void setDescription_withWhitespaceOnly_setsEmptyString() {
   }
 
   /**
-   * (Invalid input) Tests the null-check branch of the setter.
+   * Tests that null input is converted to empty string.
+   *
+   * <p>Partition: P5 (Invalid) - Null input.
    */
   @Test
   public void setDescription_withNull_setsEmptyString() {
@@ -255,33 +381,187 @@ public void setDescription_withNull_setsEmptyString() {
     assertEquals("", transaction.getDescription());
   }
 
-  // ---------------------------------------------------------------------------
-  // getAmount, setAmount
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // getAmount / setAmount
+  // ===========================================================================
 
   /**
    * Tests that the parameterized constructor correctly sets the amount.
+   *
+   * <p>Partition: P1 (Valid) - Positive amount via constructor.
    */
   @Test
   public void getAmount_afterConstruction_returnsInitialValue() {
-    assertEquals(transaction.getAmount(), 10.0);
+    assertEquals(10.0, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting a typical positive amount (expense).
+   *
+   * <p>Partition: P1 (Valid) - Positive amount.
+   */
+  @Test
+  public void setAmount_positiveValue_amountIsUpdated() {
+    transaction.setAmount(99.99);
+    assertEquals(99.99, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting a negative amount (income/refund).
+   *
+   * <p>Partition: P2 (Valid) - Negative amount.
+   */
+  @Test
+  public void setAmount_negativeValue_amountIsUpdated() {
+    transaction.setAmount(-50.25);
+    assertEquals(-50.25, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting amount to zero (boundary).
+   *
+   * <p>Partition: P3 (Valid/Boundary) - Zero amount.
+   */
+  @Test
+  public void setAmount_zeroValue_amountIsZero() {
+    transaction.setAmount(0.0);
+    assertEquals(0.0, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting a very large positive amount.
+   *
+   * <p>Partition: P4 (Valid/Boundary) - Very large positive value.
+   */
+  @Test
+  public void setAmount_largePositiveValue_amountIsUpdated() {
+    transaction.setAmount(1_000_000_000.99);
+    assertEquals(1_000_000_000.99, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting a very large negative amount.
+   *
+   * <p>Partition: P5 (Valid/Boundary) - Very large negative value.
+   */
+  @Test
+  public void setAmount_largeNegativeValue_amountIsUpdated() {
+    transaction.setAmount(-1_000_000_000.99);
+    assertEquals(-1_000_000_000.99, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting amount to Double.MAX_VALUE.
+   *
+   * <p>Partition: P6 (Invalid/Boundary) - Maximum double value.
+   */
+  @Test
+  public void setAmount_maxDoubleValue_amountIsUpdated() {
+    transaction.setAmount(Double.MAX_VALUE);
+    assertEquals(Double.MAX_VALUE, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting amount to Double.MIN_VALUE (smallest positive).
+   *
+   * <p>Partition: P7 (Invalid/Boundary) - Minimum positive double value.
+   */
+  @Test
+  public void setAmount_minDoubleValue_amountIsUpdated() {
+    transaction.setAmount(Double.MIN_VALUE);
+    assertEquals(Double.MIN_VALUE, transaction.getAmount());
+  }
+
+  /**
+   * Tests setting amount to Double.NaN.
+   *
+   * <p>Partition: P8 (Invalid/Edge) - Not a Number value.
+   */
+  @Test
+  public void setAmount_nanValue_amountIsNan() {
+    transaction.setAmount(Double.NaN);
+    assertTrue(Double.isNaN(transaction.getAmount()));
+  }
+
+  /**
+   * Tests setting amount to positive infinity.
+   *
+   * <p>Partition: P9 (Invalid/Edge) - Positive infinity.
+   */
+  @Test
+  public void setAmount_positiveInfinity_amountIsInfinity() {
+    transaction.setAmount(Double.POSITIVE_INFINITY);
+    assertTrue(Double.isInfinite(transaction.getAmount()));
+    assertTrue(transaction.getAmount() > 0);
+  }
+
+  /**
+   * Tests setting amount to negative infinity.
+   *
+   * <p>Partition: P10 (Invalid/Edge) - Negative infinity.
+   */
+  @Test
+  public void setAmount_negativeInfinity_amountIsNegativeInfinity() {
+    transaction.setAmount(Double.NEGATIVE_INFINITY);
+    assertTrue(Double.isInfinite(transaction.getAmount()));
+    assertTrue(transaction.getAmount() < 0);
+  }
+
+  // ===========================================================================
+  // getCategory / setCategory
+  // ===========================================================================
+
+  /**
+   * Tests that the parameterized constructor correctly sets the category.
+   *
+   * <p>Partition: P1 (Valid) - Normal non-empty string via constructor.
+   */
+  @Test
+  public void getCategory_afterConstruction_returnsInitialCategory() {
+    assertEquals("Category", transaction.getCategory());
+  }
+
+  /**
+   * Tests setting a typical valid string category.
+   *
+   * <p>Partition: P1 (Valid) - Normal non-empty string.
+   */
+  @Test
+  public void setCategory_validString_categoryIsUpdated() {
+    transaction.setCategory("New Category");
+    assertEquals("New Category", transaction.getCategory());
   }
 
   /**
-   * Tests the setter and getter for amount.
+   * Tests setting an empty string category.
+   *
+   * <p>Partition: P2 (Valid/Boundary) - Empty string.
    */
   @Test
-  public void setAmount_validDouble_amountIsUpdated() {
-    transaction.setAmount(5);
-    assertEquals(transaction.getAmount(), 5.0);
+  public void setCategory_emptyString_categoryIsEmpty() {
+    transaction.setCategory("");
+    assertEquals("", transaction.getCategory());
   }
 
-  // ---------------------------------------------------------------------------
-  // getTimestamp, setTimestamp
-  // ---------------------------------------------------------------------------
+  /**
+   * Tests setting a null category.
+   *
+   * <p>Partition: P3 (Invalid) - Null input.
+   */
+  @Test
+  public void setCategory_nullValue_categoryIsNull() {
+    transaction.setCategory(null);
+    assertNull(transaction.getCategory());
+  }
+
+  // ===========================================================================
+  // getTimestamp / setTimestamp
+  // ===========================================================================
 
   /**
    * Tests the setter and getter for timestamp.
+   *
+   * <p>Partition: P1 (Valid) - Non-null timestamp.
    */
   @Test
   public void getTimestamp_afterSetting_returnsSameValue() {
@@ -292,8 +572,9 @@ public void getTimestamp_afterSetting_returnsSameValue() {
   }
 
   /**
-   * (Typical valid input) Tests that setting a timestamp also updates the date.
-   * Covers the `if (timestamp != null)` branch.
+   * Tests that setting a timestamp also updates the date field.
+   *
+   * <p>Partition: P1 (Valid) - Non-null timestamp updates date field.
    */
   @Test
   public void setTimestamp_validDateTime_timestampStoredCorrectly() {
@@ -304,8 +585,9 @@ public void setTimestamp_validDateTime_timestampStoredCorrectly() {
   }
 
   /**
-   * (Atypical valid input) Tests that setting the timestamp multiple times
-   * correctly updates the date to the latest timestamp.
+   * Tests that setting the timestamp multiple times updates date to latest.
+   *
+   * <p>Partition: P2 (Valid/Edge) - Setting timestamp twice.
    */
   @Test
   public void setTimestamp_settingTwice_updatesDateToLatest() {
@@ -317,33 +599,33 @@ public void setTimestamp_settingTwice_updatesDateToLatest() {
     assertEquals(second.toLocalDate(), transaction.getDate());
   }
 
-  /** * (Invalid input) 
-   * Tests that setting a null timestamp sets timestamp to null
-   * but leaves the date field unchanged from its previous value.
+  /**
+   * Tests that setting a null timestamp sets timestamp to null but leaves date unchanged.
+   *
+   * <p>Partition: P3 (Invalid) - Null timestamp input.
    */
   @Test
   public void setTimestamp_withNull_setsTimestampToNull_leavesDateUnchanged() {
     LocalDateTime currentTime = LocalDateTime.now();
     LocalDate expectedDate = currentTime.toLocalDate();
 
-    // Set an initial state
     transaction.setTimestamp(currentTime);
     assertEquals(expectedDate, transaction.getDate());
-    
-    // Now, call with null
+
     transaction.setTimestamp(null);
-    
-    // Assert timestamp is null but the date remains
+
     assertNull(transaction.getTimestamp());
     assertEquals(expectedDate, transaction.getDate());
   }
 
-  // ---------------------------------------------------------------------------
-  // getDate, setDate
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
+  // getDate / setDate
+  // ===========================================================================
 
   /**
    * Tests the setter and getter for date.
+   *
+   * <p>Partition: P1 (Valid) - Non-null date.
    */
   @Test
   public void getDate_afterSetting_returnsSameValue() {
@@ -353,8 +635,9 @@ public void getDate_afterSetting_returnsSameValue() {
   }
 
   /**
-   * (Typical valid input) Tests setting the date when a timestamp already exists.
-   * Covers the `date != null && this.timestamp != null` branch.
+   * Tests setting date when timestamp exists - timestamp remains unchanged.
+   *
+   * <p>Partition: P2 (Valid) - Date set when timestamp exists.
    */
   @Test
   public void setDate_withExistingTimestamp_keepsOriginalTimestamp() {
@@ -363,120 +646,98 @@ public void setDate_withExistingTimestamp_keepsOriginalTimestamp() {
     LocalDate date = LocalDate.of(2024, 6, 2);
     transaction.setDate(date);
 
-    // Timestamp should remain unchanged
     assertEquals(ts, transaction.getTimestamp());
-    // Date should still be updated
     assertEquals(date, transaction.getDate());
   }
 
   /**
-   * (Typical valid input) Tests setting the date when timestamp is null.
-   * Covers the `if (date != null && this.timestamp == null)` branch.
+   * Tests setting date when timestamp is null - auto-sets timestamp to start of day.
+   *
+   * <p>Partition: P1 (Valid) - Date set when timestamp is null.
    */
   @Test
   public void setDate_validDateTimestampNull_returnsDateStartOfDay() {
+    Transaction t = new Transaction();
     LocalDate date = LocalDate.of(2025, 10, 20);
-    transaction.setTimestamp(null); // Ensure timestamp is null
-    transaction.setDate(date);
-    assertEquals(date, transaction.getDate());
-    // Verifies that the timestamp was auto-set
-    assertEquals(date.atStartOfDay(), transaction.getTimestamp());
+    t.setDate(date);
+    assertEquals(date, t.getDate());
+    assertEquals(date.atStartOfDay(), t.getTimestamp());
   }
 
   /**
-   * (Invalid input) Tests setting a null date.
-   * Covers the `date == null` branch.
+   * Tests setting a null date - date becomes null, timestamp unchanged.
+   *
+   * <p>Partition: P3 (Invalid) - Null date input.
    */
   @Test
   public void setDate_nullDate_dateIsNull() {
-    // Set initial values
     transaction.setTimestamp(LocalDateTime.now());
     assertNotNull(transaction.getDate());
     assertNotNull(transaction.getTimestamp());
 
     transaction.setDate(null);
+
     assertNull(transaction.getDate());
-    // Note: setDate(null) does *not* clear the timestamp
     assertNotNull(transaction.getTimestamp());
   }
 
-  // ---------------------------------------------------------------------------
-  // getCategory, setCategory
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Tests that the parameterized constructor correctly sets the category.
-   */
-  @Test
-  public void getCategory_afterConstruction_returnsInitialCategory() {
-    assertEquals(transaction.getCategory(), "Category");
-  }
-
-  /**
-   * Tests the setter and getter for category.
-   */
-  @Test
-  public void setCategory_validString_categoryIsUpdated() {
-    transaction.setCategory("New Category");
-    assertEquals(transaction.getCategory(), "New Category");
-  }
-
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // effectiveInstant
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * (Typical valid input) Tests the first branch of `effectiveInstant`.
-   * Covers `timestamp != null`.
+   * Tests effectiveInstant when timestamp exists - returns timestamp.
+   *
+   * <p>Partition: P1 (Valid) - Timestamp exists.
    */
   @Test
   public void effectiveInstant_withTimestamp_returnsSameTimestamp() {
     LocalDateTime timestamp = LocalDateTime.of(2025, 10, 20, 10, 15);
     transaction.setTimestamp(timestamp);
-    LocalDateTime test = transaction.effectiveInstant();
-    assertEquals(timestamp, test);
+    assertEquals(timestamp, transaction.effectiveInstant());
   }
 
-
   /**
-   * (Atypical valid input) Tests the second branch of `effectiveInstant`.
-   * Covers `timestamp == null && date != null`.
+   * Tests effectiveInstant when only date exists - returns date at start of day.
+   *
+   * <p>Partition: P2 (Valid) - Timestamp null, date exists.
    */
   @Test
   public void effectiveInstant_withDateOnly_returnsDateStartOfDay() {
+    Transaction t = new Transaction();
     LocalDate date = LocalDate.of(2025, 10, 20);
-    
-    // Rerun setup for this test case
-    transaction = new Transaction(userId, 10, "Cat", "Desc");
-    transaction.setDate(date); // This will set timestamp to atStartOfDay()
-    transaction.setTimestamp(null); // Manually clear timestamp
-    transaction.setDate(date); // Set *only* date
 
-    LocalDateTime test = transaction.effectiveInstant();
-    assertEquals(date.atStartOfDay(), test);
-  }
+    // Set date without triggering auto-timestamp
+    t.setDate(date);
+    t.setTimestamp(null);
+    // Set date directly to the field
+    t.setDate(date);
 
+    assertEquals(date.atStartOfDay(), t.effectiveInstant());
+  }
 
   /**
-   * (Invalid input) Tests the final branch of `effectiveInstant`.
-   * Covers `timestamp == null && date == null`.
+   * Tests effectiveInstant when both timestamp and date are null - returns null.
+   *
+   * <p>Partition: P3 (Invalid) - Both timestamp and date null.
    */
   @Test
   public void effectiveInstant_bothTimestampAndDateNull_returnsNull() {
-    transaction.setTimestamp(null);
-    // Note: setTimestamp(null) also nulls date
-    assertNull(transaction.effectiveInstant());
+    Transaction t = new Transaction();
+    assertNull(t.effectiveInstant());
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // compareTo
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * Tests compareTo branch: `if (other == null)`.
+   * Tests compareTo when other is null - returns positive.
+   *
+   * <p>Partition: P1 (Invalid) - Other is null.
    */
   @Test
-  void compareTo_nullOther_returnsPositive() {
+  public void compareTo_nullOther_returnsPositive() {
     Transaction t1 = new Transaction();
     t1.setTimestamp(LocalDateTime.now());
     t1.setTransactionId(UUID.randomUUID());
@@ -484,11 +745,12 @@ void compareTo_nullOther_returnsPositive() {
   }
 
   /**
-   * Tests compareTo branch: `if (thisDateTime == null && otherDateTime == null)`.
-   * Fallback to ID comparison.
+   * Tests compareTo when both have null effective instants - falls back to ID comparison.
+   *
+   * <p>Partition: P6 (Edge) - Both instants null.
    */
   @Test
-  void compareTo_bothEffectiveInstantNull_compareById() {
+  public void compareTo_bothEffectiveInstantNull_compareById() {
     UUID id1 = UUID.randomUUID();
     UUID id2 = UUID.randomUUID();
     Transaction t1 = new Transaction();
@@ -499,148 +761,167 @@ void compareTo_bothEffectiveInstantNull_compareById() {
   }
 
   /**
-   * Tests compareTo branches: `if (thisDateTime == null)` and `if (otherDateTime == null)`.
+   * Tests compareTo when one has null effective instant.
+   *
+   * <p>Partition: P4/P5 (Edge) - One instant null, other non-null.
    */
   @Test
-  void compareTo_oneEffectiveInstantNull_returnsCorrectOrder() {
-    Transaction t1 = new Transaction(); // null instant
-    Transaction t2 = new Transaction(); // non-null instant
+  public void compareTo_oneEffectiveInstantNull_returnsCorrectOrder() {
+    Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
     t1.setTransactionId(UUID.randomUUID());
     t2.setTimestamp(LocalDateTime.now());
     t2.setTransactionId(UUID.randomUUID());
 
-    // t1 (null) should come before t2 (non-null)
     assertTrue(t1.compareTo(t2) < 0);
-    // t2 (non-null) should come after t1 (null)
     assertTrue(t2.compareTo(t1) > 0);
   }
 
   /**
-   * Tests compareTo branch: `if (cmp != 0)`.
+   * Tests compareTo when transactions have different timestamps - orders by time.
+   *
+   * <p>Partition: P2 (Valid) - Different non-null instants.
    */
   @Test
-  void compareTo_differentTimestamps_ordersByTime() {
+  public void compareTo_differentTimestamps_ordersByTime() {
     Transaction t1 = new Transaction();
-    Transaction t2 = new Transaction();  
-    t1.setTimestamp(LocalDateTime.of(2025, 1, 1, 0, 0, 0));  
-    t1.setTransactionId(UUID.randomUUID());  
-    t2.setTimestamp(LocalDateTime.of(2025, 2, 2, 0, 0, 0));  
+    Transaction t2 = new Transaction();
+    t1.setTimestamp(LocalDateTime.of(2025, 1, 1, 0, 0, 0));
+    t1.setTransactionId(UUID.randomUUID());
+    t2.setTimestamp(LocalDateTime.of(2025, 2, 2, 0, 0, 0));
     t2.setTransactionId(UUID.randomUUID());
+
     assertTrue(t1.compareTo(t2) < 0);
     assertTrue(t2.compareTo(t1) > 0);
   }
 
   /**
-   * Tests compareTo branch: `if (cmp == 0)` fallback to ID compare.
+   * Tests compareTo when transactions have same timestamp - falls back to ID comparison.
+   *
+   * <p>Partition: P3 (Valid) - Same non-null instants.
    */
   @Test
-  void compareTo_sameTimestamp_ordersById() {
+  public void compareTo_sameTimestamp_ordersById() {
     LocalDateTime now = LocalDateTime.now();
-    UUID id1 = UUID.randomUUID();
     Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
     t1.setTimestamp(now);
+    UUID id1 = UUID.randomUUID();
     t1.setTransactionId(id1);
-    UUID id2 = UUID.randomUUID();
-    Transaction t2 = new Transaction();
     t2.setTimestamp(now);
+    UUID id2 = UUID.randomUUID();
     t2.setTransactionId(id2);
+
     assertEquals(id1.compareTo(id2), t1.compareTo(t2));
   }
 
   /**
-   * Tests compareTo branch: `thisDateTime == null && otherDateTime == null`
-   * and `thisUuid == null && otherUuid == null`.
+   * Tests compareTo when both instants and IDs are null - returns zero.
+   *
+   * <p>Partition: P7 (Edge) - Both instants null, both IDs null.
    */
   @Test
-  void compareTo_bothNullIds_returnsZero() {
+  public void compareTo_bothNullIds_returnsZero() {
     Transaction t1 = new Transaction();
     Transaction t2 = new Transaction();
     assertEquals(0, t1.compareTo(t2));
   }
 
   /**
-   * Tests compareTo branch: `thisDateTime == null && ... && thisUuid == null`.
+   * Tests compareTo when instants are null and one ID is null - null ID comes first.
+   *
+   * <p>Partition: P8 (Edge) - Both instants null, one ID null.
    */
   @Test
-  void compareTo_noTime_oneNullId_ordersNullFirst() {
-    Transaction t1 = new Transaction(); // No time, no ID
-    Transaction t2 = new Transaction(); // No time, has ID
+  public void compareTo_noTime_oneNullId_ordersNullFirst() {
+    Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
     t2.setTransactionId(UUID.randomUUID());
-    
-    // t1 (null id) should come before t2 (non-null id)
+
     assertTrue(t1.compareTo(t2) < 0);
     assertTrue(t2.compareTo(t1) > 0);
   }
 
   /**
-   * Tests compareTo branch: `cmp == 0 && thisUuid == null`.
+   * Tests compareTo when instants are equal and one ID is null - null ID comes first.
+   *
+   * <p>Partition: P9 (Edge) - Same instant, one ID null.
    */
   @Test
-  void compareTo_sameTime_oneNullId_ordersNullFirst() {
+  public void compareTo_sameTime_oneNullId_ordersNullFirst() {
     LocalDateTime now = LocalDateTime.now();
-    Transaction t1 = new Transaction(); // Has time, no ID
+    Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
     t1.setTimestamp(now);
-    Transaction t2 = new Transaction(); // Has time, has ID
     t2.setTimestamp(now);
     t2.setTransactionId(UUID.randomUUID());
 
-    // t1 (null id) should come before t2 (non-null id)
     assertTrue(t1.compareTo(t2) < 0);
     assertTrue(t2.compareTo(t1) > 0);
   }
 
   /**
-   * Tests compareTo branch: `cmp == 0 && thisUuid == null && otherUuid == null`.
+   * Tests compareTo when instants are equal and both IDs are null - returns zero.
+   *
+   * <p>Partition: P10 (Edge) - Same instant, both IDs null.
    */
   @Test
-  void compareTo_sameTime_bothNullId_returnsZero() {
+  public void compareTo_sameTime_bothNullId_returnsZero() {
     LocalDateTime now = LocalDateTime.now();
-    Transaction t1 = new Transaction(); // Has time, no ID
+    Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
     t1.setTimestamp(now);
-    Transaction t2 = new Transaction(); // Has time, no ID
     t2.setTimestamp(now);
 
     assertEquals(0, t1.compareTo(t2));
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // equals
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * Tests equals branch: `if (this == other)`.
+   * Tests equals when comparing object to itself - returns true.
+   *
+   * <p>Partition: P1 (Valid) - Same object reference.
    */
   @Test
-  void equals_sameObject_returnsTrue() {
+  public void equals_sameObject_returnsTrue() {
     Transaction t1 = new Transaction();
     t1.setTransactionId(UUID.randomUUID());
     assertEquals(t1, t1);
   }
 
   /**
-   * Tests equals branch: `if (!(other instanceof Transaction))` with null.
+   * Tests equals when other is null - returns false.
+   *
+   * <p>Partition: P2 (Invalid) - Other is null.
    */
   @Test
-  void equals_null_returnsFalse() {
+  public void equals_null_returnsFalse() {
     Transaction t1 = new Transaction();
-    assertNotEquals(t1, null);
+    assertNotEquals(null, t1);
   }
 
   /**
-   * Tests equals branch: `if (!(other instanceof Transaction))` with different class.
+   * Tests equals when other is different class - returns false.
+   *
+   * <p>Partition: P3 (Invalid) - Other is different class.
    */
   @Test
-  void equals_differentClass_returnsFalse() {
+  public void equals_differentClass_returnsFalse() {
     Transaction t1 = new Transaction();
-    assertNotEquals(t1, 1);
+    assertNotEquals(t1, "not a transaction");
+    assertNotEquals(t1, 123);
   }
 
   /**
-   * Tests equals branch: `Objects.equals(transactionId, transaction.transactionId)`
-   * where both are non-null and equal.
+   * Tests equals when transactions have same non-null IDs - returns true.
+   *
+   * <p>Partition: P4 (Valid) - Same class, same non-null IDs.
    */
   @Test
-  void equals_sameId_returnsTrue() {
+  public void equals_sameId_returnsTrue() {
     UUID id = UUID.randomUUID();
     Transaction t1 = new Transaction();
     Transaction t2 = new Transaction();
@@ -650,89 +931,118 @@ void equals_sameId_returnsTrue() {
   }
 
   /**
-   * Tests equals branch: `Objects.equals(transactionId, transaction.transactionId)`
-   * where both are non-null and different.
+   * Tests equals when transactions have different non-null IDs - returns false.
+   *
+   * <p>Partition: P5 (Valid) - Same class, different non-null IDs.
    */
   @Test
-  void equals_differentIds_returnsFalse() {
-    UUID id1 = UUID.randomUUID();
-    UUID id2 = UUID.randomUUID();
+  public void equals_differentIds_returnsFalse() {
     Transaction t1 = new Transaction();
     Transaction t2 = new Transaction();
-    t1.setTransactionId(id1);
-    t2.setTransactionId(id2);
+    t1.setTransactionId(UUID.randomUUID());
+    t2.setTransactionId(UUID.randomUUID());
     assertNotEquals(t1, t2);
   }
 
   /**
-   * Tests equals branch: `Objects.equals(null, null)` which is true.
+   * Tests equals when both transactions have null IDs - returns true.
+   *
+   * <p>Partition: P6 (Edge) - Same class, both IDs null.
    */
   @Test
-  void equals_bothNullId_returnsTrue() {
+  public void equals_bothNullId_returnsTrue() {
     Transaction t1 = new Transaction();
     Transaction t2 = new Transaction();
     assertEquals(t1, t2);
   }
 
   /**
-   * Tests equals branch: `Objects.equals(id, null)` which is false.
+   * Tests equals when this has non-null ID and other has null ID - returns false.
+   *
+   * <p>Partition: P7 (Edge) - This ID non-null, other ID null.
    */
   @Test
-  void equals_oneNullId_returnsFalse() {
+  public void equals_oneNullId_returnsFalse() {
     Transaction t1 = new Transaction();
-    t1.setTransactionId(UUID.randomUUID());
     Transaction t2 = new Transaction();
+    t1.setTransactionId(UUID.randomUUID());
     assertNotEquals(t1, t2);
   }
 
   /**
-   * Tests equals branch: `Objects.equals(null, id)` which is false.
+   * Tests equals when this has null ID and other has non-null ID - returns false.
+   *
+   * <p>Partition: P8 (Edge) - This ID null, other ID non-null.
    */
   @Test
-  void equals_oneNullId_returnsFalse_reverse() {
+  public void equals_oneNullId_returnsFalse_reverse() {
     Transaction t1 = new Transaction();
     Transaction t2 = new Transaction();
     t2.setTransactionId(UUID.randomUUID());
     assertNotEquals(t1, t2);
   }
 
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
   // hashCode
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * Tests hashCode() with a non-null transactionId.
+   * Tests hashCode with non-null transactionId - returns hash of ID.
+   *
+   * <p>Partition: P1 (Valid) - Non-null transactionId.
    */
   @Test
-  void hashCode_withId_returnsIdHash() {
+  public void hashCode_withId_returnsIdHash() {
     UUID id = UUID.randomUUID();
     transaction.setTransactionId(id);
     assertEquals(Objects.hash(id), transaction.hashCode());
   }
 
   /**
-   * Tests hashCode() with a null transactionId.
+   * Tests hashCode with null transactionId - returns hash of null (0).
+   *
+   * <p>Partition: P2 (Edge) - Null transactionId.
    */
   @Test
-  void hashCode_withNullId_returnsZeroHash() {
+  public void hashCode_withNullId_returnsZeroHash() {
     Transaction t1 = new Transaction();
-    // The hash of a single null object is 0
     assertEquals(Objects.hash((UUID) null), t1.hashCode());
   }
-  
-  // ---------------------------------------------------------------------------
+
+  /**
+   * Tests that equal objects have equal hash codes (contract requirement).
+   *
+   * <p>Partition: P3 (Contract) - Equal objects have equal hash codes.
+   */
+  @Test
+  public void hashCode_equalObjects_haveSameHashCode() {
+    UUID id = UUID.randomUUID();
+    Transaction t1 = new Transaction();
+    Transaction t2 = new Transaction();
+    t1.setTransactionId(id);
+    t2.setTransactionId(id);
+
+    assertEquals(t1, t2);
+    assertEquals(t1.hashCode(), t2.hashCode());
+  }
+
+  // ===========================================================================
   // toString
-  // ---------------------------------------------------------------------------
+  // ===========================================================================
 
   /**
-   * Tests that the toString() method includes key fields.
+   * Tests that toString includes all key fields for a populated object.
+   *
+   * <p>Partition: P1 (Valid) - Populated object.
    */
   @Test
-  void toString_containsAllFields() {
+  public void toString_containsAllFields() {
     UUID id = UUID.randomUUID();
     transaction.setTransactionId(id);
     transaction.setAmount(123.45);
     transaction.setDescription("Test");
+    LocalDateTime timestamp = LocalDateTime.of(2025, 6, 15, 10, 30);
+    transaction.setTimestamp(timestamp);
 
     String str = transaction.toString();
 
@@ -740,5 +1050,25 @@ void toString_containsAllFields() {
     assertTrue(str.contains("amount=123.45"));
     assertTrue(str.contains("description='Test'"));
     assertTrue(str.contains("category='Category'"));
+    assertTrue(str.contains("timestamp=" + timestamp));
+    assertTrue(str.contains("date=" + timestamp.toLocalDate()));
+  }
+
+  /**
+   * Tests that toString handles null/default values gracefully.
+   *
+   * <p>Partition: P2 (Edge) - Default object with null values.
+   */
+  @Test
+  public void toString_defaultObject_containsNullValues() {
+    Transaction t = new Transaction();
+    String str = t.toString();
+
+    assertTrue(str.contains("id=null"));
+    assertTrue(str.contains("description='null'"));
+    assertTrue(str.contains("amount=0.0"));
+    assertTrue(str.contains("timestamp=null"));
+    assertTrue(str.contains("date=null"));
+    assertTrue(str.contains("category='null'"));
   }
 }
\ No newline at end of file
diff --git a/src/test/java/dev/ase/teamproject/UserUnitTests.java b/src/test/java/dev/ase/teamproject/UserUnitTests.java
index 713ffd1..df50fae 100644
--- a/src/test/java/dev/ase/teamproject/UserUnitTests.java
+++ b/src/test/java/dev/ase/teamproject/UserUnitTests.java
@@ -10,12 +10,47 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * This class contains the unit tests for the User class.
+ * Unit tests for the User class.
  * <p>
- * Since this is a simple data class (POJO) with only trivial getters,
- * setters, and constructors, the tests focus on verifying that all
- * field assignments and retrievals work as expected.
+ * This test suite validates all getter and setter methods in the User POJO,
+ * covering both valid and invalid equivalence partitions with boundary testing
+ * where applicable. Since User is a simple data class, tests focus on field
+ * assignment, retrieval, and edge case handling.
  * </p>
+ *
+ * <h2>Equivalence Partitions Defined:</h2>
+ * <ul>
+ *   <li><b>userId</b>:
+ *     <ul>
+ *       <li>Valid: Non-null UUID</li>
+ *       <li>Invalid: null</li>
+ *     </ul>
+ *   </li>
+ *   <li><b>username</b>:
+ *     <ul>
+ *       <li>Valid: Non-empty string, typical alphanumeric string</li>
+ *       <li>Boundary: Empty string, single character, very long string</li>
+ *       <li>Edge: String with special characters, whitespace</li>
+ *       <li>Invalid: null</li>
+ *     </ul>
+ *   </li>
+ *   <li><b>email</b>:
+ *     <ul>
+ *       <li>Valid: Standard email format string</li>
+ *       <li>Boundary: Empty string, single character</li>
+ *       <li>Edge: String without @ symbol (malformed), very long string</li>
+ *       <li>Invalid: null</li>
+ *     </ul>
+ *   </li>
+ *   <li><b>budget</b>:
+ *     <ul>
+ *       <li>Valid: Positive values (including decimals)</li>
+ *       <li>Boundary: Zero, very small positive (0.01), very large positive</li>
+ *       <li>Edge: Negative values, Double.MAX_VALUE, Double.MIN_VALUE</li>
+ *       <li>Special: Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN</li>
+ *     </ul>
+ *   </li>
+ * </ul>
  */
 public class UserUnitTests {
 
@@ -32,6 +67,10 @@ public void setUp() {
   // Constructors
   // ---------------------------------------------------------------------------
 
+  /**
+   * Tests default constructor initialization.
+   * <p>Partition: Default initialization (null/zero values)</p>
+   */
   @Test
   public void constructor_defaultConstructor_initializesFieldsToNullOrZero() {
     assertNull(user.getUserId());
@@ -40,25 +79,61 @@ public void constructor_defaultConstructor_initializesFieldsToNullOrZero() {
     assertEquals(0.0, user.getBudget());
   }
 
+  /**
+   * Tests parameterized constructor with valid typical values.
+   * <p>Partition: Valid username, valid email, positive budget</p>
+   */
   @Test
   public void constructor_parameterizedConstructor_setsProvidedValues() {
     User u = new User("Alice", "alice@example.com", 100.0);
     assertEquals("Alice", u.getUsername());
     assertEquals("alice@example.com", u.getEmail());
     assertEquals(100.0, u.getBudget());
-    assertNull(u.getUserId()); // DB Assigns Later
+    assertNull(u.getUserId()); // DB assigns later
+  }
+
+  /**
+   * Tests parameterized constructor with boundary values.
+   * <p>Partition: Empty strings, zero budget</p>
+   */
+  @Test
+  public void constructor_parameterizedWithBoundaryValues_setsValues() {
+    User u = new User("", "", 0.0);
+    assertEquals("", u.getUsername());
+    assertEquals("", u.getEmail());
+    assertEquals(0.0, u.getBudget());
+  }
+
+  /**
+   * Tests parameterized constructor with null values.
+   * <p>Partition: null username, null email, negative budget</p>
+   */
+  @Test
+  public void constructor_parameterizedWithNullValues_acceptsNulls() {
+    User u = new User(null, null, -50.0);
+    assertNull(u.getUsername());
+    assertNull(u.getEmail());
+    assertEquals(-50.0, u.getBudget());
   }
 
   // ---------------------------------------------------------------------------
   // setUserId / getUserId
   // ---------------------------------------------------------------------------
 
+  /**
+   * Tests setUserId with a valid UUID.
+   * <p>Partition: Valid non-null UUID</p>
+   */
   @Test
   public void setUserId_withValidUuid_storesUuid() {
     user.setUserId(testId);
     assertEquals(testId, user.getUserId());
   }
 
+  /**
+   * Tests getUserId returns the same UUID that was set.
+   * <p>Partition: Valid non-null UUID</p>
+   */
   @Test
   public void getUserId_afterSettingUuid_returnsSameUuid() {
     user.setUserId(testId);
@@ -66,6 +141,10 @@ public void getUserId_afterSettingUuid_returnsSameUuid() {
     assertEquals(testId, result);
   }
 
+  /**
+   * Tests that different users can have distinct UUIDs.
+   * <p>Partition: Multiple valid UUIDs remain unique</p>
+   */
   @Test
   public void setUserId_twoDistinctIds_assignedIdsRemainUnique() {
     User u1 = new User();
@@ -81,33 +160,154 @@ public void setUserId_twoDistinctIds_assignedIdsRemainUnique() {
     assertEquals(id2, u2.getUserId());
   }
 
+  /**
+   * Tests setUserId with null value.
+   * <p>Partition: Invalid null UUID</p>
+   */
+  @Test
+  public void setUserId_withNull_storesNull() {
+    user.setUserId(testId);
+    user.setUserId(null);
+    assertNull(user.getUserId());
+  }
+
+  /**
+   * Tests overwriting an existing UUID.
+   * <p>Partition: Valid UUID replacement</p>
+   */
+  @Test
+  public void setUserId_overwritingExistingId_replacesWithNewId() {
+    UUID firstId = UUID.randomUUID();
+    UUID secondId = UUID.randomUUID();
+
+    user.setUserId(firstId);
+    assertEquals(firstId, user.getUserId());
+
+    user.setUserId(secondId);
+    assertEquals(secondId, user.getUserId());
+    assertNotEquals(firstId, user.getUserId());
+  }
+
   // ---------------------------------------------------------------------------
   // setUsername / getUsername
   // ---------------------------------------------------------------------------
 
+  /**
+   * Tests setUsername with a typical valid string.
+   * <p>Partition: Valid non-empty alphanumeric string</p>
+   */
   @Test
   public void setUsername_withValidString_storesUsername() {
     user.setUsername("Bob");
     assertEquals("Bob", user.getUsername());
   }
 
+  /**
+   * Tests getUsername returns the same value that was set.
+   * <p>Partition: Valid non-empty string</p>
+   */
   @Test
-  void getUsername_afterSettingUsername_returnsSameValue() {
+  public void getUsername_afterSettingUsername_returnsSameValue() {
     user.setUsername("Bob");
     String result = user.getUsername();
     assertEquals("Bob", result);
   }
 
+  /**
+   * Tests setUsername with empty string boundary.
+   * <p>Partition: Boundary - empty string</p>
+   */
+  @Test
+  public void setUsername_withEmptyString_storesEmptyString() {
+    user.setUsername("");
+    assertEquals("", user.getUsername());
+  }
+
+  /**
+   * Tests setUsername with single character boundary.
+   * <p>Partition: Boundary - single character string</p>
+   */
+  @Test
+  public void setUsername_withSingleCharacter_storesSingleCharacter() {
+    user.setUsername("A");
+    assertEquals("A", user.getUsername());
+  }
+
+  /**
+   * Tests setUsername with a very long string.
+   * <p>Partition: Boundary - very long string (1000 characters)</p>
+   */
+  @Test
+  public void setUsername_withVeryLongString_storesLongString() {
+    String longName = "A".repeat(1000);
+    user.setUsername(longName);
+    assertEquals(longName, user.getUsername());
+    assertEquals(1000, user.getUsername().length());
+  }
+
+  /**
+   * Tests setUsername with special characters.
+   * <p>Partition: Edge - string with special characters</p>
+   */
+  @Test
+  public void setUsername_withSpecialCharacters_storesSpecialCharacters() {
+    String specialName = "User@123!#$%";
+    user.setUsername(specialName);
+    assertEquals(specialName, user.getUsername());
+  }
+
+  /**
+   * Tests setUsername with whitespace.
+   * <p>Partition: Edge - string with spaces</p>
+   */
+  @Test
+  public void setUsername_withWhitespace_storesWhitespace() {
+    user.setUsername("John Doe");
+    assertEquals("John Doe", user.getUsername());
+  }
+
+  /**
+   * Tests setUsername with null value.
+   * <p>Partition: Invalid - null string</p>
+   */
+  @Test
+  public void setUsername_withNull_storesNull() {
+    user.setUsername("Bob");
+    user.setUsername(null);
+    assertNull(user.getUsername());
+  }
+
+  /**
+   * Tests overwriting an existing username.
+   * <p>Partition: Valid username replacement</p>
+   */
+  @Test
+  public void setUsername_overwritingExistingUsername_replacesWithNewValue() {
+    user.setUsername("Alice");
+    assertEquals("Alice", user.getUsername());
+
+    user.setUsername("Bob");
+    assertEquals("Bob", user.getUsername());
+  }
+
   // ---------------------------------------------------------------------------
   // setEmail / getEmail
   // ---------------------------------------------------------------------------
 
+  /**
+   * Tests setEmail with a typical valid email string.
+   * <p>Partition: Valid standard email format</p>
+   */
   @Test
   public void setEmail_withValidString_storesEmail() {
     user.setEmail("bob@example.com");
     assertEquals("bob@example.com", user.getEmail());
   }
 
+  /**
+   * Tests getEmail returns the same value that was set.
+   * <p>Partition: Valid email string</p>
+   */
   @Test
   public void getEmail_afterSettingEmail_returnsSameValue() {
     user.setEmail("bob@example.com");
@@ -115,20 +315,217 @@ public void getEmail_afterSettingEmail_returnsSameValue() {
     assertEquals("bob@example.com", result);
   }
 
+  /**
+   * Tests setEmail with empty string boundary.
+   * <p>Partition: Boundary - empty string</p>
+   */
+  @Test
+  public void setEmail_withEmptyString_storesEmptyString() {
+    user.setEmail("");
+    assertEquals("", user.getEmail());
+  }
+
+  /**
+   * Tests setEmail with single character boundary.
+   * <p>Partition: Boundary - single character</p>
+   */
+  @Test
+  public void setEmail_withSingleCharacter_storesSingleCharacter() {
+    user.setEmail("a");
+    assertEquals("a", user.getEmail());
+  }
+
+  /**
+   * Tests setEmail with malformed email (no @ symbol).
+   * <p>Partition: Edge - malformed email string</p>
+   */
+  @Test
+  public void setEmail_withMalformedEmail_storesMalformedEmail() {
+    user.setEmail("notanemail");
+    assertEquals("notanemail", user.getEmail());
+  }
+
+  /**
+   * Tests setEmail with very long email string.
+   * <p>Partition: Boundary - very long string (500 characters)</p>
+   */
+  @Test
+  public void setEmail_withVeryLongString_storesLongEmail() {
+    String longEmail = "a".repeat(490) + "@test.com";
+    user.setEmail(longEmail);
+    assertEquals(longEmail, user.getEmail());
+  }
+
+  /**
+   * Tests setEmail with special characters in email.
+   * <p>Partition: Edge - email with special characters</p>
+   */
+  @Test
+  public void setEmail_withSpecialCharacters_storesSpecialEmail() {
+    String specialEmail = "user+tag@sub-domain.example.com";
+    user.setEmail(specialEmail);
+    assertEquals(specialEmail, user.getEmail());
+  }
+
+  /**
+   * Tests setEmail with null value.
+   * <p>Partition: Invalid - null string</p>
+   */
+  @Test
+  public void setEmail_withNull_storesNull() {
+    user.setEmail("bob@example.com");
+    user.setEmail(null);
+    assertNull(user.getEmail());
+  }
+
+  /**
+   * Tests overwriting an existing email.
+   * <p>Partition: Valid email replacement</p>
+   */
+  @Test
+  public void setEmail_overwritingExistingEmail_replacesWithNewValue() {
+    user.setEmail("first@example.com");
+    assertEquals("first@example.com", user.getEmail());
+
+    user.setEmail("second@example.com");
+    assertEquals("second@example.com", user.getEmail());
+  }
+
   // ---------------------------------------------------------------------------
   // setBudget / getBudget
   // ---------------------------------------------------------------------------
 
+  /**
+   * Tests setBudget with a typical positive value.
+   * <p>Partition: Valid positive decimal value</p>
+   */
   @Test
   public void setBudget_withPositiveValue_storesBudget() {
     user.setBudget(250.75);
     assertEquals(250.75, user.getBudget());
   }
 
+  /**
+   * Tests getBudget returns the same value that was set.
+   * <p>Partition: Valid positive value</p>
+   */
   @Test
   public void getBudget_afterSettingBudget_returnsSameValue() {
     user.setBudget(250.75);
     double result = user.getBudget();
     assertEquals(250.75, result);
   }
-}
+
+  /**
+   * Tests setBudget with zero boundary value.
+   * <p>Partition: Boundary - zero</p>
+   */
+  @Test
+  public void setBudget_withZero_storesZero() {
+    user.setBudget(0.0);
+    assertEquals(0.0, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with very small positive boundary value.
+   * <p>Partition: Boundary - smallest positive practical value (0.01)</p>
+   */
+  @Test
+  public void setBudget_withVerySmallPositive_storesSmallValue() {
+    user.setBudget(0.01);
+    assertEquals(0.01, user.getBudget(), 0.001);
+  }
+
+  /**
+   * Tests setBudget with very large positive value.
+   * <p>Partition: Boundary - large positive value</p>
+   */
+  @Test
+  public void setBudget_withVeryLargePositive_storesLargeValue() {
+    user.setBudget(999999999.99);
+    assertEquals(999999999.99, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with negative value.
+   * <p>Partition: Edge - negative value</p>
+   */
+  @Test
+  public void setBudget_withNegativeValue_storesNegativeValue() {
+    user.setBudget(-100.50);
+    assertEquals(-100.50, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with Double.MAX_VALUE boundary.
+   * <p>Partition: Boundary - Double.MAX_VALUE</p>
+   */
+  @Test
+  public void setBudget_withMaxDouble_storesMaxValue() {
+    user.setBudget(Double.MAX_VALUE);
+    assertEquals(Double.MAX_VALUE, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with Double.MIN_VALUE boundary.
+   * <p>Partition: Boundary - Double.MIN_VALUE (smallest positive non-zero)</p>
+   */
+  @Test
+  public void setBudget_withMinDouble_storesMinValue() {
+    user.setBudget(Double.MIN_VALUE);
+    assertEquals(Double.MIN_VALUE, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with positive infinity.
+   * <p>Partition: Special - Double.POSITIVE_INFINITY</p>
+   */
+  @Test
+  public void setBudget_withPositiveInfinity_storesInfinity() {
+    user.setBudget(Double.POSITIVE_INFINITY);
+    assertEquals(Double.POSITIVE_INFINITY, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with negative infinity.
+   * <p>Partition: Special - Double.NEGATIVE_INFINITY</p>
+   */
+  @Test
+  public void setBudget_withNegativeInfinity_storesNegativeInfinity() {
+    user.setBudget(Double.NEGATIVE_INFINITY);
+    assertEquals(Double.NEGATIVE_INFINITY, user.getBudget());
+  }
+
+  /**
+   * Tests setBudget with NaN (Not a Number).
+   * <p>Partition: Special - Double.NaN</p>
+   */
+  @Test
+  public void setBudget_withNaN_storesNaN() {
+    user.setBudget(Double.NaN);
+    assertEquals(Double.NaN, user.getBudget());
+  }
+
+  /**
+   * Tests overwriting an existing budget value.
+   * <p>Partition: Valid budget replacement</p>
+   */
+  @Test
+  public void setBudget_overwritingExistingBudget_replacesWithNewValue() {
+    user.setBudget(100.0);
+    assertEquals(100.0, user.getBudget());
+
+    user.setBudget(200.0);
+    assertEquals(200.0, user.getBudget());
+  }
+
+  /**
+   * Tests budget precision with multiple decimal places.
+   * <p>Partition: Valid - decimal precision testing</p>
+   */
+  @Test
+  public void setBudget_withMultipleDecimalPlaces_maintainsPrecision() {
+    user.setBudget(123.456789);
+    assertEquals(123.456789, user.getBudget(), 0.000001);
+  }
+}
\ No newline at end of file

From e2764a1ef462583b0d04e307eb965f2bbc485e20 Mon Sep 17 00:00:00 2001
From: Jerry Gu <jag2430@columbia.edu>
Date: Thu, 4 Dec 2025 19:32:58 -0500
Subject: [PATCH 2/4] Fixing order of API tests

---
 postman/postman_collection.json | 362 ++++++++++++++++----------------
 1 file changed, 181 insertions(+), 181 deletions(-)

diff --git a/postman/postman_collection.json b/postman/postman_collection.json
index 4b99dea..1c42eb5 100644
--- a/postman/postman_collection.json
+++ b/postman/postman_collection.json
@@ -728,6 +728,187 @@
         }
       ]
     },
+    {
+      "name": "6. User Management - POST /users/form (HTML)",
+      "item": [
+        {
+          "name": "POST /users/form - Valid Form Data (P1: Valid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P1 - Valid form submission",
+                  "// Expected: 201 Created with HTML response",
+                  "",
+                  "pm.test('P1: Status code is 201', function () {",
+                  "    pm.response.to.have.status(201);",
+                  "});",
+                  "",
+                  "pm.test('P1: Response is HTML', function () {",
+                  "    pm.expect(pm.response.headers.get('Content-Type')).to.include('text/html');",
+                  "});",
+                  "",
+                  "pm.test('P1: Success message present', function () {",
+                  "    pm.expect(pm.response.text()).to.include('User Created Successfully');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            },
+            {
+              "listen": "prerequest",
+              "script": {
+                "exec": [
+                  "const timestamp = Date.now();",
+                  "pm.variables.set('formUsername', 'FormUser_' + timestamp);",
+                  "pm.variables.set('formEmail', 'formuser_' + timestamp + '@test.com');"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "username",
+                  "value": "{{formUsername}}",
+                  "type": "text"
+                },
+                {
+                  "key": "email",
+                  "value": "{{formEmail}}",
+                  "type": "text"
+                },
+                {
+                  "key": "budget",
+                  "value": "750",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/form - Duplicate Username (P2: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P2 - Invalid: duplicate username",
+                  "pm.test('P2: Status code is 400', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {
+                  "key": "username",
+                  "value": "{{uniqueUsername}}",
+                  "type": "text"
+                },
+                {
+                  "key": "email",
+                  "value": "unique_form@test.com",
+                  "type": "text"
+                },
+                {
+                  "key": "budget",
+                  "value": "500",
+                  "type": "text"
+                }
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/form",
+              "host": [
+                "{{baseUrl}}"
+              ],
+              "path": [
+                "users",
+                "form"
+              ]
+            }
+          }
+        },
+        {
+          "name": "POST /users/form - Duplicate Email (P3: Invalid)",
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "// Equivalence Partition: P3 - Invalid: duplicate email",
+                  "pm.test('P3: Status code is 400 for duplicate email', function () {",
+                  "    pm.response.to.have.status(400);",
+                  "});",
+                  "",
+                  "pm.test('P3: Error message mentions email', function () {",
+                  "    pm.expect(pm.response.text()).to.include('User Creation Failed');",
+                  "});"
+                ],
+                "type": "text/javascript"
+              }
+            }
+          ],
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/x-www-form-urlencoded"
+              }
+            ],
+            "body": {
+              "mode": "urlencoded",
+              "urlencoded": [
+                {"key": "username", "value": "unique_form_username", "type": "text"},
+                {"key": "email", "value": "{{uniqueEmail}}", "type": "text"},
+                {"key": "budget", "value": "500", "type": "text"}
+              ]
+            },
+            "url": {
+              "raw": "{{baseUrl}}/users/form",
+              "host": ["{{baseUrl}}"],
+              "path": ["users", "form"]
+            }
+          }
+        }
+      ]
+    },
     {
       "name": "4. User Management - GET /users/{userId}",
       "item": [
@@ -1088,187 +1269,6 @@
         }
       ]
     },
-    {
-      "name": "6. User Management - POST /users/form (HTML)",
-      "item": [
-        {
-          "name": "POST /users/form - Valid Form Data (P1: Valid)",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "// Equivalence Partition: P1 - Valid form submission",
-                  "// Expected: 201 Created with HTML response",
-                  "",
-                  "pm.test('P1: Status code is 201', function () {",
-                  "    pm.response.to.have.status(201);",
-                  "});",
-                  "",
-                  "pm.test('P1: Response is HTML', function () {",
-                  "    pm.expect(pm.response.headers.get('Content-Type')).to.include('text/html');",
-                  "});",
-                  "",
-                  "pm.test('P1: Success message present', function () {",
-                  "    pm.expect(pm.response.text()).to.include('User Created Successfully');",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            },
-            {
-              "listen": "prerequest",
-              "script": {
-                "exec": [
-                  "const timestamp = Date.now();",
-                  "pm.variables.set('formUsername', 'FormUser_' + timestamp);",
-                  "pm.variables.set('formEmail', 'formuser_' + timestamp + '@test.com');"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/x-www-form-urlencoded"
-              }
-            ],
-            "body": {
-              "mode": "urlencoded",
-              "urlencoded": [
-                {
-                  "key": "username",
-                  "value": "{{formUsername}}",
-                  "type": "text"
-                },
-                {
-                  "key": "email",
-                  "value": "{{formEmail}}",
-                  "type": "text"
-                },
-                {
-                  "key": "budget",
-                  "value": "750",
-                  "type": "text"
-                }
-              ]
-            },
-            "url": {
-              "raw": "{{baseUrl}}/users/form",
-              "host": [
-                "{{baseUrl}}"
-              ],
-              "path": [
-                "users",
-                "form"
-              ]
-            }
-          }
-        },
-        {
-          "name": "POST /users/form - Duplicate Username (P2: Invalid)",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "// Equivalence Partition: P2 - Invalid: duplicate username",
-                  "pm.test('P2: Status code is 400', function () {",
-                  "    pm.response.to.have.status(400);",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/x-www-form-urlencoded"
-              }
-            ],
-            "body": {
-              "mode": "urlencoded",
-              "urlencoded": [
-                {
-                  "key": "username",
-                  "value": "{{uniqueUsername}}",
-                  "type": "text"
-                },
-                {
-                  "key": "email",
-                  "value": "unique_form@test.com",
-                  "type": "text"
-                },
-                {
-                  "key": "budget",
-                  "value": "500",
-                  "type": "text"
-                }
-              ]
-            },
-            "url": {
-              "raw": "{{baseUrl}}/users/form",
-              "host": [
-                "{{baseUrl}}"
-              ],
-              "path": [
-                "users",
-                "form"
-              ]
-            }
-          }
-        },
-        {
-          "name": "POST /users/form - Duplicate Email (P3: Invalid)",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "// Equivalence Partition: P3 - Invalid: duplicate email",
-                  "pm.test('P3: Status code is 400 for duplicate email', function () {",
-                  "    pm.response.to.have.status(400);",
-                  "});",
-                  "",
-                  "pm.test('P3: Error message mentions email', function () {",
-                  "    pm.expect(pm.response.text()).to.include('User Creation Failed');",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/x-www-form-urlencoded"
-              }
-            ],
-            "body": {
-              "mode": "urlencoded",
-              "urlencoded": [
-                {"key": "username", "value": "unique_form_username", "type": "text"},
-                {"key": "email", "value": "{{uniqueEmail}}", "type": "text"},
-                {"key": "budget", "value": "500", "type": "text"}
-              ]
-            },
-            "url": {
-              "raw": "{{baseUrl}}/users/form",
-              "host": ["{{baseUrl}}"],
-              "path": ["users", "form"]
-            }
-          }
-        }
-      ]
-    },
     {
       "name": "7. User Management - POST /users/{userId}/update-form (HTML)",
       "item": [

From 00e2693ac8e0283f603a2ff54e34ad7cc68581ec Mon Sep 17 00:00:00 2001
From: Jerry Gu <jag2430@columbia.edu>
Date: Thu, 4 Dec 2025 19:47:02 -0500
Subject: [PATCH 3/4] Added note about equivalence partitions to README

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index f7155c5..390ded2 100644
--- a/README.md
+++ b/README.md
@@ -102,6 +102,8 @@ To view client activity:
 - `IllegalArgumentException` → `400 Bad Request` with JSON body: `{"error":"<message>"}`
 
 ## Testing
+**Note:** The set of equivalence partitions we have defined for Unit and API testing are documented in the header
+comments of our test files.
 
 ### Unit Testing
 - Framework: JUnit 5

From 4576c7c0ae613f3d9dcc759d8342b5bb25a267d7 Mon Sep 17 00:00:00 2001
From: Jerry Gu <jag2430@columbia.edu>
Date: Thu, 4 Dec 2025 20:50:45 -0500
Subject: [PATCH 4/4] Generate pmd.html report

---
 .github/workflows/maven.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index fc5e418..d2a8e29 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -320,7 +320,7 @@ jobs:
         run: mvn pmd:check --batch-mode
 
       - name: Generate PMD Report
-        run: mvn site -DgenerateReports=false --batch-mode
+        run: mvn pmd:pmd --batch-mode
 
       - name: Upload Static Analysis Reports
         uses: actions/upload-artifact@v4