Merge pull request 'ScannerImplementation' (#5) from ScannerImplementation into main

Reviewed-on: #5

Reviewed this together in a call

.idea/gradle.xml

@@ -5,6 +5,8 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="C:\Gradle\gradle-9.0.0" />
+        <option name="gradleJvm" value="17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="homebrew-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/main/java/hhn/temp/project/AssignmentManager.java

@@ -6,23 +6,35 @@ import java.util.List;
 import java.util.Map;
 
 public class AssignmentManager {
-    Map<Integer, Worker> workerMap;
-    Map<Integer, Task> taskMap;
-    int workerIdCounter;
-    int taskIdCounter;
+    private Map<Integer, Worker> workerMap;
+    private Map<Integer, Task> taskMap;
+    private int workerIdCounter;
+    private int taskIdCounter;
+    private UserCommands userInterface;
 
     public AssignmentManager() {
         workerMap = new HashMap<>();
         taskMap = new HashMap<>();
-        int workerIdCounter = 1000;
-        int taskIdCounter = 0;
+        workerIdCounter = 1000;
+        taskIdCounter = 0;
+        userInterface = new UserCommands(this);
     }
+    public Map<Integer, Task> getTaskMap() {
+        return taskMap;
+    }
+    public Map<Integer, Worker> getWorkerMap() {return workerMap;}
 
     public int createWorker(String name) {
         Worker worker = new Worker(name, ++workerIdCounter);
         workerMap.put(workerIdCounter, worker);
         return workerIdCounter;
     }
+    public void removeWorker(int workerId) {
+        if (!workerMap.containsKey(workerId)) {
+            throw new IllegalArgumentException("WorkerId must exist in order to remove it");
+        }
+        workerMap.remove(workerId);
+    }
     public int addTask(int workerId, String name, String description) {
         if (!workerMap.containsKey(workerId) || name == null || description == null) {
             throw new IllegalArgumentException("WorkerId must exist and name or description can't be null");
@@ -37,8 +49,11 @@ public class AssignmentManager {
         }
         return taskMap.get(taskId);
     }
-    public Map<Integer, Task> getTaskMap() {
-        return taskMap;
+    public Worker getWorker(int workerId) {
+        if (!workerMap.containsKey(workerId)) {
+            throw new IllegalArgumentException("Worker Id does not exist");
+        }
+        return workerMap.get(workerId);
     }
     public void editTask(int workerId, int taskId, String name, String description) {
         if (!workerMap.containsKey(workerId) || !taskMap.containsKey(taskId)) {
@@ -68,5 +83,16 @@ public class AssignmentManager {
         Task task = taskMap.get(taskId);
         task.setTaskState(TaskState.IN_PROGRESS);
     }
+    public UserCommands getUserCommands() {
+        return userInterface;
+    }
+
+    public void startCLI() {
+        userInterface.start();
+    }
+
+    public void stopCLI() {
+        userInterface.stop();
+    }
 
 }

src/main/java/hhn/temp/project/Main.java

@@ -0,0 +1,10 @@
+package hhn.temp.project;
+
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        AssignmentManager manager = new AssignmentManager();
+        manager.startCLI();
+    }
+}

src/main/java/hhn/temp/project/Task.java

@@ -1,11 +1,11 @@
 package hhn.temp.project;
 
 public class Task {
-    String name;
-    String description;
-    int taskId;
-    int workerId;
-    TaskState state;
+    private String name;
+    private String description;
+    private int taskId;
+    private int workerId;
+    private TaskState state;
     public Task(int taskId, int workerId, String name, String description) {
         this.name = name;
         this.description = description;

src/main/java/hhn/temp/project/UserCommands.java

@@ -0,0 +1,444 @@
+package hhn.temp.project;
+
+import java.util.Scanner;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class UserCommands implements Runnable {
+    private Scanner scanner;
+    private AssignmentManager manager;
+    private Integer selectedTaskId = null;
+    private Integer selectedWorkerId = null;
+    private AtomicBoolean running = new AtomicBoolean(false);
+    private Thread cliThread;
+
+    private enum InputState {
+        MAIN_MENU,
+        TASK_SELECTED,
+        WORKER_SELECTED,
+        AWAITING_EDIT_INPUT,
+        AWAITING_CREATE_TASK_WORKER,
+        AWAITING_CREATE_TASK_NAME,
+        AWAITING_CREATE_TASK_DESC,
+        AWAITING_CREATE_WORKER_NAME,
+        AWAITING_TASK_SELECTION
+    }
+
+    private InputState currentState = InputState.MAIN_MENU;
+    private Integer tempWorkerId = null;
+    private String tempTaskName = null;
+
+    public UserCommands(AssignmentManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public void run() {
+        scanner = new Scanner(System.in);
+        running.set(true);
+
+        while (running.get()) {
+            printPrompt();
+            String input = scanner.nextLine().trim();
+
+            if ("exit".equalsIgnoreCase(input)) {
+                stop();
+                continue;
+            }
+
+            handleInput(input);
+        }
+        scanner.close();
+    }
+
+    public void start() {
+        if (cliThread == null || !cliThread.isAlive()) {
+            cliThread = new Thread(this, "CLI-Thread");
+            cliThread.start();
+        }
+    }
+
+    public void stop() {
+        running.set(false);
+        if (cliThread != null) {
+            cliThread.interrupt();
+        }
+    }
+
+    private void printPrompt() {
+        if (!running.get()) return;
+
+        switch (currentState) {
+            case MAIN_MENU:
+                System.out.println("Type '?' or 'help' for a list of commands");
+                break;
+            case TASK_SELECTED:
+                System.out.println("Task " + selectedTaskId + " selected. Commands: finish, unfinish, remove, edit, back");
+                break;
+            case WORKER_SELECTED:
+                if (selectedWorkerId != null) {
+                    System.out.println("Worker " + selectedWorkerId + " selected. Commands: remove, back");
+                } else {
+                    System.out.println("Enter worker ID to select (or 'back'):");
+                }
+                break;
+            case AWAITING_EDIT_INPUT:
+                System.out.println("Enter new name;description:");
+                break;
+            case AWAITING_CREATE_WORKER_NAME:
+                System.out.println("Enter worker name:");
+                break;
+            case AWAITING_CREATE_TASK_WORKER:
+                System.out.println("Enter worker ID:");
+                break;
+            case AWAITING_CREATE_TASK_NAME:
+                System.out.println("Enter task name:");
+                break;
+            case AWAITING_CREATE_TASK_DESC:
+                System.out.println("Enter task description:");
+                break;
+        }
+        System.out.print("> ");
+    }
+
+    public void handleInput(String input) {
+        if (input == null || input.isEmpty()) {
+            return;
+        }
+
+        if ("?".equals(input) || "help".equalsIgnoreCase(input)) {
+            showHelp();
+            return;
+        }
+
+        try {
+            switch (currentState) {
+                case MAIN_MENU:
+                    handleMainMenuInput(input);
+                    break;
+                case TASK_SELECTED:
+                    handleTaskSelectionInput(input);
+                    break;
+                case WORKER_SELECTED:
+                    handleWorkerSelectionInput(input);
+                    break;
+                case AWAITING_EDIT_INPUT:
+                    handleEditInput(input);
+                    break;
+                case AWAITING_CREATE_TASK_WORKER:
+                    handleCreateTaskWorkerInput(input);
+                    break;
+                case AWAITING_CREATE_TASK_NAME:
+                    handleCreateTaskNameInput(input);
+                    break;
+                case AWAITING_CREATE_TASK_DESC:
+                    handleCreateTaskDescInput(input);
+                    break;
+                case AWAITING_CREATE_WORKER_NAME:
+                    handleCreateWorkerNameInput(input);
+                    break;
+                case AWAITING_TASK_SELECTION:
+                    handleTaskIdInput(input);
+                    break;
+            }
+        } catch (Exception e) {
+            System.out.println("Error: " + e.getMessage());
+            resetToMainMenu();
+        }
+    }
+
+    private void showHelp() {
+        System.out.println("=== Available Commands ===");
+        System.out.println("General:");
+        System.out.println("  help, ? - Show this help");
+        System.out.println("  exit - Exit the program");
+        System.out.println("  createworker - Create a new worker");
+        System.out.println("  createtask - Create a new task");
+        System.out.println("  selecttask - Select a task to work with");
+        System.out.println("  listworkers - List all workers");
+        System.out.println("  listtasks - List all tasks with status");
+        System.out.println("  listfinished - List only finished tasks");
+        System.out.println("  listunfinished - List only unfinished tasks");
+
+        System.out.println("\nWhen a task is selected:");
+        System.out.println("  finish - Mark task as finished");
+        System.out.println("  unfinish - Mark task as unfinished");
+        System.out.println("  remove - Remove the task");
+        System.out.println("  edit - Edit task name and description");
+        System.out.println("  back - Return to main menu");
+
+        System.out.println("\nWhen a worker is selected:");
+        System.out.println("  remove - Remove the worker");
+        System.out.println("  back - Return to main menu");
+    }
+
+    private void handleMainMenuInput(String input) {
+        switch (input.toLowerCase()) {
+            case "createworker":
+                System.out.println("Enter worker name:");
+                currentState = InputState.AWAITING_CREATE_WORKER_NAME;
+                break;
+
+            case "createtask":
+                System.out.println("Enter worker ID:");
+                currentState = InputState.AWAITING_CREATE_TASK_WORKER;
+                break;
+
+            case "selecttask":
+                System.out.println("Enter task ID:");
+                currentState = InputState.AWAITING_TASK_SELECTION;
+                break;
+
+            case "listworkers":
+                listWorkers();
+                break;
+
+            case "listtasks":
+                listAllTasks();
+                break;
+
+            case "listfinished":
+                listTasksByStatus(TaskState.FINISHED);
+                break;
+
+            case "listunfinished":
+                listTasksByStatus(TaskState.IN_PROGRESS);
+                break;
+
+            default:
+                System.out.println("Unknown command. Type 'help' for available commands.");
+        }
+    }
+
+    private void listWorkers() {
+        System.out.println("\nAvailable workers:");
+        if (manager.getWorkerMap().isEmpty()) {
+            System.out.println("  No workers found.");
+        } else {
+            for (Worker w : manager.getWorkerMap().values()) {
+                System.out.println("  " + w.getId() + ": " + w.getName());
+            }
+        }
+        System.out.println();
+    }
+
+    private void listAllTasks() {
+        System.out.println("\nAll tasks:");
+        if (manager.getTaskMap().isEmpty()) {
+            System.out.println("  No tasks found.");
+        } else {
+            for (Task task : manager.getTaskMap().values()) {
+                Worker worker = manager.getWorker(task.getWorkerId());
+                String status = task.getTaskState() == TaskState.FINISHED ? "[FINISHED]" : "[IN PROGRESS]";
+                System.out.println(String.format("  %d: %s - %s (Worker: %d - %s)",
+                        task.getTaskId(), status, task.getName(),
+                        worker.getId(), worker.getName()));
+            }
+        }
+        System.out.println();
+    }
+
+    private void listTasksByStatus(TaskState status) {
+        System.out.println("\nTasks with status: " + status);
+        boolean found = false;
+
+        for (Task task : manager.getTaskMap().values()) {
+            if (task.getTaskState() == status) {
+                Worker worker = manager.getWorker(task.getWorkerId());
+                System.out.println(String.format("  %d: %s (Worker: %d - %s)",
+                        task.getTaskId(), task.getName(),
+                        worker.getId(), worker.getName()));
+                found = true;
+            }
+        }
+
+        if (!found) {
+            System.out.println("  No tasks found with this status.");
+        }
+        System.out.println();
+    }
+
+    private void handleWorkerSelectionInput(String input) {
+        if ("back".equalsIgnoreCase(input)) {
+            resetToMainMenu();
+            return;
+        }
+
+        try {
+            int workerId = Integer.parseInt(input.trim());
+            Worker worker = manager.getWorker(workerId);
+            if (worker != null) {
+                selectedWorkerId = workerId;
+                System.out.println("Worker " + workerId + " (" + worker.getName() + ") selected");
+                System.out.println("Commands: remove, back");
+            } else {
+                System.out.println("Worker not found. Please enter a valid worker ID:");
+            }
+        } catch (NumberFormatException e) {
+            if (selectedWorkerId != null) {
+                handleWorkerCommand(input);
+            } else {
+                System.out.println("Invalid input. Please enter a worker ID or 'back':");
+            }
+        }
+    }
+
+    private void handleWorkerCommand(String input) {
+        switch (input.toLowerCase()) {
+            case "remove":
+                manager.removeWorker(selectedWorkerId);
+                System.out.println("Worker removed");
+                resetToMainMenu();
+                break;
+
+            case "back":
+                resetToMainMenu();
+                break;
+
+            default:
+                System.out.println("Unknown command. Available commands: remove, back");
+        }
+    }
+
+    private void handleCreateWorkerNameInput(String input) {
+        int workerId = manager.createWorker(input.trim());
+        System.out.println("Created worker with ID: " + workerId);
+        resetToMainMenu();
+    }
+    private void handleTaskIdInput(String input) {
+        if ("back".equalsIgnoreCase(input)) {
+            resetToMainMenu();
+            return;
+        }
+
+        try {
+            int taskId = Integer.parseInt(input.trim());
+            Task task = manager.getTask(taskId);
+            if (task != null) {
+                selectedTaskId = taskId;
+                currentState = InputState.TASK_SELECTED;
+                System.out.println("Task " + taskId + " (" + task.getName() + ") selected");
+                System.out.println("Commands: finish, unfinish, remove, edit, back");
+            } else {
+                System.out.println("Task not found. Please enter a valid task ID:");
+            }
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid input. Please enter a task ID or 'back':");
+        }
+    }
+
+
+    private void handleCreateTaskWorkerInput(String input) {
+        try {
+            tempWorkerId = Integer.parseInt(input.trim());
+            System.out.println("Enter task name:");
+            currentState = InputState.AWAITING_CREATE_TASK_NAME;
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid worker ID. Please enter a number:");
+        }
+    }
+
+    private void handleCreateTaskNameInput(String input) {
+        tempTaskName = input.trim();
+        System.out.println("Enter task description:");
+        currentState = InputState.AWAITING_CREATE_TASK_DESC;
+    }
+
+    private void handleCreateTaskDescInput(String input) {
+        int taskId = manager.addTask(tempWorkerId, tempTaskName, input.trim());
+        System.out.println("Created task with ID: " + taskId);
+        resetToMainMenu();
+    }
+
+    private void resetToMainMenu() {
+        currentState = InputState.MAIN_MENU;
+        selectedTaskId = null;
+        selectedWorkerId = null;
+        tempWorkerId = null;
+        tempTaskName = null;
+    }
+
+    private void handleTaskSelectionInput(String input) {
+        if ("back".equalsIgnoreCase(input)) {
+            resetToMainMenu();
+            return;
+        }
+
+        try {
+            int taskId = Integer.parseInt(input.trim());
+            Task task = manager.getTask(taskId);
+            if (task != null) {
+                selectedTaskId = taskId;
+                currentState = InputState.TASK_SELECTED;
+                System.out.println("Task " + taskId + " (" + task.getName() + ") selected");
+                System.out.println("Commands: finish, unfinish, remove, edit, back");
+            } else {
+                System.out.println("Task not found. Please enter a valid task ID:");
+            }
+        } catch (NumberFormatException e) {
+            if (selectedTaskId != null) {
+                handleTaskCommand(input);
+            } else {
+                System.out.println("Invalid input. Please enter a task ID or 'back':");
+            }
+        }
+    }
+
+    private void handleTaskCommand(String input) {
+        switch (input.toLowerCase()) {
+            case "finish":
+                manager.finishTask(manager.getTask(selectedTaskId).getWorkerId(),selectedTaskId);
+                System.out.println("Task marked as finished");
+                break;
+
+            case "unfinish":
+                manager.unfinishTask(manager.getTask(selectedTaskId).getWorkerId(),selectedTaskId);
+                System.out.println("Task marked as unfinished");
+                break;
+
+            case "remove":
+                manager.removeTask(selectedTaskId);
+                System.out.println("Task removed");
+                resetToMainMenu();
+                break;
+
+            case "edit":
+                System.out.println("Enter new name;description:");
+                currentState = InputState.AWAITING_EDIT_INPUT;
+                break;
+
+            case "back":
+                resetToMainMenu();
+                break;
+
+            default:
+                System.out.println("Unknown command. Type 'help' for available commands.");
+        }
+    }
+
+    private void handleEditInput(String input) {
+        String[] parts = input.split(";", 2);
+        if (parts.length == 2) {
+            manager.editTask(manager.getTask(selectedTaskId).getWorkerId(), selectedTaskId, parts[0], parts[1]);
+            System.out.println("Task edited");
+        } else {
+            System.out.println("Invalid format. Use: name;description");
+            System.out.println("Please try again:");
+            return;
+        }
+        currentState = InputState.TASK_SELECTED;
+    }
+
+    public Scanner getScanner() {
+        return scanner;
+    }
+
+    //only for testing
+    public void setScanner(Scanner scanner) {
+        this.scanner = scanner;
+    }
+
+    //only for testing
+    public boolean isRunning() {
+        return running.get();
+    }
+}

src/main/java/hhn/temp/project/Worker.java

@@ -1,8 +1,8 @@
 package hhn.temp.project;
 
 public class Worker {
-    String name;
-    int workerId;
+    private String name;
+    private int workerId;
     public Worker(String name, int workerId) {
         this.name = name;
         this.workerId = workerId;

test/hhn/temp/project/BadCasesTest.java

@@ -52,4 +52,20 @@ public class BadCasesTest {
         assertThrows(IllegalArgumentException.class, () -> manager.finishTask(20405, 21034));
         assertThrows(IllegalArgumentException.class, () -> manager.unfinishTask(20405, 21034));
     }
+    @Test
+    @DisplayName("Assert that removing a non-existent worker throws an Exception")
+    public void assertRemovingNonExistentWorkerFails() {
+        assertThrows(IllegalArgumentException.class, () -> manager.removeWorker(34054));
+    }
+    @Test
+    @DisplayName("Assert non-existent commands are recognized as such")
+    public void assertInvalidCommandsDontCrash() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        try {
+            manager.getUserCommands().handleInput("baum");
+        } catch (Exception e) {
+            fail("Should not crash just because a command is invalid");
+        }
+    }
 }

test/hhn/temp/project/GoodCasesTest.java

@@ -4,6 +4,8 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.util.Scanner;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 public class GoodCasesTest {
@@ -13,6 +15,7 @@ public class GoodCasesTest {
     public void setup() {
         manager = new AssignmentManager();
     }
+
     @Test
     @DisplayName("Assert that a Worker can add a Task")
     public void assertWorkerCanAddTask() {
@@ -30,6 +33,7 @@ public class GoodCasesTest {
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
         assertEquals(sizeCount + 1, manager.getTaskMap().size());
     }
+
     @Test
     @DisplayName("Assert existing Tasks can be edited")
     public void assertExistingTasksCanBeEdited() {
@@ -50,6 +54,7 @@ public class GoodCasesTest {
         manager.removeTask(taskId);
         assertEquals(sizeCount, manager.getTaskMap().size());
     }
+
     @Test
     @DisplayName("Assert deleted Tasks no longer show up in the List")
     public void assertDeletedTasksDisappear() {
@@ -58,18 +63,20 @@ public class GoodCasesTest {
         manager.removeTask(taskId);
         assertThrows(IllegalArgumentException.class, () -> manager.getTask(taskId));
     }
+
     @Test
     @DisplayName("Check Getters")
     public void assertGettersWorkCorrectly() {
         int workerId = manager.createWorker("Alfred");
         int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
-        assertEquals("Alfred", manager.workerMap.get(workerId).getName());
+        assertEquals("Alfred", manager.getWorkerMap().get(workerId).getName());
         //This one may be somewhat nonsensical, but it ensures the getId works so one may iterate over the workerMap
-        assertEquals(manager.workerMap.get(workerId).getId(), workerId);
+        assertEquals(manager.getWorkerMap().get(workerId).getId(), workerId);
         assertEquals(manager.getTask(taskId).getTaskId(), taskId);
         assertEquals(manager.getTask(taskId).getWorkerId(), workerId);
 
     }
+
     @Test
     @DisplayName("Assert that Task State is actually changed when submitted as finished")
     public void assertTaskStateChanges() {
@@ -81,4 +88,68 @@ public class GoodCasesTest {
         assertSame(TaskState.IN_PROGRESS, manager.getTask(taskId).getTaskState());
     }
 
+    @Test
+    @DisplayName("Assert that the Scanner is actually started when AM calls start")
+    public void assertScannerExists() {
+        try {
+            Scanner scanner = manager.getUserCommands().getScanner();
+        } catch (Exception e) {
+            fail("Scanner does not exists or can't be gotten by getScanner()");
+        }
+    }
+    @Test
+    @DisplayName("Check that every required surface command actually works")
+    public void assertCommandsAreRecognized() {
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("?"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("help"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("createWorker"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("createTask"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("selectTask"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("listWorkers"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("exit"));
+    }
+    @Test
+    @DisplayName("Check that every task command works")
+    public void assertFinishingTasksIsPossibleThroughUi() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        manager.getUserCommands().handleInput("selectTask");
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput(taskId + ""));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("finish"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("unfinish"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("remove"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("back"));
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("edit"));
+    }
+    @Test
+    @DisplayName("Check that editing is possible through UI")
+    public void assertEditingTasksIsPossibleThroughUi() {
+        int workerId = manager.createWorker("Alfred");
+        int taskId = manager.addTask(workerId, "Run", "Jog 10 Miles");
+        manager.getUserCommands().handleInput("selectTask");
+        manager.getUserCommands().handleInput(taskId + "");
+        manager.getUserCommands().handleInput("edit");
+        manager.getUserCommands().handleInput("Walk;Walk 3 Miles");
+        assertEquals("Walk", manager.getTask(taskId).getName());
+        assertEquals("Walk 3 Miles", manager.getTask(taskId).getDescription());
+        manager.getUserCommands().handleInput("back");
+    }
+    @Test
+    @DisplayName("Assert that removing Workers is possible through the UI")
+    public void assertRemovingWorkersIsPossibleThroughUI() {
+        int workerId = manager.createWorker("Alfred");
+        int workerId2 = manager.createWorker("Balfred");
+        manager.getUserCommands().handleInput("listWorkers");
+        manager.getUserCommands().handleInput(workerId + "");
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("remove"));
+        manager.getUserCommands().handleInput(workerId2 + "");
+        assertDoesNotThrow(() -> manager.getUserCommands().handleInput("back"));
+    }
+    @Test
+    @DisplayName("Assert that removing a worker removes the worker from the worker list")
+    public void assertRemoveWorkerActuallyRemoves() {
+        int workerId = manager.createWorker("Alfred");
+        manager.removeWorker(workerId);
+        assertThrows(IllegalArgumentException.class, () -> manager.getWorker(workerId)); // Use getWorker
+    }
 }