Added tests for the Command classes

Author: weixue123

src/main/java/duke/Duke.java

@@ -25,27 +25,20 @@ public Duke(String filepath) {
     }
 
     /**
-     * Executes the command w.r.t. the users' input.
+     * Executes the command and computes a response to display to the users w.r.t.
+     * the users' input.
      *
      * @param input A line of raw user input.
+     * @return A <code>String</code> of response.
      */
-    public void execute(String input) {
+    public String getResponse(String input) {
         Command command = this.getCommand(input);
         command.execute(this.tasks);
 
         if (command instanceof ByeCommand) {
             this.storage.saveTasks(this.tasks);
         }
-    }
 
-    /**
-     * Computes a response to display to the users w.r.t. the users' input.
-     *
-     * @param input A line of raw user input.
-     * @return A <code>String</code> of response.
-     */
-    public String getResponse(String input) {
-        Command command = this.getCommand(input);
         return command.getResponse(this.tasks);
     }
 

src/main/java/duke/commands/DeleteCommand.java

@@ -20,7 +20,6 @@ public class DeleteCommand extends Command {
      */
     public DeleteCommand(int index) {
         this.index = index;
-        this.deletedTask = null;
     }
 
     /**
@@ -38,6 +37,7 @@ public boolean isExit() {
      * @param tasks A collection of <code>Task</code> objects representing the application's state.
      */
     public void execute(TaskList tasks) {
+        // Set this.deletedTask to the popped Task (if any), or else null.
         this.deletedTask = tasks.popTaskByIndex(this.index);
     }
 
@@ -49,6 +49,9 @@ public void execute(TaskList tasks) {
      */
     public String getResponse(TaskList tasks) {
         try {
+            // Note that this getResponse method MUST be called after the execute method. Following
+            // this condition, if this.deletedTask is equal to null here, then no task was popped
+            // earlier. That can only mean that the index input into this command does not exist.
             if (null == this.deletedTask) {
                 throw new TaskNumberNotExistException(this.index);
             }

src/main/java/duke/commands/DoneCommand.java

@@ -19,7 +19,6 @@ public class DoneCommand extends Command {
      */
     public DoneCommand(int index) {
         this.index = index;
-        this.doneTask = null;
     }
 
     /**
@@ -37,6 +36,7 @@ public boolean isExit() {
      * @param tasks A collection of <code>Task</code> objects representing the application's state.
      */
     public void execute(TaskList tasks) {
+        // Set this.doneTask to the task to be marked as done (if any), or else null.
         this.doneTask = tasks.getTaskByIndex(this.index);
         if (null != this.doneTask) {
             this.doneTask.markAsDone();
@@ -51,6 +51,9 @@ public void execute(TaskList tasks) {
      */
     public String getResponse(TaskList tasks) {
         try {
+            // Note that this getResponse method MUST be called after the execute method. Following
+            // this condition, iff this.doneTask is equal to null here, then no task was marked as
+            // done earlier. That can only mean that the index input into this command does not exist.
             if (null == this.doneTask) {
                 throw new TaskNumberNotExistException(this.index);
             }

src/main/java/duke/commands/FindCommand.java

@@ -57,7 +57,7 @@ public String getResponse(TaskList tasks) {
         }
 
         if (matchingTasks.getSize() == 0) {
-            return "There are no tasks matching the '" + this.keywords + "' in your list :O";
+            return "There are no tasks matching the string '" + this.keywords + "' in your list :O";
         } else {
             return "Here are the matching tasks in your list:\n" + matchingTasks.getTaskListAsString();
         }

…/exceptions/DateTimeFormatException.java …ions/InvalidDateTimeFormatException.javasrc/main/java/duke/exceptions/DateTimeFormatException.java renamed to src/main/java/duke/exceptions/InvalidDateTimeFormatException.java src/main/java/duke/exceptions/DateTimeFormatException.java renamed to src/main/java/duke/exceptions/InvalidDateTimeFormatException.java

@@ -1,8 +1,8 @@
 package duke.exceptions;
 
-public class DateTimeFormatException extends Exception {
+public class InvalidDateTimeFormatException extends Exception {
 
-    public DateTimeFormatException(String dateString) {
+    public InvalidDateTimeFormatException(String dateString) {
         super("I can't recognize '" + dateString + "' as a date. Please follow the 'YYYY-MM-DD HH:mm' format :P");
     }
 }

src/main/java/duke/ui/MainWindow.java

@@ -55,8 +55,6 @@ public void setDuke(Duke duke) {
     @FXML
     private void handleUserInput() {
         String input = this.userInput.getText();
-
-        this.duke.execute(input);
         String response = this.duke.getResponse(input);
 
         this.dialogContainer.getChildren().addAll(

src/main/java/duke/ui/Parser.java

@@ -16,8 +16,8 @@
 import duke.commands.FindCommand;
 import duke.commands.InvalidInputCommand;
 import duke.commands.ListCommand;
-import duke.exceptions.DateTimeFormatException;
 import duke.exceptions.InvalidActionException;
+import duke.exceptions.InvalidDateTimeFormatException;
 import duke.exceptions.MissingDeadlineException;
 import duke.exceptions.MissingDescriptionException;
 import duke.exceptions.MissingEventTimeException;
@@ -243,19 +243,19 @@ private static String getExceptionMessage(String input) {
             }
 
             if (action.equals(DEADLINE) && null == convertToDateTime(byDateTimeString)) {
-                throw new DateTimeFormatException(byDateTimeString);
+                throw new InvalidDateTimeFormatException(byDateTimeString);
             }
 
             if (action.equals(EVENT) && null == convertToDateTime(atDateTimeString)) {
-                throw new DateTimeFormatException(atDateTimeString);
+                throw new InvalidDateTimeFormatException(atDateTimeString);
             }
 
         } catch (MissingDescriptionException
                 | InvalidActionException
                 | TaskNumberNotIntException
                 | MissingDeadlineException
                 | MissingEventTimeException
-                | DateTimeFormatException e) {
+                | InvalidDateTimeFormatException e) {
             return e.getMessage();
         }
 

src/test/java/duke/commands/TestAddTaskCommand.java

@@ -0,0 +1,99 @@
+package duke.commands;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+import org.junit.jupiter.api.Test;
+
+import duke.tasks.Deadline;
+import duke.tasks.Event;
+import duke.tasks.TaskList;
+import duke.tasks.ToDo;
+
+public class TestAddTaskCommand {
+    private final ToDo toDo;
+    private final Deadline deadline;
+    private final Event event;
+    private final AddTaskCommand addToDoCommand;
+    private final AddTaskCommand addDeadlineCommand;
+    private final AddTaskCommand addEventCommand;
+
+
+    /**
+     * Initialize a <code>AddTaskCommand</code> instance for testing.
+     */
+    public TestAddTaskCommand() {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm");
+        LocalDateTime dateTime = LocalDateTime.parse("2021-02-06 23:30", formatter);
+
+        this.toDo = new ToDo("CS2103 Quiz 1");
+        this.deadline = new Deadline("BT4013 Quiz 2", dateTime);
+        this.event = new Event("CS2103 Quiz 3", dateTime);
+
+        this.addToDoCommand = new AddTaskCommand(this.toDo);
+        this.addDeadlineCommand = new AddTaskCommand(this.deadline);
+        this.addEventCommand = new AddTaskCommand(this.event);
+    }
+
+    /**
+     * Test that <code>AddTaskCommand</code> correctly determines whether to exit the application.
+     */
+    @Test
+    public void testIsExit() {
+        assertFalse(this.addToDoCommand.isExit());
+        assertFalse(this.addDeadlineCommand.isExit());
+        assertFalse(this.addEventCommand.isExit());
+    }
+
+    /**
+     * Test that <code>AddTaskCommand</code> alters the input <code>TaskList</code> correctly.
+     */
+    @Test
+    public void testExecute() {
+        TaskList tasks = new TaskList();
+
+        this.addToDoCommand.execute(tasks);
+        assertEquals(1, tasks.getSize());
+        assertEquals(this.toDo, tasks.getTaskByIndex(1));
+
+        this.addDeadlineCommand.execute(tasks);
+        assertEquals(2, tasks.getSize());
+        assertEquals(this.toDo, tasks.getTaskByIndex(1));
+        assertEquals(this.deadline, tasks.getTaskByIndex(2));
+
+        this.addEventCommand.execute(tasks);
+        assertEquals(3, tasks.getSize());
+        assertEquals(this.toDo, tasks.getTaskByIndex(1));
+        assertEquals(this.deadline, tasks.getTaskByIndex(2));
+        assertEquals(this.event, tasks.getTaskByIndex(3));
+    }
+
+    /**
+     * Test that <code>AddTaskCommand</code> computes the response message correctly.
+     */
+    @Test
+    public void testResponse() {
+        TaskList tasks = new TaskList();
+
+        this.addToDoCommand.execute(tasks);
+        String expectedAddToDoResponse = "Got it. I've added this task:\n"
+                + "[T][ ] CS2103 Quiz 1\n"
+                + "Now you have 1 task(s) in the list.";
+        assertEquals(expectedAddToDoResponse, this.addToDoCommand.getResponse(tasks));
+
+        this.addDeadlineCommand.execute(tasks);
+        String expectedAddDeadlineResponse = "Got it. I've added this task:\n"
+                + "[D][ ] BT4013 Quiz 2 (by: 2021-02-06 23:30)\n"
+                + "Now you have 2 task(s) in the list.";
+        assertEquals(expectedAddDeadlineResponse, this.addDeadlineCommand.getResponse(tasks));
+
+        this.addEventCommand.execute(tasks);
+        String expectedAddEventResponse = "Got it. I've added this task:\n"
+                + "[E][ ] CS2103 Quiz 3 (at: 2021-02-06 23:30)\n"
+                + "Now you have 3 task(s) in the list.";
+        assertEquals(expectedAddEventResponse, this.addEventCommand.getResponse(tasks));
+    }
+}

src/test/java/duke/commands/TestByeCommand.java

@@ -0,0 +1,57 @@
+package duke.commands;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+import duke.tasks.TaskList;
+import duke.tasks.ToDo;
+
+public class TestByeCommand {
+    private final ToDo toDo;
+    private final TaskList tasks;
+    private final ByeCommand command;
+
+    /**
+     * Initialize a <code>ByeCommand</code> instance for testing.
+     */
+    public TestByeCommand() {
+        this.command = new ByeCommand();
+        this.tasks = new TaskList();
+
+        this.toDo = new ToDo("CS2103 Quiz");
+        this.tasks.addTask(this.toDo);
+    }
+
+    /**
+     * Test that <code>ByeCommand</code> correctly determines whether to exit the application.
+     */
+    @Test
+    public void testIsExit() {
+        assertTrue(this.command.isExit());
+    }
+
+    /**
+     * Test that <code>ByeCommand</code> (correctly) does not change the input <code>TaskList</code>.
+     */
+    @Test
+    public void testExecute() {
+        assertEquals(1, this.tasks.getSize());
+        assertEquals(this.toDo, this.tasks.getTaskByIndex(1));
+
+        this.command.execute(this.tasks);
+
+        assertEquals(1, this.tasks.getSize());
+        assertEquals(this.toDo, this.tasks.getTaskByIndex(1));
+    }
+
+    /**
+     * Test that <code>ByeCommand</code> computes the response message correctly.
+     */
+    @Test
+    public void testResponse() {
+        String expectedResponse = "Bye. Hope to see you again soon!";
+        assertEquals(expectedResponse, this.command.getResponse(this.tasks));
+    }
+}

src/test/java/duke/commands/TestDeleteCommand.java

@@ -0,0 +1,82 @@
+package duke.commands;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+import org.junit.jupiter.api.Test;
+
+import duke.tasks.Deadline;
+import duke.tasks.Event;
+import duke.tasks.TaskList;
+import duke.tasks.ToDo;
+
+public class TestDeleteCommand {
+    private final ToDo toDo;
+    private final Deadline deadline;
+    private final Event event;
+    private final TaskList tasks;
+    private final DeleteCommand command;
+
+    /**
+     * Initialize a <code>DeleteCommand</code> instance and a <code>TaskList</code> instance for testing.
+     */
+    public TestDeleteCommand() {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm");
+        LocalDateTime dateTime = LocalDateTime.parse("2021-02-06 23:30", formatter);
+
+        this.tasks = new TaskList();
+        this.toDo = new ToDo("CS2103 Quiz 1");
+        this.deadline = new Deadline("BT4013 Quiz 2", dateTime);
+        this.event = new Event("CS2103 Quiz 3", dateTime);
+
+        this.deadline.markAsDone();
+
+        this.tasks.addTask(this.toDo);
+        this.tasks.addTask(this.deadline);
+        this.tasks.addTask(this.event);
+
+        this.command = new DeleteCommand(1);
+    }
+
+    /**
+     * Test that <code>DeleteCommand</code> correctly determines whether to exit the application.
+     */
+    @Test
+    public void testIsExit() {
+        assertFalse(this.command.isExit());
+    }
+
+    /**
+     * Test that <code>DeleteCommand</code> alters the input <code>TaskList</code> correctly.
+     */
+    @Test
+    public void testExecute() {
+        assertEquals(3, this.tasks.getSize());
+        assertEquals(this.toDo, this.tasks.getTaskByIndex(1));
+        assertEquals(this.deadline, this.tasks.getTaskByIndex(2));
+        assertEquals(this.event, this.tasks.getTaskByIndex(3));
+
+        this.command.execute(this.tasks);
+
+        assertEquals(2, this.tasks.getSize());
+        assertEquals(this.deadline, this.tasks.getTaskByIndex(1));
+        assertEquals(this.event, this.tasks.getTaskByIndex(2));
+    }
+
+    /**
+     * Test that <code>DeleteCommand</code> computes the response message correctly.
+     */
+    @Test
+    public void testResponse() {
+        this.command.execute(this.tasks);
+        String expectedResponse = "Noted. I've removed this task:\n" + "[T][ ] CS2103 Quiz 1";
+        assertEquals(expectedResponse, this.command.getResponse(this.tasks));
+
+        DeleteCommand invalidCommand = new DeleteCommand(10);
+        String expectedExceptionMessage = "Task 10 does not exist :O";
+        assertEquals(expectedExceptionMessage, invalidCommand.getResponse(this.tasks));
+    }
+}