@datadog/mobile-react-native-session-replay 2.0.2-alpha.0

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/GenericAssert.kt

@@ -0,0 +1,69 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit
+
+import org.assertj.core.api.AbstractAssert
+import org.assertj.core.api.Assertions.assertThat
+
+class GenericAssert(actual: Any?) :
+    AbstractAssert<GenericAssert, Any>(actual, GenericAssert::class.java) {
+
+    fun doesNotHaveField(name: String): GenericAssert {
+        val field: Any? = actual.getFieldValue(name)
+        assertThat(field)
+            .overridingErrorMessage(
+                "Expecting object to not have $name, but found it having value $field"
+            )
+            .isNull()
+        return this
+    }
+
+    fun <T> getActualValue(name: String): T {
+        val field: Any? = actual.getFieldValue(name)
+        assertThat(field)
+            .overridingErrorMessage(
+                "Expecting object to have a non null field named $name, but field was null"
+            )
+            .isNotNull()
+        return field!! as T
+    }
+
+    fun hasField(name: String, nestedAssert: (GenericAssert) -> Unit = {}): GenericAssert {
+        val field: Any? = actual.getFieldValue(name)
+        assertThat(field)
+            .overridingErrorMessage(
+                "Expecting object to have a non null field named $name, but field was null"
+            )
+            .isNotNull()
+        nestedAssert(GenericAssert(field!!))
+        return this
+    }
+
+    fun <F> hasFieldEqualTo(name: String, expected: F): GenericAssert {
+        val field: Any? = actual.getFieldValue(name)
+        assertThat(field).isEqualTo(expected)
+        return this
+    }
+
+    fun hasFieldWithClass(name: String, expectedClassName: String): GenericAssert {
+        val field: Any? = actual.getFieldValue(name)
+        assertThat(field?.javaClass?.name).isEqualTo(expectedClassName)
+        return this
+    }
+
+    fun isInstanceOf(expectedClassName: String): GenericAssert {
+        val className = actual.javaClass.canonicalName!!
+        assertThat(className).isEqualTo(expectedClassName)
+        return this
+    }
+
+    companion object {
+        fun assertThat(actual: Any?): GenericAssert {
+            return GenericAssert(actual)
+        }
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/MapExt.kt

@@ -0,0 +1,29 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+fun Map<*, *>.toReadableMap(): ReadableMap {
+    val keysAndValues = mutableListOf<Any?>()
+
+    entries.forEach {
+        keysAndValues.add(it.key)
+        keysAndValues.add(it.value)
+    }
+
+    // this FB implementation is not backed by Android-specific .so library, so ok for unit tests
+    return JavaOnlyMap.of(*keysAndValues.toTypedArray())
+}
+
+fun List<*>.toReadableArray(): ReadableArray {
+    // this FB implementation is not backed by Android-specific .so library, so ok for unit tests
+    return JavaOnlyArray.from(this)
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/ReflectUtils.kt

@@ -0,0 +1,266 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit
+
+import java.lang.reflect.Field
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import java.util.LinkedList
+import kotlin.reflect.jvm.isAccessible
+
+/**
+ * Creates an instance of the given class name.
+ * @param className the full name of the class to instantiate
+ * @param params the parameters to provide the constructor
+ * @return the created instance
+ */
+@Suppress("SpreadOperator")
+fun createInstance(
+    className: String,
+    vararg params: Any?
+): Any {
+    return Class.forName(className)
+        .kotlin
+        .constructors.first()
+        .apply { isAccessible = true }
+        .call(*params)
+}
+
+/**
+ * Sets a static value on the target class.
+ * @param fieldName the name of the field
+ * @param fieldValue the value to set
+ */
+@Suppress("SwallowedException")
+inline fun <reified T, R> Class<T>.setStaticValue(
+    fieldName: String,
+    fieldValue: R
+) {
+    val field = getDeclaredField(fieldName)
+
+    // make it accessible
+    field.isAccessible = true
+
+    // Make it non final
+    try {
+        val modifiersField = Field::class.java.getDeclaredField("modifiers")
+        modifiersField.isAccessible = true
+        modifiersField.setInt(field, field.modifiers and Modifier.FINAL.inv())
+    } catch (e: NoSuchFieldException) {
+        // do nothing
+        @Suppress("PrintStackTrace")
+        e.printStackTrace()
+    }
+    field.set(null, fieldValue)
+}
+
+/**
+ * Gets the static value from the target class.
+ * @param className the full name of the class
+ * @param fieldName the name of the field
+ */
+inline fun <reified R> getStaticValue(
+    className: String,
+    fieldName: String
+): R {
+    val clazz = Class.forName(className)
+    val field = clazz.getDeclaredField(fieldName)
+    // make it accessible
+    field.isAccessible = true
+
+    return field.get(null) as R
+}
+
+/**
+ * Gets the static value from the target class.
+ * @param fieldName the name of the field
+ */
+inline fun <reified T, reified R> Class<T>.getStaticValue(fieldName: String): R {
+    val field = getDeclaredField(fieldName)
+
+    // make it accessible
+    field.isAccessible = true
+
+    return field.get(null) as R
+}
+
+/**
+ * Sets the field value on the target instance.
+ * @param fieldName the name of the field
+ * @param fieldValue the value of the field
+ */
+@Suppress("SwallowedException")
+inline fun <reified T> Any.setFieldValue(
+    fieldName: String,
+    fieldValue: T
+): Boolean {
+    var field: Field? = null
+    val classesToSearch = LinkedList<Class<*>>()
+    classesToSearch.add(this.javaClass)
+    val classesSearched = mutableSetOf<Class<*>>()
+
+    while (field == null && classesToSearch.isNotEmpty()) {
+        val toSearchIn = classesToSearch.remove()
+        try {
+            field = toSearchIn.getDeclaredField(fieldName)
+        } catch (e: NoSuchFieldException) {
+            // do nothing
+        }
+        classesSearched.add(toSearchIn)
+        toSearchIn.superclass?.let {
+            if (!classesSearched.contains(it)) {
+                classesToSearch.add(it)
+            }
+        }
+    }
+
+    // make it accessible
+    if (field != null) {
+        field.isAccessible = true
+
+        // Make it non final
+        val modifiersField = Field::class.java.getDeclaredField("modifiers")
+        modifiersField.isAccessible = true
+        modifiersField.setInt(field, field.modifiers and Modifier.FINAL.inv())
+
+        field.set(this, fieldValue)
+        return true
+    } else {
+        return false
+    }
+}
+
+/**
+ * Gets the field value from the target instance.
+ * @param fieldName the name of the field
+ */
+inline fun <reified T, R : Any> R.getFieldValue(
+    fieldName: String,
+    enclosingClass: Class<R> = this.javaClass
+): T {
+    val field = enclosingClass.getDeclaredField(fieldName)
+    field.isAccessible = true
+    return field.get(this) as T
+}
+
+/**
+ * Invokes a method on the target instance.
+ * @param methodName the name of the method
+ * @param params the parameters to provide the method
+ * @return the result from the invoked method
+ */
+@Suppress("SpreadOperator", "UNCHECKED_CAST", "TooGenericExceptionCaught")
+fun <T : Any> T.invokeMethod(
+    methodName: String,
+    vararg params: Any?
+): Any? {
+    val declarationParams = Array<Class<*>?>(params.size) {
+        params[it]?.javaClass
+    }
+
+    val method = getDeclaredMethodRecursively(methodName, true, declarationParams)
+    val wasAccessible = method.isAccessible
+
+    val output: Any?
+    method.isAccessible = true
+    try {
+        output = if (params.isEmpty()) {
+            method.invoke(this)
+        } else {
+            method.invoke(this, *params)
+        }
+    } catch (e: InvocationTargetException) {
+        throw e.cause ?: e
+    } finally {
+        method.isAccessible = wasAccessible
+    }
+
+    return output
+}
+
+/**
+ * Invokes a method on the target instance, where one or more of the parameters
+ * are generics.
+ * @param methodName the name of the method
+ * @param params the parameters to provide the method
+ * @return the result from the invoked method
+ */
+@Suppress("SpreadOperator", "UNCHECKED_CAST")
+fun <T : Any> T.invokeGenericMethod(
+    methodName: String,
+    vararg params: Any
+): Any? {
+    val declarationParams = Array<Class<*>?>(params.size) {
+        params[it].javaClass
+    }
+
+    val method = getDeclaredMethodRecursively(methodName, false, declarationParams)
+    val wasAccessible = method.isAccessible
+
+    val output: Any?
+    method.isAccessible = true
+    try {
+        output = if (params.isEmpty()) {
+            method.invoke(this)
+        } else {
+            method.invoke(this, *params)
+        }
+    } catch (e: InvocationTargetException) {
+        throw e.cause ?: e
+    } finally {
+        method.isAccessible = wasAccessible
+    }
+
+    return output
+}
+
+@Suppress("TooGenericExceptionCaught", "SwallowedException", "SpreadOperator")
+private fun <T : Any> T.getDeclaredMethodRecursively(
+    methodName: String,
+    matchingParams: Boolean,
+    declarationParams: Array<Class<*>?>
+): Method {
+    val classesToSearch = mutableListOf<Class<*>>(this.javaClass)
+    val classesSearched = mutableListOf<Class<*>>()
+    var method: Method?
+    do {
+        val lookingInClass = classesToSearch.removeAt(0)
+        classesSearched.add(lookingInClass)
+        method = try {
+            if (matchingParams) {
+                lookingInClass.getDeclaredMethod(methodName, *declarationParams)
+            } else {
+                lookingInClass.declaredMethods.firstOrNull {
+                    it.name == methodName &&
+                        it.parameterTypes.size == declarationParams.size
+                }
+            }
+        } catch (e: Throwable) {
+            null
+        }
+
+        val superclass = lookingInClass.superclass
+        if (superclass != null &&
+            !classesToSearch.contains(superclass) &&
+            !classesSearched.contains(superclass)
+        ) {
+            classesToSearch.add(superclass)
+        }
+        lookingInClass.interfaces.forEach {
+            if (!classesToSearch.contains(it) && !classesSearched.contains(it)) {
+                classesToSearch.add(it)
+            }
+        }
+    } while (method == null && classesToSearch.isNotEmpty())
+
+    checkNotNull(method) {
+        "Unable to access method $methodName on ${javaClass.canonicalName}"
+    }
+
+    return method
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/BaseConfigurator.kt

@@ -0,0 +1,24 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit.forge
+
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.ForgeConfigurator
+import fr.xgouchet.elmyr.jvm.useJvmFactories
+
+/**
+ * Base implementation of a [ForgeConfigurator], adding the JVM Forgery Factories (Date, …) and
+ * a [ThrowableForgeryFactory].
+ */
+open class BaseConfigurator :
+    ForgeConfigurator {
+    /** @inheritDoc */
+    override fun configure(forge: Forge) {
+        forge.addFactory(ThrowableForgeryFactory())
+        forge.useJvmFactories()
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/ForgeConfigurator.kt

@@ -0,0 +1,24 @@
+/*
+ *
+ *  * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ *  * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ *  * Copyright 2016-Present Datadog, Inc.
+ *
+ */
+
+package com.datadog.reactnative.tools.unit.forge
+
+import com.datadog.tools.unit.forge.BaseConfigurator
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.jvm.useJvmFactories
+
+internal class ForgeConfigurator : BaseConfigurator() {
+    override fun configure(forge: Forge) {
+        super.configure(forge)
+
+        forge.addFactory(TextWireframeForgeryFactory())
+        forge.addFactory(WireframeClipForgeryFactory())
+
+        forge.useJvmFactories()
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/TextWireframeForgeryFactory.kt

@@ -0,0 +1,64 @@
+/*
+ *
+ *  * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ *  * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ *  * Copyright 2016-Present Datadog, Inc.
+ *
+ */
+
+package com.datadog.reactnative.tools.unit.forge
+
+import com.datadog.android.sessionreplay.model.MobileSegment
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.ForgeryFactory
+
+internal class TextWireframeForgeryFactory :
+    ForgeryFactory<MobileSegment.Wireframe.TextWireframe> {
+    override fun getForgery(forge: Forge): MobileSegment.Wireframe.TextWireframe {
+        return MobileSegment.Wireframe.TextWireframe(
+            id = forge.aPositiveInt().toLong(),
+            x = forge.aPositiveLong(),
+            y = forge.aPositiveLong(),
+            width = forge.aPositiveLong(strict = true),
+            height = forge.aPositiveLong(strict = true),
+            text = forge.aString(),
+            shapeStyle = forge.aNullable {
+                MobileSegment.ShapeStyle(
+                    forge.aStringMatching("#[0-9A-F]{6}FF"),
+                    opacity = forge.aFloat(min = 0f, max = 1f),
+                    cornerRadius = forge.aPositiveLong()
+                )
+            },
+            textStyle = MobileSegment.TextStyle(
+                family = forge.aString(),
+                size = forge.aPositiveLong(strict = true),
+                color = forge.aStringMatching("#[0-9A-F]{6}FF")
+            ),
+            textPosition = forge.aNullable {
+                MobileSegment.TextPosition(
+                    padding = forge.aNullable {
+                        MobileSegment.Padding(
+                            forge.aNullable { aPositiveLong() },
+                            forge.aNullable { aPositiveLong() },
+                            forge.aNullable { aPositiveLong() },
+                            forge.aNullable { aPositiveLong() }
+                        )
+                    },
+                    alignment = forge.aNullable {
+                        MobileSegment.Alignment(
+                            horizontal = forge.aNullable {
+                                forge.aValueFrom(MobileSegment.Horizontal::class.java)
+                            },
+                            vertical = forge.aNullable {
+                                forge.aValueFrom(MobileSegment.Vertical::class.java)
+                            }
+                        )
+                    }
+                )
+            },
+            clip = forge.aNullable {
+                getForgery()
+            }
+        )
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/Throwable.kt

@@ -0,0 +1,31 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit.forge
+
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.ForgeryException
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.io.InvalidObjectException
+
+/**
+ * @return a random [Throwable] instance with a forged message.
+ */
+fun Forge.aThrowable(): Throwable {
+    val errorMessage = anAlphabeticalString()
+    return anElementFrom(
+        IOException(errorMessage),
+        IllegalStateException(errorMessage),
+        UnknownError(errorMessage),
+        ArrayIndexOutOfBoundsException(errorMessage),
+        NullPointerException(errorMessage),
+        ForgeryException(errorMessage),
+        InvalidObjectException(errorMessage),
+        UnsupportedOperationException(errorMessage),
+        FileNotFoundException(errorMessage)
+    )
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/ThrowableForgeryFactory.kt

@@ -0,0 +1,21 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.tools.unit.forge
+
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.ForgeryFactory
+
+/**
+ *  A [ForgeryFactory] generating a random [Throwable] instance with a forged message.
+ */
+class ThrowableForgeryFactory :
+    ForgeryFactory<Throwable> {
+    /** @inheritDoc */
+    override fun getForgery(forge: Forge): Throwable {
+        return forge.aThrowable()
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/tools/unit/forge/WireframeClipForgeryFactory.kt

@@ -0,0 +1,25 @@
+/*
+ *
+ *  * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ *  * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ *  * Copyright 2016-Present Datadog, Inc.
+ *
+ */
+
+package com.datadog.reactnative.tools.unit.forge
+
+import com.datadog.android.sessionreplay.model.MobileSegment
+import fr.xgouchet.elmyr.Forge
+import fr.xgouchet.elmyr.ForgeryFactory
+
+internal class WireframeClipForgeryFactory :
+    ForgeryFactory<MobileSegment.WireframeClip> {
+    override fun getForgery(forge: Forge): MobileSegment.WireframeClip {
+        return MobileSegment.WireframeClip(
+            top = forge.aNullable { aLong(min = 0, max = 100) },
+            bottom = forge.aNullable { aLong(min = 0, max = 100) },
+            left = forge.aNullable { aLong(min = 0, max = 100) },
+            right = forge.aNullable { aLong(min = 0, max = 100) }
+        )
+    }
+}

package/android/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -0,0 +1 @@
+mock-maker-inline