Merge pull request #7279 from adamszewe/refactor-mailto-class-to-kotlin

package com.fsck.k9.helper;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import android.net.Uri;

import app.k9mail.core.android.testing.RobolectricTest;

import com.fsck.k9.helper.MailTo.CaseInsensitiveParamWrapper;

import com.fsck.k9.mail.Address;

import org.junit.Rule;

import org.junit.Test;

import org.junit.rules.ExpectedException;

import static junit.framework.Assert.assertEquals;

import static junit.framework.Assert.assertFalse;

import static junit.framework.Assert.assertTrue;

import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;

public class MailToTest extends RobolectricTest {

    @Rule

    public ExpectedException exception = ExpectedException.none();

    @Test

    public void testIsMailTo_validMailToURI() {

        Uri uri = Uri.parse("mailto:nobody");

        boolean result = MailTo.isMailTo(uri);

        assertTrue(result);

    }

    @Test

    public void testIsMailTo_invalidMailToUri() {

        Uri uri = Uri.parse("http://example.org/");

        boolean result = MailTo.isMailTo(uri);

        assertFalse(result);

    }

    @SuppressWarnings("ConstantConditions")

    @Test

    public void testIsMailTo_nullArgument() {

        Uri uri = null;

        boolean result = MailTo.isMailTo(uri);

        assertFalse(result);

    }

    @Test

    public void parse_withNullArgument_shouldThrow() throws Exception {

        exception.expect(NullPointerException.class);

        exception.expectMessage("Argument 'uri' must not be null");

        MailTo.parse(null);

    }

    @Test

    public void parse_withoutMailtoUri_shouldThrow() throws Exception {

        exception.expect(IllegalArgumentException.class);

        exception.expectMessage("Not a mailto scheme");

        Uri uri = Uri.parse("http://example.org/");

        MailTo.parse(uri);

    }

    @Test

    public void testGetTo_singleEmailAddress() {

        Uri uri = Uri.parse("mailto:test@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getTo();

        assertEquals(emailAddressList[0].getAddress(), "test@abc.com");

    }

    @Test

    public void testGetTo_multipleEmailAddress() {

        Uri uri = Uri.parse("mailto:test1@abc.com?to=test2@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getTo();

        assertEquals(emailAddressList[0].getAddress(), "test1@abc.com");

        assertEquals(emailAddressList[1].getAddress(), "test2@abc.com");

    }

    @Test

    public void testGetCc_singleEmailAddress() {

        Uri uri = Uri.parse("mailto:test1@abc.com?cc=test3@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getCc();

        assertEquals(emailAddressList[0].getAddress(), "test3@abc.com");

    }

    @Test

    public void testGetCc_multipleEmailAddress() {

        Uri uri = Uri.parse("mailto:test1@abc.com?cc=test3@abc.com,test4@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getCc();

        assertEquals(emailAddressList[0].getAddress(), "test3@abc.com");

        assertEquals(emailAddressList[1].getAddress(), "test4@abc.com");

    }

    @Test

    public void testGetBcc_singleEmailAddress() {

        Uri uri = Uri.parse("mailto:?bcc=test3@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getBcc();

        assertEquals(emailAddressList[0].getAddress(), "test3@abc.com");

    }

    @Test

    public void testGetBcc_multipleEmailAddress() {

        Uri uri = Uri.parse("mailto:?bcc=test3@abc.com&bcc=test4@abc.com");

        MailTo mailToHelper = MailTo.parse(uri);

        Address[] emailAddressList = mailToHelper.getBcc();

        assertEquals(emailAddressList[0].getAddress(), "test3@abc.com");

        assertEquals(emailAddressList[1].getAddress(), "test4@abc.com");

    }

    @Test

    public void testGetSubject() {

        Uri uri = Uri.parse("mailto:?subject=Hello");

        MailTo mailToHelper = MailTo.parse(uri);

        String subject = mailToHelper.getSubject();

        assertEquals(subject, "Hello");

    }

    @Test

    public void testGetBody() {

        Uri uri = Uri.parse("mailto:?body=Test%20Body&something=else");

        MailTo mailToHelper = MailTo.parse(uri);

        String subject = mailToHelper.getBody();

        assertEquals(subject, "Test Body");

    }

    @Test

    public void testCaseInsensitiveParamWrapper() {

        Uri uri = Uri.parse("scheme://authority?a=one&b=two&c=three");

        CaseInsensitiveParamWrapper caseInsensitiveParamWrapper = new CaseInsensitiveParamWrapper(uri);

        List<String> result = caseInsensitiveParamWrapper.getQueryParameters("b");

        assertThat(Collections.singletonList("two"), is(result));

    }

    @Test

    public void testCaseInsensitiveParamWrapper_multipleMatchingQueryParameters() {

        Uri uri = Uri.parse("scheme://authority?xname=one&name=two&Name=Three&NAME=FOUR");

        CaseInsensitiveParamWrapper caseInsensitiveParamWrapper = new CaseInsensitiveParamWrapper(uri);

        List<String> result = caseInsensitiveParamWrapper.getQueryParameters("name");

        assertThat(Arrays.asList("two", "Three", "FOUR"), is(result));

    }

    @Test

    public void testCaseInsensitiveParamWrapper_withoutQueryParameters() {

        Uri uri = Uri.parse("scheme://authority");

        CaseInsensitiveParamWrapper caseInsensitiveParamWrapper = new CaseInsensitiveParamWrapper(uri);

        List<String> result = caseInsensitiveParamWrapper.getQueryParameters("name");

        assertThat(Collections.<String>emptyList(), is(result));

    }

    @Test

    public void testGetInReplyTo_singleMessageId() {

        Uri uri = Uri.parse("mailto:?in-reply-to=%3C7C72B202-73F3@somewhere%3E");

        MailTo mailToHelper = MailTo.parse(uri);

        assertEquals("<7C72B202-73F3@somewhere>", mailToHelper.getInReplyTo());

    }

    @Test

    public void testGetInReplyTo_multipleMessageIds() {

        Uri uri = Uri.parse("mailto:?in-reply-to=%3C7C72B202-73F3@somewhere%3E%3C8A39-1A87CB40C114@somewhereelse%3E");

        MailTo mailToHelper = MailTo.parse(uri);

        assertEquals("<7C72B202-73F3@somewhere>", mailToHelper.getInReplyTo());

    }

    @Test

    public void testGetInReplyTo_RFC6068Example() {

        Uri uri = Uri.parse("mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E");

        MailTo mailToHelper = MailTo.parse(uri);

        assertEquals("<3469A91.D10AF4C@example.com>", mailToHelper.getInReplyTo());

    }

    @Test

    public void testGetInReplyTo_invalid() {

        Uri uri = Uri.parse("mailto:?in-reply-to=7C72B202-73F3somewhere");

        MailTo mailToHelper = MailTo.parse(uri);

        assertEquals(null, mailToHelper.getInReplyTo());

    }

    @Test

    public void testGetInReplyTo_empty() {

        Uri uri = Uri.parse("mailto:?in-reply-to=");

        MailTo mailToHelper = MailTo.parse(uri);

        assertEquals(null, mailToHelper.getInReplyTo());

    }

}

package com.fsck.k9.helper

import android.net.Uri

import androidx.core.net.toUri

import app.k9mail.core.android.testing.RobolectricTest

import assertk.assertFailure

import assertk.assertThat

import assertk.assertions.containsExactly

import assertk.assertions.hasMessage

import assertk.assertions.isEqualTo

import assertk.assertions.isFalse

import assertk.assertions.isInstanceOf

import assertk.assertions.isNull

import assertk.assertions.isTrue

import com.fsck.k9.mail.Address

import org.junit.Test

class MailToTest : RobolectricTest() {

    @Test

    fun `isMailTo() with mailto scheme should return true`() {

        val uri = "mailto:nobody".toUri()

        val result = MailTo.isMailTo(uri)

        assertThat(result).isTrue()

    }

    @Test

    fun `isMailTo() with http scheme should return false`() {

        val uri = "http://example.org/".toUri()

        val result = MailTo.isMailTo(uri)

        assertThat(result).isFalse()

    }

    @Test

    fun `isMailTo() with null argument should return false`() {

        val uri: Uri? = null

        val result = MailTo.isMailTo(uri)

        assertThat(result).isFalse()

    }

    @Test

    fun `parse() with null argument should throw`() {

        assertFailure {

            MailTo.parse(null)

        }.isInstanceOf<NullPointerException>()

            .hasMessage("Argument 'uri' must not be null")

    }

    @Test

    fun `parse() without mailto URI should throw`() {

        val uri = "http://example.org/".toUri()

        assertFailure {

            MailTo.parse(uri)

        }.isInstanceOf<IllegalArgumentException>()

            .hasMessage("Not a mailto scheme")

    }

    @Test

    fun `single To recipient`() {

        val uri = "mailto:test@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.to).containsExactly("test@domain.example".toAddress())

    }

    @Test

    fun `multiple To recipients`() {

        val uri = "mailto:test1@domain.example?to=test2@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.to).containsExactly(

            "test1@domain.example".toAddress(),

            "test2@domain.example".toAddress(),

        )

    }

    @Test

    fun `single Cc recipient`() {

        val uri = "mailto:test1@domain.example?cc=test3@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.cc).containsExactly("test3@domain.example".toAddress())

    }

    @Test

    fun `multiple Cc recipients`() {

        val uri = "mailto:test1@domain.example?cc=test3@domain.example,test4@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.cc).containsExactly(

            "test3@domain.example".toAddress(),

            "test4@domain.example".toAddress(),

        )

    }

    @Test

    fun `single Bcc recipient`() {

        val uri = "mailto:?bcc=test3@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.bcc).containsExactly("test3@domain.example".toAddress())

    }

    @Test

    fun `multiple Bcc recipients`() {

        val uri = "mailto:?bcc=test3@domain.example&bcc=test4@domain.example".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.bcc).containsExactly(

            "test3@domain.example".toAddress(),

            "test4@domain.example".toAddress(),

        )

    }

    @Test

    fun `mailto URI with subject`() {

        val uri = "mailto:?subject=Hello".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.subject).isEqualTo("Hello")

    }

    @Test

    fun `mailto URI with body and additional parameter following`() {

        val uri = "mailto:?body=Test%20Body&something=else".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.body).isEqualTo("Test Body")

    }

    @Test

    fun `In-Reply-To parameter`() {

        val uri = "mailto:?in-reply-to=%3C7C72B202-73F3@somewhere%3E".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.inReplyTo).isEqualTo("<7C72B202-73F3@somewhere>")

    }

    @Test

    fun `In-Reply-To parameter with multiple message IDs should only return first`() {

        val uri = "mailto:?in-reply-to=%3C7C72B202-73F3@somewhere%3E%3C8A39-1A87CB40C114@somewhereelse%3E".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.inReplyTo).isEqualTo("<7C72B202-73F3@somewhere>")

    }

    @Test

    fun `In-Reply-To example from RFC 6068`() {

        val uri = "mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.inReplyTo).isEqualTo("<3469A91.D10AF4C@example.com>")

    }

    @Test

    fun `invalid In-Reply-To value should return null`() {

        val uri = "mailto:?in-reply-to=7C72B202-73F3somewhere".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.inReplyTo).isNull()

    }

    @Test

    fun `empty In-Reply-To value should return null`() {

        val uri = "mailto:?in-reply-to=".toUri()

        val result = MailTo.parse(uri)

        assertThat(result.inReplyTo).isNull()

    }

    @Test

    fun `mixed case parameter names should be treated case insensitive`() {

        val uri = (

            "mailto:" +

                "?to=to@domain.example" +

                "&CC=cc@domain.example" +

                "&bCC=bcc@domain.example" +

                "&SUBJECT=subject" +

                "&BODY=body" +

                "&IN-REPLY-TO=%3Cmsg@id%3E"

            ).toUri()

        val result = MailTo.parse(uri)

        assertThat(result.to).containsExactly("to@domain.example".toAddress())

        assertThat(result.cc).containsExactly("cc@domain.example".toAddress())

        assertThat(result.bcc).containsExactly("bcc@domain.example".toAddress())

        assertThat(result.subject).isEqualTo("subject")

        assertThat(result.body).isEqualTo("body")

        assertThat(result.inReplyTo).isEqualTo("<msg@id>")

    }

}

private fun String.toAddress(): Address = Address(this)