UIautomator Python测试

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import unittest
from mock import MagicMock, patch
import os
import subprocess
from uiautomator import Adb


class TestAdb(unittest.TestCase):

    def setUp(self):
        self.os_name = os.name

    def tearDown(self):
        os.name = self.os_name

    def test_serial(self):
        serial = "abcdef1234567890"
        adb = Adb(serial)
        self.assertEqual(adb.default_serial, serial)

        adb.devices = MagicMock()
        adb.devices.return_value = [serial, "123456"]
        self.assertEqual(adb.device_serial(), serial)

    def test_adb_from_env(self):
        home_dir = ‘/android/home‘
        with patch.dict(‘os.environ‘, {‘ANDROID_HOME‘: home_dir}):
            with patch(‘os.path.exists‘) as exists:
                exists.return_value = True

                os.name = "posix"  # linux
                adb_obj = Adb()
                adb_path = os.path.join(home_dir, "platform-tools", "adb")
                self.assertEqual(adb_obj.adb(), adb_path)
                exists.assert_called_once_with(adb_path)
                self.assertEqual(adb_obj.adb(), adb_path)
                # the second call will return the __adb_cmd directly
                exists.assert_called_once_with(adb_path)

                os.name = "nt"  # linux
                adb_obj = Adb()
                adb_path = os.path.join(home_dir, "platform-tools", "adb.exe")
                self.assertEqual(adb_obj.adb(), adb_path)

                exists.return_value = False
                with self.assertRaises(EnvironmentError):
                    Adb().adb()

    def test_adb_from_find(self):
        with patch.dict(‘os.environ‘, {}, clear=True):
            with patch("distutils.spawn.find_executable") as find_executable:
                find_executable.return_value = "/usr/bin/adb"
                with patch("os.path.realpath") as realpath:
                    realpath.return_value = "/home/user/android/platform-tools/adb"
                    self.assertEqual(realpath.return_value, Adb().adb())
                    find_executable.assert_called_once_with("adb")  # find_exectable should be called once
                    realpath.assert_called_once_with(find_executable.return_value)
                    realpath.return_value = find_executable.return_value
                    self.assertEqual(find_executable.return_value, Adb().adb())
                find_executable.return_value = None
                call_count = find_executable.call_count
                with self.assertRaises(EnvironmentError):
                    Adb().adb()
                self.assertEqual(call_count + 1, find_executable.call_count)

    def test_devices(self):
        adb = Adb()
        adb.raw_cmd = MagicMock()
        adb.raw_cmd.return_value.communicate.return_value = (b"List of devices attached \r\n014E05DE0F02000E\tdevice\r\n489328DKFL7DF\tdevice", b"")
        self.assertEqual(adb.devices(), {"014E05DE0F02000E": "device", "489328DKFL7DF": "device"})
        adb.raw_cmd.assert_called_once_with("devices")
        adb.raw_cmd.return_value.communicate.return_value = (b"List of devices attached \n\r014E05DE0F02000E\tdevice\n\r489328DKFL7DF\tdevice", b"")
        self.assertEqual(adb.devices(), {"014E05DE0F02000E": "device", "489328DKFL7DF": "device"})
        adb.raw_cmd.return_value.communicate.return_value = (b"List of devices attached \r014E05DE0F02000E\tdevice\r489328DKFL7DF\tdevice", b"")
        self.assertEqual(adb.devices(), {"014E05DE0F02000E": "device", "489328DKFL7DF": "device"})
        adb.raw_cmd.return_value.communicate.return_value = (b"List of devices attached \n014E05DE0F02000E\tdevice\n489328DKFL7DF\tdevice", b"")
        self.assertEqual(adb.devices(), {"014E05DE0F02000E": "device", "489328DKFL7DF": "device"})
        adb.raw_cmd.return_value.communicate.return_value = (b"not match", "")
        with self.assertRaises(EnvironmentError):
            adb.devices()

    def test_forward(self):
        adb = Adb()
        adb.cmd = MagicMock()
        adb.forward(90, 91)
        adb.cmd.assert_called_once_with("forward", "tcp:90", "tcp:91")
        adb.cmd.return_value.wait.assert_called_once_with()

    def test_adb_raw_cmd(self):
        import subprocess
        adb = Adb()
        adb.adb = MagicMock()
        adb.adb.return_value = "adb"
        args = ["a", "b", "c"]
        with patch("subprocess.Popen") as Popen:
            os.name = "posix"
            adb.raw_cmd(*args)
            Popen.assert_called_once_with(["%s %s" % (adb.adb(), " ".join(args))], shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        with patch("subprocess.Popen") as Popen:
            os.name = "nt"
            adb.raw_cmd(*args)
            Popen.assert_called_once_with([adb.adb()] + list(args), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

    def test_adb_cmd(self):
        adb = Adb()
        adb.device_serial = MagicMock()
        adb.device_serial.return_value = "ANDROID_SERIAL"
        adb.raw_cmd = MagicMock()
        args = ["a", "b", "c"]
        adb.cmd(*args)
        adb.raw_cmd.assert_called_once_with("-s", "%s" % adb.device_serial(), *args)

        adb.device_serial.return_value = "ANDROID SERIAL"
        adb.raw_cmd = MagicMock()
        args = ["a", "b", "c"]
        adb.cmd(*args)
        adb.raw_cmd.assert_called_once_with("-s", "‘%s‘" % adb.device_serial(), *args)

    def test_adb_cmd_server_host(self):
        adb = Adb(adb_server_host="localhost", adb_server_port=5037)
        adb.adb = MagicMock()
        adb.adb.return_value = "adb"
        adb.device_serial = MagicMock()
        adb.device_serial.return_value = "ANDROID_SERIAL"
        args = ["a", "b", "c"]
        with patch("subprocess.Popen") as Popen:
            os.name = "nt"
            adb.raw_cmd(*args)
            Popen.assert_called_once_with(
                [adb.adb()] + args,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )

        adb = Adb(adb_server_host="test.com", adb_server_port=1000)
        adb.adb = MagicMock()
        adb.adb.return_value = "adb"
        adb.device_serial = MagicMock()
        adb.device_serial.return_value = "ANDROID_SERIAL"
        args = ["a", "b", "c"]
        with patch("subprocess.Popen") as Popen:
            os.name = "posix"
            adb.raw_cmd(*args)
            Popen.assert_called_once_with(
                [" ".join([adb.adb()] + ["-H", "test.com", "-P", "1000"] + args)],
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )

    def test_device_serial(self):
        with patch.dict(‘os.environ‘, {‘ANDROID_SERIAL‘: "ABCDEF123456"}):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {"ABCDEF123456": "device"}
            self.assertEqual(adb.device_serial(), "ABCDEF123456")
        with patch.dict(‘os.environ‘, {‘ANDROID_SERIAL‘: "ABCDEF123456"}):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {"ABCDEF123456": "device", "123456ABCDEF": "device"}
            self.assertEqual(adb.device_serial(), "ABCDEF123456")
        with patch.dict(‘os.environ‘, {‘ANDROID_SERIAL‘: "HIJKLMN098765"}):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {"ABCDEF123456": "device", "123456ABCDEF": "device"}
            self.assertEqual(adb.device_serial(), "HIJKLMN098765")
        with patch.dict(‘os.environ‘, {}, clear=True):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {"ABCDEF123456": "device", "123456ABCDEF": "device"}
            with self.assertRaises(EnvironmentError):
                adb.device_serial()
        with patch.dict(‘os.environ‘, {}, clear=True):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {"ABCDEF123456": "device"}
            self.assertEqual(adb.device_serial(), "ABCDEF123456")

        with self.assertRaises(EnvironmentError):
            adb = Adb()
            adb.devices = MagicMock()
            adb.devices.return_value = {}
            adb.device_serial()

    def test_forward_list(self):
        adb = Adb()
        adb.version = MagicMock()
        adb.version.return_value = [‘1.0.31‘, ‘1‘, ‘0‘, ‘31‘]
        adb.raw_cmd = MagicMock()
        adb.raw_cmd.return_value.communicate.return_value = (b"014E05DE0F02000E    tcp:9008    tcp:9008\r\n489328DKFL7DF    tcp:9008    tcp:9008", b"")
        self.assertEqual(adb.forward_list(), [[‘014E05DE0F02000E‘, ‘tcp:9008‘, ‘tcp:9008‘], [‘489328DKFL7DF‘, ‘tcp:9008‘, ‘tcp:9008‘]])

        adb.version.return_value = [‘1.0.29‘, ‘1‘, ‘0‘, ‘29‘]
        with self.assertRaises(EnvironmentError):
            adb.forward_list()