Merge branch 'master' into develop-budget

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

@@ -51,4 +51,16 @@ public CommandResult execute(Model model) throws CommandException {
         }
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj instanceof ReceiveCommand) {
+            ReceiveCommand receiveMoney = (ReceiveCommand) obj;
+            return transaction.equals(receiveMoney.transaction);
+        } else {
+            return false;
+        }
+    }
+
 }

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

@@ -61,4 +61,15 @@ public CommandResult execute(Model model) throws CommandException {
         }
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj instanceof SplitCommand) {
+            SplitCommand splitCommand = (SplitCommand) obj;
+            return transaction.equals(splitCommand.transaction);
+        } else {
+            return false;
+        }
+    }
 }

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

@@ -114,7 +114,7 @@ public static Date parseDate(String date) throws ParseException {
         requireNonNull(date);
         String trimmedDate = date.trim();
         if (!trimmedDate.matches(Date.DATE_FORMAT)) {
-            throw new ParseException(Date.MESSAGE_FORMAT_CONSTRAINTS);
+            throw new ParseException(String.format(Date.MESSAGE_FORMAT_CONSTRAINTS, trimmedDate));
         }
         if (!Date.isValidDate(trimmedDate)) {
             throw new ParseException(Date.MESSAGE_DATE_INVALID);

src/main/java/seedu/address/model/transaction/ReceiveMoney.java

@@ -18,7 +18,7 @@ public ReceiveMoney(Person person, Amount amount, Description description) {
 
     @Override
     public Amount getAmount() {
-        return amount.makePositive();
+        return amount;
     }
 
     @Override

src/main/java/seedu/address/model/transaction/Split.java

@@ -93,7 +93,7 @@ public boolean equals(Object obj) {
                 && this.date.equals(splitObj.date)
                 && peopleInvolved.equals(splitObj.peopleInvolved)
                 && description.equals(splitObj.description)
-                && splitAmounts == splitObj.splitAmounts;
+                && splitAmounts.equals(splitObj.splitAmounts);
         } else {
             return false;
         }

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

@@ -63,7 +63,8 @@ public void parse_optionalFieldsMissing_success() {
                 + DESCRIPTION_DESC_ALICE, new InCommand(expectedTransaction2));
     }
 
-    @Test void parse_compulsoryFieldMissing_failure() {
+    @Test
+    void parse_compulsoryFieldMissing_failure() {
         String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, InCommand.MESSAGE_USAGE);
 
         // missing amount prefix

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

@@ -0,0 +1,78 @@
+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.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.core.Messages;
+import seedu.address.logic.commands.ReceiveCommand;
+import seedu.address.model.person.Name;
+import seedu.address.model.transaction.Amount;
+import seedu.address.model.transaction.Description;
+import seedu.address.model.transaction.ReceiveMoney;
+import seedu.address.model.util.Date;
+import seedu.address.testutil.LedgerOperationBuilder;
+
+class ReceiveCommandParserTest {
+    private ReceiveCommandParser parser = new ReceiveCommandParser();
+    private ReceiveMoney expected;
+
+    @BeforeEach
+    void init() {
+        LedgerOperationBuilder lob = new LedgerOperationBuilder();
+        expected = lob.withPerson("amy")
+                .withAmount("23")
+                .withDate("20022019")
+                .withDescription("return money")
+                .asReceiveMoney();
+    }
+
+    @Test
+    void parse_allFieldsPresent_success() {
+        assertParseSuccess(parser, " $/23 d/20022019 n/amy a/return money", new ReceiveCommand(expected));
+    }
+
+    @Test
+    void parse_optionalFieldsMissing_success() {
+        expected = new LedgerOperationBuilder()
+                .withDescription("receive")
+                .withPerson("amy")
+                .withAmount("23")
+                .withDate(Date.now().toString())
+                .asReceiveMoney();
+        assertParseSuccess(parser, " $/23 n/amy ", new ReceiveCommand(expected));
+    }
+
+    @Test
+    void parse_compulsoryFieldMissing_failure() {
+        String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, ReceiveCommand.MESSAGE_USAGE);
+        // no amount
+        assertParseFailure(parser, " n/amy ", expectedMessage);
+        // no name
+        assertParseFailure(parser, " $/23 ", expectedMessage);
+    }
+
+    @Test
+    void parse_invalidValues_failure() {
+        // invalid amount
+        assertParseFailure(parser, " $/2003.23049 n/amy ", Amount.DOUBLE_CONSTRAINTS);
+
+        // overflow amount
+        assertParseFailure(parser, " $/383838388382003 n/amy ", Messages.MESSAGE_AMOUNT_OVERFLOW);
+
+        // invalid name
+        assertParseFailure(parser, " $/2003 n/amy#@ ", Name.MESSAGE_CONSTRAINTS);
+
+        // invalid description
+        assertParseFailure(parser, " $/2003 n/amy a/amy#@ ", Description.MESSAGE_CONSTRAINTS);
+
+        // invalid date
+        assertParseFailure(parser, " $/2003 n/amy d/amy#@ ", Date.MESSAGE_FORMAT_CONSTRAINTS);
+
+        // invalid date format
+        assertParseFailure(parser, " $/2003 n/amy d/20202019 ", Date.MESSAGE_DATE_INVALID);
+    }
+}

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

@@ -0,0 +1,146 @@
+package seedu.address.logic.parser;
+
+import static seedu.address.commons.core.Messages.MESSAGE_AMOUNT_OVERFLOW;
+import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
+import static seedu.address.logic.commands.CommandTestUtil.AMOUNT_DESC_ALICE;
+import static seedu.address.logic.commands.CommandTestUtil.DATE_DESC_ALICE;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_AMOUNT_OVERFLOW_DESC;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_AMOUNT_RANGE_DESC;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_AMOUNT_TYPE_DESC;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_AMOUNT_ZERO_DESC;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_DATETYPE_DESC;
+import static seedu.address.logic.commands.CommandTestUtil.INVALID_DATE_DESC;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseFailure;
+import static seedu.address.logic.parser.CommandParserTestUtil.assertParseSuccess;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.core.Messages;
+import seedu.address.logic.commands.SplitCommand;
+import seedu.address.model.person.Name;
+import seedu.address.model.person.Person;
+import seedu.address.model.transaction.Amount;
+import seedu.address.model.transaction.Description;
+import seedu.address.model.transaction.Split;
+import seedu.address.model.util.Date;
+import seedu.address.testutil.LedgerOperationBuilder;
+import seedu.address.testutil.PersonBuilder;
+import seedu.address.testutil.TypicalPersons;
+
+class SplitCommandParserTest {
+    private final SplitCommandParser parser = new SplitCommandParser();
+    private Split expectedEvenSplit;
+
+    @BeforeEach
+    void init() {
+        Person a = new PersonBuilder(TypicalPersons.ALICE).withAmount("0").build();
+        Person b = new PersonBuilder(TypicalPersons.BENSON).withAmount("0").build();
+        Person f = new PersonBuilder(TypicalPersons.FIONA).withAmount("0").build();
+        Person d = new PersonBuilder(TypicalPersons.DANIEL).withAmount("0").build();
+        expectedEvenSplit = new LedgerOperationBuilder()
+                .addPerson(a)
+                .addPerson(b)
+                .addPerson(f)
+                .addPerson(d)
+                .withDescription("description")
+                .withAmount("5")
+                .withDate("20102019")
+                .asSplit(1, 1, 1, 1, 1);
+    }
+
+    @Test
+    void parse_allFieldsPresent_success() {
+        assertParseSuccess(parser,
+                String.format(" $/5 d/20102019 n/%s n/%s n/%s n/%s s/1 s/1 s/1 s/1 s/1 a/description",
+                TypicalPersons.ALICE.getName().fullName,
+                TypicalPersons.BENSON.getName().fullName,
+                TypicalPersons.FIONA.getName().fullName,
+                TypicalPersons.DANIEL.getName().fullName),
+                new SplitCommand(expectedEvenSplit));
+    }
+
+    @Test
+    void parse_optionalFieldsMissing_success() {
+        assertParseSuccess(parser,
+                String.format(" $/5 d/20102019 n/%s n/%s n/%s n/%s a/description",
+                        TypicalPersons.ALICE.getName().fullName,
+                        TypicalPersons.BENSON.getName().fullName,
+                        TypicalPersons.FIONA.getName().fullName,
+                        TypicalPersons.DANIEL.getName().fullName),
+                new SplitCommand(expectedEvenSplit));
+
+        Split today = new LedgerOperationBuilder(expectedEvenSplit)
+                .withDate(Date.now().toString())
+                .asSplit(1, 1, 1, 1, 1);
+
+        assertParseSuccess(parser,
+                String.format(" $/5 n/%s n/%s n/%s n/%s a/description",
+                        TypicalPersons.ALICE.getName().fullName,
+                        TypicalPersons.BENSON.getName().fullName,
+                        TypicalPersons.FIONA.getName().fullName,
+                        TypicalPersons.DANIEL.getName().fullName),
+                new SplitCommand(today));
+    }
+
+    @Test
+    void parse_compulsoryFieldMissing_failure() {
+        String expectedMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, SplitCommand.MESSAGE_USAGE);
+
+        //no amount
+        assertParseFailure(parser,
+                String.format(" d/20102019 n/%s n/%s n/%s n/%s a/description",
+                        TypicalPersons.ALICE.getName().fullName,
+                        TypicalPersons.BENSON.getName().fullName,
+                        TypicalPersons.FIONA.getName().fullName,
+                        TypicalPersons.DANIEL.getName().fullName),
+                expectedMessage);
+
+        //no description
+        assertParseFailure(parser,
+                String.format(" $/5 d/20102019 n/%s n/%s n/%s n/%s ",
+                        TypicalPersons.ALICE.getName().fullName,
+                        TypicalPersons.BENSON.getName().fullName,
+                        TypicalPersons.FIONA.getName().fullName,
+                        TypicalPersons.DANIEL.getName().fullName),
+                expectedMessage);
+
+        //no names
+        assertParseFailure(parser, " $/5 d/20102019 a/description", expectedMessage);
+    }
+
+    @Test
+    void parse_invalidValues_failure() {
+        // invalid amount (zero)
+        assertParseFailure(parser, " " + INVALID_AMOUNT_ZERO_DESC + " d/20102019 a/description n/Name",
+                Messages.MESSAGE_AMOUNT_ZERO);
+
+        // invalid amount (range)
+        assertParseFailure(parser, " " + INVALID_AMOUNT_RANGE_DESC + " d/20102019 a/description n/Name",
+                MESSAGE_AMOUNT_OVERFLOW);
+
+        // invalid amount (double)
+        assertParseFailure(parser, " " + INVALID_AMOUNT_TYPE_DESC + " d/20102019 a/description n/Name",
+                Amount.DOUBLE_CONSTRAINTS);
+
+        // invalid amount (overflow)
+        assertParseFailure(parser, " " + INVALID_AMOUNT_OVERFLOW_DESC + " d/20102019 a/description n/Name",
+                MESSAGE_AMOUNT_OVERFLOW);
+
+        // invalid date (format)
+        assertParseFailure(parser, " " + AMOUNT_DESC_ALICE + INVALID_DATE_DESC + " a/description n/Name",
+                Date.MESSAGE_FORMAT_CONSTRAINTS);
+
+        //invalid date (type)
+        assertParseFailure(parser, " " + AMOUNT_DESC_ALICE + INVALID_DATETYPE_DESC + " a/description n/Name",
+                Date.MESSAGE_DATE_INVALID);
+
+        //invalid description
+        assertParseFailure(parser, " " + AMOUNT_DESC_ALICE + DATE_DESC_ALICE + " a/Milk@ n/Name",
+                Description.MESSAGE_CONSTRAINTS);
+
+        //invalid name
+        assertParseFailure(parser, " " + AMOUNT_DESC_ALICE + DATE_DESC_ALICE + " a/milk n/Name!!",
+                Name.MESSAGE_CONSTRAINTS);
+    }
+}

src/test/java/seedu/address/model/transaction/BudgetTest.java

@@ -16,15 +16,15 @@
 
 
 public class BudgetTest {
-    private static final Amount ONE = new Amount(100);
+    private static final Amount HUNDRED = new Amount(100);
 
     private static final String VALID_DATE = "31122025";
     private static final Set<Category> CATEGORIES = new HashSet<>();
     private static final String VALID_CATEGORIES = "food";
 
     private static final Budget BUDGET_ONE = new Budget();
-    private static final Budget BUDGET_TWO = new Budget(ONE, new Date(VALID_DATE));
-    private static final Budget BUDGET_THREE = new Budget(ONE, new Date(VALID_DATE), CATEGORIES);
+    private static final Budget BUDGET_TWO = new Budget(HUNDRED, new Date(VALID_DATE));
+    private static final Budget BUDGET_THREE = new Budget(HUNDRED, new Date(VALID_DATE), CATEGORIES);
 
 
     @Test
@@ -37,31 +37,31 @@ public void budgetConstructor_overBoundary_throwsException() {
 
     @Test
     public void getBudget_success() {
-        assertEquals(ONE, new Budget(ONE, new Date(VALID_DATE)).getBudget());
+        assertEquals(HUNDRED, new Budget(HUNDRED, new Date(VALID_DATE)).getBudget());
         assertEquals(new Amount(10000), new Budget(new Amount(10000), new Date(VALID_DATE)).getBudget());
     }
 
     @Test
     public void getBudget_fail() {
-        assertNotEquals(ONE, new Budget(new Amount(10000), new Date(VALID_DATE)).getBudget());
+        assertNotEquals(HUNDRED, new Budget(new Amount(10000), new Date(VALID_DATE)).getBudget());
     }
 
     @Test
     public void getInitialBudget_success() {
-        assertEquals(ONE, new Budget(ONE, new Date(VALID_DATE)).getInitialBudget());
+        assertEquals(HUNDRED, new Budget(HUNDRED, new Date(VALID_DATE)).getInitialBudget());
         assertEquals(new Amount(10000), new Budget(new Amount(10000), new Date(VALID_DATE)).getInitialBudget());
-        assertEquals(ONE, new Budget(ONE, ONE, new Date(VALID_DATE), CATEGORIES).getInitialBudget());
+        assertEquals(HUNDRED, new Budget(HUNDRED, HUNDRED, new Date(VALID_DATE), CATEGORIES).getInitialBudget());
     }
 
     @Test
     public void getInitialBudget_fail() {
-        assertNotEquals(ONE, new Budget(new Amount(10000), new Date(VALID_DATE)).getInitialBudget());
+        assertNotEquals(HUNDRED, new Budget(new Amount(10000), new Date(VALID_DATE)).getInitialBudget());
     }
 
 
     @Test
     public void getDeadline_success() {
-        assertEquals(new Date(VALID_DATE), new Budget(ONE, new Date(VALID_DATE)).getDeadline());
+        assertEquals(new Date(VALID_DATE), new Budget(HUNDRED, new Date(VALID_DATE)).getDeadline());
         assertEquals(new Date("31122020"), new Budget(new Amount(10000), new Date("31122020")).getDeadline());
     }
 
@@ -73,19 +73,19 @@ public void getDeadline_fail() {
     @Test
     public void getCategories_success() {
         CATEGORIES.add(new Category(VALID_CATEGORIES));
-        assertEquals(CATEGORIES, new Budget(ONE, new Date(VALID_DATE), CATEGORIES).getCategories());
+        assertEquals(CATEGORIES, new Budget(HUNDRED, new Date(VALID_DATE), CATEGORIES).getCategories());
     }
 
     @Test
     public void getCategories_fail() {
         CATEGORIES.add(new Category(VALID_CATEGORIES));
-        assertNotEquals(new HashSet<Category>(), new Budget(ONE, new Date(VALID_DATE), CATEGORIES).getCategories());
+        assertNotEquals(new HashSet<Category>(), new Budget(HUNDRED, new Date(VALID_DATE), CATEGORIES).getCategories());
     }
 
     @Test
     public void isValid_true() {
-        assertTrue(new Budget(ONE, new Date(VALID_DATE)).isValid());
-        assertTrue(new Budget(ONE, new Date(VALID_DATE), CATEGORIES).isValid());
+        assertTrue(new Budget(HUNDRED, new Date(VALID_DATE)).isValid());
+        assertTrue(new Budget(HUNDRED, new Date(VALID_DATE), CATEGORIES).isValid());
     }
 
     @Test