appium-espresso-driver 1.46.0

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/MobileBackdoorMethodTest.java

@@ -0,0 +1,110 @@
+package io.appium.espressoserver.test.model;
+
+import com.google.gson.Gson;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import io.appium.espressoserver.lib.model.BackdoorMethodArg;
+import io.appium.espressoserver.lib.model.InvocationTarget;
+import io.appium.espressoserver.lib.model.MobileBackdoorMethod;
+import io.appium.espressoserver.lib.model.MobileBackdoorParams;
+
+import static io.appium.espressoserver.test.assets.HelpersKt.readAssetFile;
+import static java.util.Objects.requireNonNull;
+import static org.junit.Assert.fail;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class MobileBackdoorMethodTest {
+
+    @Test
+    public void shouldParseArgumentsAndTypes() {
+        MobileBackdoorMethod method = new MobileBackdoorMethod();
+        List<BackdoorMethodArg> args = new ArrayList<>();
+        BackdoorMethodArg arg1 = new BackdoorMethodArg();
+        arg1.setType("java.lang.String");
+        arg1.setValue("Oh");
+        args.add(arg1);
+
+        BackdoorMethodArg arg2 = new BackdoorMethodArg();
+        arg2.setType("java.lang.Integer");
+        arg2.setValue("10");
+        args.add(arg2);
+
+        BackdoorMethodArg arg3 = new BackdoorMethodArg();
+        arg3.setType("int");
+        arg3.setValue("20");
+        args.add(arg3);
+
+        BackdoorMethodArg arg4 = new BackdoorMethodArg();
+        arg4.setType("Boolean");
+        arg4.setValue("true");
+        args.add(arg4);
+
+        method.setArgs(args);
+        assertArrayEquals(new Class[]{String.class, Integer.class, int.class, Boolean.class}, method.getArgumentTypes());
+        assertArrayEquals(new Object[]{"Oh", 10, 20, true}, method.getArguments());
+
+    }
+
+    @Test
+    public void shouldNotAllowInvalidArgumentTypes() {
+        MobileBackdoorMethod method = new MobileBackdoorMethod();
+        List<BackdoorMethodArg> args = new ArrayList<>();
+        BackdoorMethodArg arg1 = new BackdoorMethodArg();
+        arg1.setType("java.lang.Lol");
+        arg1.setValue("Oh");
+        args.add(arg1);
+        method.setArgs(args);
+        try {
+            method.getArgumentTypes();
+            fail("expected exception was not occured.");
+        } catch (Exception e) {
+            assertTrue(e.getMessage().contains("Class not found: java.lang.Lol"));
+        }
+
+    }
+
+    @Test
+    public void shouldNotAllowIncompatibleValueForGivenType() {
+        MobileBackdoorMethod method = new MobileBackdoorMethod();
+        List<BackdoorMethodArg> args = new ArrayList<>();
+        BackdoorMethodArg arg1 = new BackdoorMethodArg();
+        arg1.setType("int");
+        arg1.setValue("lol");
+        args.add(arg1);
+        method.setArgs(args);
+        try {
+            method.getArguments();
+            fail("expected exception was not occured.");
+        } catch (Exception e) {
+            assertTrue(e.getMessage().contains("For input string: \"lol\""));
+        }
+
+    }
+
+    @Test
+    public void shouldPullMethodsWithArguments() throws IOException {
+        String backdoorMethods = readAssetFile("backdoor-methods.json");
+        MobileBackdoorParams params = (MobileBackdoorParams) (new Gson()).fromJson(backdoorMethods, MobileBackdoorParams.class);
+        List<MobileBackdoorMethod> mobileBackdoor = requireNonNull(params).getMethods();
+
+        assertEquals(InvocationTarget.ACTIVITY, params.getTarget());
+
+        MobileBackdoorMethod firstMethod = mobileBackdoor.get(0);
+        assertEquals("firstMethod", firstMethod.getName());
+        assertArrayEquals(new Class[]{boolean.class, int.class, byte.class, char.class}, firstMethod.getArgumentTypes());
+        assertArrayEquals(new Object[]{true, 1, (byte) 20, 'X'}, firstMethod.getArguments());
+
+        MobileBackdoorMethod secondMethod = mobileBackdoor.get(1);
+        assertEquals("secondMethod", secondMethod.getName());
+        assertArrayEquals(new Class[]{boolean.class, int.class, byte.class, Character.class, String.class}, secondMethod.getArgumentTypes());
+        assertArrayEquals(new Object[]{true, 1, (byte) 20, 'X', "Y"}, secondMethod.getArguments());
+
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/MobileClickTest.kt

@@ -0,0 +1,46 @@
+package io.appium.espressoserver.test.model
+
+import androidx.test.espresso.action.GeneralLocation.TOP_RIGHT
+import androidx.test.espresso.action.GeneralLocation.VISIBLE_CENTER
+import androidx.test.espresso.action.Press.FINGER
+import androidx.test.espresso.action.Press.PINPOINT
+import androidx.test.espresso.action.Tap.DOUBLE
+import androidx.test.espresso.action.Tap.SINGLE
+import com.google.gson.JsonObject
+import com.google.gson.JsonPrimitive
+import io.appium.espressoserver.lib.model.MobileClickActionParams
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class `mobile clickAction test` {
+
+    @Test
+    fun `should parse "MobileClickParams" and set defaults if some params not provided` () {
+        val jsonElement = JsonObject()
+        val clickActionParams = MobileClickActionParams.MobileClickActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+        assertEquals(clickActionParams.inputDevice, 0)
+        assertEquals(clickActionParams.buttonState, 0)
+        assertEquals(clickActionParams.tapper, SINGLE)
+        assertEquals(clickActionParams.coordinatesProvider, VISIBLE_CENTER)
+        assertEquals(clickActionParams.precisionDescriber, FINGER)
+    }
+
+    @Test
+    fun `should parse "MobileClickParams" and set values if all params provided` () {
+        val jsonElement = JsonObject()
+        jsonElement.add("inputDevice", JsonPrimitive(2))
+        jsonElement.add("buttonState", JsonPrimitive("3"))
+        jsonElement.add("tapper", JsonPrimitive("DOUBLE"))
+        jsonElement.add("coordinatesProvider", JsonPrimitive("TOP_RIGHT"))
+        jsonElement.add("precisionDescriber", JsonPrimitive("PINPOINT"))
+        val clickActionParams = MobileClickActionParams.MobileClickActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+        assertEquals(clickActionParams.inputDevice, 2)
+        assertEquals(clickActionParams.buttonState, 3)
+        assertEquals(clickActionParams.tapper, DOUBLE)
+        assertEquals(clickActionParams.coordinatesProvider, TOP_RIGHT)
+        assertEquals(clickActionParams.precisionDescriber, PINPOINT)
+
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/MobileSwipeTest.kt

@@ -0,0 +1,68 @@
+package io.appium.espressoserver.test.model
+
+import androidx.test.espresso.action.GeneralLocation.*
+import androidx.test.espresso.action.Press.PINPOINT
+import androidx.test.espresso.action.Press.THUMB
+import androidx.test.espresso.action.Swipe.FAST
+import com.google.gson.JsonObject
+import com.google.gson.JsonParseException
+import com.google.gson.JsonPrimitive
+import io.appium.espressoserver.lib.model.MobileSwipeParams.Direction.DOWN
+import io.appium.espressoserver.lib.model.MobileSwipeParams.MobileSwipeActionParamsDeserializer
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class `mobile swipe test` {
+
+    @Test
+    fun `should parse "MobileSwipeActionParams" with 'direction' property` () {
+        val jsonElement = JsonObject()
+        jsonElement.add("direction", JsonPrimitive("DOWN"))
+        val mobileSwipeActionParams = MobileSwipeActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+        assertEquals(mobileSwipeActionParams.direction, DOWN)
+    }
+
+    @Test
+    fun `should parse "MobileSwipeActionParams" with 'swiper' property and use default parameters` () {
+        val jsonElement = JsonObject()
+        jsonElement.add("swiper", JsonPrimitive("FAST"))
+        val mobileSwipeActionParams = MobileSwipeActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+        assertEquals(mobileSwipeActionParams.swiper, FAST);
+        assertEquals(mobileSwipeActionParams.startCoordinates, BOTTOM_CENTER);
+        assertEquals(mobileSwipeActionParams.endCoordinates, TOP_CENTER);
+        assertEquals(mobileSwipeActionParams.precisionDescriber, THUMB);
+    }
+
+    @Test
+    fun `should parse "MobileSwipeActionParams" with 'swiper' property plus other parameters` () {
+        val jsonElement = JsonObject()
+        jsonElement.add("swiper", JsonPrimitive("FAST"))
+        jsonElement.add("startCoordinates", JsonPrimitive("TOP_LEFT"))
+        jsonElement.add("endCoordinates", JsonPrimitive("TOP_RIGHT"))
+        jsonElement.add("precisionDescriber", JsonPrimitive("PINPOINT"))
+        val mobileSwipeActionParams = MobileSwipeActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+        assertEquals(mobileSwipeActionParams.swiper, FAST);
+        assertEquals(mobileSwipeActionParams.startCoordinates, TOP_LEFT);
+        assertEquals(mobileSwipeActionParams.endCoordinates, TOP_RIGHT);
+        assertEquals(mobileSwipeActionParams.precisionDescriber, PINPOINT);
+    }
+
+    @Test(expected = JsonParseException::class)
+    fun `should reject if both 'direction' and 'swiper' provided`() {
+        val jsonElement = JsonObject()
+        jsonElement.add("swiper", JsonPrimitive("FAST"))
+        jsonElement.add("direction", JsonPrimitive("DOWN"))
+        MobileSwipeActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+    }
+
+    @Test(expected = JsonParseException::class)
+    fun `should reject if do not provided 'direction' or 'swiper` () {
+        val jsonElement = JsonObject()
+        MobileSwipeActionParamsDeserializer()
+                .deserialize(jsonElement, null, null)
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/TouchActionTest.kt

@@ -0,0 +1,56 @@
+package io.appium.espressoserver.test.model
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.model.TouchAction
+import io.appium.espressoserver.lib.model.TouchAction.TouchActionOptions
+import io.appium.espressoserver.test.helpers.w3c.assertFloatEquals
+import org.junit.Assert
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class TouchActionTest {
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldConvertMoveTo() {
+        val touchAction = TouchAction()
+        touchAction.action = TouchAction.ActionType.MOVE_TO
+        val options = TouchActionOptions()
+        options.x = 100L
+        options.y = 200L
+        touchAction.options = options
+        val actions = touchAction.toW3CAction()
+        Assert.assertEquals(actions[0].type, InputSource.ActionType.PAUSE)
+        Assert.assertEquals(actions[1].type, InputSource.ActionType.PAUSE)
+        val action = actions[2]
+        assertFloatEquals(action.x!!, 100f)
+        assertFloatEquals(action.y!!, 200f)
+        Assert.assertEquals(action.type, InputSource.ActionType.POINTER_MOVE)
+        Assert.assertTrue(action.isOriginViewport)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldConvertPress() {
+        val actionTypes = arrayOf(TouchAction.ActionType.TAP, TouchAction.ActionType.PRESS, TouchAction.ActionType.LONG_PRESS)
+        for (actionType in actionTypes) {
+            val touchAction = TouchAction()
+            touchAction.action = actionType
+            val options = TouchActionOptions()
+            options.x = 100L
+            options.y = 200L
+            touchAction.options = options
+            val actions = touchAction.toW3CAction()
+            val moveAction = actions[0]
+            Assert.assertEquals(moveAction.type, InputSource.ActionType.POINTER_MOVE)
+            assertFloatEquals(moveAction.x!!, 100f)
+            assertFloatEquals(moveAction.y!!, 200f)
+            val upAction = actions[1]
+            Assert.assertEquals(upAction.type, InputSource.ActionType.POINTER_DOWN)
+            assertEquals(upAction.button, 0)
+            val waitAction = actions[2]
+            Assert.assertEquals(waitAction.type, InputSource.ActionType.PAUSE)
+        }
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/web/WebAtomTest.kt

@@ -0,0 +1,68 @@
+package io.appium.espressoserver.test.model.web
+
+import androidx.test.espresso.web.webdriver.Locator
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import com.google.gson.JsonPrimitive
+import io.appium.espressoserver.lib.model.web.WebAtomDeserializer
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class WebAtomTest {
+
+    @Test
+    fun `should parse web atom with no args`() {
+        val jsonObject = JsonObject()
+        jsonObject.addProperty("name", "clearElement")
+        val webAtom = WebAtomDeserializer().deserialize(jsonObject, null, null)
+        assertEquals(webAtom.name, "clearElement")
+    }
+
+    @Test
+    fun `should parse JSON primtive as web atom with name and no args`() {
+        val jsonObject = JsonPrimitive("clearElement")
+        val webAtom = WebAtomDeserializer().deserialize(jsonObject, null, null)
+        assertEquals(webAtom.name, "clearElement")
+    }
+
+    @Test
+    fun `should parse web atom with singleton args`() {
+        val jsonObject = JsonObject()
+        jsonObject.addProperty("name", "webKeys")
+        jsonObject.addProperty("args", "Hello World!")
+        val webAtom = WebAtomDeserializer().deserialize(jsonObject, null, null)
+        assertEquals(webAtom.name, "webKeys")
+        assertEquals(webAtom.args.first(), "Hello World!")
+        assertEquals(webAtom.args.size, 1)
+    }
+
+    @Test
+    fun `should parse web atom name with array of args of containing differing JSON primitive types`() {
+        val jsonObject = JsonObject()
+        jsonObject.addProperty("name", "someFakeAtom")
+        val argsArr = JsonArray()
+        argsArr.add(JsonPrimitive("hello"))
+        argsArr.add(JsonPrimitive(true))
+        argsArr.add(JsonPrimitive(100))
+        argsArr.add(JsonPrimitive(1.1))
+        jsonObject.add("args", argsArr)
+        val webAtom = WebAtomDeserializer().deserialize(jsonObject, null, null)
+        assertEquals(webAtom.name, "someFakeAtom")
+        assertTrue(webAtom.args contentEquals arrayOf("hello", true, 100, 1.1))
+        assertEquals(webAtom.args.size, 4)
+    }
+
+    @Test
+    fun `should accept locator shorthand in place of "args"`() {
+        val jsonObject = JsonObject()
+        jsonObject.addProperty("name", "findElement")
+        val locatorObject = JsonObject()
+        locatorObject.addProperty("using", "id")
+        locatorObject.addProperty("value", "some_html_id")
+        jsonObject.add("locator", locatorObject)
+        val webAtom = WebAtomDeserializer().deserialize(jsonObject, null, null)
+        assertEquals(webAtom.name, "findElement")
+        assertTrue(webAtom.args contentEquals arrayOf(Locator.ID, "some_html_id"))
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/web/WebAtomsTest.kt

@@ -0,0 +1,96 @@
+package io.appium.espressoserver.test.model.web
+
+import androidx.test.espresso.web.webdriver.Locator
+import com.google.gson.Gson
+import io.appium.espressoserver.lib.model.web.WebAtomsParams
+import io.appium.espressoserver.lib.model.web.WebAtomsMethod
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class WebAtomsTest {
+    val g = Gson()
+    @Test
+    fun `should parse name and atom for WebAtoms method`() {
+        val webAtomsMethod = g.fromJson("""{
+          "name": "withElement",
+          "atom": {
+            "name": "findElement",
+            "locator": {
+              "using": "id",
+              "value": "text_input"
+            }
+          }
+        }""".trimIndent(), WebAtomsMethod::class.java)
+        assertEquals(webAtomsMethod.name, "withElement")
+        assertEquals(webAtomsMethod.atom.name, "findElement")
+        assertTrue(webAtomsMethod.atom.args contentEquals  arrayOf(Locator.ID, "text_input"))
+    }
+
+    @Test
+    fun `should parse selectFrameByIndex for WebAtoms method`() {
+        val webAtomsMethod = g.fromJson("""{
+          "name": "withElement",
+          "atom": {
+            "name": "selectFrameByIndex",
+            "args": 1
+          }
+        }""".trimIndent(), WebAtomsMethod::class.java)
+        assertEquals(webAtomsMethod.name, "withElement")
+        assertEquals(webAtomsMethod.atom.name, "selectFrameByIndex")
+        assertEquals(webAtomsMethod.atom.args[0], 1)
+    }
+
+    @Test
+    fun `should parse web atoms object`() {
+        val json = """{
+           "webviewElement":"abc",
+           "forceJavascriptEnabled":true,
+           "methodChain":[
+              {
+                 "name":"withElement",
+                 "atom":{
+                    "name":"findElement",
+                    "locator":{
+                       "using":"id",
+                       "value":"text_input"
+                    }
+                 }
+              },
+              {
+                 "name":"perform",
+                 "atom":"clearElement"
+              },
+              {
+                 "name":"perform",
+                 "atom":{
+                    "name":"webKeys",
+                    "args":"Foo"
+                 }
+              }
+           ]
+        }"""
+        val webAtoms = g.fromJson(json, WebAtomsParams::class.java)
+        assertEquals(webAtoms.webviewElement, "abc")
+        assertEquals(webAtoms.forceJavascriptEnabled, true)
+
+        webAtoms.methodChain[0].let {
+            assertEquals(it.name, "withElement")
+            assertEquals(it.atom.name, "findElement")
+            assertTrue(it.atom.args contentEquals arrayOf(Locator.ID, "text_input"))
+        }
+
+        webAtoms.methodChain[1].let {
+            assertEquals(it.name, "perform")
+            assertEquals(it.atom.name, "clearElement")
+            assertTrue(it.atom.args contentEquals  emptyArray())
+        }
+
+        webAtoms.methodChain[2].let {
+            assertEquals(it.name, "perform")
+            assertEquals(it.atom.name, "webKeys")
+            assertTrue(it.atom.args contentEquals  arrayOf("Foo"))
+        }
+
+    }
+}

package/espresso-server/build.gradle.kts

@@ -0,0 +1,33 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    val appiumKotlin =
+        properties.getOrDefault("appiumKotlin", "1.4.32")
+
+    val appiumAndroidGradlePlugin =
+        properties.getOrDefault("appiumAndroidGradlePlugin", "4.1.1")
+
+    repositories {
+        google()
+        mavenCentral()
+        jcenter()
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$appiumKotlin")
+        classpath("com.android.tools.build:gradle:$appiumAndroidGradlePlugin")
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle.kts files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+tasks.register("clean", Delete::class) {
+    delete(rootProject.buildDir)
+}

package/espresso-server/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-all.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/espresso-server/gradle.properties

@@ -0,0 +1,26 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+org.gradle.configureondemand=false
+
+android.useAndroidX=true
+
+org.gradle.vfs.watch=true
+org.gradle.caching=true
+# https://youtrack.jetbrains.com/issue/KT-46708
+kotlin.stdlib.default.dependency=false