diff --git a/library/build.gradle b/library/build.gradle index 822fc324..1f7c6513 100755 --- a/library/build.gradle +++ b/library/build.gradle @@ -88,7 +88,7 @@ dependencies { implementation 'io.reactivex.rxjava2:rxandroid:2.0.1' implementation 'io.reactivex.rxjava2:rxjava:2.1.8' implementation 'io.reactivex.rxjava2:rxkotlin:2.2.0' - testImplementation 'io.mockk:mockk:1.7.14' + testImplementation 'io.mockk:mockk:1.9.kotlin12' testImplementation 'org.robolectric:robolectric:3.6.1' testImplementation 'com.squareup.okhttp3:mockwebserver:3.11.0' implementation supportLibs diff --git a/library/src/main/java/io/constructor/core/ConstructorIo.kt b/library/src/main/java/io/constructor/core/ConstructorIo.kt index 4286a04c..098979db 100755 --- a/library/src/main/java/io/constructor/core/ConstructorIo.kt +++ b/library/src/main/java/io/constructor/core/ConstructorIo.kt @@ -197,8 +197,7 @@ object ConstructorIo { val sectionNameParam = sectionName ?: preferenceHelper.defaultItemSection val params = mutableListOf(Constants.QueryConstants.SESSION to sessionId.toString(), Constants.QueryConstants.AUTOCOMPLETE_SECTION to sectionNameParam) - clientIds.forEach { params.add(Constants.QueryConstants.CUSTOMER_ID to it) } - disposable.add(dataManager.trackPurchase(params.toTypedArray()).subscribeOn(Schedulers.io()) + disposable.add(dataManager.trackPurchase(clientIds.toList(), params.toTypedArray()).subscribeOn(Schedulers.io()) .subscribe({}, { t -> t.printStackTrace() errorCallback?.invoke(t) diff --git a/library/src/main/java/io/constructor/data/DataManager.kt b/library/src/main/java/io/constructor/data/DataManager.kt index d4582b01..be1e76ce 100755 --- a/library/src/main/java/io/constructor/data/DataManager.kt +++ b/library/src/main/java/io/constructor/data/DataManager.kt @@ -53,8 +53,8 @@ constructor(private val constructorApi: ConstructorApi) { return constructorApi.trackInputFocus(term, params.toMap()) } - fun trackPurchase(params: Array>): Completable { - return constructorApi.trackPurchase(params.toMap()) + fun trackPurchase(customerIds: List, params: Array>): Completable { + return constructorApi.trackPurchase(customerIds, params.toMap()) } } \ No newline at end of file diff --git a/library/src/main/java/io/constructor/data/remote/ConstructorApi.kt b/library/src/main/java/io/constructor/data/remote/ConstructorApi.kt index 0a04d8ca..ab98edf0 100755 --- a/library/src/main/java/io/constructor/data/remote/ConstructorApi.kt +++ b/library/src/main/java/io/constructor/data/remote/ConstructorApi.kt @@ -1,5 +1,6 @@ package io.constructor.data.remote +import io.constructor.core.Constants import io.constructor.data.model.AutocompleteResult import io.reactivex.Completable import io.reactivex.Single @@ -36,5 +37,5 @@ interface ConstructorApi { fun trackInputFocus(@Query("term") term: String?, @QueryMap params: Map): Completable @GET(ApiPaths.URL_PURCHASE) - fun trackPurchase(@QueryMap params: Map): Completable + fun trackPurchase(@Query(Constants.QueryConstants.CUSTOMER_ID) customerIds: List, @QueryMap params: Map): Completable } \ No newline at end of file diff --git a/library/src/test/java/io/constructor/core/ConstructorIoTest.kt b/library/src/test/java/io/constructor/core/ConstructorIoTest.kt index 1d8982b2..897c4834 100755 --- a/library/src/test/java/io/constructor/core/ConstructorIoTest.kt +++ b/library/src/test/java/io/constructor/core/ConstructorIoTest.kt @@ -273,9 +273,9 @@ class ConstructorIoTest { @Test fun trackPurchase() { every { pref.defaultItemSection } returns "Products" - every { data.trackPurchase(any()) } returns Completable.complete() + every { data.trackPurchase(any(), any()) } returns Completable.complete() constructorIo.trackPurchase(arrayOf("id1")) - verify(exactly = 1) { data.trackPurchase(any()) } + verify(exactly = 1) { data.trackPurchase(any(), any()) } } } \ No newline at end of file diff --git a/library/src/test/java/io/constructor/data/DataManagerHttpTest.kt b/library/src/test/java/io/constructor/data/DataManagerHttpTest.kt new file mode 100755 index 00000000..d3bb3471 --- /dev/null +++ b/library/src/test/java/io/constructor/data/DataManagerHttpTest.kt @@ -0,0 +1,439 @@ +package io.constructor.data + +import android.content.Context +import com.squareup.moshi.KotlinJsonAdapterFactory +import com.squareup.moshi.Moshi +import io.constructor.core.Constants +import io.constructor.data.interceptor.TokenInterceptor +import io.constructor.data.local.PreferencesHelper +import io.constructor.data.memory.ConfigMemoryHolder +import io.constructor.data.remote.ApiPaths +import io.constructor.data.remote.ConstructorApi +import io.constructor.util.RxSchedulersOverrideRule +import io.constructor.util.TestDataLoader +import io.mockk.Runs +import io.mockk.every +import io.mockk.just +import io.mockk.mockk +import okhttp3.OkHttpClient +import okhttp3.mockwebserver.MockResponse +import okhttp3.mockwebserver.MockWebServer +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import retrofit2.Retrofit +import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory +import retrofit2.converter.moshi.MoshiConverterFactory +import java.net.SocketTimeoutException +import java.util.concurrent.TimeUnit + +class DataManagerHttpTest { + + @Rule + @JvmField val overrideSchedulersRule = RxSchedulersOverrideRule() + + private lateinit var constructorApi: ConstructorApi + + private val ctx = mockk() + private val pref = mockk() + private val configMemoryHolder = mockk() + + private lateinit var dataManager: DataManager + + private lateinit var mockServer: MockWebServer + + @Before + fun setup() { + every { pref.token } returns "123" + every { pref.id } returns "1" + every { configMemoryHolder.testCellParams = any() } just Runs + every { configMemoryHolder.userId } returns "id1" + every { configMemoryHolder.testCellParams } returns emptyList() + mockServer = MockWebServer() + mockServer.start() + + val client = OkHttpClient.Builder().addInterceptor(TokenInterceptor(ctx, pref, configMemoryHolder)).readTimeout(4, TimeUnit.SECONDS).build() + + val moshi = Moshi + .Builder() + .add(KotlinJsonAdapterFactory()) + .build() + + // Get an instance of Retrofit + val retrofit = Retrofit.Builder() + .baseUrl(mockServer.url("").toString()) + .client(client) + .addConverterFactory(MoshiConverterFactory.create(moshi)) + .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) + .build() + + constructorApi = retrofit.create(ConstructorApi::class.java) + dataManager = DataManager(constructorApi) + } + + @Test + fun getAutocompleteResults() { + val path = "/" + ApiPaths.URL_GET_SUGGESTIONS.replace("{value}", "titanic") + val mockResponse = MockResponse().setResponseCode(200).setBody(TestDataLoader.loadAsString("response.json")) + mockServer.enqueue(mockResponse) + val observer = dataManager.getAutocompleteResults("titanic").test() + observer.assertComplete().assertValue { + it.get()!!.isNotEmpty() && it.get()!!.size == 5 + } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun getAutocompleteResultsBadServerResponse() { + val path = "/" + ApiPaths.URL_GET_SUGGESTIONS.replace("{value}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.getAutocompleteResults("titanic").test() + observer.assertComplete().assertValue { + it.networkError + } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun getAutocompleteResultsTimeoutException() { + val path = "/" + ApiPaths.URL_GET_SUGGESTIONS.replace("{value}", "titanic") + val mockResponse = MockResponse().setResponseCode(200).setBody(TestDataLoader.loadAsString("response.json")) + mockResponse.throttleBody(128, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.getAutocompleteResults("titanic").test() + observer.assertComplete().assertValue { + it.isError + } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun getAutocompleteResultsUnexpectedDataResponse() { + val path = "/" + ApiPaths.URL_GET_SUGGESTIONS.replace("{value}", "titanic") + val mockResponse = MockResponse().setResponseCode(200).setBody(TestDataLoader.loadAsString("response_with_unexpected_data.json")) + mockServer.enqueue(mockResponse) + val observer = dataManager.getAutocompleteResults("titanic").test() + observer.assertComplete().assertValue { + it.get()!!.isNotEmpty() && it.get()!!.size == 5 + } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun getAutocompleteResultsEmptyResponse() { + val path = "/" + ApiPaths.URL_GET_SUGGESTIONS.replace("{value}", "titanic") + val mockResponse = MockResponse().setResponseCode(200).setBody(TestDataLoader.loadAsString("empty_response.json")) + mockServer.enqueue(mockResponse) + val observer = dataManager.getAutocompleteResults("titanic").test() + observer.assertComplete().assertValue { + it.isEmpty + } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackAutocompleteSelect() { + val path = "/" + ApiPaths.URL_AUTOCOMPLETE_SELECT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackAutocompleteSelect("titanic").test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackAutocompleteSelect500() { + val path = "/" + ApiPaths.URL_AUTOCOMPLETE_SELECT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackAutocompleteSelect("titanic").test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackAutocompleteTimeout() { + val path = "/" + ApiPaths.URL_AUTOCOMPLETE_SELECT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackAutocompleteSelect("titanic").test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackSearchSubmit() { + val path = "/" + ApiPaths.URL_SEARCH_SUBMIT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchSubmit("titanic").test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackSearchSubmit500() { + val path = "/" + ApiPaths.URL_SEARCH_SUBMIT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchSubmit("titanic").test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackSearchSubmitTimeout() { + val path = "/" + ApiPaths.URL_SEARCH_SUBMIT_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchSubmit("titanic").test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + } + + @Test + fun trackSessionStart() { + val path = "/" + ApiPaths.URL_SESSION_START_EVENT + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSessionStart(arrayOf(Constants.QueryConstants.SESSION to "1")).test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("s=1")) + } + + @Test + fun trackSessionStart500() { + val path = "/" + ApiPaths.URL_SESSION_START_EVENT + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSessionStart(arrayOf(Constants.QueryConstants.SESSION to "1")).test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("s=1")) + } + + @Test + fun trackSessionStartTimeout() { + val path = "/" + ApiPaths.URL_SESSION_START_EVENT + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSessionStart(arrayOf(Constants.QueryConstants.SESSION to "1")).test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("s=1")) + } + + @Test + fun trackConversion() { + val path = "/" + ApiPaths.URL_CONVERSION_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackConversion("titanic", "ship", "cid").test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackConversion500() { + val path = "/" + ApiPaths.URL_CONVERSION_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackConversion("titanic", "ship", "cid").test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackConversionTimeout() { + val path = "/" + ApiPaths.URL_CONVERSION_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackConversion("titanic", "ship", "cid").test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackSearchResultClick() { + val path = "/" + ApiPaths.URL_SEARCH_RESULT_CLICK_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultClick("ship", "cid", "titanic").test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackSearchResultClick500() { + val path = "/" + ApiPaths.URL_SEARCH_RESULT_CLICK_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultClick("ship", "cid", "titanic").test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackSearchResultClickTimeout() { + val path = "/" + ApiPaths.URL_SEARCH_RESULT_CLICK_EVENT.replace("{term}", "titanic") + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultClick("ship", "cid", "titanic").test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("name=ship")) + assert(request.path.contains("customer_id=cid")) + } + + @Test + fun trackSearchResultLoaded() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultsLoaded("titanic", 10, arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_SEARCH_RESULTS)).test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_SEARCH_RESULTS}")) + } + + @Test + fun trackSearchResultLoaded500() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultsLoaded("titanic", 10, arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_SEARCH_RESULTS)).test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_SEARCH_RESULTS}")) + } + + @Test + fun trackSearchResultLoadedTimeout() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackSearchResultsLoaded("titanic", 10, arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_SEARCH_RESULTS)).test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_SEARCH_RESULTS}")) + } + + @Test + fun trackInputFocus() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackInputFocus("titanic", arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_INPUT_FOCUS)).test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_INPUT_FOCUS}")) + } + + @Test + fun trackInputFocus500() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackInputFocus("titanic", arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_INPUT_FOCUS)).test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_INPUT_FOCUS}")) + } + + @Test + fun trackInputFocusTimeout() { + val path = "/" + ApiPaths.URL_BEHAVIOR + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackInputFocus("titanic", arrayOf(Constants.QueryConstants.ACTION to Constants.QueryValues.EVENT_INPUT_FOCUS)).test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.ACTION}=${Constants.QueryValues.EVENT_INPUT_FOCUS}")) + } + + @Test + fun trackPurchase() { + val path = "/" + ApiPaths.URL_PURCHASE + val mockResponse = MockResponse().setResponseCode(204) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackPurchase(listOf("1", "2"), arrayOf()).test() + observer.assertComplete() + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=1")) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=2")) + } + + @Test + fun trackPurchase500() { + val path = "/" + ApiPaths.URL_PURCHASE + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockServer.enqueue(mockResponse) + val observer = dataManager.trackPurchase(listOf("1", "2"), arrayOf()).test() + observer.assertError { true } + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=1")) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=2")) + } + + @Test + fun trackPurchaseTimeout() { + val path = "/" + ApiPaths.URL_PURCHASE + val mockResponse = MockResponse().setResponseCode(500).setBody("Internal server error") + mockResponse.throttleBody(0, 5, TimeUnit.SECONDS) + mockServer.enqueue(mockResponse) + val observer = dataManager.trackPurchase(listOf("1", "2"), arrayOf()).test() + observer.assertError(SocketTimeoutException::class.java) + val request = mockServer.takeRequest() + assert(request.path.startsWith(path)) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=1")) + assert(request.path.contains("${Constants.QueryConstants.CUSTOMER_ID}=2")) + } + +} \ No newline at end of file diff --git a/library/src/test/java/io/constructor/data/DataManagerTest.kt b/library/src/test/java/io/constructor/data/DataManagerTest.kt index 2ebfad37..697764b9 100755 --- a/library/src/test/java/io/constructor/data/DataManagerTest.kt +++ b/library/src/test/java/io/constructor/data/DataManagerTest.kt @@ -186,9 +186,9 @@ class DataManagerTest { @Test fun trackPurchase() { - every { constructorApi.trackPurchase(any()) } returns Completable.complete() - dataManager.trackPurchase(arrayOf()) - verify(exactly = 1) { constructorApi.trackPurchase(any()) } + every { constructorApi.trackPurchase(any(), any()) } returns Completable.complete() + dataManager.trackPurchase(listOf(), arrayOf()) + verify(exactly = 1) { constructorApi.trackPurchase(any(), any()) } } } \ No newline at end of file diff --git a/library/src/test/java/io/constructor/util/TestDataLoader.kt b/library/src/test/java/io/constructor/util/TestDataLoader.kt index 2794d7ce..140a0693 100755 --- a/library/src/test/java/io/constructor/util/TestDataLoader.kt +++ b/library/src/test/java/io/constructor/util/TestDataLoader.kt @@ -7,6 +7,7 @@ import okio.Buffer import java.io.File import java.io.FileInputStream import java.io.IOException +import java.nio.charset.Charset object TestDataLoader { @@ -30,4 +31,15 @@ object TestDataLoader { return result } + fun loadAsString(fileName: String): String { + var result = "" + try { + result = File(TestDataLoader::class.java.classLoader.getResource(fileName).path).inputStream().readBytes().toString(Charset.defaultCharset()) + } catch (e: IOException) { + e.printStackTrace() + } + return result + } + + }