expo-modules-test-core 0.8.0 → 0.9.0

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'org.unimodules'
-version = '0.8.0'
+version = '0.9.0'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -74,7 +74,7 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 31)
     versionCode 3
-    versionName '0.8.0'
+    versionName '0.9.0'
   }
   lintOptions {
     abortOnError false
@@ -98,3 +98,13 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
   implementation "org.jetbrains.kotlin:kotlin-reflect:${getKotlinVersion()}"
 }
+
+/**
+ * To make the users of annotations @OptIn and @RequiresOptIn aware of their experimental status,
+ * the compiler raises warnings when compiling the code with these annotations:
+ * This class can only be used with the compiler argument '-Xopt-in=kotlin.RequiresOptIn'
+ * To remove the warnings, we add the compiler argument -Xopt-in=kotlin.RequiresOptIn.
+ */
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+  kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
+}

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

@@ -1,5 +1,6 @@
 package expo.modules.test.core
 
+import android.content.Context
 import android.os.Bundle
 import androidx.test.core.app.ApplicationProvider
 import com.facebook.react.bridge.ReactApplicationContext
@@ -7,6 +8,8 @@ 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.MockK
+import io.mockk.MockKGateway
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.spyk
@@ -14,26 +17,39 @@ import java.lang.ref.WeakReference
 import java.lang.reflect.Proxy
 import kotlin.reflect.KClass
 
-class ModuleMock {
+/**
+ * This class shouldn't be used directly. Instead use
+ * ```kotlin
+ * ModuleMock.createMock(MyModuleTestInterface::class, MyModule()) {
+ *   // module test code here
+ * }
+ * ```
+ */
+data class ModuleMock<TestInterfaceType : Any, ModuleType : Module>(
+  val testInterface: TestInterfaceType,
+  val appContext: AppContext,
+  val eventEmitter: EventEmitter,
+  val moduleSpy: ModuleType
+) {
   companion object {
-    fun <T : Any> createMock(
-      moduleTestInterface: KClass<T>,
-      module: Module,
+    /**
+     * This overload shouldn't be used directly. Instead use
+     * the inline overload with `block` being the last argument:
+     * `ModuleMock.createMock(..., block: (...) -> Unit)` instead
+     */
+    fun <TestInterfaceType : Any, ModuleType : Module> createMock(
+      moduleTestInterface: KClass<TestInterfaceType>,
+      module: ModuleType,
       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)
-      )
-
+      customEventEmitter: EventEmitter? = null
+    ): ModuleMock<TestInterfaceType, ModuleType> {
+      val appContext = prepareMockAppContext(customAppContext)
       val eventEmitter: EventEmitter = customEventEmitter ?: mockk(relaxed = true)
 
-      val moduleSpy = spyk(module)
+      // prepare module spy
+      val moduleSpy = convertToSpy(module, recordPrivateCalls = true)
       every { moduleSpy getProperty "appContext" } returns appContext
-      every { moduleSpy.sendEvent(any(), any()) } answers { call ->
+      every { moduleSpy.sendEvent(any(), any<Bundle>()) } answers { call ->
         val (eventName, eventBody) = call.invocation.args
         eventEmitter.emit(eventName as String, eventBody as? Bundle)
       }
@@ -47,34 +63,48 @@ class ModuleMock {
         holder
       )
       @Suppress("UNCHECKED_CAST")
-      return Triple(
+      return ModuleMock(
         Proxy
           .newProxyInstance(
             moduleTestInterface.java.classLoader,
             arrayOf(moduleTestInterface.java, ModuleController::class.java),
             invocationHandler
-          ) as T,
+          ) as TestInterfaceType,
         appContext,
-        eventEmitter
+        eventEmitter,
+        moduleSpy
       )
     }
 
-    inline fun <T : Any> createMock(
-      moduleTestInterface: KClass<T>,
-      module: Module,
+    /**
+     * Executes the given [block] in the mocked module scope.
+     * Example usage:
+     * ```kotlin
+     * ModuleMock.createMock(MyModuleTestInterface::class, MyModule()) {
+     *   every { moduleSpy.someModulePrivateFn() } returns 5
+     *   val result = module.someFunctionAsync()
+     *   assertEquals(result, 5)
+     * }
+     * ```
+     */
+    inline fun <TestInterfaceType : Any, ModuleType : Module> createMock(
+      moduleTestInterface: KClass<TestInterfaceType>,
+      module: ModuleType,
       autoOnCreate: Boolean = true,
       customAppContext: AppContext? = null,
       customEventEmitter: EventEmitter? = null,
-      block: ModuleMockHolder<T>.() -> Unit
+      block: ModuleMockHolder<TestInterfaceType, ModuleType>.() -> Unit
     ) {
-      val (mock, appContext, eventEmitter) = createMock(
+      val (mock, appContext, eventEmitter, moduleSpy) = createMock(
         moduleTestInterface,
         module,
         customAppContext,
         customEventEmitter
       )
       val controller = mock as ModuleController
-      val holder = ModuleMockHolder<T>(mock, controller, appContext, eventEmitter)
+      val holder = ModuleMockHolder<TestInterfaceType, ModuleType>(
+        mock, controller, appContext, eventEmitter, moduleSpy
+      )
 
       if (autoOnCreate) {
         controller.onCreate()
@@ -84,3 +114,39 @@ class ModuleMock {
     }
   }
 }
+
+private fun prepareMockAppContext(customAppContext: AppContext?): AppContext {
+  val reactContext = ReactApplicationContext(ApplicationProvider.getApplicationContext<Context>())
+  val appContext = customAppContext ?: AppContext(
+    modulesProvider = mockk(relaxed = true),
+    legacyModuleRegistry = mockk(relaxed = true),
+    reactContextHolder = WeakReference(reactContext)
+  )
+
+  // as AppContext holds only weak reference to Android Context which can be destroyed too early
+  // we need to override it to return actual strong reference (held by mockk internals)
+  val appContextSpy = convertToSpy(appContext)
+  every { appContextSpy getProperty "reactContext" } returns reactContext
+
+  return appContextSpy
+}
+
+/**
+ * Creates a spy from a given object or returns it as-is if it's already a spy
+ */
+private fun <T : Any> convertToSpy(obj: T, recordPrivateCalls: Boolean = false): T =
+  MockK.useImpl {
+    return@useImpl if (MockKGateway.implementation().mockTypeChecker.isSpy(obj)) {
+      obj
+    } else {
+      // this is actually spyk<T>(obj) but without syntax sugar
+      // because we're already inside MockK.useImpl { } which is part of that sugar
+      MockKGateway.implementation().mockFactory.spyk(
+        mockType = null, // this should be null if objToCopy is provided
+        objToCopy = obj,
+        name = null,
+        moreInterfaces = emptyArray(),
+        recordPrivateCalls = recordPrivateCalls
+      )
+    }
+  }

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

@@ -2,10 +2,12 @@ package expo.modules.test.core
 
 import expo.modules.core.interfaces.services.EventEmitter
 import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.modules.Module
 
-data class ModuleMockHolder<T>(
-  val module: T,
+data class ModuleMockHolder<TestInterfaceType, ModuleType : Module>(
+  val module: TestInterfaceType,
   val controller: ModuleController,
   val appContext: AppContext,
-  val eventEmitter: EventEmitter
+  val eventEmitter: EventEmitter,
+  val moduleSpy: ModuleType
 )

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

@@ -22,14 +22,17 @@ class TestCodedException(
  * 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:
+ *   AsyncFunction("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:
+ *   AsyncFunction("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
  *
+ *   Function("name") { args: ArgsType -> return ReturnType } can be invoked using non-promise mapping only:
+ *     - fun ModuleTestInterface.name(args: ArgsType): ReturnType
+ *
  * In tests, the non-promise mapping should be preferred if possible.
  * The promise mapping should be only used when dealing with native async code.
  *
@@ -43,7 +46,9 @@ class ModuleMockInvocationHandler<T : Any>(
   private val holder: ModuleHolder
 ) : InvocationHandler {
   override fun invoke(proxy: Any, method: Method, args: Array<out Any>?): Any? {
-    if (!holder.definition.methods.containsKey(method.name)) {
+    if (!holder.definition.asyncFunctions.containsKey(method.name) &&
+      !holder.definition.syncFunctions.containsKey(method.name)
+    ) {
       return method.invoke(moduleController, *(args ?: emptyArray()))
     }
 
@@ -51,13 +56,23 @@ class ModuleMockInvocationHandler<T : Any>(
   }
 
   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
+    if (holder.definition.syncFunctions.containsKey(methodName)) {
+      // Call as a sync function
+      return holder.callSync(methodName, convertArgs(args?.asList() ?: emptyList()))
     }
 
-    return nonPromiseMappingCall(methodName, args)
+    if (holder.definition.asyncFunctions.containsKey(methodName)) {
+      // We know it's a async function, but we don't know which mapping we're using
+      val lastArg = args?.lastOrNull()
+      if (Promise::class.java.isInstance(lastArg)) {
+        promiseMappingCall(methodName, args!!.dropLast(1), lastArg as Promise)
+        return Unit
+      }
+
+      return nonPromiseMappingCall(methodName, args)
+    }
+
+    throw IllegalStateException("Module class method '$methodName' not found")
   }
 
   private fun nonPromiseMappingCall(methodName: String, args: Array<out Any>?): Any? {
@@ -98,6 +113,10 @@ class ModuleMockInvocationHandler<T : Any>(
     holder.call(methodName, convertArgs(args), promise)
   }
 
+  private fun syncCall(methodName: String, args: Iterable<Any?>): Any? {
+    return holder.callSync(methodName, convertArgs(args))
+  }
+
   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

@@ -10,6 +10,11 @@ enum class PromiseState {
   ILLEGAL
 }
 
+/**
+ * The [Promise] mock that should be used in conjunction with promise-mapped functions
+ * in the module test interface. See [ModuleMockInvocationHandler] documentation for more details
+ * @see ModuleMockInvocationHandler
+ */
 class PromiseMock : Promise {
 
   var state = PromiseState.NONE

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

@@ -6,7 +6,7 @@ import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import expo.modules.kotlin.types.JSTypeConverter
 
-object TestJSContainerProvider : JSTypeConverter.ContainerProvider {
+internal 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

@@ -1,32 +1,47 @@
 package expo.modules.test.core
 
+import expo.modules.kotlin.exception.CodedException
 import org.junit.Assert
+import java.lang.reflect.UndeclaredThrowableException
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
 
-fun assertResolved(promise: PromiseMock) {
-  Assert.assertEquals(PromiseState.RESOLVED, promise.state)
-}
+/**
+ * Asserts that provided [exception] is a [CodedException]
+ */
+@OptIn(ExperimentalContracts::class)
+fun assertCodedException(exception: Throwable?) {
+  contract {
+    returns() implies (exception is CodedException)
+  }
 
-fun assertRejected(promise: PromiseMock) {
-  Assert.assertEquals(PromiseState.REJECTED, promise.state)
-}
+  Assert.assertNotNull("Expected exception, received null", exception)
 
-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)
-}
+  if (exception is UndeclaredThrowableException) {
+    Assert.fail(
+      "Expected CodedException, got UndeclaredThrowableException. " +
+        "Did you forget to add '@Throws' annotations to module test interface methods?"
+    )
+  }
 
-fun promiseRejected(promise: PromiseMock, with: (PromiseMock) -> Unit) {
-  assertRejected(promise)
-  with(promise)
+  if (exception !is CodedException) {
+    Assert.fail(
+      "Expected CodedException, got ${exception!!::class.simpleName}. " +
+        "Full stack trace:\n${exception.stackTraceToString()}"
+    )
+  }
 }
 
-fun assertRejectedWithCode(promise: PromiseMock, rejectCode: String) {
-  promiseRejected(promise) {
-    Assert.assertTrue("Promise has no rejection code", it.rejectCodeSet)
-    Assert.assertEquals(it.rejectCode, rejectCode)
+/**
+ * Asserts that provided [exception] is a [CodedException] and then executes a block with
+ * the [exception] as an argument
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun assertCodedException(exception: Throwable?, block: (exception: CodedException) -> Unit) {
+  contract {
+    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
   }
+  assertCodedException(exception)
+  block(exception)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-test-core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "main": "./app.plugin.js",
   "description": "Module providing native testing utilities for testing Expo modules",
   "keywords": [
@@ -21,5 +21,5 @@
   "author": "650 Industries, Inc.",
   "license": "MIT",
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo-modules-test-core",
-  "gitHead": "22dce752354bb429c84851bc4389abe47a766b1f"
+  "gitHead": "6e131f2da851a47c3a24eb3d6fc971a1a7822086"
 }