expo-modules-test-core 0.8.0

package/README.md

@@ -0,0 +1,5 @@
+# expo-modules-test-core
+
+Goal of this module is to provide utility methods that will help developers easily write unit tests for native code in expo modules.
+
+Module is purely native and should be included and used exclusively in tests targets. It defines and exposes default set of dependencies used for testing in Android.

package/android/build.gradle

@@ -0,0 +1,100 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'org.unimodules'
+version = '0.8.0'
+
+buildscript {
+  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+  if (expoModulesCorePlugin.exists()) {
+    apply from: expoModulesCorePlugin
+    applyKotlinExpoModulesCorePlugin()
+  }
+
+  // Simple helper that allows the root project to override versions declared by this library.
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+
+  // Ensures backward compatibility
+  ext.getKotlinVersion = {
+    if (ext.has("kotlinVersion")) {
+      ext.kotlinVersion()
+    } else {
+      ext.safeExtGet("kotlinVersion", "1.6.10")
+    }
+  }
+
+  repositories {
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+  }
+}
+
+// Creating sources with comments
+task androidSourcesJar(type: Jar) {
+  classifier = 'sources'
+  from android.sourceSets.main.java.srcDirs
+}
+
+afterEvaluate {
+  publishing {
+    publications {
+      release(MavenPublication) {
+        from components.release
+        // Add additional sourcesJar to artifacts
+        artifact(androidSourcesJar)
+      }
+    }
+    repositories {
+      maven {
+        url = mavenLocal().url
+      }
+    }
+  }
+}
+
+android {
+  compileSdkVersion safeExtGet("compileSdkVersion", 31)
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_11.majorVersion
+  }
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 21)
+    targetSdkVersion safeExtGet("targetSdkVersion", 31)
+    versionCode 3
+    versionName '0.8.0'
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  api 'androidx.test:core:1.4.0'
+  api 'junit:junit:4.13.1'
+  api 'io.mockk:mockk:1.12.0'
+  api "org.robolectric:robolectric:4.5.1"
+
+  //noinspection GradleDynamicVersion
+  implementation 'com.facebook.react:react-native:+'
+
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation "org.jetbrains.kotlin:kotlin-reflect:${getKotlinVersion()}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="org.unimodules.test.core">
+
+</manifest>

package/android/src/main/java/expo/modules/test/core/ModuleController.kt

@@ -0,0 +1,34 @@
+package expo.modules.test.core
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.events.EventName
+
+interface ModuleController {
+  fun onCreate()
+  fun onDestroy()
+  fun onActivityEntersForeground()
+  fun onActivityEntersBackground()
+  fun onActivityDestroys()
+}
+
+class ModuleControllerImpl(private val holder: ModuleHolder) : ModuleController {
+  override fun onCreate() {
+    holder.post(EventName.MODULE_CREATE)
+  }
+
+  override fun onDestroy() {
+    holder.post(EventName.MODULE_DESTROY)
+  }
+
+  override fun onActivityEntersForeground() {
+    holder.post(EventName.ACTIVITY_ENTERS_FOREGROUND)
+  }
+
+  override fun onActivityEntersBackground() {
+    holder.post(EventName.ACTIVITY_ENTERS_BACKGROUND)
+  }
+
+  override fun onActivityDestroys() {
+    holder.post(EventName.ACTIVITY_DESTROYS)
+  }
+}

package/android/src/main/java/expo/modules/test/core/ModuleMock.kt

@@ -0,0 +1,86 @@
+package expo.modules.test.core
+
+import android.os.Bundle
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.ReactApplicationContext
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.modules.Module
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import java.lang.ref.WeakReference
+import java.lang.reflect.Proxy
+import kotlin.reflect.KClass
+
+class ModuleMock {
+  companion object {
+    fun <T : Any> createMock(
+      moduleTestInterface: KClass<T>,
+      module: Module,
+      customAppContext: AppContext? = null,
+      customEventEmitter: EventEmitter? = null,
+    ): Triple<T, AppContext, EventEmitter> {
+      val context = ReactApplicationContext(ApplicationProvider.getApplicationContext())
+      val appContext = customAppContext ?: AppContext(
+        modulesProvider = mockk(relaxed = true),
+        legacyModuleRegistry = mockk(relaxed = true),
+        reactContextHolder = WeakReference(context)
+      )
+
+      val eventEmitter: EventEmitter = customEventEmitter ?: mockk(relaxed = true)
+
+      val moduleSpy = spyk(module)
+      every { moduleSpy getProperty "appContext" } returns appContext
+      every { moduleSpy.sendEvent(any(), any()) } answers { call ->
+        val (eventName, eventBody) = call.invocation.args
+        eventEmitter.emit(eventName as String, eventBody as? Bundle)
+      }
+
+      val holder = ModuleHolder(moduleSpy)
+      val moduleControllerImpl = ModuleControllerImpl(holder)
+
+      val invocationHandler = ModuleMockInvocationHandler(
+        moduleTestInterface,
+        moduleControllerImpl,
+        holder
+      )
+      @Suppress("UNCHECKED_CAST")
+      return Triple(
+        Proxy
+          .newProxyInstance(
+            moduleTestInterface.java.classLoader,
+            arrayOf(moduleTestInterface.java, ModuleController::class.java),
+            invocationHandler
+          ) as T,
+        appContext,
+        eventEmitter
+      )
+    }
+
+    inline fun <T : Any> createMock(
+      moduleTestInterface: KClass<T>,
+      module: Module,
+      autoOnCreate: Boolean = true,
+      customAppContext: AppContext? = null,
+      customEventEmitter: EventEmitter? = null,
+      block: ModuleMockHolder<T>.() -> Unit
+    ) {
+      val (mock, appContext, eventEmitter) = createMock(
+        moduleTestInterface,
+        module,
+        customAppContext,
+        customEventEmitter
+      )
+      val controller = mock as ModuleController
+      val holder = ModuleMockHolder<T>(mock, controller, appContext, eventEmitter)
+
+      if (autoOnCreate) {
+        controller.onCreate()
+      }
+
+      block.invoke(holder)
+    }
+  }
+}

package/android/src/main/java/expo/modules/test/core/ModuleMockHolder.kt

@@ -0,0 +1,11 @@
+package expo.modules.test.core
+
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.AppContext
+
+data class ModuleMockHolder<T>(
+  val module: T,
+  val controller: ModuleController,
+  val appContext: AppContext,
+  val eventEmitter: EventEmitter
+)

package/android/src/main/java/expo/modules/test/core/ModuleMockInvocationHandler.kt

@@ -0,0 +1,104 @@
+package expo.modules.test.core
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.JSTypeConverter
+import java.lang.reflect.InvocationHandler
+import java.lang.reflect.Method
+import kotlin.reflect.KClass
+
+/**
+ * The promise rejection will be converted into this exception.
+ */
+class TestCodedException(
+  code: String,
+  message: String?,
+  cause: Throwable?
+) : Exception("[$code] $message", cause)
+
+/**
+ * Mocked module invocation handler which dispatches a call on test interface to the corresponding
+ * exported function or to the module controller if the method doesn't exist in the module definition.
+ *
+ * Methods mapping:
+ *   function("name") { args: ArgsType -> return ReturnType } can be invoked using one of the following methods mapping rules:
+ *     - [non-promise mapping] fun ModuleTestInterface.name(args: ArgsType): ReturnType
+ *     - [promise mapping] fun ModuleTestInterface.name(args: ArgsType, promise: Promise): Unit
+ *
+ *   function("name") { args: ArgsType, promise: Promise -> promise.resolve(ReturnType) } can be invoked using one of the following methods mapping rules:
+ *     - [non-promise mapping] fun ModuleTestInterface.name(args: ArgsType): ReturnType
+ *     - [promise mapping] fun ModuleTestInterface.name(args: ArgsType, promise: Promise): Unit
+ *
+ * In tests, the non-promise mapping should be preferred if possible.
+ * The promise mapping should be only used when dealing with native async code.
+ *
+ * In the non-promise mapping, rejection will be converted into exceptions.
+ * If you want to test if the method rejects, add the `@Throws` annotation to the `ModuleTestInterface` method you are testing.
+ * Otherwise, the exception will be wrapped in `UndeclaredThrowableException`.
+ */
+class ModuleMockInvocationHandler<T : Any>(
+  private val moduleTestInterface: KClass<T>,
+  private val moduleController: ModuleController,
+  private val holder: ModuleHolder
+) : InvocationHandler {
+  override fun invoke(proxy: Any, method: Method, args: Array<out Any>?): Any? {
+    if (!holder.definition.methods.containsKey(method.name)) {
+      return method.invoke(moduleController, *(args ?: emptyArray()))
+    }
+
+    return callExportedFunction(method.name, args)
+  }
+
+  private fun callExportedFunction(methodName: String, args: Array<out Any>?): Any? {
+    val lastArg = args?.lastOrNull()
+    if (Promise::class.java.isInstance(lastArg)) {
+      promiseMappingCall(methodName, args!!.dropLast(1), lastArg as Promise)
+      return Unit
+    }
+
+    return nonPromiseMappingCall(methodName, args)
+  }
+
+  private fun nonPromiseMappingCall(methodName: String, args: Array<out Any>?): Any? {
+    val mockedPromise = PromiseMock()
+    holder.call(methodName, convertArgs(args?.asList() ?: emptyList()), mockedPromise)
+
+    when (mockedPromise.state) {
+      PromiseState.RESOLVED -> {
+        val moduleClassMethod = moduleTestInterface.members.firstOrNull { it.name == methodName }
+          ?: throw IllegalStateException("Module class method '$methodName' not found")
+
+        if (mockedPromise.resolveValue == null) {
+          if (moduleClassMethod.returnType.isMarkedNullable) {
+            return null
+          }
+
+          throw IllegalStateException("Method returns 'null' but the non-nullable type was expected")
+        }
+
+        if (!(moduleClassMethod.returnType.classifier as KClass<*>).isInstance(mockedPromise.resolveValue)) {
+          throw IllegalStateException("Illegal return type ${mockedPromise.resolveValue?.javaClass}, expected ${moduleClassMethod.returnType.classifier}.")
+        }
+
+        return mockedPromise.resolveValue
+      }
+      PromiseState.REJECTED ->
+        throw TestCodedException(
+          mockedPromise.rejectCode!!,
+          mockedPromise.rejectMessage,
+          mockedPromise.rejectThrowable
+        )
+      PromiseState.NONE, PromiseState.ILLEGAL ->
+        throw IllegalStateException("Illegal promise state '${mockedPromise.state}'")
+    }
+  }
+
+  private fun promiseMappingCall(methodName: String, args: List<Any>, promise: Promise) {
+    holder.call(methodName, convertArgs(args), promise)
+  }
+
+  private fun convertArgs(args: Iterable<Any?>): ReadableArray {
+    return JSTypeConverter.convertToJSValue(args, TestJSContainerProvider) as ReadableArray
+  }
+}

package/android/src/main/java/expo/modules/test/core/PromiseMock.kt

@@ -0,0 +1,71 @@
+// copied from expo-modules-core
+package expo.modules.test.core
+
+import expo.modules.kotlin.Promise
+
+enum class PromiseState {
+  NONE,
+  REJECTED,
+  RESOLVED,
+  ILLEGAL
+}
+
+class PromiseMock : Promise {
+
+  var state = PromiseState.NONE
+
+  var resolveValueSet: Boolean = false
+  var resolveValue: Any? = null
+    set(value) {
+      this.resolveValueSet = true
+      field = value
+    }
+
+  var rejectCodeSet: Boolean = false
+  var rejectCode: String? = null
+    set(value) {
+      this.rejectCodeSet = true
+      field = value
+    }
+
+  var rejectMessageSet: Boolean = false
+  var rejectMessage: String? = null
+    set(value) {
+      this.rejectMessageSet = true
+      field = value
+    }
+
+  var rejectThrowableSet: Boolean = false
+  var rejectThrowable: Throwable? = null
+    set(value) {
+      this.rejectThrowableSet = true
+      field = value
+    }
+
+  override fun resolve(value: Any?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.RESOLVED
+    resolveValue = value
+  }
+
+  override fun reject(code: String, message: String?, cause: Throwable?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.REJECTED
+    rejectCode = code
+    rejectMessage = message
+    rejectThrowable = cause
+  }
+
+  private fun assertNotResolvedNorRejected() {
+    when (state) {
+      PromiseState.RESOLVED,
+      PromiseState.REJECTED,
+      PromiseState.ILLEGAL -> {
+        state = PromiseState.ILLEGAL
+        throw IllegalStateException("Cannot resolve same promise twice!")
+      }
+      else -> {
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/test/core/TestJSContainerProvider.kt

@@ -0,0 +1,12 @@
+package expo.modules.test.core
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import expo.modules.kotlin.types.JSTypeConverter
+
+object TestJSContainerProvider : JSTypeConverter.ContainerProvider {
+  override fun createMap(): WritableMap = JavaOnlyMap()
+  override fun createArray(): WritableArray = JavaOnlyArray()
+}

package/android/src/main/java/expo/modules/test/core/TestUtils.kt

@@ -0,0 +1,32 @@
+package expo.modules.test.core
+
+import org.junit.Assert
+
+fun assertResolved(promise: PromiseMock) {
+  Assert.assertEquals(PromiseState.RESOLVED, promise.state)
+}
+
+fun assertRejected(promise: PromiseMock) {
+  Assert.assertEquals(PromiseState.REJECTED, promise.state)
+}
+
+inline fun <reified ResolveType> promiseResolved(promise: PromiseMock, with: (ResolveType) -> Unit) {
+  assertResolved(promise)
+  Assert.assertTrue(
+    "Promise resolved with incorrect type: ${ResolveType::class.simpleName}",
+    promise.resolveValue is ResolveType
+  )
+  with(promise.resolveValue as ResolveType)
+}
+
+fun promiseRejected(promise: PromiseMock, with: (PromiseMock) -> Unit) {
+  assertRejected(promise)
+  with(promise)
+}
+
+fun assertRejectedWithCode(promise: PromiseMock, rejectCode: String) {
+  promiseRejected(promise) {
+    Assert.assertTrue("Promise has no rejection code", it.rejectCodeSet)
+    Assert.assertEquals(it.rejectCode, rejectCode)
+  }
+}

package/android/src/main/java/org/unimodules/test/core/PromiseMock.kt

@@ -0,0 +1,88 @@
+package org.unimodules.test.core
+
+import expo.modules.core.Promise
+
+enum class PromiseState {
+  NONE,
+  REJECTED,
+  RESOLVED,
+  ILLEGAL
+}
+
+class PromiseMock : Promise {
+
+  var state = PromiseState.NONE
+
+  var resolveValueSet: Boolean = false
+  var resolveValue: Any? = null
+    set(value) {
+      this.resolveValueSet = true
+      field = value
+    }
+
+  var rejectCodeSet: Boolean = false
+  var rejectCode: String? = null
+    set(value) {
+      this.rejectCodeSet = true
+      field = value
+    }
+
+  var rejectMessageSet: Boolean = false
+  var rejectMessage: String? = null
+    set(value) {
+      this.rejectMessageSet = true
+      field = value
+    }
+
+  var rejectThrowableSet: Boolean = false
+  var rejectThrowable: Throwable? = null
+    set(value) {
+      this.rejectThrowableSet = true
+      field = value
+    }
+
+  override fun resolve(value: Any?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.RESOLVED
+    resolveValue = value
+  }
+
+  override fun reject(code: String?, message: String?, e: Throwable?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.REJECTED
+    rejectCode = code
+    rejectMessage = message
+    rejectThrowable = e
+  }
+
+  override fun reject(e: Throwable?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.REJECTED
+    rejectThrowable = e
+  }
+
+  override fun reject(code: String?, message: String?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.REJECTED
+    rejectCode = code
+    rejectMessage = message
+  }
+
+  override fun reject(code: String?, e: Throwable?) {
+    assertNotResolvedNorRejected()
+    state = PromiseState.REJECTED
+    rejectCode = code
+    rejectThrowable = e
+  }
+
+  private fun assertNotResolvedNorRejected() {
+    when (state) {
+      PromiseState.RESOLVED, PromiseState.REJECTED, PromiseState.ILLEGAL -> {
+        state = PromiseState.ILLEGAL
+        throw IllegalStateException("Cannot resolve same promise twice!")
+      }
+      else -> {
+      }
+    }
+  }
+}

package/android/src/main/java/org/unimodules/test/core/TestUtils.kt

@@ -0,0 +1,66 @@
+package org.unimodules.test.core
+
+import android.os.Bundle
+import junit.framework.ComparisonFailure
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import expo.modules.core.arguments.MapArguments
+import expo.modules.core.arguments.ReadableArguments
+
+fun assertSetsEqual(first: Set<*>, second: Set<*>, message: String = "") {
+  if (!first.all { second.contains(it) }) {
+    throw ComparisonFailure(message, first.toString(), second.toString())
+  }
+}
+
+fun assertListsEqual(first: List<*>?, second: List<*>?, message: String = "") {
+  if (first == second) return
+
+  if (first == null || second == null) {
+    throw throw ComparisonFailure(message, first.toString(), second.toString())
+  }
+
+  if (!first.toTypedArray().contentDeepEquals(second.toTypedArray())) {
+    throw ComparisonFailure(message, first.toString(), second.toString())
+  }
+}
+
+fun assertResolved(promise: PromiseMock) {
+  assertEquals(PromiseState.RESOLVED, promise.state)
+}
+
+fun assertRejected(promise: PromiseMock) {
+  assertEquals(PromiseState.REJECTED, promise.state)
+}
+
+fun promiseResolved(promise: PromiseMock, with: (Bundle) -> Unit) {
+  assertResolved(promise)
+  with(promise.resolveValue as Bundle)
+}
+
+inline fun <reified T> promiseResolvedWithType(promise: PromiseMock, with: (T) -> Unit) {
+  assertResolved(promise)
+  assertTrue("Promise resolved with incorrect type", promise.resolveValue is T)
+  with(promise.resolveValue as T)
+}
+
+fun promiseRejected(promise: PromiseMock, with: (PromiseMock) -> Unit) {
+  assertRejected(promise)
+  with(promise)
+}
+
+fun assertRejectedWithCode(promise: PromiseMock, rejectCode: String) {
+  promiseRejected(promise) {
+    assertTrue("Promise has no rejection code", it.rejectCodeSet)
+    assertEquals(it.rejectCode, rejectCode)
+  }
+}
+
+fun readableArgumentsOf(values: Map<String, Any>): ReadableArguments {
+  return MapArguments(values)
+}
+
+fun assertStringValueNull(bundle: Bundle, key: String) {
+  assertTrue(bundle.containsKey(key))
+  assertEquals(null, bundle.getString(key))
+}

package/android/src/main/java/org/unimodules/test/core/UnimoduleMocks.kt

@@ -0,0 +1,70 @@
+package org.unimodules.test.core
+
+import io.mockk.MockKGateway
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.interfaces.InternalModule
+import java.util.*
+
+@JvmOverloads
+fun moduleRegistryMock(
+  internalModules: List<InternalModule> = Collections.emptyList(),
+  exportedModules: List<ExportedModule> = Collections.emptyList()
+): ModuleRegistry {
+  return mockk<ModuleRegistry>().also {
+    mockInternalModules(it, internalModules)
+    mockExternalModules(it, exportedModules)
+  }
+}
+
+inline fun <reified T : InternalModule> mockkInternalModule(relaxed: Boolean = false, asInterface: Class<*> = T::class.java): T {
+  val mock: T = mockk(relaxed = relaxed)
+  every { mock.exportedInterfaces } returns listOf(asInterface)
+  return mock
+}
+
+private fun mockInternalModules(mock: ModuleRegistry, internalModules: List<InternalModule>) {
+  internalModules.forEach {
+    mock.mockInternalModule(it)
+  }
+  every { mock.getModule<Any>(any()) } returns null
+}
+
+private fun mockExternalModules(mock: ModuleRegistry, exportedModules: List<ExportedModule>) {
+  exportedModules.forEach {
+    every { mock.getExportedModule(it.name) } returns it
+  }
+  every { mock.getExportedModule(any()) } returns null
+}
+
+fun ModuleRegistry.mockInternalModule(module: InternalModule) =
+  if (!this.isMock) {
+    throw IllegalStateException("Mocking modules available only for mocked module registry!")
+  } else {
+    module.exportedInterfaces.forEach {
+      every { this@mockInternalModule.getModule(it) } returns module
+    }
+  }
+
+fun ModuleRegistry.mockExportedModule(module: ExportedModule) =
+  if (!this.isMock) {
+    throw IllegalStateException("Mocking modules available only for mocked module registry!")
+  } else {
+    every { this@mockExportedModule.getExportedModule(module.name) } returns module
+  }
+
+fun mockPromise(): PromiseMock {
+  return spyk()
+}
+
+private val <T : Any> T.isMock: Boolean
+  get() {
+    return try {
+      MockKGateway.implementation().mockFactory.isMock(this)
+    } catch (e: UninitializedPropertyAccessException) {
+      false
+    }
+  }

package/app.plugin.js

@@ -0,0 +1,46 @@
+const { withProjectBuildGradle } = require('@expo/config-plugins');
+const kotlinClassPath = 'org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion';
+
+const withKotlinGradle = (config, version) => {
+  return withProjectBuildGradle(config, config => {
+    if (config.modResults.language === 'groovy') {
+      config.modResults.contents = setKotlinVersion(config.modResults.contents, version);
+      config.modResults.contents = setKotlinClassPath(config.modResults.contents);
+    } else {
+      throw new Error('Cannot setup kotlin because the build.gradle is not groovy');
+    }
+    return config;
+  });
+};
+
+function setKotlinVersion(buildGradle, version) {
+  const pattern = /kotlinVersion\s?=\s?(["'])(?:(?=(\\?))\2.)*?\1/g;
+  const replacement = `kotlinVersion = "${version}"`;
+  if (buildGradle.match(pattern)) {
+    // Select kotlinVersion = '***' and replace the contents between the quotes.
+    return buildGradle.replace(pattern, replacement);
+  }
+  return buildGradle.replace(
+    /ext\s?{/,
+    `ext {
+        ${replacement}`
+  );
+}
+
+function setKotlinClassPath(buildGradle) {
+  if (buildGradle.includes(kotlinClassPath)) {
+    return buildGradle;
+  }
+
+  return buildGradle.replace(
+    /dependencies\s?{/,
+    `dependencies {
+        classpath "${kotlinClassPath}"`
+  );
+}
+
+const withUnimodulesTestCore = (config) => {
+    return withKotlinGradle(config, '1.3.50');
+}
+
+module.exports = withUnimodulesTestCore;

package/ios/ExpoModulesTestCore.podspec

@@ -0,0 +1,24 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoModulesTestCore'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '12.0'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
+  s.header_dir     = 'ExpoModulesTestCore'
+
+  s.source_files   = '**/*.{h,m,mm,swift}'
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'Quick', '~> 5.0.0'
+  s.dependency 'Nimble', '~> 9.2.0'
+end

package/ios/ExpoSpec.swift

@@ -0,0 +1,9 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#if DEBUG
+@_exported import Quick
+@_exported import Nimble
+@_exported @testable import ExpoModulesCore
+
+open class ExpoSpec: QuickSpec {}
+#endif

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "expo-modules-test-core",
+  "version": "0.8.0",
+  "main": "./app.plugin.js",
+  "description": "Module providing native testing utilities for testing Expo modules",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-modules",
+    "expo-modules-core",
+    "expo-modules-test-core"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expo/expo.git",
+    "directory": "packages/expo-modules-test-core"
+  },
+  "bugs": {
+    "url": "https://github.com/expo/expo/issues"
+  },
+  "author": "650 Industries, Inc.",
+  "license": "MIT",
+  "homepage": "https://github.com/expo/expo/tree/main/packages/expo-modules-test-core",
+  "gitHead": "22dce752354bb429c84851bc4389abe47a766b1f"
+}