forked from nusCS2113-AY1819S1/addressbook-level3
-
Notifications
You must be signed in to change notification settings - Fork 5
/
ParserTest.java
300 lines (258 loc) · 11.2 KB
/
ParserTest.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
package seedu.addressbook.parser;
import org.junit.Before;
import org.junit.Test;
import seedu.addressbook.commands.*;
import seedu.addressbook.data.exception.IllegalValueException;
import seedu.addressbook.data.tag.Tag;
import seedu.addressbook.data.person.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import static org.junit.Assert.*;
import static seedu.addressbook.common.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
public class ParserTest {
private Parser parser;
@Before
public void setup() {
parser = new Parser();
}
@Test
public void emptyInput_returnsIncorrect() {
final String[] emptyInputs = { "", " ", "\n \n" };
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, emptyInputs);
}
@Test
public void unknownCommandWord_returnsHelp() {
final String input = "unknowncommandword arguments arguments";
parseAndAssertCommandType(input, HelpCommand.class);
}
/**
* Test 0-argument commands
*/
@Test
public void helpCommand_parsedCorrectly() {
final String input = "help";
parseAndAssertCommandType(input, HelpCommand.class);
}
@Test
public void clearCommand_parsedCorrectly() {
final String input = "clear";
parseAndAssertCommandType(input, ClearCommand.class);
}
@Test
public void listCommand_parsedCorrectly() {
final String input = "list";
parseAndAssertCommandType(input, ListCommand.class);
}
@Test
public void exitCommand_parsedCorrectly() {
final String input = "exit";
parseAndAssertCommandType(input, ExitCommand.class);
}
/**
* Test ingle index argument commands
*/
@Test
public void deleteCommand_noArgs() {
final String[] inputs = { "delete", "delete " };
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
// @Test
// public void deleteCommand_argsIsNotSingleNumber() {
// final String[] inputs = { "delete notAnumber ", "delete 8*wh12", "delete 1 2 3 4 5" };
// final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, DeleteCommand.MESSAGE_USAGE);
// parseAndAssertIncorrectWithMessage(resultMessage, inputs);
// }
@Test
public void deleteCommand_numericArg_indexParsedCorrectly() {
final int testIndex = 1;
final String input = "delete " + testIndex;
final DeleteCommand result = parseAndAssertCommandType(input, DeleteCommand.class);
assertEquals(result.getTargetIndex(), testIndex);
}
@Test
public void viewCommand_noArgs() {
final String[] inputs = { "view", "view " };
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, ViewCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void viewCommand_argsIsNotSingleNumber() {
final String[] inputs = { "view notAnumber ", "view 8*wh12", "view 1 2 3 4 5" };
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, ViewCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void viewCommand_numericArg_indexParsedCorrectly() {
final int testIndex = 2;
final String input = "view " + testIndex;
final ViewCommand result = parseAndAssertCommandType(input, ViewCommand.class);
assertEquals(result.getTargetIndex(), testIndex);
}
@Test
public void viewAllCommand_noArgs() {
final String[] inputs = { "viewall", "viewall " };
final String resultMessage =
String.format(MESSAGE_INVALID_COMMAND_FORMAT, ViewAllCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void viewAllCommand_argsIsNotSingleNumber() {
final String[] inputs = { "viewall notAnumber ", "viewall 8*wh12", "viewall 1 2 3 4 5" };
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, ViewAllCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void viewAllCommand_numericArg_indexParsedCorrectly() {
final int testIndex = 3;
final String input = "viewall " + testIndex;
final ViewAllCommand result = parseAndAssertCommandType(input, ViewAllCommand.class);
assertEquals(result.getTargetIndex(), testIndex);
}
/**
* Test find persons by keyword in name command
*/
@Test
public void findCommand_invalidArgs() {
// no keywords
final String[] inputs = {
"find",
"find "
};
final String resultMessage =
String.format(MESSAGE_INVALID_COMMAND_FORMAT, FindCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void findCommand_validArgs_parsedCorrectly() {
final String[] keywords = { "key1", "key2", "key3" };
final Set<String> keySet = new HashSet<>(Arrays.asList(keywords));
final String input = "find " + String.join(" ", keySet);
final FindCommand result =
parseAndAssertCommandType(input, FindCommand.class);
assertEquals(keySet, result.getKeywords());
}
@Test
public void findCommand_duplicateKeys_parsedCorrectly() {
final String[] keywords = { "key1", "key2", "key3" };
final Set<String> keySet = new HashSet<>(Arrays.asList(keywords));
// duplicate every keyword
final String input = "find " + String.join(" ", keySet) + " " + String.join(" ", keySet);
final FindCommand result =
parseAndAssertCommandType(input, FindCommand.class);
assertEquals(keySet, result.getKeywords());
}
/**
* Test add person command
*/
@Test
public void addCommand_invalidArgs() {
final String[] inputs = {
"add",
"add ",
"add wrong args format",
// no phone prefix
String.format("add $s $s e/$s a/$s", Name.EXAMPLE, Phone.EXAMPLE, Email.EXAMPLE, Address.EXAMPLE),
// no email prefix
String.format("add $s p/$s $s a/$s", Name.EXAMPLE, Phone.EXAMPLE, Email.EXAMPLE, Address.EXAMPLE),
// no address prefix
String.format("add $s p/$s e/$s $s", Name.EXAMPLE, Phone.EXAMPLE, Email.EXAMPLE, Address.EXAMPLE)
};
final String resultMessage = String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddCommand.MESSAGE_USAGE);
parseAndAssertIncorrectWithMessage(resultMessage, inputs);
}
@Test
public void addCommand_invalidPersonDataInArgs() {
final String invalidName = "[]\\[;]";
final String validName = Name.EXAMPLE;
final String invalidPhoneArg = "p/not__numbers";
final String validPhoneArg = "p/" + Phone.EXAMPLE;
final String invalidEmailArg = "e/notAnEmail123";
final String validEmailArg = "e/" + Email.EXAMPLE;
final String invalidTagArg = "t/invalid_-[.tag";
// address can be any string, so no invalid address
final String addCommandFormatString = "add $s $s $s a/" + Address.EXAMPLE;
// test each incorrect person data field argument individually
final String[] inputs = {
// invalid name
String.format(addCommandFormatString, invalidName, validPhoneArg, validEmailArg),
// invalid phone
String.format(addCommandFormatString, validName, invalidPhoneArg, validEmailArg),
// invalid email
String.format(addCommandFormatString, validName, validPhoneArg, invalidEmailArg),
// invalid tag
String.format(addCommandFormatString, validName, validPhoneArg, validEmailArg) + " " + invalidTagArg
};
for (String input : inputs) {
parseAndAssertCommandType(input, IncorrectCommand.class);
}
}
@Test
public void addCommand_validPersonData_parsedCorrectly() {
final Person testPerson = generateTestPerson();
final String input = convertPersonToAddCommandString(testPerson);
final AddCommand result = parseAndAssertCommandType(input, AddCommand.class);
assertEquals(result.getPerson(), testPerson);
}
@Test
public void addCommand_duplicateTags_merged() throws IllegalValueException {
final Person testPerson = generateTestPerson();
String input = convertPersonToAddCommandString(testPerson);
for (Tag tag : testPerson.getTags()) {
// create duplicates by doubling each tag
input += " t/" + tag.tagName;
}
final AddCommand result = parseAndAssertCommandType(input, AddCommand.class);
assertEquals(result.getPerson(), testPerson);
}
private static Person generateTestPerson() {
try {
return new Person(
new Name(Name.EXAMPLE),
new Phone(Phone.EXAMPLE, true),
new Email(Email.EXAMPLE, false),
new Address(Address.EXAMPLE, true),
new HashSet<>(Arrays.asList(new Tag("tag1"), new Tag("tag2"), new Tag("tag3")))
);
} catch (IllegalValueException ive) {
throw new RuntimeException("test person data should be valid by definition");
}
}
private static String convertPersonToAddCommandString(ReadOnlyPerson person) {
String addCommand = "add "
+ person.getName().fullName
+ (person.getPhone().isPrivate() ? " pp/" : " p/") + person.getPhone().value
+ (person.getEmail().isPrivate() ? " pe/" : " e/") + person.getEmail().value
+ (person.getAddress().isPrivate() ? " pa/" : " a/") + person.getAddress().value;
for (Tag tag : person.getTags()) {
addCommand += " t/" + tag.tagName;
}
return addCommand;
}
/**
* Utility methods
*/
/**
* Asserts that parsing the given inputs will return IncorrectCommand with the given feedback message.
*/
private void parseAndAssertIncorrectWithMessage(String feedbackMessage, String... inputs) {
for (String input : inputs) {
final IncorrectCommand result = parseAndAssertCommandType(input, IncorrectCommand.class);
assertEquals(result.feedbackToUser, feedbackMessage);
}
}
/**
* Utility method for parsing input and asserting the class/type of the returned command object.
*
* @param input to be parsed
* @param expectedCommandClass expected class of returned command
* @return the parsed command object
*/
private <T extends Command> T parseAndAssertCommandType(String input, Class<T> expectedCommandClass) {
final Command result = parser.parseCommand(input);
assertTrue(result.getClass().isAssignableFrom(expectedCommandClass));
return (T) result;
}
}