xref: /packages/apps/Email/tests/src/com/android/email/mail/store/imap/ImapResponseParserTest.java

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.email.mail.store.imap;

import static com.android.email.mail.store.imap.ImapTestUtils.assertElement;
import static com.android.email.mail.store.imap.ImapTestUtils.buildList;
import static com.android.email.mail.store.imap.ImapTestUtils.buildResponse;
import static com.android.email.mail.store.imap.ImapTestUtils.createFixedLengthInputStream;

import com.android.email.mail.store.imap.ImapResponseParser.ByeException;
import com.android.email.mail.transport.DiscourseLogger;
import com.android.emailcommon.TempDirectory;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.utility.Utility;

import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;

import java.io.ByteArrayInputStream;
import java.io.IOException;

@SmallTest
public class ImapResponseParserTest extends AndroidTestCase {
    private static ImapResponseParser generateParser(int literalKeepInMemoryThreshold,
            String responses) {
        return new ImapResponseParser(new ByteArrayInputStream(Utility.toAscii(responses)),
                new DiscourseLogger(4), literalKeepInMemoryThreshold);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        TempDirectory.setTempDirectory(getContext());
    }

    public void testExpect() throws Exception {
        final ImapResponseParser p = generateParser(100000, "abc");
        p.expect('a');
        p.expect('b');
        try {
            p.expect('C');
            fail();
        } catch (IOException e) {
            // OK
        }
    }

    public void testreadUntil() throws Exception {
        final ImapResponseParser p = generateParser(100000, "!ab!c!!def!");
        assertEquals("", p.readUntil('!'));
        assertEquals("ab", p.readUntil('!'));
        assertEquals("c", p.readUntil('!'));
        assertEquals("", p.readUntil('!'));
        assertEquals("def", p.readUntil('!'));
    }

    public void testBasic() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* STATUS \"INBOX\" (UNSEEN 2)\r\n" +
                "100 OK STATUS completed\r\n" +
                "+ continuation request+(\r\n" +
                "* STATUS {5}\r\n" +
                "IN%OX (UNSEEN 10) \"a b c\"\r\n" +
                "101 OK STATUS completed %!(\r\n" +
                "102 OK 1\r\n" +
                "* 1 FETCH\r\n" +
                "103 OK\r\n" + // shortest OK
                "* a\r\n" // shortest response
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("STATUS"),
                new ImapSimpleString("INBOX"),
                buildList(
                        new ImapSimpleString("UNSEEN"),
                        new ImapSimpleString("2")
                        )
                ), r);

        r = p.readResponse();
        assertElement(buildResponse("100", false,
                new ImapSimpleString("OK"),
                new ImapSimpleString("STATUS completed") // one string
                ), r);

        r = p.readResponse();
        assertElement(buildResponse(null, true,
                new ImapSimpleString("continuation request+(") // one string
                ), r);

        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("STATUS"),
                new ImapMemoryLiteral(createFixedLengthInputStream("IN%OX")),
                buildList(
                        new ImapSimpleString("UNSEEN"),
                        new ImapSimpleString("10")
                        ),
                new ImapSimpleString("a b c")
                ), r);

        r = p.readResponse();
        assertElement(buildResponse("101", false,
                new ImapSimpleString("OK"),
                new ImapSimpleString("STATUS completed %!(") // one string
                ), r);

        r = p.readResponse();
        assertElement(buildResponse("102", false,
                new ImapSimpleString("OK"),
                new ImapSimpleString("1")
                ), r);

        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("1"),
                new ImapSimpleString("FETCH")
                ), r);

        r = p.readResponse();
        assertElement(buildResponse("103", false,
                new ImapSimpleString("OK")
                ), r);

        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("a")
                ), r);
    }

    public void testNil() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* nil nil NIL \"NIL\" {3}\r\n" +
                "NIL\r\n"
                );

        r = p.readResponse();
        assertElement(buildResponse(null, false,
                ImapString.EMPTY,
                ImapString.EMPTY,
                ImapString.EMPTY,
                new ImapSimpleString("NIL"),
                new ImapMemoryLiteral(createFixedLengthInputStream("NIL"))
                ), r);
    }

    public void testBareLf() throws Exception {
        ImapResponse r;

        // Threshold = 3 bytes: use in memory literal.
        ImapResponseParser p = generateParser(3,
                "* a b\n" + // Bare LF -- should be treated like CRLF
                "* x y\r\n"
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("a"),
                new ImapSimpleString("b")
                ), r);

        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("x"),
                new ImapSimpleString("y")
                ), r);
    }

    public void testLiteral() throws Exception {
        ImapResponse r;

        // Threshold = 3 bytes: use in memory literal.
        ImapResponseParser p = generateParser(3,
                "* test {3}\r\n" +
                "ABC\r\n"
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("test"),
                new ImapMemoryLiteral(createFixedLengthInputStream("ABC"))
                ), r);

        // Threshold = 2 bytes: use temp file literal.
        p = generateParser(2,
                "* test {3}\r\n" +
                "ABC\r\n"
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("test"),
                new ImapTempFileLiteral(createFixedLengthInputStream("ABC"))
                ), r);

        // 2 literals in a line
        p = generateParser(0,
                "* test {3}\r\n" +
                "ABC {4}\r\n" +
                "wxyz\r\n"
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("test"),
                new ImapTempFileLiteral(createFixedLengthInputStream("ABC")),
                new ImapTempFileLiteral(createFixedLengthInputStream("wxyz"))
                ), r);
    }

    public void testAlert() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* OK [ALERT]\r\n" + // No message
                "* OK [ALERT] alert ( message ) %*\r\n" +
                "* OK [ABC] not alert\r\n"
                );
        r = p.readResponse();
        assertTrue(r.isOk());
        assertTrue(r.getAlertTextOrEmpty().isEmpty());

        r = p.readResponse();
        assertTrue(r.isOk());
        assertEquals("alert ( message ) %*", r.getAlertTextOrEmpty().getString());

        r = p.readResponse();
        assertTrue(r.isOk());
        assertTrue(r.getAlertTextOrEmpty().isEmpty());
    }

    /**
     * If a [ appears in the middle of a string, the following string until the next ']' will
     * be considered a part of the string.
     */
    public void testBracket() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* AAA BODY[HEADER.FIELDS (\"DATE\" \"SUBJECT\")]\r\n" +
                "* BBB B[a b c]d e f\r\n"
                );
        r = p.readResponse();
        assertEquals("BODY[HEADER.FIELDS (\"DATE\" \"SUBJECT\")]",
                r.getStringOrEmpty(1).getString());

        r = p.readResponse();
        assertEquals("B[a b c]d", r.getStringOrEmpty(1).getString());
    }

    public void testNest() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* A (a B () DEF) (a (ab)) ((() ())) ((a) ab) ((x y ZZ) () [] [A B] (A B C))" +
                " ([abc] a[abc])\r\n"
                );
        r = p.readResponse();
        assertElement(buildResponse(null, false,
                new ImapSimpleString("A"),
                buildList(
                        new ImapSimpleString("a"),
                        new ImapSimpleString("B"),
                        buildList(),
                        new ImapSimpleString("DEF")
                        ),
                buildList(
                        new ImapSimpleString("a"),
                        buildList(
                                new ImapSimpleString("ab")
                                )
                        ),
                buildList(
                        buildList(
                                buildList(),
                                buildList()
                                )
                        ),
                buildList(
                        buildList(
                                new ImapSimpleString("a")
                                ),
                        new ImapSimpleString("ab")
                        ),
                buildList(
                        buildList(
                                new ImapSimpleString("x"),
                                new ImapSimpleString("y"),
                                new ImapSimpleString("ZZ")
                                ),
                        buildList(),
                        buildList(),
                        buildList(
                                new ImapSimpleString("A"),
                                new ImapSimpleString("B")
                                ),
                        buildList(
                                new ImapSimpleString("A"),
                                new ImapSimpleString("B"),
                                new ImapSimpleString("C")
                                )
                        ),
                buildList(
                        buildList(
                                new ImapSimpleString("abc")
                                ),
                        new ImapSimpleString("a[abc]")
                        )
                ), r);
    }

    /**
     * Parser shouldn't crash for any response.  Should just throw IO/MessagingException.
     */
    public void testMalformedResponse() throws Exception {
        expectMessagingException("");
        expectMessagingException("\r");
        expectMessagingException("\r\n");

        expectMessagingException("*\r\n");
        expectMessagingException("1\r\n");

        expectMessagingException("* \r\n");
        expectMessagingException("1 \r\n");

        expectMessagingException("* A (\r\n");
        expectMessagingException("* A )\r\n");
        expectMessagingException("* A (()\r\n");
        expectMessagingException("* A ())\r\n");
        expectMessagingException("* A [\r\n");
        expectMessagingException("* A ]\r\n");
        expectMessagingException("* A [[]\r\n");
        expectMessagingException("* A []]\r\n");

        expectMessagingException("* A ([)]\r\n");

        expectMessagingException("* A");
        expectMessagingException("* {3}");
        expectMessagingException("* {3}\r\nab");
    }

    private static void expectMessagingException(String response) throws Exception {
        final ImapResponseParser p = generateParser(100000, response);
        try {
            p.readResponse();
            fail("Didn't throw Exception: response='" + response + "'");
        } catch (MessagingException ok) {
            return;
        } catch (IOException ok) {
            return;
        }
    }

    // Compatibility tests...

    /**
     * OK response with a long message that contains special chars. (including tabs)
     */
    public void testOkWithLongMessage() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* OK [CAPABILITY IMAP4 IMAP4rev1 LITERAL+ ID STARTTLS AUTH=PLAIN AUTH=LOGIN" +
                "AUTH=CRAM-MD5] server.domain.tld\tCyrus IMAP4 v2.3.8-OS X Server 10.5:"
                +"  \t\t\t9F33 server ready %%\r\n");
        assertTrue(p.readResponse().isOk());
    }

    /** Make sure literals and strings are interchangeable. */
    public void testLiteralStringConversion() throws Exception {
        ImapResponse r;
        final ImapResponseParser p = generateParser(100000,
                "* XXX {5}\r\n" +
                "a b c\r\n");
        assertEquals("a b c", p.readResponse().getStringOrEmpty(1).getString());
    }

    public void testByeReceived() throws Exception {
        final ImapResponseParser p = generateParser(100000,
                "* BYE Autologout timer; idle for too long\r\n");
        try {
            p.readResponse();
            fail("Didn't throw ByeException");
        } catch (ByeException ok) {
        }
    }
}