expo-modules-test-core 0.17.2 → 0.18.0

package/android/build.gradle

@@ -1,113 +1,24 @@
 apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-apply plugin: 'maven-publish'
 
 group = 'org.unimodules'
-version = '0.17.2'
+version = '0.18.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-if (expoModulesCorePlugin.exists()) {
-  apply from: expoModulesCorePlugin
-  applyKotlinExpoModulesCorePlugin()
-  // Remove this check, but keep the contents after SDK49 support is dropped
-  if (safeExtGet("expoProvidesDefaultConfig", false)) {
-    useExpoPublishing()
-    useCoreDependencies()
-  }
-}
-
-buildscript {
-  // 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.8.10")
-    }
-  }
-
-  repositories {
-    mavenCentral()
-  }
-
-  dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
-  }
-}
-
-// Remove this if and it's contents, when support for SDK49 is dropped
-if (!safeExtGet("expoProvidesDefaultConfig", false)) {
-  afterEvaluate {
-    publishing {
-      publications {
-        release(MavenPublication) {
-          from components.release
-        }
-      }
-      repositories {
-        maven {
-          url = mavenLocal().url
-        }
-      }
-    }
-  }
-}
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useDefaultAndroidSdkVersions()
+useExpoPublishing()
 
 android {
-  // Remove this if and it's contents, when support for SDK49 is dropped
-  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
-    compileSdkVersion safeExtGet("compileSdkVersion", 34)
-
-    defaultConfig {
-      minSdkVersion safeExtGet("minSdkVersion", 23)
-      targetSdkVersion safeExtGet("targetSdkVersion", 34)
-    }
-
-    publishing {
-      singleVariant("release") {
-        withSourcesJar()
-      }
-    }
-
-    lintOptions {
-      abortOnError false
-    }
-  }
-
-  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-  if (agpVersion.tokenize('.')[0].toInteger() < 8) {
-    compileOptions {
-      sourceCompatibility JavaVersion.VERSION_11
-      targetCompatibility JavaVersion.VERSION_11
-    }
-
-    kotlinOptions {
-      jvmTarget = JavaVersion.VERSION_11.majorVersion
-    }
-  }
-
   namespace "org.unimodules.test.core"
   defaultConfig {
     versionCode 3
-    versionName '0.17.2'
+    versionName '0.18.0'
   }
 }
 
-repositories {
-  mavenCentral()
-}
-
 dependencies {
-  // Remove this if and it's contents, when support for SDK49 is dropped
-  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
-    implementation project(':expo-modules-core')
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
-  }
   api 'androidx.test:core:1.5.0'
   api 'junit:junit:4.13.2'
   api 'io.mockk:mockk:1.13.5'
@@ -115,5 +26,5 @@ dependencies {
 
   implementation 'com.facebook.react:react-android'
 
-  implementation "org.jetbrains.kotlin:kotlin-reflect:${getKotlinVersion()}"
+  implementation "org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion()}"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-test-core",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "main": "./app.plugin.js",
   "description": "Module providing native testing utilities for testing Expo modules",
   "keywords": [
@@ -34,5 +34,5 @@
     "xml-js": "^1.6.11",
     "yaml": "^2.3.2"
   },
-  "gitHead": "3b5abfe819bdcbd5e9eb4090da1be2305ff0589b"
+  "gitHead": "4165b8d72e1b9a1889c2767534cc619e21468110"
 }

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

@@ -1,88 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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
-    }
-  }