001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.net.pop3;
018
019 import junit.framework.TestCase;
020 import junit.framework.TestSuite;
021
022 import java.net.InetAddress;
023 import java.io.IOException;
024 import java.io.Reader;
025
026 /**
027 * @author <a href="mailto:commons-dev@apache.org">[Net]</a>
028 * @version $Id: POP3ClientCommandsTest.java 631313 2008-02-26 17:41:09Z niallp $
029 *
030 * The POP3* tests all presume the existence of the following parameters:
031 * mailserver: localhost (running on the default port 110)
032 * account: username=test; password=password
033 * account: username=alwaysempty; password=password.
034 * mail: At least four emails in the test account and zero emails
035 * in the alwaysempty account
036 *
037 * If this won't work for you, you can change these parameters in the
038 * TestSetupParameters class.
039 *
040 * The tests were originally run on a default installation of James.
041 * Your mileage may vary based on the POP3 server you run the tests against.
042 * Some servers are more standards-compliant than others.
043 */
044 public class POP3ClientCommandsTest extends TestCase
045 {
046 POP3Client p = null;
047
048 String user = TestSetupParameters.user;
049 String emptyUser = TestSetupParameters.emptyuser;
050 String password = TestSetupParameters.password;
051 String mailhost = TestSetupParameters.mailhost;
052
053 /**
054 *
055 */
056 public POP3ClientCommandsTest(String name)
057 {
058 super(name);
059 }
060
061 /**
062 * Method suite.
063 * @return TestSuite
064 */
065 public static TestSuite suite()
066 {
067 return (new TestSuite(POP3ClientCommandsTest.class));
068 }
069
070 private void reset() throws IOException
071 {
072 //Case where this is the first time reset is called
073 if (p == null)
074 {
075 //Do nothing
076 }
077 else if (p.isConnected())
078 {
079 p.disconnect();
080 }
081 p = null;
082 p = new POP3Client();
083 }
084
085 private void connect() throws Exception
086 {
087 p.connect(InetAddress.getByName(mailhost));
088 assertTrue(p.isConnected());
089 assertEquals(POP3.AUTHORIZATION_STATE, p.getState());
090 }
091
092 private void login() throws Exception
093 {
094 assertTrue(p.login(user, password));
095 assertEquals(POP3.TRANSACTION_STATE, p.getState());
096 }
097
098 /**
099 *
100 *
101 */
102 public void testNoopCommand() throws Exception
103 {
104 reset();
105 connect();
106
107 //Should fail before authorization
108 assertFalse(p.noop());
109
110 //Should pass in transaction state
111 login();
112 assertTrue(p.noop());
113
114 //Should fail in update state
115 p.setState(POP3.UPDATE_STATE);
116 assertFalse(p.noop());
117 }
118
119 /**
120 *
121 *
122 */
123 public void testStatus() throws Exception
124 {
125 reset();
126 connect();
127
128 //Should fail in authorization state
129 assertNull(p.status());
130
131 //Should pass on a mailbox with mail in it
132 login();
133 POP3MessageInfo msg = p.status();
134 assertTrue(msg.number > 0);
135 assertTrue(msg.size > 0);
136 assertNull(msg.identifier);
137 p.logout();
138
139 //Should also pass on a mailbox with no mail in it
140 reset();
141 connect();
142 assertTrue(p.login(emptyUser, password));
143 POP3MessageInfo msg2 = p.status();
144 assertTrue(msg2.number == 0);
145 assertTrue(msg2.size == 0);
146 assertNull(msg2.identifier);
147 p.logout();
148
149 //Should fail in the 'update' state
150 reset();
151 connect();
152 login();
153 p.setState(POP3.UPDATE_STATE);
154 assertNull(p.status());
155 }
156
157 /**
158 *
159 *
160 */
161 public void testListMessagesOnFullMailbox() throws Exception
162 {
163 reset();
164 connect();
165 login();
166
167 POP3MessageInfo[] msg = p.listMessages();
168 assertTrue(msg.length > 0);
169
170 for(int i = 0; i < msg.length; i++)
171 {
172 assertNotNull(msg[i]);
173 assertTrue(msg[i].number == i + 1);
174 assertTrue(msg[i].size > 0);
175 assertNull(msg[i].identifier);
176 }
177
178 //Now test from the update state
179 p.setState(POP3.UPDATE_STATE);
180 msg = p.listMessages();
181 assertNull(msg);
182 }
183
184 /**
185 *
186 *
187 */
188 public void testListMessageOnFullMailbox() throws Exception
189 {
190 reset();
191 connect();
192 login();
193
194 //The first message is always at index 1
195 POP3MessageInfo msg = p.listMessage(1);
196 assertNotNull(msg);
197 assertTrue(msg.number == 1);
198 assertTrue(msg.size > 0);
199 assertNull(msg.identifier);
200
201 //Now retrieve a message from index 0
202 msg = p.listMessage(0);
203 assertNull(msg);
204
205 //Now retrieve a msg that is not there
206 msg = p.listMessage(100000);
207 assertNull(msg);
208
209 //Now retrieve a msg with a negative index
210 msg = p.listMessage(-2);
211 assertNull(msg);
212
213 //Now try to get a valid message from the update state
214 p.setState(POP3.UPDATE_STATE);
215 msg = p.listMessage(1);
216 assertNull(msg);
217 }
218
219 /**
220 *
221 *
222 */
223 public void testListMessagesOnEmptyMailbox() throws Exception
224 {
225 reset();
226 connect();
227 assertTrue(p.login(emptyUser, password));
228
229 POP3MessageInfo[] msg = p.listMessages();
230 assertTrue(msg.length == 0);
231
232 //Now test from the update state
233 p.setState(POP3.UPDATE_STATE);
234 msg = p.listMessages();
235 assertNull(msg);
236 }
237
238 /**
239 *
240 *
241 */
242 public void testListMessageOnEmptyMailbox() throws Exception
243 {
244 reset();
245 connect();
246 assertTrue(p.login(emptyUser, password));
247
248 //The first message is always at index 1
249 POP3MessageInfo msg = p.listMessage(1);
250 assertNull(msg);
251 }
252
253 /**
254 *
255 *
256 */
257 public void testListUniqueIDsOnFullMailbox() throws Exception
258 {
259 reset();
260 connect();
261 login();
262
263 POP3MessageInfo[] msg = p.listUniqueIdentifiers();
264 assertTrue(msg.length > 0);
265
266 for(int i = 0; i < msg.length; i++)
267 {
268 assertNotNull(msg[i]);
269 assertTrue(msg[i].number == i + 1);
270 assertNotNull(msg[i].identifier);
271 }
272
273 //Now test from the update state
274 p.setState(POP3.UPDATE_STATE);
275 msg = p.listUniqueIdentifiers();
276 assertNull(msg);
277 }
278
279 /**
280 *
281 *
282 */
283 public void testListUniqueIDOnFullMailbox() throws Exception
284 {
285 reset();
286 connect();
287 login();
288
289 //The first message is always at index 1
290 POP3MessageInfo msg = p.listUniqueIdentifier(1);
291 assertNotNull(msg);
292 assertTrue(msg.number == 1);
293 assertNotNull(msg.identifier);
294
295 //Now retrieve a message from index 0
296 msg = p.listUniqueIdentifier(0);
297 assertNull(msg);
298
299 //Now retrieve a msg that is not there
300 msg = p.listUniqueIdentifier(100000);
301 assertNull(msg);
302
303 //Now retrieve a msg with a negative index
304 msg = p.listUniqueIdentifier(-2);
305 assertNull(msg);
306
307 //Now try to get a valid message from the update state
308 p.setState(POP3.UPDATE_STATE);
309 msg = p.listUniqueIdentifier(1);
310 assertNull(msg);
311 }
312
313 /**
314 *
315 *
316 */
317 public void testListUniqueIDsOnEmptyMailbox() throws Exception
318 {
319 reset();
320 connect();
321 assertTrue(p.login(emptyUser, password));
322
323 POP3MessageInfo[] msg = p.listUniqueIdentifiers();
324 assertTrue(msg.length == 0);
325
326 //Now test from the update state
327 p.setState(POP3.UPDATE_STATE);
328 msg = p.listUniqueIdentifiers();
329 assertNull(msg);
330 }
331
332 /**
333 *
334 *
335 */
336 public void testListUniqueIdentifierOnEmptyMailbox() throws Exception
337 {
338 reset();
339 connect();
340 assertTrue(p.login(emptyUser, password));
341
342 //The first message is always at index 1
343 POP3MessageInfo msg = p.listUniqueIdentifier(1);
344 assertNull(msg);
345 }
346
347 /**
348 *
349 *
350 */
351 public void testRetrieveMessageOnFullMailbox() throws Exception
352 {
353 reset();
354 connect();
355 login();
356 int reportedSize = 0;
357 int actualSize = 0;
358
359 POP3MessageInfo[] msg = p.listMessages();
360 assertTrue(msg.length > 0);
361
362 for (int i = msg.length; i > 0; i--)
363 {
364 reportedSize = msg[i - 1].size;
365 Reader r = p.retrieveMessage(i);
366 assertNotNull(r);
367
368 int delaycount = 0;
369 if (!r.ready())
370 {
371 //Give the reader time to get the message
372 //from the server
373 Thread.sleep(500);
374 delaycount++;
375 //but don't wait too long
376 if (delaycount == 4)
377 {
378 break;
379 }
380 }
381 while(r.ready())
382 {
383 r.read();
384 actualSize++;
385 }
386 //Due to variations in line termination
387 //on different platforms, the actual
388 //size may vary slightly. On Win2KPro, the
389 //actual size is 2 bytes larger than the reported
390 //size.
391 assertTrue(actualSize >= reportedSize);
392 }
393 }
394
395 /**
396 *
397 *
398 */
399 public void testRetrieveMessageOnEmptyMailbox() throws Exception
400 {
401 reset();
402 connect();
403 assertTrue(p.login(emptyUser, password));
404 assertNull(p.retrieveMessage(1));
405 }
406
407 /**
408 *
409 *
410 */
411 public void testRetrieveMessageShouldFails() throws Exception
412 {
413 reset();
414 connect();
415 login();
416
417 //Try to get message 0
418 assertNull(p.retrieveMessage(0));
419
420 //Try to get a negative message
421 assertNull(p.retrieveMessage(-2));
422
423 //Try to get a message that is not there
424 assertNull(p.retrieveMessage(100000));
425
426 //Change states and try to get a valid message
427 p.setState(POP3.UPDATE_STATE);
428 assertNull(p.retrieveMessage(1));
429 }
430
431 /**
432 *
433 *
434 */
435 public void testRetrieveMessageTopOnFullMailbox() throws Exception
436 {
437 reset();
438 connect();
439 login();
440 int numLines = 10;
441
442 POP3MessageInfo[] msg = p.listMessages();
443 assertTrue(msg.length > 0);
444
445 for (int i = 0; i < msg.length; i++)
446 {
447 Reader r = p.retrieveMessageTop(i + 1, numLines);
448 assertNotNull(r);
449 r.close();
450 r = null;
451 }
452 }
453
454 /**
455 *
456 *
457 */
458 public void testRetrieveOverSizedMessageTopOnFullMailbox() throws Exception
459 {
460 reset();
461 connect();
462 login();
463 int reportedSize = 0;
464 int actualSize = 0;
465
466 POP3MessageInfo msg = p.listMessage(1);
467 reportedSize = msg.size;
468
469 //Now try to retrieve more lines than exist in the message
470 Reader r = p.retrieveMessageTop(1, 100000);
471 assertNotNull(r);
472
473 int delaycount = 0;
474 while(!r.ready())
475 {
476 //Give the reader time to get the message
477 //from the server
478 Thread.sleep(500);
479 delaycount++;
480 //but don't wait too long
481 if (delaycount == 4)
482 {
483 break;
484 }
485 }
486 while(r.ready())
487 {
488 r.read();
489 actualSize++;
490 }
491 //Due to variations in line termination
492 //on different platforms, the actual
493 //size may vary slightly. On Win2KPro, the
494 //actual size is 2 bytes larger than the reported
495 //size.
496 assertTrue(actualSize >= reportedSize);
497 }
498
499 /**
500 *
501 *
502 */
503 public void testRetrieveMessageTopOnEmptyMailbox() throws Exception
504 {
505 reset();
506 connect();
507 assertTrue(p.login(emptyUser, password));
508 assertNull(p.retrieveMessageTop(1, 10));
509 }
510
511 /**
512 *
513 *
514 */
515 public void testRetrieveMessageTopShouldFails() throws Exception
516 {
517 reset();
518 connect();
519 login();
520
521 //Try to get message 0
522 assertNull(p.retrieveMessageTop(0, 10));
523
524 //Try to get a negative message
525 assertNull(p.retrieveMessageTop(-2, 10));
526
527 //Try to get a message that is not there
528 assertNull(p.retrieveMessageTop(100000, 10));
529
530 //Change states and try to get a valid message
531 p.setState(POP3.UPDATE_STATE);
532 assertNull(p.retrieveMessageTop(1, 10));
533 }
534
535 public void testDeleteWithReset() throws Exception
536 {
537 reset();
538 connect();
539 login();
540 //Get the original number of messages
541 POP3MessageInfo[] msg = p.listMessages();
542 int numMessages = msg.length;
543 int numDeleted = 0;
544
545 //Now delete some and logout
546 for (int i = 0; i < numMessages - 1; i ++)
547 {
548 p.deleteMessage(i + 1);
549 numDeleted++;
550 }
551 //Check to see that they are marked as deleted
552 assertEquals(numMessages, (numDeleted + 1));
553
554 //Now reset to unmark the messages as deleted
555 p.reset();
556
557 //Logout and come back in
558 p.logout();
559 reset();
560 connect();
561 login();
562
563 //Get the new number of messages, because of
564 //reset, new number should match old number
565 msg = p.listMessages();
566 assertEquals(numMessages, msg.length);
567 }
568
569 public void testDelete() throws Exception
570 {
571 reset();
572 connect();
573 login();
574 //Get the original number of messages
575 POP3MessageInfo[] msg = p.listMessages();
576 int numMessages = msg.length;
577 int numDeleted = 0;
578
579 //Now delete some and logout
580 for (int i = 0; i < numMessages - 3; i ++)
581 {
582 p.deleteMessage(i + 1);
583 numDeleted++;
584 }
585 //Check to see that they are marked as deleted
586 assertEquals(numMessages, (numDeleted + 3));
587
588 //Logout and come back in
589 p.logout();
590 reset();
591 connect();
592 login();
593
594 //Get the new number of messages, because of
595 //reset, new number should match old number
596 msg = p.listMessages();
597 assertEquals(numMessages - numDeleted, msg.length);
598 }
599
600 public void testResetAndDeleteShouldFails() throws Exception
601 {
602 reset();
603 connect();
604 login();
605
606 p.setState(POP3.UPDATE_STATE);
607 assertFalse(p.reset());
608
609 assertFalse(p.deleteMessage(1));
610 }
611 }