| # Copyright 2017 Google Inc. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import unittest |
| from unittest import mock |
| |
| from mobly.controllers.android_device_lib import adb |
| from mobly.controllers.android_device_lib import jsonrpc_client_base |
| from mobly.controllers.android_device_lib import snippet_client |
| from tests.lib import jsonrpc_client_test_base |
| from tests.lib import mock_android_device |
| |
| MOCK_PACKAGE_NAME = 'some.package.name' |
| MOCK_MISSING_PACKAGE_NAME = 'not.installed' |
| JSONRPC_BASE_CLASS = ( |
| 'mobly.controllers.android_device_lib.jsonrpc_client_base.JsonRpcClientBase' |
| ) |
| MOCK_USER_ID = 0 |
| |
| |
| class SnippetClientTest(jsonrpc_client_test_base.JsonRpcClientTestBase): |
| """Unit tests for mobly.controllers.android_device_lib.snippet_client.""" |
| |
| def test_check_app_installed_normal(self): |
| sc = self._make_client() |
| sc._check_app_installed() |
| |
| def test_check_app_installed_fail_app_not_installed(self): |
| sc = self._make_client(mock_android_device.MockAdbProxy()) |
| expected_msg = '.* %s is not installed.' % MOCK_PACKAGE_NAME |
| with self.assertRaisesRegex( |
| snippet_client.AppStartPreCheckError, expected_msg |
| ): |
| sc._check_app_installed() |
| |
| def test_check_app_installed_fail_not_instrumented(self): |
| sc = self._make_client( |
| mock_android_device.MockAdbProxy(installed_packages=[MOCK_PACKAGE_NAME]) |
| ) |
| expected_msg = ( |
| '.* %s is installed, but it is not instrumented.' % MOCK_PACKAGE_NAME |
| ) |
| with self.assertRaisesRegex( |
| snippet_client.AppStartPreCheckError, expected_msg |
| ): |
| sc._check_app_installed() |
| |
| def test_check_app_installed_fail_target_not_installed(self): |
| sc = self._make_client( |
| mock_android_device.MockAdbProxy( |
| instrumented_packages=[ |
| ( |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| MOCK_MISSING_PACKAGE_NAME, |
| ) |
| ] |
| ) |
| ) |
| expected_msg = ( |
| '.* Instrumentation target %s is not installed.' |
| % MOCK_MISSING_PACKAGE_NAME |
| ) |
| with self.assertRaisesRegex( |
| snippet_client.AppStartPreCheckError, expected_msg |
| ): |
| sc._check_app_installed() |
| |
| @mock.patch('socket.create_connection') |
| def test_snippet_start(self, mock_create_connection): |
| self.setup_mock_socket_file(mock_create_connection) |
| client = self._make_client() |
| client.connect() |
| result = client.testSnippetCall() |
| self.assertEqual(123, result) |
| |
| @mock.patch('socket.create_connection') |
| def test_snippet_start_event_client(self, mock_create_connection): |
| fake_file = self.setup_mock_socket_file(mock_create_connection) |
| client = self._make_client() |
| client.host_port = 123 # normally picked by start_app_and_connect |
| client.connect() |
| fake_file.resp = self.MOCK_RESP_WITH_CALLBACK |
| callback = client.testSnippetCall() |
| self.assertEqual(123, callback.ret_value) |
| self.assertEqual('1-0', callback._id) |
| |
| # Check to make sure the event client is using the same port as the |
| # main client. |
| self.assertEqual(123, callback._event_client.host_port) |
| |
| fake_file.resp = self.MOCK_RESP_WITH_ERROR |
| with self.assertRaisesRegex(jsonrpc_client_base.ApiError, '1'): |
| callback.getAll('eventName') |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_restore_event_client( |
| self, mock_get_port, mock_create_connection |
| ): |
| mock_get_port.return_value = 789 |
| fake_file = self.setup_mock_socket_file(mock_create_connection) |
| client = self._make_client() |
| client.host_port = 123 # normally picked by start_app_and_connect |
| client.device_port = 456 |
| client.connect() |
| fake_file.resp = self.MOCK_RESP_WITH_CALLBACK |
| callback = client.testSnippetCall() |
| |
| # before reconnect, clients use previously selected ports |
| self.assertEqual(123, client.host_port) |
| self.assertEqual(456, client.device_port) |
| self.assertEqual(123, callback._event_client.host_port) |
| self.assertEqual(456, callback._event_client.device_port) |
| |
| # after reconnect, if host port specified, clients use specified port |
| client.restore_app_connection(port=321) |
| self.assertEqual(321, client.host_port) |
| self.assertEqual(456, client.device_port) |
| self.assertEqual(321, callback._event_client.host_port) |
| self.assertEqual(456, callback._event_client.device_port) |
| |
| # after reconnect, if host port not specified, clients use selected |
| # available port |
| client.restore_app_connection() |
| self.assertEqual(789, client.host_port) |
| self.assertEqual(456, client.device_port) |
| self.assertEqual(789, callback._event_client.host_port) |
| self.assertEqual(456, callback._event_client.device_port) |
| |
| # if unable to reconnect for any reason, a |
| # jsonrpc_client_base.AppRestoreConnectionError is raised. |
| mock_create_connection.side_effect = IOError('socket timed out') |
| with self.assertRaisesRegex( |
| jsonrpc_client_base.AppRestoreConnectionError, |
| ( |
| 'Failed to restore app connection for %s at host port %s, ' |
| 'device port %s' |
| ) |
| % (MOCK_PACKAGE_NAME, 789, 456), |
| ): |
| client.restore_app_connection() |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_and_connect( |
| self, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'SNIPPET START, PROTOCOL 1 0\n', |
| b'SNIPPET SERVING, PORT 123\n', |
| ], |
| ) |
| client = self._make_client() |
| client.start_app_and_connect() |
| self.assertEqual(123, client.device_port) |
| self.assertTrue(client.is_alive) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch('mobly.utils.stop_standing_subprocess') |
| def test_snippet_stop_app( |
| self, mock_stop_standing_subprocess, mock_create_connection |
| ): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| client.stop_app() |
| self.assertFalse(client.is_alive) |
| |
| def test_snippet_stop_app_raises(self): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| client.host_port = 1 |
| client._conn = mock.MagicMock() |
| # Explicitly making the second side_effect noop to avoid uncaught exception |
| # when `__del__` is called after the test is done, which triggers |
| # `disconnect`. |
| client._conn.close.side_effect = [Exception('ha'), None] |
| with self.assertRaisesRegex(Exception, 'ha'): |
| client.stop_app() |
| adb_proxy.forward.assert_called_once_with(['--remove', 'tcp:1']) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch('mobly.utils.stop_standing_subprocess') |
| def test_snippet_stop_app_stops_event_client( |
| self, mock_stop_standing_subprocess, mock_create_connection |
| ): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| event_client = snippet_client.SnippetClient( |
| package=MOCK_PACKAGE_NAME, ad=client._ad |
| ) |
| client._event_client = event_client |
| event_client_conn = mock.Mock() |
| event_client._conn = event_client_conn |
| |
| client.stop_app() |
| self.assertFalse(client.is_alive) |
| event_client_conn.close.assert_called_once() |
| self.assertIsNone(client._event_client) |
| self.assertIsNone(event_client._conn) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch('mobly.utils.stop_standing_subprocess') |
| def test_snippet_stop_app_stops_event_client_without_connection( |
| self, mock_stop_standing_subprocess, mock_create_connection |
| ): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| event_client = snippet_client.SnippetClient( |
| package=MOCK_PACKAGE_NAME, ad=client._ad |
| ) |
| client._event_client = event_client |
| event_client._conn = None |
| |
| client.stop_app() |
| self.assertFalse(client.is_alive) |
| self.assertIsNone(client._event_client) |
| self.assertIsNone(event_client._conn) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch('mobly.utils.stop_standing_subprocess') |
| def test_snippet_stop_app_without_event_client( |
| self, mock_stop_standing_subprocess, mock_create_connection |
| ): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| client._event_client = None |
| |
| client.stop_app() |
| self.assertFalse(client.is_alive) |
| self.assertIsNone(client._event_client) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch('mobly.utils.stop_standing_subprocess') |
| @mock.patch.object(snippet_client.SnippetClient, 'connect') |
| def test_event_client_does_not_stop_port_forwarding( |
| self, mock_stop_standing_subprocess, mock_create_connection, mock_connect |
| ): |
| adb_proxy = mock.MagicMock() |
| adb_proxy.shell.return_value = b'OK (0 tests)' |
| client = self._make_client(adb_proxy) |
| client.host_port = 12345 |
| client.device_port = 67890 |
| |
| event_client = client._start_event_client() |
| # Mock adb proxy of event client to validate forward call |
| event_client._ad = mock.MagicMock() |
| event_client._adb = event_client._ad.adb |
| client._event_client = event_client |
| |
| # Verify that neither the stop process nor the deconstructor is trying to |
| # stop the port forwarding |
| client.stop_app() |
| event_client.__del__() |
| |
| event_client._adb.forward.assert_not_called() |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient.' |
| 'disable_hidden_api_blacklist' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient.' |
| 'stop_app' |
| ) |
| def test_start_app_and_connect_precheck_fail( |
| self, |
| mock_stop, |
| mock_precheck, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'SNIPPET START, PROTOCOL 1 0\n', |
| b'SNIPPET SERVING, PORT 123\n', |
| ], |
| ) |
| client = self._make_client() |
| mock_precheck.side_effect = snippet_client.AppStartPreCheckError( |
| client.ad, 'ha' |
| ) |
| with self.assertRaisesRegex(snippet_client.AppStartPreCheckError, 'ha'): |
| client.start_app_and_connect() |
| mock_stop.assert_not_called() |
| self.assertFalse(client.is_alive) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient._start_app_and_connect' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient.stop_app' |
| ) |
| def test_start_app_and_connect_generic_error( |
| self, |
| mock_stop, |
| mock_start, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'SNIPPET START, PROTOCOL 1 0\n', |
| b'SNIPPET SERVING, PORT 123\n', |
| ], |
| ) |
| client = self._make_client() |
| mock_start.side_effect = Exception('ha') |
| with self.assertRaisesRegex(Exception, 'ha'): |
| client.start_app_and_connect() |
| mock_stop.assert_called_once_with() |
| self.assertFalse(client.is_alive) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient._start_app_and_connect' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.SnippetClient.stop_app' |
| ) |
| def test_start_app_and_connect_fail_stop_also_fail( |
| self, |
| mock_stop, |
| mock_start, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'SNIPPET START, PROTOCOL 1 0\n', |
| b'SNIPPET SERVING, PORT 123\n', |
| ], |
| ) |
| client = self._make_client() |
| mock_start.side_effect = Exception('Some error') |
| mock_stop.side_effect = Exception('Another error') |
| with self.assertRaisesRegex(Exception, 'Some error'): |
| client.start_app_and_connect() |
| mock_stop.assert_called_once_with() |
| self.assertFalse(client.is_alive) |
| |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._do_start_app' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._check_app_installed' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._read_protocol_line' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient.connect' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_on_sdk_21( |
| self, |
| mock_get_port, |
| mock_connect, |
| mock_read_protocol_line, |
| mock_check_app_installed, |
| mock_do_start_app, |
| ): |
| """Check that `--user` is not added to start command on SDK < 24.""" |
| |
| def _mocked_shell(arg): |
| if 'setsid' in arg: |
| raise adb.AdbError('cmd', 'stdout', 'stderr', 'ret_code') |
| else: |
| return b'nohup' |
| |
| mock_get_port.return_value = 123 |
| mock_read_protocol_line.side_effect = [ |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| ] |
| |
| # Test 'setsid' exists |
| client = self._make_client() |
| client._ad.build_info['build_version_sdk'] = 21 |
| client._adb.shell = mock.Mock(return_value=b'setsid') |
| client.start_app_and_connect() |
| cmd_setsid = '%s am instrument -w -e action start %s/%s' % ( |
| snippet_client._SETSID_COMMAND, |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| ) |
| mock_do_start_app.assert_has_calls([mock.call(cmd_setsid)]) |
| |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._do_start_app' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._check_app_installed' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient._read_protocol_line' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'SnippetClient.connect' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_and_connect_persistent_session( |
| self, |
| mock_get_port, |
| mock_connect, |
| mock_read_protocol_line, |
| mock_check_app_installed, |
| mock_do_start_app, |
| ): |
| def _mocked_shell(arg): |
| if 'setsid' in arg: |
| raise adb.AdbError('cmd', 'stdout', 'stderr', 'ret_code') |
| else: |
| return b'nohup' |
| |
| mock_get_port.return_value = 123 |
| mock_read_protocol_line.side_effect = [ |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| 'SNIPPET START, PROTOCOL 1 234', |
| 'SNIPPET SERVING, PORT 1234', |
| ] |
| |
| # Test 'setsid' exists |
| client = self._make_client() |
| client._adb = mock.MagicMock() |
| client._adb.shell.return_value = b'setsid' |
| client._adb.current_user_id = MOCK_USER_ID |
| client.start_app_and_connect() |
| cmd_setsid = '%s am instrument --user %s -w -e action start %s/%s' % ( |
| snippet_client._SETSID_COMMAND, |
| MOCK_USER_ID, |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| ) |
| mock_do_start_app.assert_has_calls([mock.call(cmd_setsid)]) |
| |
| # Test 'setsid' does not exist, but 'nohup' exsits |
| client = self._make_client() |
| client._adb.shell = _mocked_shell |
| client.start_app_and_connect() |
| cmd_nohup = '%s am instrument --user %s -w -e action start %s/%s' % ( |
| snippet_client._NOHUP_COMMAND, |
| MOCK_USER_ID, |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| ) |
| mock_do_start_app.assert_has_calls( |
| [mock.call(cmd_setsid), mock.call(cmd_nohup)] |
| ) |
| |
| # Test both 'setsid' and 'nohup' do not exist |
| client._adb.shell = mock.Mock( |
| side_effect=adb.AdbError('cmd', 'stdout', 'stderr', 'ret_code') |
| ) |
| client = self._make_client() |
| client.start_app_and_connect() |
| cmd_not_persist = ' am instrument --user %s -w -e action start %s/%s' % ( |
| MOCK_USER_ID, |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| ) |
| mock_do_start_app.assert_has_calls( |
| [ |
| mock.call(cmd_setsid), |
| mock.call(cmd_nohup), |
| mock.call(cmd_not_persist), |
| ] |
| ) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_crash( |
| self, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| mock_get_port.return_value = 456 |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[b'INSTRUMENTATION_RESULT: shortMsg=Process crashed.\n'], |
| ) |
| client = self._make_client() |
| with self.assertRaisesRegex( |
| snippet_client.ProtocolVersionError, |
| 'INSTRUMENTATION_RESULT: shortMsg=Process crashed.', |
| ): |
| client.start_app_and_connect() |
| |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_and_connect_unknown_protocol( |
| self, mock_get_port, mock_start_standing_subprocess |
| ): |
| mock_get_port.return_value = 789 |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[b'SNIPPET START, PROTOCOL 99 0\n'], |
| ) |
| client = self._make_client() |
| with self.assertRaisesRegex( |
| snippet_client.ProtocolVersionError, 'SNIPPET START, PROTOCOL 99 0' |
| ): |
| client.start_app_and_connect() |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_and_connect_header_junk( |
| self, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'This is some header junk\n', |
| b'Some phones print arbitrary output\n', |
| b'SNIPPET START, PROTOCOL 1 0\n', |
| b'Maybe in the middle too\n', |
| b'SNIPPET SERVING, PORT 123\n', |
| ], |
| ) |
| client = self._make_client() |
| client.start_app_and_connect() |
| self.assertEqual(123, client.device_port) |
| |
| @mock.patch('socket.create_connection') |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.start_standing_subprocess' |
| ) |
| @mock.patch( |
| 'mobly.controllers.android_device_lib.snippet_client.' |
| 'utils.get_available_host_port' |
| ) |
| def test_snippet_start_app_and_connect_no_valid_line( |
| self, |
| mock_get_port, |
| mock_start_standing_subprocess, |
| mock_create_connection, |
| ): |
| mock_get_port.return_value = 456 |
| self.setup_mock_socket_file(mock_create_connection) |
| self._setup_mock_instrumentation_cmd( |
| mock_start_standing_subprocess, |
| resp_lines=[ |
| b'This is some header junk\n', |
| b'Some phones print arbitrary output\n', |
| b'', # readline uses '' to mark EOF |
| ], |
| ) |
| client = self._make_client() |
| with self.assertRaisesRegex( |
| jsonrpc_client_base.AppStartError, |
| 'Unexpected EOF waiting for app to start', |
| ): |
| client.start_app_and_connect() |
| |
| @mock.patch('builtins.print') |
| def test_help_rpc_when_printing_by_default(self, mock_print): |
| client = self._make_client() |
| mock_rpc = mock.MagicMock() |
| client._rpc = mock_rpc |
| |
| result = client.help() |
| mock_rpc.assert_called_once_with('help') |
| self.assertEqual(None, result) |
| mock_print.assert_called_once_with(mock_rpc.return_value) |
| |
| @mock.patch('builtins.print') |
| def test_help_rpc_when_not_printing(self, mock_print): |
| client = self._make_client() |
| mock_rpc = mock.MagicMock() |
| client._rpc = mock_rpc |
| |
| result = client.help(print_output=False) |
| mock_rpc.assert_called_once_with('help') |
| self.assertEqual(mock_rpc.return_value, result) |
| mock_print.assert_not_called() |
| |
| def _make_client(self, adb_proxy=None): |
| adb_proxy = adb_proxy or mock_android_device.MockAdbProxy( |
| instrumented_packages=[ |
| ( |
| MOCK_PACKAGE_NAME, |
| snippet_client._INSTRUMENTATION_RUNNER_PACKAGE, |
| MOCK_PACKAGE_NAME, |
| ) |
| ] |
| ) |
| ad = mock.Mock() |
| ad.adb = adb_proxy |
| ad.adb.current_user_id = MOCK_USER_ID |
| ad.build_info = { |
| 'build_version_codename': ad.adb.getprop('ro.build.version.codename'), |
| 'build_version_sdk': ad.adb.getprop('ro.build.version.sdk'), |
| } |
| return snippet_client.SnippetClient(package=MOCK_PACKAGE_NAME, ad=ad) |
| |
| def _setup_mock_instrumentation_cmd( |
| self, mock_start_standing_subprocess, resp_lines |
| ): |
| mock_proc = mock_start_standing_subprocess() |
| mock_proc.stdout.readline.side_effect = resp_lines |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
