Refactor typical reservations and typical tables to another class

src/main/java/seedu/address/model/table/Table.java

@@ -39,7 +39,7 @@ public Table(int numOfSeats, int tableId) {
      * Checks if this table can accommodate specified number of customers
      */
     public boolean canFit(int numOfCustomers) {
-        return numOfCustomers <= numOfSeats;
+        return numOfCustomers <= numOfSeats && numOfCustomers > 0;
     }
 
     public int getTableId() {

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

@@ -4,17 +4,15 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static seedu.address.logic.commands.ReservationCommandTestUtil.assertCommandSuccess;
-import static seedu.address.logic.parser.ParserUtil.DATE_FORMATTER;
-import static seedu.address.logic.parser.ParserUtil.TIME_FORMATTER;
 import static seedu.address.testutil.TypicalCustomers.CUSTOMER_ALICE;
-import static seedu.address.testutil.TypicalCustomers.CUSTOMER_BOB;
 import static seedu.address.testutil.TypicalCustomers.getTypicalAddressBookCustomers;
+import static seedu.address.testutil.TypicalReservation.ALICE_RESERVATION;
+import static seedu.address.testutil.TypicalReservation.BENSON_RESERVATION;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.util.Collections;
-import java.util.Set;
 
 import org.junit.jupiter.api.Test;
 
@@ -25,25 +23,17 @@
 import seedu.address.model.UserPrefs;
 import seedu.address.model.reservation.CustomerContainsReservationPredicate;
 import seedu.address.model.reservation.ListContainsReservationPredicate;
-import seedu.address.model.reservation.Remark;
 import seedu.address.model.reservation.Reservation;
-import seedu.address.model.table.Table;
 
 class CheckCommandTest {
-    private LocalDate date1 = LocalDate.parse("2021-01-01", DATE_FORMATTER);
-    private LocalDate date2 = LocalDate.parse("2021-02-02", DATE_FORMATTER);
-    private LocalTime time = LocalTime.parse("1200", TIME_FORMATTER);
+    private LocalDate date1 = ALICE_RESERVATION.getDateTime().toLocalDate();
+    private LocalDate date2 = BENSON_RESERVATION.getDateTime().toLocalDate();
+    private LocalTime time = ALICE_RESERVATION.getDateTime().toLocalTime();
     private EnumTypeOfCheck typeOfCheck = EnumTypeOfCheck.DateTime;
     private Model model = new ModelManager(getTypicalAddressBookCustomers(), new UserPrefs());
     private Model resultModel = new ModelManager(getTypicalAddressBookCustomers(), new UserPrefs());
-    private Table table1 = new Table(5, 10);
-    private Table table2 = new Table(10, 11);
-    private Reservation reservation1 = new Reservation(
-            CUSTOMER_ALICE.getPhone(), 5, LocalDateTime.of(date1, time), table1, new Remark(""), Set.of()
-    );
-    private Reservation reservation2 = new Reservation(
-            CUSTOMER_BOB.getPhone(), 10, LocalDateTime.of(date2, time), table2, new Remark(""), Set.of()
-    );
+    private Reservation reservation1 = ALICE_RESERVATION;
+    private Reservation reservation2 = BENSON_RESERVATION;
 
     @Test
     void execute_validDateTime_success() {
@@ -84,23 +74,23 @@ void testEquals() {
         ListContainsReservationPredicate predicate1 = new ListContainsReservationPredicate(date1, time, typeOfCheck);
         ListContainsReservationPredicate predicate2 = new ListContainsReservationPredicate(date2, time, typeOfCheck);
 
-        CheckCommand findFirstCommand = new CheckCommand(predicate1);
-        CheckCommand findSecondCommand = new CheckCommand(predicate2);
+        CheckCommand checkFirstCommand = new CheckCommand(predicate1);
+        CheckCommand checkSecondCommand = new CheckCommand(predicate2);
 
         // same object -> returns true
-        assertTrue(findFirstCommand.equals(findFirstCommand));
+        assertTrue(checkFirstCommand.equals(checkFirstCommand));
 
         // same values -> returns true
-        CheckCommand findFirstCommandCopy = new CheckCommand(predicate1);
-        assertTrue(findFirstCommand.equals(findFirstCommandCopy));
+        CheckCommand checkFirstCommandCopy = new CheckCommand(predicate1);
+        assertTrue(checkFirstCommand.equals(checkFirstCommandCopy));
 
         // different types -> returns false
-        assertFalse(findFirstCommand.equals(1));
+        assertFalse(checkFirstCommand.equals(1));
 
         // null -> returns false
-        assertFalse(findFirstCommand.equals(null));
+        assertFalse(checkFirstCommand.equals(null));
 
         // different command -> returns false
-        assertFalse(findFirstCommand.equals(findSecondCommand));
+        assertFalse(checkFirstCommand.equals(checkSecondCommand));
     }
 }

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

@@ -4,6 +4,13 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static seedu.address.testutil.TypicalCustomers.getTypicalAddressBookCustomers;
+import static seedu.address.testutil.TypicalTables.DUMMY_LIST_OF_TABLES;
+import static seedu.address.testutil.TypicalTables.DUMMY_LIST_OF_TABLE_SIZES;
+import static seedu.address.testutil.TypicalTables.DUMMY_TABLE_1;
+import static seedu.address.testutil.TypicalTables.DUMMY_TABLE_2;
+import static seedu.address.testutil.TypicalTables.DUMMY_TABLE_3;
+import static seedu.address.testutil.TypicalTables.DUMMY_TABLE_4;
+import static seedu.address.testutil.TypicalTables.DUMMY_TABLE_5;
 
 import java.util.Arrays;
 import java.util.List;
@@ -13,7 +20,6 @@
 import seedu.address.model.Model;
 import seedu.address.model.ModelManager;
 import seedu.address.model.UserPrefs;
-import seedu.address.model.table.Table;
 
 
 class SetTablesCommandTest {
@@ -26,31 +32,23 @@ public void constructor_nullArgument_throwsNullPointerException() {
 
     @Test
     public void execute_validListOfTableSizes_addSuccessful() throws Exception {
-        List<Integer> tableSizeList = Arrays.asList(1, 2, 3, 4, 5);
-        List<Table> tableList = Arrays.asList(
-                new Table(1, 1),
-                new Table(2, 2),
-                new Table(3, 3),
-                new Table(4, 4),
-                new Table(5, 5)
-        );
-        SetTablesCommand command = new SetTablesCommand(tableSizeList);
-        model.setTableList(tableList);
+        SetTablesCommand command = new SetTablesCommand(DUMMY_LIST_OF_TABLE_SIZES);
+        model.setTableList(DUMMY_LIST_OF_TABLES);
 
         command.execute(model);
 
-        assertTrue(model.hasTable(new Table(1, 1)));
-        assertTrue(model.hasTable(new Table(2, 2)));
-        assertTrue(model.hasTable(new Table(3, 3)));
-        assertTrue(model.hasTable(new Table(4, 4)));
-        assertTrue(model.hasTable(new Table(5, 5)));
+        assertTrue(model.hasTable(DUMMY_TABLE_1));
+        assertTrue(model.hasTable(DUMMY_TABLE_2));
+        assertTrue(model.hasTable(DUMMY_TABLE_3));
+        assertTrue(model.hasTable(DUMMY_TABLE_4));
+        assertTrue(model.hasTable(DUMMY_TABLE_5));
     }
 
     @Test
     public void equals() {
 
-        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-        List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        List<Integer> list1 = DUMMY_LIST_OF_TABLE_SIZES;
+        List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5);
 
         SetTablesCommand setTablesCommand = new SetTablesCommand(list1);
         SetTablesCommand setTablesCommandCopied = new SetTablesCommand(list2);
@@ -68,6 +66,6 @@ public void equals() {
         assertFalse(setTablesCommand.equals(null));
 
         // different list values -> returns false
-        assertFalse(setTablesCommand.equals(new SetTablesCommand(Arrays.asList(99, 2, 3, 4, 5, 6, 7, 8, 9, 10))));
+        assertFalse(setTablesCommand.equals(new SetTablesCommand(Arrays.asList(99, 2, 3, 4, 5))));
     }
 }

src/test/java/seedu/address/model/reservation/CustomerContainsReservationPredicateTest.java

@@ -2,41 +2,26 @@
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.time.LocalDateTime;
-import java.util.Set;
+import static seedu.address.testutil.TypicalReservation.ALICE_RESERVATION;
+import static seedu.address.testutil.TypicalReservation.BENSON_RESERVATION;
 
 import org.junit.jupiter.api.Test;
 
 import javafx.collections.transformation.FilteredList;
-import seedu.address.model.person.Phone;
 import seedu.address.model.person.customer.Customer;
-import seedu.address.model.table.Table;
-import seedu.address.model.tag.Tag;
 import seedu.address.testutil.CustomerBuilder;
 
 class CustomerContainsReservationPredicateTest {
 
     @Test
     void testEquals() {
-        int numberOfCustomer = 5;
-        LocalDateTime dateTime = LocalDateTime.parse("2020-10-10T19:00");
-
-        Phone phone1 = new Phone("99999999");
-        Table table1 = new Table(5, 10);
-        Remark remark = new Remark("");
-        Set<Tag> tags = Set.of();
-        Reservation reservation1 = new Reservation(phone1, numberOfCustomer, dateTime, table1, remark, tags);
         ReservationList reservationList1 = new ReservationList();
-        reservationList1.add(reservation1);
+        reservationList1.add(ALICE_RESERVATION);
         FilteredList<Reservation> filteredList1 = new FilteredList<>(reservationList1.asUnmodifiableObservableList());
         CustomerContainsReservationPredicate predicate1 = new CustomerContainsReservationPredicate(filteredList1);
 
-        Phone phone2 = new Phone("88888888");
-        Table table2 = new Table(5, 11);
-        Reservation reservation2 = new Reservation(phone2, numberOfCustomer, dateTime, table2, remark, tags);
         ReservationList reservationList2 = new ReservationList();
-        reservationList2.add(reservation2);
+        reservationList2.add(BENSON_RESERVATION);
         FilteredList<Reservation> filteredList2 = new FilteredList<>(reservationList2.asUnmodifiableObservableList());
         CustomerContainsReservationPredicate predicate2 =
                 new CustomerContainsReservationPredicate(filteredList2);
@@ -61,37 +46,21 @@ void testEquals() {
 
     @Test
     void test_customerPhoneNumberMatchReservation_returnTrue() {
-        int numberOfCustomer = 5;
-        LocalDateTime dateTime = LocalDateTime.parse("2020-10-10T19:00");
-
-        Phone phone = new Phone("99999999");
-        Table table = new Table(5, 10);
-        Remark remark = new Remark("");
-        Set<Tag> tags = Set.of();
-        Reservation reservation = new Reservation(phone, numberOfCustomer, dateTime, table, remark, tags);
         ReservationList reservationList = new ReservationList();
-        reservationList.add(reservation);
+        reservationList.add(ALICE_RESERVATION);
         FilteredList<Reservation> filteredList = new FilteredList<>(reservationList.asUnmodifiableObservableList());
         CustomerContainsReservationPredicate predicate =
                 new CustomerContainsReservationPredicate(filteredList);
-        Customer customer = new CustomerBuilder().withPhone("99999999").build();
+        Customer customer = new CustomerBuilder().withPhone(ALICE_RESERVATION.getPhone().toString()).build();
 
         // Person's phone number matches the phone number in the reservation
         assertTrue(predicate.test(customer));
     }
 
     @Test
     void test_customerPhoneNumberDoesNotMatchReservation_returnFalse() {
-        int numberOfCustomer = 5;
-        LocalDateTime dateTime = LocalDateTime.parse("2020-10-10T19:00");
-
-        Phone phone = new Phone("99999999");
-        Table table = new Table(5, 10);
-        Remark remark = new Remark("");
-        Set<Tag> tags = Set.of();
-        Reservation reservation = new Reservation(phone, numberOfCustomer, dateTime, table, remark, tags);
         ReservationList reservationList = new ReservationList();
-        reservationList.add(reservation);
+        reservationList.add(ALICE_RESERVATION);
         FilteredList<Reservation> filteredList = new FilteredList<>(reservationList.asUnmodifiableObservableList());
         CustomerContainsReservationPredicate predicate =
                 new CustomerContainsReservationPredicate(filteredList);

src/test/java/seedu/address/model/reservation/ListContainsReservationPredicateTest.java

@@ -2,11 +2,11 @@
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static seedu.address.testutil.TypicalReservation.ALICE_RESERVATION;
+import static seedu.address.testutil.TypicalReservation.BENSON_RESERVATION;
 
 import java.time.LocalDate;
-import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.time.format.DateTimeFormatter;
 import java.util.Set;
 
 import org.junit.jupiter.api.Test;
@@ -17,13 +17,13 @@
 import seedu.address.model.tag.Tag;
 
 class ListContainsReservationPredicateTest {
-    private LocalDate date1 = LocalDate.parse("2021-01-01", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
-    private LocalDate date2 = LocalDate.parse("2021-02-02", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
-    private LocalTime time = LocalTime.parse("1200", DateTimeFormatter.ofPattern("HHmm"));
+    private LocalDate date1 = ALICE_RESERVATION.getDateTime().toLocalDate();
+    private LocalDate date2 = BENSON_RESERVATION.getDateTime().toLocalDate();
+    private LocalTime time = ALICE_RESERVATION.getDateTime().toLocalTime();
+    private Phone phone = ALICE_RESERVATION.getPhone();
     private EnumTypeOfCheck typeOfCheck = EnumTypeOfCheck.DateTime;
-    private Phone phone = new Phone("98765432");
-    private int numberOfPeople = 5;
-    private Table table = new Table(numberOfPeople, 10);
+    private int numberOfPeople = ALICE_RESERVATION.getNumberOfPeople();
+    private Table table = new Table(numberOfPeople, ALICE_RESERVATION.getTableId());
     private Remark remark = new Remark("");
     private Set<Tag> tags = Set.of();
 
@@ -52,47 +52,41 @@ void testEquals() {
 
     @Test
     void test_reservationDateTimeMatch_returnsTrue() {
-        Reservation reservation = new Reservation(phone, numberOfPeople,
-                LocalDateTime.parse("2021-01-01 1900", DateTimeFormatter.ofPattern("yyyy-MM-dd HHmm")),
-                table, remark, tags);
         ListContainsReservationPredicate predicate;
 
-        // Matching date and time in query containing both date and time
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-01-01"), LocalTime.parse("19:00"),
+        predicate = new ListContainsReservationPredicate(date1, time,
                 EnumTypeOfCheck.DateTime);
-        assertTrue(predicate.test(reservation));
+        assertTrue(predicate.test(ALICE_RESERVATION));
 
-        // Matching date in query containing only date
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-01-01"), LocalTime.parse("23:00"),
+        predicate = new ListContainsReservationPredicate(date1, time,
                 EnumTypeOfCheck.Date);
-        assertTrue(predicate.test(reservation));
+        assertTrue(predicate.test(ALICE_RESERVATION));
     }
 
     @Test
     void test_reservationDateTimeNoMatch_returnsFalse() {
-        Reservation reservation = new Reservation(phone, numberOfPeople,
-                LocalDateTime.parse("2021-01-01 1900", DateTimeFormatter.ofPattern("yyyy-MM-dd HHmm")),
-                table, remark, tags);
         ListContainsReservationPredicate predicate;
 
         // Not matching date and time in query containing both date and time
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-12-12"), LocalTime.parse("23:00"),
+        predicate = new ListContainsReservationPredicate(LocalDate.parse("2000-12-12"), LocalTime.parse("23:00"),
                 EnumTypeOfCheck.DateTime);
-        assertFalse(predicate.test(reservation));
+        assertFalse(predicate.test(ALICE_RESERVATION));
 
         // Not matching date and matching time in query containing both date and time
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-12-12"), LocalTime.parse("19:00"),
+        predicate = new ListContainsReservationPredicate(LocalDate.parse("2000-12-12"),
+                ALICE_RESERVATION.getDateTime().toLocalTime(),
                 EnumTypeOfCheck.DateTime);
-        assertFalse(predicate.test(reservation));
+        assertFalse(predicate.test(ALICE_RESERVATION));
 
         // Matching date and not matching time in query containing both date and time
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-01-01"), LocalTime.parse("23:00"),
+        predicate = new ListContainsReservationPredicate(ALICE_RESERVATION.getDateTime().toLocalDate(),
+                LocalTime.parse("23:00"),
                 EnumTypeOfCheck.DateTime);
-        assertFalse(predicate.test(reservation));
+        assertFalse(predicate.test(ALICE_RESERVATION));
 
         // Not matching date in query containing only date
-        predicate = new ListContainsReservationPredicate(LocalDate.parse("2021-01-02"), LocalTime.parse("19:00"),
+        predicate = new ListContainsReservationPredicate(LocalDate.parse("2000-01-02"), LocalTime.parse("23:00"),
                 EnumTypeOfCheck.Date);
-        assertFalse(predicate.test(reservation));
+        assertFalse(predicate.test(ALICE_RESERVATION));
     }
 }