Add tests for details feature

src/main/java/seedu/address/logic/commands/DetailsCommand.java

@@ -29,6 +29,7 @@ public DetailsCommand(NameEqualKeywordPredicate predicate) {
     public CommandResult execute(Model model) {
         requireNonNull(model);
         model.updateFilteredPersonList(predicate);
+        assert model.getFilteredPersonList().size() < 2;
         if (model.getFilteredPersonList().size() == 0) {
             return new CommandResult(
                     String.format(Messages.MESSAGE_PERSON_DETAILS_NOT_FOUND, predicate),

src/main/java/seedu/address/model/Model.java

@@ -84,5 +84,4 @@ public interface Model {
      * @throws NullPointerException if {@code predicate} is null.
      */
     void updateFilteredPersonList(Predicate<Person> predicate);
-
 }

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

@@ -0,0 +1,77 @@
+package seedu.address.logic.commands;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static seedu.address.commons.core.Messages.MESSAGE_PERSON_DETAILS_FOUND;
+import static seedu.address.commons.core.Messages.MESSAGE_PERSON_DETAILS_NOT_FOUND;
+import static seedu.address.logic.commands.CommandTestUtil.assertCommandSuccess;
+import static seedu.address.testutil.TypicalPersons.CARL;
+import static seedu.address.testutil.TypicalPersons.getTypicalAddressBook;
+
+import java.util.Collections;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.model.Model;
+import seedu.address.model.ModelManager;
+import seedu.address.model.UserPrefs;
+import seedu.address.model.person.Name;
+import seedu.address.model.person.NameEqualKeywordPredicate;
+
+/**
+ * Contains integration tests (interaction with the Model) for {@code DetailsCommand}.
+ */
+class DetailsCommandTest {
+    private Model model = new ModelManager(getTypicalAddressBook(), new UserPrefs());
+    private Model expectedModel = new ModelManager(getTypicalAddressBook(), new UserPrefs());
+
+    @Test
+    public void equals() {
+        NameEqualKeywordPredicate firstPredicate =
+                new NameEqualKeywordPredicate(new Name("first"));
+        NameEqualKeywordPredicate secondPredicate =
+                new NameEqualKeywordPredicate(new Name("second"));
+
+        DetailsCommand findFirstCommand = new DetailsCommand(firstPredicate);
+        DetailsCommand findSecondCommand = new DetailsCommand(secondPredicate);
+
+        // same object -> returns true
+        assertTrue(findFirstCommand.equals(findFirstCommand));
+
+        // same values -> returns true
+        DetailsCommand findFirstCommandCopy = new DetailsCommand(firstPredicate);
+        assertTrue(findFirstCommand.equals(findFirstCommandCopy));
+
+        // different types -> returns false
+        assertFalse(findFirstCommand.equals(1));
+
+        // null -> returns false
+        assertFalse(findFirstCommand.equals(null));
+
+        // different person -> returns false
+        assertFalse(findFirstCommand.equals(findSecondCommand));
+    }
+
+    @Test
+    public void execute_zeroKeywords_noPersonFound() {
+        String name = "cool name";
+        String expectedMessage = String.format(MESSAGE_PERSON_DETAILS_NOT_FOUND, name);
+        NameEqualKeywordPredicate predicate = new NameEqualKeywordPredicate(new Name(name));
+        DetailsCommand command = new DetailsCommand(predicate);
+        expectedModel.updateFilteredPersonList(predicate);
+        assertCommandSuccess(command, model, expectedMessage, expectedModel);
+        assertEquals(Collections.emptyList(), model.getFilteredPersonList());
+    }
+
+    @Test
+    public void execute_multipleKeywords_multiplePersonsFound() {
+        Name name = CARL.getName();
+        String expectedMessage = String.format(MESSAGE_PERSON_DETAILS_FOUND, name);
+        NameEqualKeywordPredicate predicate = new NameEqualKeywordPredicate(name);
+        DetailsCommand command = new DetailsCommand(predicate);
+        expectedModel.updateFilteredPersonList(predicate);
+        assertCommandSuccess(command, model, expectedMessage, expectedModel);
+        assertEquals(Collections.singletonList(CARL), model.getFilteredPersonList());
+    }
+}

src/test/java/seedu/address/logic/parser/AddressBookParserTest.java

@@ -16,6 +16,7 @@
 import seedu.address.logic.commands.AddCommand;
 import seedu.address.logic.commands.ClearCommand;
 import seedu.address.logic.commands.DeleteCommand;
+import seedu.address.logic.commands.DetailsCommand;
 import seedu.address.logic.commands.EditCommand;
 import seedu.address.logic.commands.EditCommand.EditPersonDescriptor;
 import seedu.address.logic.commands.ExitCommand;
@@ -24,6 +25,7 @@
 import seedu.address.logic.commands.ListCommand;
 import seedu.address.logic.parser.exceptions.ParseException;
 import seedu.address.model.person.NameContainsKeywordsPredicate;
+import seedu.address.model.person.NameEqualKeywordPredicate;
 import seedu.address.model.person.Person;
 import seedu.address.testutil.EditPersonDescriptorBuilder;
 import seedu.address.testutil.PersonBuilder;
@@ -53,6 +55,14 @@ public void parseCommand_delete() throws Exception {
         assertEquals(new DeleteCommand(INDEX_FIRST_PERSON), command);
     }
 
+    @Test
+    public void parseCommand_details() throws Exception {
+        String keyword = "foo";
+        DetailsCommand command = (DetailsCommand) parser.parseCommand(
+                DetailsCommand.COMMAND_WORD + " " + keyword);
+        assertEquals(new DetailsCommand(new NameEqualKeywordPredicate(ParserUtil.parseName(keyword))), command);
+    }
+
     @Test
     public void parseCommand_edit() throws Exception {
         Person person = new PersonBuilder().build();

src/test/java/seedu/address/logic/parser/DetailsCommandParserTest.java

@@ -0,0 +1,40 @@
+package seedu.address.logic.parser;
+
+import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseFailure;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseSuccess;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.logic.commands.DetailsCommand;
+import seedu.address.model.person.Name;
+import seedu.address.model.person.NameEqualKeywordPredicate;
+
+class DetailsCommandParserTest {
+
+    private DetailsCommandParser parser = new DetailsCommandParser();
+
+    @Test
+    public void parse_emptyArg_throwsParseException() {
+        assertParseFailure(parser, "     ",
+                String.format(MESSAGE_INVALID_COMMAND_FORMAT, DetailsCommand.MESSAGE_USAGE));
+    }
+
+    @Test
+    public void parse_validArgs_returnsDetailsCommand() {
+        DetailsCommand expectedFindCommand =
+                new DetailsCommand(new NameEqualKeywordPredicate(new Name("Alice Bob")));
+
+        // No trailing and leading whitespace
+        assertParseSuccess(parser, "Alice Bob", expectedFindCommand);
+
+        // Leading whitespace
+        assertParseSuccess(parser, "      Alice Bob", expectedFindCommand);
+
+        // Trailing whitespace
+        assertParseSuccess(parser, "Alice Bob    ", expectedFindCommand);
+
+        // Leading and trailing whitespace
+        assertParseSuccess(parser, "     Alice Bob    ", expectedFindCommand);
+    }
+}

src/test/java/seedu/address/model/person/NameEqualKeywordPredicateTest.java

@@ -0,0 +1,70 @@
+package seedu.address.model.person;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.testutil.PersonBuilder;
+
+class NameEqualKeywordPredicateTest {
+    @Test
+    public void equals() {
+        String firstKeyword = "keyword";
+        String secondKeyword = "Keyword";
+        String thirdKeyword = "keyword ";
+
+        NameEqualKeywordPredicate firstPredicate = new NameEqualKeywordPredicate(new Name(firstKeyword));
+        NameEqualKeywordPredicate secondPredicate = new NameEqualKeywordPredicate(new Name(secondKeyword));
+        NameEqualKeywordPredicate thirdPredicate = new NameEqualKeywordPredicate(new Name(thirdKeyword));
+
+        // same object -> returns true
+        assertTrue(firstPredicate.equals(firstPredicate));
+
+        // same values -> returns true
+        NameEqualKeywordPredicate firstPredicateCopy = new NameEqualKeywordPredicate(new Name(firstKeyword));
+        assertTrue(firstPredicate.equals(firstPredicateCopy));
+
+        // different types -> returns false
+        assertFalse(firstPredicate.equals(1));
+
+        // null -> returns false
+        assertFalse(firstPredicate.equals(null));
+
+        // different person -> returns false
+        assertFalse(firstPredicate.equals(secondPredicate));
+
+        // extra spacing -> returns false
+        assertFalse(thirdPredicate.equals(firstPredicate));
+    }
+
+    @Test
+    public void test_nameMatchKeyword_returnsTrue() {
+        // Exact 1 word match
+        NameEqualKeywordPredicate predicate = new NameEqualKeywordPredicate(new Name("Alice"));
+        assertTrue(predicate.test(new PersonBuilder().withName("Alice").build()));
+
+        // Exact 2 word match
+        predicate = new NameEqualKeywordPredicate(new Name("Alice Bob"));
+        assertTrue(predicate.test(new PersonBuilder().withName("Alice Bob").build()));
+    }
+
+    @Test
+    public void test_nameDoesNotMatchKeyword_returnsFalse() {
+        // Non-matching keyword
+        NameEqualKeywordPredicate predicate = new NameEqualKeywordPredicate(new Name("Carol"));
+        assertFalse(predicate.test(new PersonBuilder().withName("Alice").build()));
+
+        // Partial match
+        predicate = new NameEqualKeywordPredicate(new Name("Carol"));
+        assertFalse(predicate.test(new PersonBuilder().withName("Caroline").build()));
+
+        // Partial match 2 words
+        predicate = new NameEqualKeywordPredicate(new Name("Bob"));
+        assertFalse(predicate.test(new PersonBuilder().withName("Bob boy").build()));
+
+        // Predicate with more words than person
+        predicate = new NameEqualKeywordPredicate(new Name("Bob the builder"));
+        assertFalse(predicate.test(new PersonBuilder().withName("Bob").build()));
+    }
+}