Add a base64 encoding implementation (#23)

* add own implementation of base64

* fix import

* make httpclient stateful, cache authHeader to prevent base64 recomputation, improve httpclient tests

Author: prayansh

core/src/main/java/com/segment/analytics/kotlin/core/HTTPClient.kt

@@ -1,5 +1,7 @@
 package com.segment.analytics.kotlin.core
 
+import com.segment.analytics.kotlin.core.Constants.LIBRARY_VERSION
+import com.segment.analytics.kotlin.core.utilities.encodeToBase64
 import java.io.BufferedReader
 import java.io.Closeable
 import java.io.IOException
@@ -8,11 +10,12 @@ import java.io.OutputStream
 import java.net.HttpURLConnection
 import java.net.MalformedURLException
 import java.net.URL
-import java.util.Base64
 import java.util.zip.GZIPOutputStream
 
-class HTTPClient {
-    fun settings(writeKey: String): Connection {
+class HTTPClient(private val writeKey: String) {
+    internal val authHeader = authorizationHeader(writeKey)
+
+    fun settings(): Connection {
         val connection: HttpURLConnection =
             openConnection("https://cdn-settings.segment.com/v1/projects/$writeKey/settings")
         val responseCode = connection.responseCode
@@ -23,9 +26,9 @@ class HTTPClient {
         return connection.createGetConnection()
     }
 
-    fun upload(apiHost: String, writeKey: String): Connection {
-        val connection: HttpURLConnection = openConnection("https://$apiHost/import")
-        connection.setRequestProperty("Authorization", authorizationHeader(writeKey))
+    fun upload(apiHost: String): Connection {
+        val connection: HttpURLConnection = openConnection("https://$apiHost/batch")
+        connection.setRequestProperty("Authorization", authHeader)
         connection.setRequestProperty("Content-Encoding", "gzip")
         connection.doOutput = true
         connection.setChunkedStreamingMode(0)
@@ -34,16 +37,15 @@ class HTTPClient {
 
     private fun authorizationHeader(writeKey: String): String {
         val auth = "$writeKey:"
-        return "Basic " + Base64.getEncoder().encodeToString(auth.toByteArray())
+        return "Basic ${encodeToBase64(auth)}"
     }
 
     /**
      * Configures defaults for connections opened with [.upload], and [ ][.projectSettings].
      */
     @Throws(IOException::class)
     private fun openConnection(url: String): HttpURLConnection {
-        val requestedURL: URL
-        requestedURL = try {
+        val requestedURL: URL = try {
             URL(url)
         } catch (e: MalformedURLException) {
             throw IOException("Attempted to use malformed url: $url", e)
@@ -55,7 +57,7 @@ class HTTPClient {
         connection.setRequestProperty("Content-Type", "application/json; charset=utf-8")
         connection.setRequestProperty(
             "User-Agent",
-            "analytics-kotlin/1.0.0"
+            "analytics-kotlin/$LIBRARY_VERSION"
         )
         connection.doInput = true
         return connection

core/src/main/java/com/segment/analytics/kotlin/core/SegmentDestination.kt

@@ -31,7 +31,7 @@ class SegmentDestination(
 ) : DestinationPlugin() {
 
     override val key: String = "Segment.io"
-    internal val httpClient: HTTPClient = HTTPClient()
+    internal val httpClient: HTTPClient = HTTPClient(apiKey)
     internal lateinit var storage: Storage
     lateinit var flushScheduler: ScheduledExecutorService
     internal val eventCount = AtomicInteger(0)
@@ -135,7 +135,7 @@ class SegmentDestination(
         eventCount.set(0)
         for (fileUrl in fileUrls) {
             try {
-                val connection = httpClient.upload(apiHost, apiKey)
+                val connection = httpClient.upload(apiHost)
                 val file = File(fileUrl)
                 // flush is executed in a thread pool and file could have been deleted by another thread
                 if (!file.exists()) {

core/src/main/java/com/segment/analytics/kotlin/core/Settings.kt

@@ -56,7 +56,7 @@ fun Analytics.checkSettings() {
     analyticsScope.launch(ioDispatcher) {
         log("Fetching settings on ${Thread.currentThread().name}")
         val settingsObj: Settings? = try {
-            val connection = HTTPClient().settings(writeKey)
+            val connection = HTTPClient(writeKey).settings()
             val settingsString =
                 connection.inputStream?.bufferedReader()?.use(BufferedReader::readText) ?: ""
             log("Fetched Settings: $settingsString")

core/src/main/java/com/segment/analytics/kotlin/core/utilities/Base64Utils.kt

@@ -0,0 +1,43 @@
+package com.segment.analytics.kotlin.core.utilities
+
+// Encode string to base64
+fun encodeToBase64(str: String) = encodeToBase64(str.toByteArray())
+
+// Encode byte-array to base64
+fun encodeToBase64(bytes: ByteArray) = buildString {
+    val wData = ByteArray(3) // working data
+    var i = 0
+    while (i < bytes.size) {
+        val leftover = bytes.size - i
+        val available = if (leftover >= 3) {
+            3
+        } else {
+            leftover
+        }
+        for (j in 0 until available) {
+            wData[j] = bytes[i++]
+        }
+        for (j in 2 downTo available) {
+            wData[j] = 0 // clear out
+        }
+        // Given a 3 byte block (24 bits), encode it to 4 base64 characters
+        val chunk = ((wData[0].toInt() and 0xFF) shl 16) or
+                ((wData[1].toInt() and 0xFF) shl 8) or
+                (wData[2].toInt() and 0xFF)
+
+        // if we have too little characters in this block, we add padding
+        val padCount = (wData.size - available) * 8 / 6
+
+        // encode to base64
+        for (index in 3 downTo padCount) { // 4 base64 characters
+            val char = (chunk shr (6 * index)) and 0x3f // 0b00111111
+            append(char.base64Val())
+        }
+
+        // add padding if needed
+        repeat(padCount) { append("=") }
+    }
+}
+
+private const val ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+private fun Int.base64Val(): Char = ALPHABET[this]

core/src/test/kotlin/com/segment/analytics/kotlin/core/Base64UtilsTest.kt

@@ -0,0 +1,21 @@
+package com.segment.analytics.kotlin.core
+
+import com.segment.analytics.kotlin.core.utilities.encodeToBase64
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class Base64UtilsTest {
+
+    @Test
+    fun testBase64Encoding() {
+        assertEquals(encodeToBase64(""), "")
+        assertEquals(encodeToBase64("f"), "Zg==")
+        assertEquals(encodeToBase64("fo"), "Zm8=")
+        assertEquals(encodeToBase64("foo"), "Zm9v")
+        assertEquals(encodeToBase64("foob"), "Zm9vYg==")
+        assertEquals(encodeToBase64("fooba"), "Zm9vYmE=")
+        assertEquals(encodeToBase64("foobar"), "Zm9vYmFy")
+    }
+}

core/src/test/kotlin/com/segment/analytics/kotlin/core/HTTPClientTests.kt

@@ -1,31 +1,54 @@
 package com.segment.analytics.kotlin.core
 
-import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.json.Json
+import com.segment.analytics.kotlin.core.Constants.LIBRARY_VERSION
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.io.BufferedReader
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class HTTPClientTests {
 
-    private val httpClient = HTTPClient()
+    private val httpClient = HTTPClient("1vNgUqwJeCHmqgI9S1sOm9UHCyfYqbaQ")
 
     @BeforeEach
     fun setup() {
 
     }
 
     @Test
-    fun `fetch settings works`() = runBlocking {
-        val connection = httpClient.settings("1vNgUqwJeCHmqgI9S1sOm9UHCyfYqbaQ")
-        val settingsString = connection.inputStream?.bufferedReader()?.use(BufferedReader::readText) ?: ""
-        val settingsObj: Settings = Json { ignoreUnknownKeys = true }.decodeFromString(settingsString)
-        assertEquals(emptyJsonObject, settingsObj.edgeFunction)
-        assertNotEquals(emptyJsonObject, settingsObj.integrations)
-        assertEquals(1, settingsObj.integrations.size)
+    fun `authHeader is correctly computed`() {
+        assertEquals("Basic MXZOZ1Vxd0plQ0htcWdJOVMxc09tOVVIQ3lmWXFiYVE6", httpClient.authHeader)
+    }
+
+    @Test
+    fun `upload connection has correct configuration`()  {
+        httpClient.settings().connection.let {
+            assertEquals(
+                "https://cdn-settings.segment.com/v1/projects/1vNgUqwJeCHmqgI9S1sOm9UHCyfYqbaQ/settings",
+                it.url.toString()
+            )
+            assertEquals(
+                "analytics-kotlin/$LIBRARY_VERSION",
+                it.getRequestProperty("User-Agent")
+            )
+        }
+    }
+
+    @Test
+    fun `settings connection has correct configuration`() {
+        httpClient.upload("api.segment.io/v1").connection.let {
+            assertEquals(
+                "https://api.segment.io/v1/batch",
+                it.url.toString()
+            )
+            assertEquals(
+                "analytics-kotlin/$LIBRARY_VERSION",
+                it.getRequestProperty("User-Agent")
+            )
+            assertEquals("gzip", it.getRequestProperty("Content-Encoding"))
+            // ideally we would also test if auth Header is set, but due to security concerns this
+            // is not possible https://bit.ly/3CVpR3J
+        }
     }
 }

core/src/test/kotlin/com/segment/analytics/kotlin/core/SegmentDestinationTests.kt

@@ -196,7 +196,7 @@ class SegmentDestinationTests {
                 outputBytes = (outputStream as ByteArrayOutputStream).toByteArray()
             }
         }
-        every { anyConstructed<HTTPClient>().upload(any(), any()) } returns connection
+        every { anyConstructed<HTTPClient>().upload(any()) } returns connection
 
         assertEquals(trackEvent, destSpy.track(trackEvent))
         assertEquals(1, segmentDestination.eventCount.get())
@@ -246,7 +246,7 @@ class SegmentDestinationTests {
                 throw HTTPException(400, "", null)
             }
         }
-        every { anyConstructed<HTTPClient>().upload(any(), any()) } returns connection
+        every { anyConstructed<HTTPClient>().upload(any()) } returns connection
 
         assertEquals(trackEvent, destSpy.track(trackEvent))
         assertEquals(1, segmentDestination.eventCount.get())
@@ -284,7 +284,7 @@ class SegmentDestinationTests {
                 throw HTTPException(429, "", null)
             }
         }
-        every { anyConstructed<HTTPClient>().upload(any(), any()) } returns connection
+        every { anyConstructed<HTTPClient>().upload(any()) } returns connection
 
         assertEquals(trackEvent, destSpy.track(trackEvent))
         assertEquals(1, segmentDestination.eventCount.get())
@@ -328,7 +328,7 @@ class SegmentDestinationTests {
                 throw HTTPException(500, "", null)
             }
         }
-        every { anyConstructed<HTTPClient>().upload(any(), any()) } returns connection
+        every { anyConstructed<HTTPClient>().upload(any()) } returns connection
 
         assertEquals(trackEvent, destSpy.track(trackEvent))
         assertEquals(1, segmentDestination.eventCount.get())

core/src/test/kotlin/com/segment/analytics/kotlin/core/SettingsTests.kt

@@ -33,7 +33,7 @@ class SettingsTests {
         )
         val httpConnection: HttpURLConnection = mockk()
         val connection = object : Connection(httpConnection, settingsStream, null) {}
-        every { anyConstructed<HTTPClient>().settings(any()) } returns connection
+        every { anyConstructed<HTTPClient>().settings() } returns connection
     }
 
     @BeforeEach