[CS2103T-W13-4] TutorPro

src/main/java/seedu/address/logic/commands/exam/UpdateExamCommand.java

@@ -129,11 +129,6 @@ public CommandResult execute(Model model) throws CommandException {
         }
         Double newWeightage = this.weightage.orElse(examToUpdate.getWeightage());
         Grade newGrade = this.grade.orElse(examToUpdate.getGrade());
-
-        //if (Duration.between(newStartTime, newEndTime).toMinutes() < 30 || Duration.between(newStartTime,
-        //    newEndTime).toHours() > 3) {
-        //    throw new CommandException(Messages.MESSAGE_INVALID_EXAM_DURATION);
-        //}
         Exam newExam = new Exam(newExamName, newStartTime, newEndTime, newWeightage, newGrade);
 
         try {

src/main/java/seedu/address/logic/commands/lesson/UpdateLessonCommand.java

@@ -147,9 +147,11 @@ public boolean equals(Object other) {
         return other == this // short circuit if same object
             || (other instanceof UpdateLessonCommand // instanceof handles nulls
             && predicate.equals(((UpdateLessonCommand) other).predicate)
-            && index == ((UpdateLessonCommand) other).index
+            && index.equals(((UpdateLessonCommand) other).index)
             && lessonName.equals(((UpdateLessonCommand) other).lessonName)
-            && startTime.equals(((UpdateLessonCommand) other).startTime)
-            && endTime.equals((((UpdateLessonCommand) other).endTime)));
+            && startTime.orElse(LocalDateTime.parse("2090-04-10T08:30:00")).isEqual((((UpdateLessonCommand) other))
+            .startTime.orElse(LocalDateTime.parse("2090-04-10T08:30:00")))
+            && endTime.orElse(LocalDateTime.parse("2090-04-10T08:30:00")).isEqual((((UpdateLessonCommand) other))
+            .endTime.orElse(LocalDateTime.parse("2090-04-10T08:30:00"))));
     }
 }

src/main/java/seedu/address/logic/parser/DeleteCommandParser.java

@@ -33,13 +33,6 @@ public DeleteCommand parse(String args) throws ParseException {
 
         Index index = ParserUtil.parseIndex(argMultimap.getValue(PREFIX_INDEX).get());
         return new DeleteCommand(index);
-        //        try {
-        //            Index index = ParserUtil.parseIndex(args);
-        //            return new DeleteCommand(index);
-        //        } catch (ParseException pe) {
-        //            throw new ParseException(
-        //                    String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE), pe);
-        //        }
     }
 
     /**

src/main/java/seedu/address/logic/parser/FindCommandParser.java

@@ -43,19 +43,8 @@ public FindCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     ViewExamCommand.MESSAGE_USAGE));
             }
-            int spaceIndex = name.indexOf(" ");
-            //                if (spaceIndex != -1) {
-            //                    name = name.substring(0, spaceIndex);
-            //                }
             nameKeywords.set(i, name);
         }
-        //        String trimmedArgs = args.trim();
-        //        if (trimmedArgs.isEmpty()) {
-        //            throw new ParseException(
-        //                    String.format(MESSAGE_INVALID_COMMAND_FORMAT, FindCommand.MESSAGE_USAGE));
-        //        }
-        //
-        //        String[] nameKeywords = trimmedArgs.split("\\s+");
         return new FindCommand(new NamePredicate(nameKeywords));
     }
 

src/main/java/seedu/address/logic/parser/exam/CreateExamCommandParser.java

@@ -76,10 +76,6 @@ public CreateExamCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     CreateExamCommand.MESSAGE_USAGE));
             }
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         names = nameKeywords;

src/main/java/seedu/address/logic/parser/exam/DeleteExamCommandParser.java

@@ -50,10 +50,6 @@ public DeleteExamCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     DeleteExamCommand.MESSAGE_USAGE));
             }
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         inputNames = nameKeywords;

src/main/java/seedu/address/logic/parser/exam/UpdateExamCommandParser.java

@@ -65,10 +65,6 @@ public UpdateExamCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     UpdateExamCommand.MESSAGE_USAGE));
             }
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         names = nameKeywords;

src/main/java/seedu/address/logic/parser/exam/ViewExamCommandParser.java

@@ -55,7 +55,6 @@ public ViewExamCommand parse(String args) throws ParseException {
 
         // If name is present, create a predicate to filter by name
         if (argMultimap.getValue(PREFIX_NAME).isPresent()) {
-
             List<String> nameKeywords = argMultimap.getAllValues(PREFIX_NAME);
             // for all the names, trim the name and only take the first word
             for (int i = 0; i < nameKeywords.size(); i++) {
@@ -65,10 +64,6 @@ public ViewExamCommand parse(String args) throws ParseException {
                     throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                         ViewExamCommand.MESSAGE_USAGE));
                 }
-                int spaceIndex = name.indexOf(" ");
-                //                if (spaceIndex != -1) {
-                //                    name = name.substring(0, spaceIndex);
-                //                }
                 nameKeywords.set(i, name);
             }
             nameList = nameKeywords;

src/main/java/seedu/address/logic/parser/lesson/CreateLessonCommandParser.java

@@ -67,10 +67,6 @@ public CreateLessonCommand parse(String args) throws ParseException {
                     CreateLessonCommand.MESSAGE_USAGE));
             }
             name = name.trim();
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         names = nameKeywords;

src/main/java/seedu/address/logic/parser/lesson/DeleteLessonCommandParser.java

@@ -50,10 +50,6 @@ public DeleteLessonCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     DeleteLessonCommand.MESSAGE_USAGE));
             }
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         inputNames = nameKeywords;

src/main/java/seedu/address/logic/parser/lesson/UpdateLessonCommandParser.java

@@ -60,17 +60,13 @@ public UpdateLessonCommand parse(String args) throws ParseException {
                 throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                     UpdateLessonCommand.MESSAGE_USAGE));
             }
-            //            int spaceIndex = name.indexOf(" ");
-            //            if (spaceIndex != -1) {
-            //                name = name.substring(0, spaceIndex);
-            //            }
             nameKeywords.set(i, name);
         }
         names = nameKeywords;
 
         if (nameKeywords.size() > 1) {
             throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
-                "Only one name is allowed for update homework command."));
+                "Only one name is allowed for update lesson command."));
         }
 
         // if homework name is not present, set it to null, else parse it

src/main/java/seedu/address/logic/parser/lesson/ViewLessonCommandParser.java

@@ -65,10 +65,6 @@ public ViewLessonCommand parse(String args) throws ParseException {
                     throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT,
                         ViewLessonCommand.MESSAGE_USAGE));
                 }
-                int spaceIndex = name.indexOf(" ");
-                //                if (spaceIndex != -1) {
-                //                    name = name.substring(0, spaceIndex);
-                //                }
                 nameKeywords.set(i, name);
             }
             nameList = nameKeywords;
@@ -110,6 +106,6 @@ public ViewLessonCommand parse(String args) throws ParseException {
     public boolean equals(Object other) {
         return other == this // short circuit if same object
             || (other instanceof ViewLessonCommandParser // instanceof handles nulls
-            && this.equals((ViewLessonCommandParser) other)); // state check
+            && this.equals(other)); // state check
     }
 }

src/main/java/seedu/address/model/student/Lesson.java

@@ -43,24 +43,6 @@ public LocalDateTime getEndTime() {
         return endTime;
     }
 
-    /**
-     * Returns the start time of the lesson in a String format.
-     *
-     * @return The start time of the lesson in a String format.
-     */
-    public String getStartTimeString() {
-        return startTime.format(formatter);
-    }
-
-    /**
-     * Returns the end time of the lesson in a String format.
-     *
-     * @return
-     */
-    public String getEndTimeString() {
-        return endTime.format(formatter);
-    }
-
     /**
      * Returns true if the 2 lessons' timeslot conflict with each other.
      * @param otherLesson The other lesson to compare with.

src/main/java/seedu/address/model/student/LessonBelongsToDatePredicate.java

@@ -32,6 +32,6 @@ public boolean test(Lesson lesson) {
     public boolean equals(Object other) {
         return other == this // short circuit if same object
             || (other instanceof LessonBelongsToDatePredicate // instanceof handles nulls
-            && targetDate == ((LessonBelongsToDatePredicate) other).targetDate); // date check
+            && targetDate.isEqual(((LessonBelongsToDatePredicate) other).targetDate)); // date check
     }
 }

src/main/java/seedu/address/model/student/NamePredicate.java

@@ -36,7 +36,6 @@ public boolean test(Student student) {
     @Override
     public boolean equals(Object other) {
         return other == this // short circuit if same object
-            || (other instanceof NamePredicate // instanceof handles nulls
-            && names.equals(((NamePredicate) other).names)); // date check
+            || (other instanceof NamePredicate && names.equals(((NamePredicate) other).names));
     }
 }

src/main/java/seedu/address/model/student/Student.java

@@ -139,25 +139,6 @@ public ObservableList<Exam> getExamsList() {
     }
 
     //HOMEWORK########################################################################################
-    /**
-     * Returns an immutable assignment list, which throws {@code UnsupportedOperationException}
-     * if modification is attempted.
-     *
-     * @return list of completed homework
-     */
-    public ObservableList<Homework> getCompletedHomeworkList() {
-        return homeworkList.asUnmodifiableObservableList().filtered(Homework::isCompleted);
-    }
-
-    /**
-     * Returns an immutable assignment list, which throws {@code UnsupportedOperationException}
-     *
-     * @return list of pending homework
-     */
-    public ObservableList<Homework> getPendingHomeworkList() {
-        return homeworkList.asUnmodifiableObservableList().filtered(homework -> !homework.isCompleted());
-    }
-
     /**
      * Adds a homework to the homework list.
      *
@@ -314,21 +295,11 @@ public final List<Lesson> getFilteredLessonsList(Predicate<Lesson>... predicates
 
     public void setLesson(Integer target, Lesson editedLesson) {
         requireAllNonNull(target, editedLesson);
-        //        UniqueLessonsList tempLessonList = lessonsList.clone();
-        //        tempLessonList.setLesson(target, editedLesson);
-        //        if (!(tempLessonList.validLessons())) {
-        //            throw new ConflictingLessonsException();
-        //        }
         lessonsList.setLesson(target, editedLesson);
     }
 
     public void setExam(Integer target, Exam editedExam) {
         requireAllNonNull(target, editedExam);
-        //        UniqueExamList tempExamList = examList;
-        //        tempExamList.setExam(target, editedExam);
-        //        if (!(tempExamList.validExams())) {
-        //            throw new ConflictingExamsException();
-        //        }
         examList.setExam(target, editedExam);
     }
 

src/main/java/seedu/address/model/student/UniqueExamList.java

@@ -5,7 +5,6 @@
 
 import java.util.Iterator;
 import java.util.List;
-import java.util.function.Predicate;
 
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
@@ -91,7 +90,6 @@ public void remove(Exam toRemove) {
         }
     }
 
-
     /**
      * Replaces the contents of this list with {@code replacement}.
      * {@code replacement} must not contain duplicate Exams.
@@ -192,16 +190,6 @@ public int hashCode() {
         return internalList.hashCode();
     }
 
-    /**
-     * Updates the list of exams to only contain exams that fufil a predicate.
-     *
-     * @param examStatusPredicate predicate object encapsulating qualifier
-     */
-    public void updateFilteredExamList(Predicate<Exam> examStatusPredicate) {
-        requireNonNull(examStatusPredicate);
-        internalList.removeIf(examStatusPredicate.negate());
-    }
-
     /**
      * Returns a list of past exams.
      * The list is sorted by start time and capped at 3 exams.

src/main/java/seedu/address/model/student/UniqueLessonsList.java

@@ -3,6 +3,7 @@
 import static java.util.Objects.requireNonNull;
 import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
 
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 
@@ -59,7 +60,7 @@ public void add(Lesson toAdd) throws DuplicateLessonException, ConflictingLesson
             }
         }
         internalList.add(toAdd);
-        internalList.sort((l1, l2) -> l1.getStartTime().compareTo(l2.getStartTime()));
+        internalList.sort(Comparator.comparing(Lesson::getStartTime));
     }
 
     /**
@@ -73,7 +74,7 @@ public void remove(Lesson toRemove) {
         if (!internalList.remove(toRemove)) {
             throw new LessonNotFoundException();
         }
-        internalList.sort((l1, l2) -> l1.getStartTime().compareTo(l2.getStartTime()));
+        internalList.sort(Comparator.comparing(Lesson::getStartTime));
     }
 
     /**
@@ -98,7 +99,7 @@ public void setLessons(List<Lesson> lessons) {
             throw new ConflictingLessonsException();
         }
         internalList.setAll(lessons);
-        internalList.sort((l1, l2) -> l1.getStartTime().compareTo(l2.getStartTime()));
+        internalList.sort(Comparator.comparing(Lesson::getStartTime));
     }
 
     public boolean validLessons() {
@@ -167,7 +168,7 @@ public int size() {
 
     public List<Lesson> getSortedLessonsList() {
         List<Lesson> tempList = internalList;
-        tempList.sort((l1, l2) -> l1.getStartTime().compareTo(l2.getStartTime()));
+        tempList.sort(Comparator.comparing(Lesson::getStartTime));
         return tempList;
     }
 

src/test/java/seedu/address/logic/LogicManagerTest.java

@@ -49,18 +49,6 @@ public void setUp() {
         logic = new LogicManager(model, storage);
     }
 
-    //    @Test
-    //    public void execute_invalidCommandFormat_throwsParseException() {
-    //        String invalidCommand = "uicfhmowqewca";
-    //        assertParseException(invalidCommand, MESSAGE_UNKNOWN_COMMAND);
-    //    }
-    //
-    //    @Test
-    //    public void execute_commandExecutionError_throwsCommandException() {
-    //        String deleteCommand = "delete index/10";
-    //        assertCommandException(deleteCommand, MESSAGE_INVALID_STUDENT_DISPLAYED_INDEX);
-    //    }
-
     @Test
     public void execute_validCommand_success() throws Exception {
         String listCommand = ListCommand.COMMAND_WORD;

src/test/java/seedu/address/logic/commands/AddCommandTest.java

@@ -29,17 +29,6 @@ public void constructor_nullPerson_throwsNullPointerException() {
         assertThrows(NullPointerException.class, () -> new AddCommand(null));
     }
 
-    //    @Test
-    //    public void execute_personAcceptedByModel_addSuccessful() throws Exception {
-    //        ModelStubAcceptingPersonAdded modelStub = new ModelStubAcceptingPersonAdded();
-    //        Student validPerson = new StudentBuilder().build();
-    //
-    //        CommandResult commandResult = new AddCommand(validPerson).execute(modelStub);
-    //
-    //        assertEquals(String.format(AddCommand.MESSAGE_SUCCESS, validPerson), commandResult.getFeedbackToUser());
-    //        assertEquals(Arrays.asList(validPerson), modelStub.personsAdded);
-    //    }
-
     @Test
     public void execute_duplicatePerson_throwsCommandException() {
         Student validPerson = new StudentBuilder().build();

src/test/java/seedu/address/logic/commands/EditCommandTest.java

@@ -98,14 +98,15 @@ public void execute_filteredList_success() {
         assertCommandSuccess(editCommand, model, expectedMessage, expectedModel);
     }
 
-    //    @Test
-    //    public void execute_duplicatePersonUnfilteredList_failure() {
-    //        Student firstPerson = model.getFilteredStudentList().get(INDEX_FIRST_PERSON.getZeroBased());
-    //        EditCommand.EditStudentDescriptor descriptor = new EditStudentDescriptorBuilder(firstPerson).build();
-    //        EditCommand editCommand = new EditCommand(INDEX_SECOND_PERSON, descriptor);
-    //
-    //        assertCommandFailure(editCommand, model, EditCommand.MESSAGE_DUPLICATE_PERSON);
-    //    }
+    @Test
+    public void execute_duplicatePersonUnfilteredList_failure() {
+        Student firstPerson = model.getFilteredStudentList().get(INDEX_FIRST_PERSON.getZeroBased());
+        EditCommand.EditStudentDescriptor descriptor = new EditStudentDescriptorBuilder(firstPerson).build();
+        EditCommand editCommand = new EditCommand(INDEX_SECOND_PERSON, descriptor);
+
+        assertCommandFailure(editCommand, model, String.format(Messages.MESSAGE_CONTAIN_STUDENT_NAME,
+            firstPerson.getName().toString()));
+    }
 
     @Test
     public void execute_duplicatePersonFilteredList_failure() {

src/test/java/seedu/address/logic/parser/lesson/CreateLessonCommandParserTest.java

@@ -0,0 +1,71 @@
+package seedu.address.logic.parser.lesson;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_ENDTIME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_LESSON;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_STARTTIME;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.logic.parser.exceptions.ParseException;
+
+public class CreateLessonCommandParserTest {
+
+    private CreateLessonCommandParser parser = new CreateLessonCommandParser();
+
+    //    @Test
+    //    public void parse_validArgs_returnsCreateLessonCommand() throws ParseException {
+    //        List<String> names = Arrays.asList("Alice", "Bob");
+    //        String lessonName = "Math";
+    //        LocalDateTime startTime = LocalDateTime.parse("2023-04-10T09:00");
+    //        LocalDateTime endTime = LocalDateTime.parse("2023-04-10T11:00");
+    //        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+    //            + PREFIX_STARTTIME + "2023-04-10T09:00 " + PREFIX_ENDTIME + "2023-04-10T11:00";
+    //        CreateLessonCommand expectedCommand = new CreateLessonCommand(names, new NamePredicate(names),
+    //            lessonName, startTime, endTime);
+    //        assertEquals(expectedCommand, parser.parse(userInput));
+    //    }
+
+    @Test
+    public void parse_invalidArgs_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+            + PREFIX_STARTTIME + "2023-04-10T09:00 " + PREFIX_ENDTIME + "2023-04-10T08:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+
+    @Test
+    public void parse_missingArgs_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+            + PREFIX_STARTTIME + "2023-04-10T09:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+
+    @Test
+    public void parse_emptyName_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + " " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+            + PREFIX_STARTTIME + "2023-04-10T09:00 " + PREFIX_ENDTIME + "2023-04-10T11:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+
+    @Test
+    public void parse_invalidLessonName_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + " "
+            + PREFIX_STARTTIME + "2023-04-10T09:00 " + PREFIX_ENDTIME + "2023-04-10T11:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+
+    @Test
+    public void parse_invalidStartTimeFormat_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+            + PREFIX_STARTTIME + "2023-04-10-09:00 " + PREFIX_ENDTIME + "2023-04-10T11:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+
+    @Test
+    public void parse_invalidEndTimeFormat_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_LESSON + "Math "
+            + PREFIX_STARTTIME + "2023-04-10T09:00 " + PREFIX_ENDTIME + "2023-04-10-11:00";
+        assertThrows(ParseException.class, () -> parser.parse(userInput));
+    }
+}

src/test/java/seedu/address/logic/parser/lesson/DeleteLessonCommandParserTest.java

@@ -0,0 +1,47 @@
+package seedu.address.logic.parser.lesson;
+
+import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_INDEX;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseFailure;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseSuccess;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.core.index.Index;
+import seedu.address.logic.commands.lesson.DeleteLessonCommand;
+import seedu.address.model.student.NamePredicate;
+
+public class DeleteLessonCommandParserTest {
+
+    private DeleteLessonCommandParser parser = new DeleteLessonCommandParser();
+
+    @Test
+    public void parse_allFieldsPresent_success() {
+        List<String> inputNames = new ArrayList<>(Arrays.asList("Alice", "Bob"));
+        NamePredicate namePredicate = new NamePredicate(inputNames);
+        Index targetIndex = Index.fromOneBased(1);
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob " + PREFIX_INDEX + "1";
+        DeleteLessonCommand expectedCommand = new DeleteLessonCommand(inputNames, namePredicate, targetIndex);
+
+        assertParseSuccess(parser, userInput, expectedCommand);
+    }
+
+    @Test
+    public void parse_missingName_throwsParseException() {
+        String userInput = " " + PREFIX_INDEX + "1";
+        assertParseFailure(parser, userInput, String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+            DeleteLessonCommand.MESSAGE_USAGE));
+    }
+
+    @Test
+    public void parse_missingIndex_throwsParseException() {
+        String userInput = " " + PREFIX_NAME + "Alice " + PREFIX_NAME + "Bob";
+        assertParseFailure(parser, userInput, String.format(MESSAGE_INVALID_COMMAND_FORMAT,
+            DeleteLessonCommand.MESSAGE_USAGE));
+    }
+}

src/test/java/seedu/address/logic/parser/lesson/UpdateLessonCommandParser.java

@@ -0,0 +1,74 @@
+package seedu.address.logic.parser.lesson;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.core.index.Index;
+import seedu.address.logic.commands.lesson.UpdateLessonCommand;
+import seedu.address.logic.parser.exceptions.ParseException;
+import seedu.address.model.student.NamePredicate;
+
+class UpdateLessonCommandParserTest {
+    private final UpdateLessonCommandParser parser = new UpdateLessonCommandParser();
+
+    @Test
+    void parse_allFieldsPresent_success() throws ParseException {
+        // All fields provided
+        assertEquals(parser.parse(" name/John index/1 lesson/Math start/2023-05-21T10:00 "
+                + "end/2023-05-21 1100"),
+            new UpdateLessonCommand(List.of("John"), Index.fromOneBased(1),
+                new NamePredicate(List.of("John")),
+                Optional.of("Math"),
+                Optional.of(LocalDateTime.of(2023, 5, 21, 10, 0)),
+                Optional.of(LocalDateTime.of(2023, 5, 21, 11, 0))));
+    }
+
+    @Test
+    void parse_optionalFieldsMissing_success() throws ParseException {
+        // Lesson name and end time missing
+        assertEquals(parser.parse(" name/John index/1 start/2023-05-21T10:00"),
+            new UpdateLessonCommand(List.of("John"), Index.fromOneBased(1),
+                new NamePredicate(List.of("John")),
+                Optional.empty(),
+                Optional.of(LocalDateTime.of(2023, 5, 21, 10, 0)),
+                Optional.empty()));
+
+        // Start time and end time missing
+        Optional<LocalDateTime> start = Optional.empty();
+        Optional<LocalDateTime> end = Optional.empty();
+        assertEquals(parser.parse(" name/John index/1 lesson/Math"),
+            new UpdateLessonCommand(List.of("John"), Index.fromOneBased(1),
+                new NamePredicate(List.of("John")),
+                Optional.of("Math"),
+                start,
+                end));
+    }
+
+    @Test
+    void parse_missingCompulsoryField_failure() {
+        // Missing index
+        assertThrows(ParseException.class, () -> parser.parse(" name/John name/Doe lesson/Math"
+            + "startTime/2023-05-21T10:00 endTime/2023-05-21T11:00"));
+
+        // Missing name
+        assertThrows(ParseException.class, () -> parser.parse(" index/1 lesson/Math startTime/2023-05-21T10:00"
+            + "endTime/2023-05-21T11:00"));
+    }
+
+    @Test
+    void parse_invalidValue_failure() {
+        // Invalid index
+        assertThrows(ParseException.class, () -> parser.parse(" name/John name/Doe index/0"
+            + "lesson/Math startTime/2023-05-21T10:00 endTime/2023-05-21T11:00"));
+
+        // Invalid date
+        assertThrows(ParseException.class, () -> parser.parse(" name/John name/Doe index/1 lesson/Math"
+            + "startTime/2023-13-21T10:00 endTime/2023-05-21T11:00"));
+    }
+}

src/test/java/seedu/address/logic/parser/lesson/ViewLessonCommandParserTest.java

@@ -0,0 +1,53 @@
+package seedu.address.logic.parser.lesson;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static seedu.address.model.Model.PREDICATE_SHOW_ALL_STUDENTS;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.logic.commands.lesson.ViewLessonCommand;
+import seedu.address.logic.parser.exceptions.ParseException;
+import seedu.address.model.student.LessonBelongsToDatePredicate;
+import seedu.address.model.student.LessonDonePredicate;
+import seedu.address.model.student.LessonSubjectPredicate;
+import seedu.address.model.student.NamePredicate;
+
+class ViewLessonCommandParserTest {
+    private final ViewLessonCommandParser parser = new ViewLessonCommandParser();
+
+    @Test
+    public void parse_validArgs_returnsViewLessonCommand() throws ParseException {
+        // No filters provided
+        assertEquals(parser.parse(""), new ViewLessonCommand(Collections.emptyList(), PREDICATE_SHOW_ALL_STUDENTS,
+            lesson -> true, lesson -> true, true));
+
+        // Only name provided
+        List<String> nameKeywords = Arrays.asList("John", "Doe");
+        assertEquals(parser.parse(" name/John name/Doe"), new ViewLessonCommand(nameKeywords,
+            new NamePredicate(nameKeywords), lesson -> true, lesson -> true, false));
+
+        // All filters provided
+        List<String> names = Arrays.asList("John", "Doe");
+        assertEquals(parser.parse(" name/John name/Doe date/2023-05-21 subject/Math done/done"),
+            new ViewLessonCommand(names, new NamePredicate(names), new LessonBelongsToDatePredicate(LocalDate.of(2023,
+                5, 21)), new LessonSubjectPredicate("Math"), new LessonDonePredicate("done"), false));
+    }
+
+    @Test
+    public void parse_invalidArgs_throwsParseException() {
+        // Invalid done keyword
+        assertThrows(ParseException.class, () -> parser.parse(" done/invalid"));
+
+        // Invalid date format
+        assertThrows(ParseException.class, () -> parser.parse(" d/2023-13-32"));
+
+        // Invalid prefix
+        assertThrows(ParseException.class, () -> parser.parse(" x/John"));
+    }
+}