Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 236 insertions, 0 deletions

diff --git a/testing/mozbase/mozdevice/tests/conftest.py b/testing/mozbase/mozdevice/tests/conftest.py
new file mode 100644
index 0000000000..831090a428
--- /dev/null
+++ b/testing/mozbase/mozdevice/tests/conftest.py
@@ -0,0 +1,236 @@
+import sys
+from random import randint, seed
+from unittest.mock import patch
+
+import mozdevice
+import pytest
+from six import StringIO
+
+# set up required module-level variables/objects
+seed(1488590)
+
+
+def random_tcp_port():
+    """Returns a pseudo-random integer generated from a seed.
+
+    :returns: int: pseudo-randomly generated integer
+    """
+    return randint(8000, 12000)
+
+
+@pytest.fixture(autouse=True)
+def mock_command_output(monkeypatch):
+    """Monkeypatches the ADBDevice.command_output() method call.
+
+    Instead of calling the concrete method implemented in adb.py::ADBDevice,
+    this method simply returns a string representation of the command that was
+    received.
+
+    As an exception, if the command begins with "forward tcp:0 ", this method
+    returns a mock port number.
+
+    :param object monkeypatch: pytest provided fixture for mocking.
+    """
+
+    def command_output_wrapper(object, cmd, timeout):
+        """Actual monkeypatch implementation of the command_output method call.
+
+        :param object object: placeholder object representing ADBDevice
+        :param str cmd: command to be executed
+        :param timeout: unused parameter to represent timeout threshold
+        :returns: string - string representation of command to be executed
+                  int - mock port number (only used when cmd begins with "forward tcp:0 ")
+        """
+
+        if cmd[0] == "forward" and cmd[1] == "tcp:0":
+            return 7777
+
+        print(str(cmd))
+        return str(cmd)
+
+    monkeypatch.setattr(mozdevice.ADBDevice, "command_output", command_output_wrapper)
+
+
+@pytest.fixture(autouse=True)
+def mock_shell_output(monkeypatch):
+    """Monkeypatches the ADBDevice.shell_output() method call.
+
+    Instead of returning the output of an adb call, this method will
+    return appropriate string output. Content of the string output is
+    in line with the calling method's expectations.
+
+    :param object monkeypatch: pytest provided fixture for mocking.
+    """
+
+    def shell_output_wrapper(
+        object, cmd, env=None, cwd=None, timeout=None, enable_run_as=False
+    ):
+        """Actual monkeypatch implementation of the shell_output method call.
+
+        :param object object: placeholder object representing ADBDevice
+        :param str cmd: command to be executed
+        :param env: contains the environment variable
+        :type env: dict or None
+        :param cwd: The directory from which to execute.
+        :type cwd: str or None
+        :param timeout: unused parameter tp represent timeout threshold
+        :param enable_run_as: bool determining if run_as <app> is to be used
+        :returns: string - string representation of a simulated call to adb
+        """
+        if "pm list package error" in cmd:
+            return "Error: Could not access the Package Manager"
+        elif "pm list package none" in cmd:
+            return ""
+        elif "pm list package" in cmd:
+            apps = ["org.mozilla.fennec", "org.mozilla.geckoview_example"]
+            return ("package:{}\n" * len(apps)).format(*apps)
+        else:
+            print(str(cmd))
+            return str(cmd)
+
+    monkeypatch.setattr(mozdevice.ADBDevice, "shell_output", shell_output_wrapper)
+
+
+@pytest.fixture(autouse=True)
+def mock_is_path_internal_storage(monkeypatch):
+    """Monkeypatches the ADBDevice.is_path_internal_storage() method call.
+
+    Instead of returning the outcome of whether the path provided is
+    internal storage or external, this will always return True.
+
+    :param object monkeypatch: pytest provided fixture for mocking.
+    """
+
+    def is_path_internal_storage_wrapper(object, path, timeout=None):
+        """Actual monkeypatch implementation of the is_path_internal_storage() call.
+
+        :param str path: The path to test.
+        :param timeout: The maximum time in
+            seconds for any spawned adb process to complete before
+            throwing an ADBTimeoutError.  This timeout is per adb call. The
+            total time spent may exceed this value. If it is not
+            specified, the value set in the ADBDevice constructor is used.
+        :returns: boolean
+
+        :raises: * ADBTimeoutError
+                 * ADBError
+        """
+        if "internal_storage" in path:
+            return True
+        return False
+
+    monkeypatch.setattr(
+        mozdevice.ADBDevice,
+        "is_path_internal_storage",
+        is_path_internal_storage_wrapper,
+    )
+
+
+@pytest.fixture(autouse=True)
+def mock_enable_run_as_for_path(monkeypatch):
+    """Monkeypatches the ADBDevice.enable_run_as_for_path(path) method.
+
+    Always return True
+
+    :param object monkeypatch: pytest provided fixture for mocking.
+    """
+
+    def enable_run_as_for_path_wrapper(object, path):
+        """Actual monkeypatch implementation of the enable_run_as_for_path() call.
+
+        :param str path: The path to test.
+        :returns: boolean
+        """
+        return True
+
+    monkeypatch.setattr(
+        mozdevice.ADBDevice, "enable_run_as_for_path", enable_run_as_for_path_wrapper
+    )
+
+
+@pytest.fixture(autouse=True)
+def mock_shell_bool(monkeypatch):
+    """Monkeypatches the ADBDevice.shell_bool() method call.
+
+    Instead of returning the output of an adb call, this method will
+    return appropriate string output. Content of the string output is
+    in line with the calling method's expectations.
+
+    :param object monkeypatch: pytest provided fixture for mocking.
+    """
+
+    def shell_bool_wrapper(
+        object, cmd, env=None, cwd=None, timeout=None, enable_run_as=False
+    ):
+        """Actual monkeypatch implementation of the shell_bool method call.
+
+        :param object object: placeholder object representing ADBDevice
+        :param str cmd: command to be executed
+        :param env: contains the environment variable
+        :type env: dict or None
+        :param cwd: The directory from which to execute.
+        :type cwd: str or None
+        :param timeout: unused parameter tp represent timeout threshold
+        :param enable_run_as: bool determining if run_as <app> is to be used
+        :returns: string - string representation of a simulated call to adb
+        """
+        print(cmd)
+        return str(cmd)
+
+    monkeypatch.setattr(mozdevice.ADBDevice, "shell_bool", shell_bool_wrapper)
+
+
+@pytest.fixture(autouse=True)
+def mock_adb_object():
+    """Patches the __init__ method call when instantiating ADBDevice.
+
+    ADBDevice normally requires instantiated objects in order to execute
+    its commands.
+
+    With a pytest-mock patch, we are able to mock the initialization of
+    the ADBDevice object. By yielding the instantiated mock object,
+    unit tests can be run that call methods that require an instantiated
+    object.
+
+    :yields: ADBDevice - mock instance of ADBDevice object
+    """
+    with patch.object(mozdevice.ADBDevice, "__init__", lambda self: None):
+        yield mozdevice.ADBDevice()
+
+
+@pytest.fixture
+def redirect_stdout_and_assert():
+    """Redirects the stdout pipe temporarily to a StringIO stream.
+
+    This is useful to assert on methods that do not return
+    a value, such as most ADBDevice methods.
+
+    The original stdout pipe is preserved throughout the process.
+
+    :returns: _wrapper method
+    """
+
+    def _wrapper(func, **kwargs):
+        """Implements the stdout sleight-of-hand.
+
+        After preserving the original sys.stdout, it is switched
+        to use cStringIO.StringIO.
+
+        Method with no return value is called, and the stdout
+        pipe is switched back to the original sys.stdout.
+
+        The expected outcome is received as part of the kwargs.
+        This is asserted against a sanitized output from the method
+        under test.
+
+        :param object func: method under test
+        :param dict kwargs: dictionary of function parameters
+        """
+        original_stdout = sys.stdout
+        sys.stdout = testing_stdout = StringIO()
+        expected_text = kwargs.pop("text")
+        func(**kwargs)
+        sys.stdout = original_stdout
+        assert expected_text in testing_stdout.getvalue().rstrip()
+
+    return _wrapper