Refactor tests.

2023-10-02 13:51:16 +02:00
parent 238d470f6d
commit 35b37f0caa
1 changed files with 94 additions and 119 deletions
--- a/features/call/src/test/kotlin/io/element/android/features/call/CallIntentDataParserTests.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/CallIntentDataParserTests.kt
@@ -35,92 +35,51 @@ class CallIntentDataParserTests {

    @Test
    fun `empty data returns null`() {
-        val url = ""
-        assertThat(callIntentDataParser.parse(url)).isNull()
+        doTest("", null)
    }

    @Test
    fun `invalid data returns null`() {
-        val url = "!"
-        assertThat(callIntentDataParser.parse(url)).isNull()
+        doTest("!", null)
    }

    @Test
    fun `data with no scheme returns null`() {
-        val url = "test"
-        assertThat(callIntentDataParser.parse(url)).isNull()
+        doTest("test", null)
    }

    @Test
    fun `Element Call http urls returns null`() {
-        val httpBaseUrl = "http://call.element.io"
-        val httpCallUrl = "http://call.element.io/some-actual-call?with=parameters"
-        assertThat(callIntentDataParser.parse(httpBaseUrl)).isNull()
-        assertThat(callIntentDataParser.parse(httpCallUrl)).isNull()
+        doTest("http://call.element.io", null)
+        doTest("http://call.element.io/some-actual-call?with=parameters", null)
    }

    @Test
    fun `Element Call urls will be returned as is`() {
-        val httpsBaseUrl = "https://call.element.io"
-        val httpsCallUrl = VALID_CALL_URL_WITH_PARAM
-        assertThat(callIntentDataParser.parse(httpsBaseUrl)).isEqualTo("$httpsBaseUrl#?$EXTRA_PARAMS")
-        assertThat(callIntentDataParser.parse(httpsCallUrl)).isEqualTo("$httpsCallUrl#?$EXTRA_PARAMS")
+        doTest(
+            url = "https://call.element.io",
+            expectedResult = "https://call.element.io#?$EXTRA_PARAMS"
+        )
+    }
+
+    @Test
+    fun `Element Call url with url param gets url extracted`() {
+        doTest(
+            url = VALID_CALL_URL_WITH_PARAM,
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
+        )
    }

    @Test
    fun `HTTP and HTTPS urls that don't come from EC return null`() {
-        val httpBaseUrl = "http://app.element.io"
-        val httpsBaseUrl = "https://app.element.io"
-        val httpInvalidUrl = "http://"
-        val httpsInvalidUrl = "http://"
-        assertThat(callIntentDataParser.parse(httpBaseUrl)).isNull()
-        assertThat(callIntentDataParser.parse(httpsBaseUrl)).isNull()
-        assertThat(callIntentDataParser.parse(httpInvalidUrl)).isNull()
-        assertThat(callIntentDataParser.parse(httpsInvalidUrl)).isNull()
+        doTest("http://app.element.io", null)
+        doTest("https://app.element.io", null, testEmbedded = false)
+        doTest("http://", null)
+        doTest("https://", null)
    }

    @Test
-    fun `element scheme with call host and url with http will returns null`() {
-        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "element://call?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isNull()
-    }
-
-    @Test
-    fun `element scheme with call host and url param gets url extracted`() {
-        val embeddedUrl = VALID_CALL_URL_WITH_PARAM
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "element://call?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
-    }
-
-    @Test
-    fun `element scheme 2 with url param with http returns null`() {
-        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isNull()
-    }
-
-    @Test
-    fun `element scheme 2 with url param gets url extracted`() {
-        val embeddedUrl = VALID_CALL_URL_WITH_PARAM
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
-    }
-
-    @Test
-    fun `element scheme with call host and no url param returns null`() {
-        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "element://call?no-url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isNull()
-    }
-
-    @Test
-    fun `element scheme 2 with no url returns null`() {
+    fun `Element Call url with no url returns null`() {
        val embeddedUrl = VALID_CALL_URL_WITH_PARAM
        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
        val url = "io.element.call:/?no_url=$encodedUrl"
@@ -142,7 +101,7 @@ class CallIntentDataParserTests {
    }

    @Test
-    fun `element scheme 2 with no data returns null`() {
+    fun `Element Call url with no data returns null`() {
        val url = "io.element.call:/?url="
        assertThat(callIntentDataParser.parse(url)).isNull()
    }
@@ -156,91 +115,107 @@ class CallIntentDataParserTests {
    }

    @Test
-    fun `element scheme 2 with url extra param appPrompt gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}&appPrompt=true"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
+    fun `Element Call url with url extra param appPrompt gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}&appPrompt=true",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with url extra param in fragment appPrompt gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?appPrompt=true"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?appPrompt=false&confineToRoom=true")
+    fun `Element Call url with url extra param in fragment appPrompt gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?appPrompt=true",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?appPrompt=false&confineToRoom=true"
+        )
    }

    @Test
-    fun `element scheme 2 with url extra param in fragment appPrompt and other gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?appPrompt=true&otherParam=maybe"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?appPrompt=false&otherParam=maybe&confineToRoom=true")
+    fun `Element Call url with url extra param in fragment appPrompt and other gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?appPrompt=true&otherParam=maybe",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?appPrompt=false&otherParam=maybe&confineToRoom=true"
+        )
    }

    @Test
-    fun `element scheme 2 with url extra param confineToRoom gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}&confineToRoom=false"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
+    fun `Element Call url with url extra param confineToRoom gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}&confineToRoom=false",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with url extra param in fragment confineToRoom gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?confineToRoom=false"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?confineToRoom=true&appPrompt=false")
+    fun `Element Call url with url extra param in fragment confineToRoom gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?confineToRoom=false",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?confineToRoom=true&appPrompt=false"
+        )
    }

    @Test
-    fun `element scheme 2 with url extra param in fragment confineToRoom and more gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?confineToRoom=false&otherParam=maybe"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?confineToRoom=true&otherParam=maybe&appPrompt=false")
+    fun `Element Call url with url extra param in fragment confineToRoom and more gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?confineToRoom=false&otherParam=maybe",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?confineToRoom=true&otherParam=maybe&appPrompt=false"
+        )
    }

    @Test
-    fun `element scheme 2 with url fragment gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#fragment"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#fragment?$EXTRA_PARAMS")
+    fun `Element Call url with url fragment gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#fragment",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#fragment?$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with url fragment with params gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#fragment?otherParam=maybe"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#fragment?otherParam=maybe&$EXTRA_PARAMS")
+    fun `Element Call url with url fragment with params gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#fragment?otherParam=maybe",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#fragment?otherParam=maybe&$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with url fragment with other params gets url extracted`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?otherParam=maybe"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?otherParam=maybe&$EXTRA_PARAMS")
+    fun `Element Call url with url fragment with other params gets url extracted`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?otherParam=maybe",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?otherParam=maybe&$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with empty fragment`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
+    fun `Element Call url with empty fragment`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
+        )
    }

    @Test
-    fun `element scheme 2 with empty fragment and fragment query`() {
-        val embeddedUrl = "${VALID_CALL_URL_WITH_PARAM}#?"
-        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
-        val url = "io.element.call:/?url=$encodedUrl"
-        assertThat(callIntentDataParser.parse(url)).isEqualTo("$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS")
+    fun `Element Call url with empty fragment query`() {
+        doTest(
+            url = "${VALID_CALL_URL_WITH_PARAM}#?",
+            expectedResult = "$VALID_CALL_URL_WITH_PARAM#?$EXTRA_PARAMS"
+        )
+    }
+
+    private fun doTest(url: String, expectedResult: String?, testEmbedded: Boolean = true) {
+        // Test direct parsing
+        assertThat(callIntentDataParser.parse(url)).isEqualTo(expectedResult)
+
+        if (testEmbedded) {
+            // Test embedded url, scheme 1
+            val encodedUrl = URLEncoder.encode(url, "utf-8")
+            val urlScheme1 = "element://call?url=$encodedUrl"
+            assertThat(callIntentDataParser.parse(urlScheme1)).isEqualTo(expectedResult)
+
+            // Test embedded url, scheme 2
+            val urlScheme2 = "io.element.call:/?url=$encodedUrl"
+            assertThat(callIntentDataParser.parse(urlScheme2)).isEqualTo(expectedResult)
+        }
    }

    companion object {