class TestWatchman(BaseTest):
PATCH_OPTS = dict(autospec=True, spec_set=True)
WORK_DIR = '/path/to/a/fake/work_dir'
BUILD_ROOT = '/path/to/a/fake/build_root'
WATCHMAN_PATH = '/path/to/a/fake/watchman'
TEST_DIR = '/path/to/a/fake/test'
WATCHMAN_DIR = os.path.join(WORK_DIR, 'watchman')
STATE_FILE = os.path.join(WATCHMAN_DIR, 'watchman.state')
HANDLERS = [Watchman.EventHandler('test', {}, mock.Mock())]
def setUp(self):
BaseTest.setUp(self)
with mock.patch.object(Watchman, '_resolve_watchman_path', **self.PATCH_OPTS) as mock_find:
mock_find.return_value = self.WATCHMAN_PATH
self.watchman = Watchman(self.WORK_DIR)
def test_client_property(self):
self.assertIsInstance(self.watchman.client, pywatchman.client)
def test_client_property_cached(self):
self.watchman._watchman_client = 1
self.assertEquals(self.watchman.client, 1)
def test_make_client(self):
self.assertIsInstance(self.watchman._make_client(), pywatchman.client)
def test_is_valid_executable(self):
self.assertTrue(self.watchman._is_valid_executable(sys.executable))
@contextmanager
def setup_find_watchman_in_path(self):
with mock.patch.object(Watchman, '_is_valid_executable', **self.PATCH_OPTS) as mock_valid, \
environment_as(PATH='a:b:c'):
yield mock_valid
def test_find_watchman_in_path(self):
with self.setup_find_watchman_in_path() as mock_valid:
mock_valid.side_effect = [False, False, True]
self.assertEquals(self.watchman._find_watchman_in_path(), 'c/watchman')
mock_valid.assert_has_calls([
mock.call(self.watchman, 'a/{}'.format(self.watchman.process_name)),
mock.call(self.watchman, 'b/{}'.format(self.watchman.process_name)),
mock.call(self.watchman, 'c/{}'.format(self.watchman.process_name))
])
def test_find_watchman_in_path_neg(self):
with self.setup_find_watchman_in_path() as mock_valid:
mock_valid.side_effect = [False, False, False]
self.assertIsNone(self.watchman._find_watchman_in_path())
def test_resolve_watchman_path_provided_exception(self):
with mock.patch.object(Watchman, '_is_valid_executable', **self.PATCH_OPTS) as mock_valid:
mock_valid.return_value = False
with self.assertRaises(Watchman.ExecutionError):
self.watchman._resolve_watchman_path(self.WATCHMAN_PATH)
def test_resolve_watchman_path_provided(self):
with mock.patch.object(Watchman, '_is_valid_executable', **self.PATCH_OPTS) as mock_valid:
mock_valid.return_value = True
self.assertEquals(self.watchman._resolve_watchman_path(self.WATCHMAN_PATH),
self.WATCHMAN_PATH)
def test_resolve_watchman_path_default_exception(self):
with mock.patch.object(Watchman, '_find_watchman_in_path', **self.PATCH_OPTS) as mock_find:
mock_find.return_value = None
with self.assertRaises(Watchman.ExecutionError):
self.watchman._resolve_watchman_path(None)
def test_resolve_watchman_path_default(self):
with mock.patch.object(Watchman, '_find_watchman_in_path', **self.PATCH_OPTS) as mock_find:
mock_find.return_value = self.WATCHMAN_PATH
self.assertEquals(self.watchman._resolve_watchman_path(None), self.WATCHMAN_PATH)
def test_maybe_init_metadata(self):
with mock.patch('pants.pantsd.watchman.safe_mkdir', **self.PATCH_OPTS) as mock_mkdir, \
mock.patch('pants.pantsd.watchman.safe_file_dump', **self.PATCH_OPTS) as mock_file_dump:
self.watchman._maybe_init_metadata()
mock_mkdir.assert_called_once_with(self.WATCHMAN_DIR)
mock_file_dump.assert_called_once_with(self.STATE_FILE, '{}')
def test_construct_cmd(self):
output = self.watchman._construct_cmd(['cmd', 'parts', 'etc'],
'state_file',
'sock_file',
'log_file',
'log_level')
self.assertEquals(output, ['cmd',
'parts',
'etc',
'--no-save-state',
'--statefile=state_file',
'--sockname=sock_file',
'--logfile=log_file',
'--log-level',
'log_level'])
def test_parse_pid_from_output(self):
output = json.dumps(dict(pid=3))
self.assertEquals(self.watchman._parse_pid_from_output(output), 3)
def test_parse_pid_from_output_bad_output(self):
output = '{bad JSON.,/#!'
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_parse_pid_from_output_no_pid(self):
output = json.dumps(dict(nothing=True))
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_launch(self):
with mock.patch.object(Watchman, '_maybe_init_metadata') as mock_initmeta, \
mock.patch.object(Watchman, 'get_subprocess_output') as mock_getsubout, \
mock.patch.object(Watchman, 'write_pid') as mock_writepid, \
mock.patch.object(Watchman, 'write_socket') as mock_writesock:
mock_getsubout.return_value = json.dumps(dict(pid='3'))
self.watchman.launch()
assert mock_getsubout.called
mock_initmeta.assert_called_once_with()
mock_writepid.assert_called_once_with('3')
mock_writesock.assert_called_once_with(self.watchman._sock_file)
def test_watch_project(self):
self.watchman._watchman_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
self.watchman.watch_project(self.TEST_DIR)
self.watchman._watchman_client.query.assert_called_once_with('watch-project', self.TEST_DIR)
@contextmanager
def setup_subscribed(self, iterable):
mock_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
mock_client.stream_query.return_value = iter(iterable)
self.watchman._watchman_client = mock_client
yield mock_client
assert mock_client.stream_query.called
def test_subscribed_empty(self):
"""Test yielding when watchman reads timeout."""
with self.setup_subscribed([None]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_response(self):
"""Test yielding on the watchman response to the initial subscribe command."""
with self.setup_subscribed([dict(subscribe='test')]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_event(self):
"""Test yielding on a watchman event for a given subscription."""
test_event = dict(subscription='test3', msg='blah')
with self.setup_subscribed([test_event]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [('test3', test_event)])
def test_subscribed_unknown_event(self):
"""Test yielding on an unknown watchman event."""
with self.setup_subscribed([dict(unknown=True)]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [])
class TestWatchman(BaseTest):
PATCH_OPTS = dict(autospec=True, spec_set=True)
BUILD_ROOT = '/path/to/a/fake/build_root'
WATCHMAN_PATH = '/path/to/a/fake/watchman'
TEST_DIR = '/path/to/a/fake/test'
HANDLERS = [Watchman.EventHandler('test', {}, mock.Mock())]
def setUp(self):
super(TestWatchman, self).setUp()
with mock.patch.object(Watchman, '_is_valid_executable', **self.PATCH_OPTS) as mock_is_valid:
mock_is_valid.return_value = True
self.watchman = Watchman('/fake/path/to/watchman', self.subprocess_dir)
@property
def _watchman_dir(self):
return os.path.join(self.subprocess_dir, 'watchman')
@property
def _state_file(self):
return os.path.join(self._watchman_dir, 'watchman.state')
def test_client_property(self):
self.assertIsInstance(self.watchman.client, pywatchman.client)
def test_client_property_cached(self):
self.watchman._watchman_client = 1
self.assertEquals(self.watchman.client, 1)
def test_make_client(self):
self.assertIsInstance(self.watchman._make_client(), pywatchman.client)
def test_is_valid_executable(self):
self.assertTrue(self.watchman._is_valid_executable(sys.executable))
def test_resolve_watchman_path_provided_exception(self):
with self.assertRaises(Watchman.ExecutionError):
self.watchman = Watchman('/fake/path/to/watchman',
metadata_base_dir=self.subprocess_dir)
def test_maybe_init_metadata(self):
with mock.patch('pants.pantsd.watchman.safe_mkdir', **self.PATCH_OPTS) as mock_mkdir, \
mock.patch('pants.pantsd.watchman.safe_file_dump', **self.PATCH_OPTS) as mock_file_dump:
self.watchman._maybe_init_metadata()
mock_mkdir.assert_called_once_with(self._watchman_dir)
mock_file_dump.assert_called_once_with(self._state_file, '{}')
def test_construct_cmd(self):
output = self.watchman._construct_cmd(['cmd', 'parts', 'etc'],
'state_file',
'sock_file',
'log_file',
'log_level')
self.assertEquals(output, ['cmd',
'parts',
'etc',
'--no-save-state',
'--statefile=state_file',
'--sockname=sock_file',
'--logfile=log_file',
'--log-level',
'log_level'])
def test_parse_pid_from_output(self):
output = json.dumps(dict(pid=3))
self.assertEquals(self.watchman._parse_pid_from_output(output), 3)
def test_parse_pid_from_output_bad_output(self):
output = '{bad JSON.,/#!'
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_parse_pid_from_output_no_pid(self):
output = json.dumps(dict(nothing=True))
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_launch(self):
with mock.patch.object(Watchman, '_maybe_init_metadata') as mock_initmeta, \
mock.patch.object(Watchman, 'get_subprocess_output') as mock_getsubout, \
mock.patch.object(Watchman, 'write_pid') as mock_writepid, \
mock.patch.object(Watchman, 'write_socket') as mock_writesock:
mock_getsubout.return_value = json.dumps(dict(pid='3'))
self.watchman.launch()
assert mock_getsubout.called
mock_initmeta.assert_called_once_with()
mock_writepid.assert_called_once_with('3')
mock_writesock.assert_called_once_with(self.watchman._sock_file)
def test_watch_project(self):
self.watchman._watchman_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
self.watchman.watch_project(self.TEST_DIR)
self.watchman._watchman_client.query.assert_called_once_with('watch-project', self.TEST_DIR)
@contextmanager
def setup_subscribed(self, iterable):
mock_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
mock_client.stream_query.return_value = iter(iterable)
self.watchman._watchman_client = mock_client
yield mock_client
assert mock_client.stream_query.called
def test_subscribed_empty(self):
"""Test yielding when watchman reads timeout."""
with self.setup_subscribed([None]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_response(self):
"""Test yielding on the watchman response to the initial subscribe command."""
with self.setup_subscribed([dict(subscribe='test')]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_event(self):
"""Test yielding on a watchman event for a given subscription."""
test_event = dict(subscription='test3', msg='blah')
with self.setup_subscribed([test_event]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [('test3', test_event)])
def test_subscribed_unknown_event(self):
"""Test yielding on an unknown watchman event."""
with self.setup_subscribed([dict(unknown=True)]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [])
class TestWatchman(TestBase):
PATCH_OPTS = dict(autospec=True, spec_set=True)
BUILD_ROOT = "/path/to/a/fake/build_root"
WATCHMAN_PATH = "/path/to/a/fake/watchman"
TEST_DIR = "/path/to/a/fake/test"
HANDLERS = [Watchman.EventHandler("test", {}, unittest.mock.Mock())]
def setUp(self):
super().setUp()
with unittest.mock.patch.object(Watchman, "_is_valid_executable",
**self.PATCH_OPTS) as mock_is_valid:
mock_is_valid.return_value = True
self.watchman = Watchman("/fake/path/to/watchman",
self.subprocess_dir)
@property
def _watchman_dir(self):
return os.path.join(self.subprocess_dir, "watchman")
@property
def _state_file(self):
return os.path.join(self._watchman_dir, "watchman.state")
def test_client_property(self):
self.assertIsInstance(self.watchman.client, pywatchman.client)
def test_client_property_cached(self):
self.watchman._watchman_client = 1
self.assertEqual(self.watchman.client, 1)
def test_make_client(self):
self.assertIsInstance(self.watchman._make_client(), pywatchman.client)
def test_is_valid_executable(self):
self.assertTrue(self.watchman._is_valid_executable(sys.executable))
def test_resolve_watchman_path_provided_exception(self):
with self.assertRaises(Watchman.ExecutionError):
self.watchman = Watchman("/fake/path/to/watchman",
metadata_base_dir=self.subprocess_dir)
def test_maybe_init_metadata(self):
# TODO(#7106): is this the right path to patch?
with unittest.mock.patch(
"pants.pantsd.watchman.safe_mkdir",
**self.PATCH_OPTS) as mock_mkdir, unittest.mock.patch(
"pants.pantsd.watchman.safe_file_dump",
**self.PATCH_OPTS) as mock_file_dump:
self.watchman._maybe_init_metadata()
mock_mkdir.assert_called_once_with(self._watchman_dir)
mock_file_dump.assert_called_once_with(self._state_file,
b"{}",
mode="wb")
def test_construct_cmd(self):
output = self.watchman._construct_cmd(["cmd", "parts", "etc"],
"state_file", "sock_file",
"pid_file", "log_file",
"log_level")
self.assertEqual(
output,
[
"cmd",
"parts",
"etc",
"--no-save-state",
"--no-site-spawner",
"--statefile=state_file",
"--sockname=sock_file",
"--pidfile=pid_file",
"--logfile=log_file",
"--log-level",
"log_level",
],
)
def test_parse_pid_from_output(self):
output = json.dumps(dict(pid=3))
self.assertEqual(self.watchman._parse_pid_from_output(output), 3)
def test_parse_pid_from_output_bad_output(self):
output = "{bad JSON.,/#!"
with self.assertRaises(Watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_parse_pid_from_output_no_pid(self):
output = json.dumps(dict(nothing=True))
with self.assertRaises(Watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_launch(self):
with unittest.mock.patch.object(
Watchman, "_maybe_init_metadata"
) as mock_initmeta, unittest.mock.patch.object(
Watchman, "get_subprocess_output"
) as mock_getsubout, unittest.mock.patch.object(
Watchman,
"write_pid") as mock_writepid, unittest.mock.patch.object(
Watchman, "write_socket") as mock_writesock:
mock_getsubout.return_value = json.dumps(dict(pid="3"))
self.watchman.launch()
assert mock_getsubout.called
mock_initmeta.assert_called_once_with()
mock_writepid.assert_called_once_with("3")
mock_writesock.assert_called_once_with(self.watchman._sock_file)
def test_watch_project(self):
self.watchman._watchman_client = unittest.mock.create_autospec(
StreamableWatchmanClient, spec_set=True)
self.watchman.watch_project(self.TEST_DIR)
self.watchman._watchman_client.query.assert_called_once_with(
"watch-project", self.TEST_DIR)
@contextmanager
def setup_subscribed(self, iterable):
mock_client = unittest.mock.create_autospec(StreamableWatchmanClient,
spec_set=True)
mock_client.stream_query.return_value = iter(iterable)
self.watchman._watchman_client = mock_client
yield mock_client
assert mock_client.stream_query.called
def test_subscribed_empty(self):
"""Test yielding when watchman reads timeout."""
with self.setup_subscribed([None]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [(None, None)])
def test_subscribed_response(self):
"""Test yielding on the watchman response to the initial subscribe command."""
with self.setup_subscribed([dict(subscribe="test")]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [(None, None)])
def test_subscribed_event(self):
"""Test yielding on a watchman event for a given subscription."""
test_event = dict(subscription="test3", msg="blah")
with self.setup_subscribed([test_event]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [("test3", test_event)])
def test_subscribed_unknown_event(self):
"""Test yielding on an unknown watchman event."""
with self.setup_subscribed([dict(unknown=True)]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [])
class TestWatchman(BaseTest):
PATCH_OPTS = dict(autospec=True, spec_set=True)
WORK_DIR = "/path/to/a/fake/work_dir"
BUILD_ROOT = "/path/to/a/fake/build_root"
WATCHMAN_PATH = "/path/to/a/fake/watchman"
TEST_DIR = "/path/to/a/fake/test"
WATCHMAN_DIR = os.path.join(WORK_DIR, "watchman")
STATE_FILE = os.path.join(WATCHMAN_DIR, "watchman.state")
HANDLERS = [Watchman.EventHandler("test", {}, mock.Mock())]
def setUp(self):
BaseTest.setUp(self)
with mock.patch.object(Watchman, "_resolve_watchman_path", **self.PATCH_OPTS) as mock_find:
mock_find.return_value = self.WATCHMAN_PATH
self.watchman = Watchman(self.WORK_DIR)
def test_client_property(self):
self.assertIsInstance(self.watchman.client, pywatchman.client)
def test_client_property_cached(self):
self.watchman._watchman_client = 1
self.assertEquals(self.watchman.client, 1)
def test_make_client(self):
self.assertIsInstance(self.watchman._make_client(), pywatchman.client)
def test_is_valid_executable(self):
self.assertTrue(self.watchman._is_valid_executable(sys.executable))
@contextmanager
def setup_find_watchman_in_path(self):
with mock.patch.object(Watchman, "_is_valid_executable", **self.PATCH_OPTS) as mock_valid, environment_as(
PATH="a:b:c"
):
yield mock_valid
def test_find_watchman_in_path(self):
with self.setup_find_watchman_in_path() as mock_valid:
mock_valid.side_effect = [False, False, True]
self.assertEquals(self.watchman._find_watchman_in_path(), "c/watchman")
mock_valid.assert_has_calls(
[
mock.call(self.watchman, "a/{}".format(self.watchman.process_name)),
mock.call(self.watchman, "b/{}".format(self.watchman.process_name)),
mock.call(self.watchman, "c/{}".format(self.watchman.process_name)),
]
)
def test_find_watchman_in_path_neg(self):
with self.setup_find_watchman_in_path() as mock_valid:
mock_valid.side_effect = [False, False, False]
self.assertIsNone(self.watchman._find_watchman_in_path())
def test_resolve_watchman_path_provided_exception(self):
with mock.patch.object(Watchman, "_is_valid_executable", **self.PATCH_OPTS) as mock_valid:
mock_valid.return_value = False
with self.assertRaises(Watchman.ExecutionError):
self.watchman._resolve_watchman_path(self.WATCHMAN_PATH)
def test_resolve_watchman_path_provided(self):
with mock.patch.object(Watchman, "_is_valid_executable", **self.PATCH_OPTS) as mock_valid:
mock_valid.return_value = True
self.assertEquals(self.watchman._resolve_watchman_path(self.WATCHMAN_PATH), self.WATCHMAN_PATH)
def test_resolve_watchman_path_default_exception(self):
with mock.patch.object(Watchman, "_find_watchman_in_path", **self.PATCH_OPTS) as mock_find:
mock_find.return_value = None
with self.assertRaises(Watchman.ExecutionError):
self.watchman._resolve_watchman_path(None)
def test_resolve_watchman_path_default(self):
with mock.patch.object(Watchman, "_find_watchman_in_path", **self.PATCH_OPTS) as mock_find:
mock_find.return_value = self.WATCHMAN_PATH
self.assertEquals(self.watchman._resolve_watchman_path(None), self.WATCHMAN_PATH)
def test_maybe_init_metadata(self):
with mock.patch("pants.pantsd.watchman.safe_mkdir", **self.PATCH_OPTS) as mock_mkdir, mock.patch.object(
Watchman, "_write_file", **self.PATCH_OPTS
) as mock_write_file:
self.watchman._maybe_init_metadata()
mock_mkdir.assert_called_once_with(self.WATCHMAN_DIR)
mock_write_file.assert_called_once_with(self.watchman, self.STATE_FILE, "{}")
def test_construct_cmd(self):
output = self.watchman._construct_cmd(
["cmd", "parts", "etc"], "state_file", "sock_file", "log_file", "log_level"
)
self.assertEquals(
output,
[
"cmd",
"parts",
"etc",
"--no-save-state",
"--statefile=state_file",
"--sockname=sock_file",
"--logfile=log_file",
"--log-level",
"log_level",
],
)
def test_parse_pid_from_output(self):
output = json.dumps(dict(pid=3))
self.assertEquals(self.watchman._parse_pid_from_output(output), 3)
def test_parse_pid_from_output_bad_output(self):
output = "{bad JSON.,/#!"
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_parse_pid_from_output_no_pid(self):
output = json.dumps(dict(nothing=True))
with self.assertRaises(self.watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_launch(self):
with mock.patch.object(Watchman, "_maybe_init_metadata") as mock_initmeta, mock.patch.object(
Watchman, "get_subprocess_output"
) as mock_getsubout, mock.patch.object(Watchman, "write_pid") as mock_writepid, mock.patch.object(
Watchman, "write_socket"
) as mock_writesock:
mock_getsubout.return_value = json.dumps(dict(pid="3"))
self.watchman.launch()
assert mock_getsubout.called
mock_initmeta.assert_called_once_with()
mock_writepid.assert_called_once_with("3")
mock_writesock.assert_called_once_with(self.watchman._sock_file)
def test_watch_project(self):
self.watchman._watchman_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
self.watchman.watch_project(self.TEST_DIR)
self.watchman._watchman_client.query.assert_called_once_with("watch-project", self.TEST_DIR)
@contextmanager
def setup_subscribed(self, iterable):
mock_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
mock_client.stream_query.return_value = iter(iterable)
self.watchman._watchman_client = mock_client
yield mock_client
assert mock_client.stream_query.called
def test_subscribed_empty(self):
"""Test yielding when watchman reads timeout."""
with self.setup_subscribed([None]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_response(self):
"""Test yielding on the watchman response to the initial subscribe command."""
with self.setup_subscribed([dict(subscribe="test")]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [(None, None)])
def test_subscribed_event(self):
"""Test yielding on a watchman event for a given subscription."""
test_event = dict(subscription="test3", msg="blah")
with self.setup_subscribed([test_event]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [("test3", test_event)])
def test_subscribed_unknown_event(self):
"""Test yielding on an unknown watchman event."""
with self.setup_subscribed([dict(unknown=True)]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEquals(list(out), [])
class TestWatchman(TestBase):
PATCH_OPTS = dict(autospec=True, spec_set=True)
BUILD_ROOT = '/path/to/a/fake/build_root'
WATCHMAN_PATH = '/path/to/a/fake/watchman'
TEST_DIR = '/path/to/a/fake/test'
HANDLERS = [Watchman.EventHandler('test', {}, mock.Mock())]
def setUp(self):
super(TestWatchman, self).setUp()
with mock.patch.object(Watchman, '_is_valid_executable', **self.PATCH_OPTS) as mock_is_valid:
mock_is_valid.return_value = True
self.watchman = Watchman('/fake/path/to/watchman', self.subprocess_dir)
@property
def _watchman_dir(self):
return os.path.join(self.subprocess_dir, 'watchman')
@property
def _state_file(self):
return os.path.join(self._watchman_dir, 'watchman.state')
def test_client_property(self):
self.assertIsInstance(self.watchman.client, pywatchman.client)
def test_client_property_cached(self):
self.watchman._watchman_client = 1
self.assertEqual(self.watchman.client, 1)
def test_make_client(self):
self.assertIsInstance(self.watchman._make_client(), pywatchman.client)
def test_is_valid_executable(self):
self.assertTrue(self.watchman._is_valid_executable(sys.executable))
def test_resolve_watchman_path_provided_exception(self):
with self.assertRaises(Watchman.ExecutionError):
self.watchman = Watchman('/fake/path/to/watchman',
metadata_base_dir=self.subprocess_dir)
def test_maybe_init_metadata(self):
# TODO(#7106): is this the right path to patch?
with mock.patch('pants.pantsd.watchman.safe_mkdir', **self.PATCH_OPTS) as mock_mkdir, \
mock.patch('pants.pantsd.watchman.safe_file_dump', **self.PATCH_OPTS) as mock_file_dump:
self.watchman._maybe_init_metadata()
mock_mkdir.assert_called_once_with(self._watchman_dir)
mock_file_dump.assert_called_once_with(self._state_file, b'{}', mode='wb')
def test_construct_cmd(self):
output = self.watchman._construct_cmd(['cmd', 'parts', 'etc'],
'state_file',
'sock_file',
'pid_file',
'log_file',
'log_level')
self.assertEqual(output, ['cmd',
'parts',
'etc',
'--no-save-state',
'--no-site-spawner',
'--statefile=state_file',
'--sockname=sock_file',
'--pidfile=pid_file',
'--logfile=log_file',
'--log-level',
'log_level'])
def test_parse_pid_from_output(self):
output = json.dumps(dict(pid=3))
self.assertEqual(self.watchman._parse_pid_from_output(output), 3)
def test_parse_pid_from_output_bad_output(self):
output = '{bad JSON.,/#!'
with self.assertRaises(Watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_parse_pid_from_output_no_pid(self):
output = json.dumps(dict(nothing=True))
with self.assertRaises(Watchman.InvalidCommandOutput):
self.watchman._parse_pid_from_output(output)
def test_launch(self):
with mock.patch.object(Watchman, '_maybe_init_metadata') as mock_initmeta, \
mock.patch.object(Watchman, 'get_subprocess_output') as mock_getsubout, \
mock.patch.object(Watchman, 'write_pid') as mock_writepid, \
mock.patch.object(Watchman, 'write_socket') as mock_writesock:
mock_getsubout.return_value = json.dumps(dict(pid='3'))
self.watchman.launch()
assert mock_getsubout.called
mock_initmeta.assert_called_once_with()
mock_writepid.assert_called_once_with('3')
mock_writesock.assert_called_once_with(self.watchman._sock_file)
def test_watch_project(self):
self.watchman._watchman_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
self.watchman.watch_project(self.TEST_DIR)
self.watchman._watchman_client.query.assert_called_once_with('watch-project', self.TEST_DIR)
@contextmanager
def setup_subscribed(self, iterable):
mock_client = mock.create_autospec(StreamableWatchmanClient, spec_set=True)
mock_client.stream_query.return_value = iter(iterable)
self.watchman._watchman_client = mock_client
yield mock_client
assert mock_client.stream_query.called
def test_subscribed_empty(self):
"""Test yielding when watchman reads timeout."""
with self.setup_subscribed([None]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [(None, None)])
def test_subscribed_response(self):
"""Test yielding on the watchman response to the initial subscribe command."""
with self.setup_subscribed([dict(subscribe='test')]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [(None, None)])
def test_subscribed_event(self):
"""Test yielding on a watchman event for a given subscription."""
test_event = dict(subscription='test3', msg='blah')
with self.setup_subscribed([test_event]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [('test3', test_event)])
def test_subscribed_unknown_event(self):
"""Test yielding on an unknown watchman event."""
with self.setup_subscribed([dict(unknown=True)]):
out = self.watchman.subscribed(self.BUILD_ROOT, self.HANDLERS)
self.assertEqual(list(out), [])
