def test_separated_user_group_returns_user_only(self):
name_to_uid = Mock(return_value=42)
@patch("supervisor.datatypes.name_to_uid", name_to_uid)
def colon_separated(value):
return self._callFUT(value)
uid, gid = colon_separated("foo")
name_to_uid.assert_called_with("foo")
self.assertEqual(42, uid)
self.assertEqual(-1, gid)
def test_separated_user_group_returns_user_only(self):
name_to_uid = Mock(return_value=42)
@patch("supervisor.datatypes.name_to_uid", name_to_uid)
def colon_separated(value):
return self._callFUT(value)
uid, gid = colon_separated("foo")
name_to_uid.assert_called_with("foo")
self.assertEqual(42, uid)
self.assertEqual(-1, gid)
def test_after_daemonize_restores_kqueue(self):
options = DummyOptions()
poller = self._makeOne(options)
poller.readables = [1]
poller.writables = [3]
poller.register_readable = Mock()
poller.register_writable = Mock()
poller.after_daemonize()
self.assertTrue(isinstance(poller._kqueue, select.kqueue))
poller.register_readable.assert_called_with(1)
poller.register_writable.assert_called_with(3)
def test_close_closes_kqueue(self):
mock_kqueue = Mock()
options = DummyOptions()
poller = self._makeOne(options)
poller._kqueue = mock_kqueue
poller.close()
mock_kqueue.close.assert_called_once_with()
self.assertEqual(poller._kqueue, None)
def test_create_and_bind_when_chmod_fails(self):
(tf_fd, tf_name) = tempfile.mkstemp()
owner = (sentinel.uid, sentinel.gid)
mode = sentinel.mode
conf = self._makeOne(tf_name, owner=owner, mode=mode)
@patch('os.chown', Mock())
@patch('os.chmod', Mock(side_effect=OSError("msg")))
def call_create_and_bind(conf):
return conf.create_and_bind()
try:
call_create_and_bind(conf)
self.fail()
except ValueError as e:
expected = "Could not change permissions of socket file: msg"
self.assertEqual(e.args[0], expected)
self.assertFalse(os.path.exists(tf_name))
class NameToUidTests(unittest.TestCase):
def _callFUT(self, arg):
return datatypes.name_to_uid(arg)
@patch("pwd.getpwnam", Mock(return_value=[0, 0, 42]))
def test_gets_uid_from_username(self):
uid = self._callFUT("foo")
self.assertEqual(uid, 42)
@patch("pwd.getpwuid", Mock(return_value=[0, 0, 42]))
def test_gets_uid_from_user_id(self):
uid = self._callFUT("42")
self.assertEqual(uid, 42)
@patch("pwd.getpwnam", Mock(side_effect=KeyError("bad username")))
def test_raises_for_bad_username(self):
self.assertRaises(ValueError, self._callFUT, "foo")
@patch("pwd.getpwuid", Mock(side_effect=KeyError("bad user id")))
def test_raises_for_bad_user_id(self):
self.assertRaises(ValueError, self._callFUT, "42")
class NameToGidTests(unittest.TestCase):
def _callFUT(self, arg):
return datatypes.name_to_gid(arg)
@patch("grp.getgrnam", Mock(return_value=[0, 0, 42]))
def test_gets_gid_from_group_name(self):
gid = self._callFUT("foo")
self.assertEqual(gid, 42)
@patch("grp.getgrgid", Mock(return_value=[0, 0, 42]))
def test_gets_gid_from_group_id(self):
gid = self._callFUT("42")
self.assertEqual(gid, 42)
@patch("grp.getgrnam", Mock(side_effect=KeyError("bad group name")))
def test_raises_for_bad_group_name(self):
self.assertRaises(ValueError, self._callFUT, "foo")
@patch("grp.getgrgid", Mock(side_effect=KeyError("bad group id")))
def test_raises_for_bad_group_id(self):
self.assertRaises(ValueError, self._callFUT, "42")
def test_separated_user_group_returns_both(self):
name_to_uid = Mock(return_value=12)
name_to_gid = Mock(return_value=34)
@patch("supervisor.datatypes.name_to_uid", name_to_uid)
@patch("supervisor.datatypes.name_to_gid", name_to_gid)
def colon_separated(value):
return self._callFUT(value)
uid, gid = colon_separated("foo:bar")
name_to_uid.assert_called_with("foo")
self.assertEqual(12, uid)
name_to_gid.assert_called_with("bar")
self.assertEqual(34, gid)
def test_create_and_bind(self):
(tf_fd, tf_name) = tempfile.mkstemp()
owner = (sentinel.uid, sentinel.gid)
mode = sentinel.mode
conf = self._makeOne(tf_name, owner=owner, mode=mode)
# Patch os.chmod and os.chown functions with mocks
# objects so that the test does not depend on
# any specific system users or permissions
chown_mock = Mock()
chmod_mock = Mock()
@patch('os.chown', chown_mock)
@patch('os.chmod', chmod_mock)
def call_create_and_bind(conf):
return conf.create_and_bind()
sock = call_create_and_bind(conf)
self.assertTrue(os.path.exists(tf_name))
# verifies that bind was called
self.assertEqual(conf.addr(), sock.getsockname())
sock.close()
self.assertTrue(os.path.exists(tf_name))
os.unlink(tf_name)
# Verify that os.chown was called with correct args
self.assertEqual(1, chown_mock.call_count)
path_arg = chown_mock.call_args[0][0]
uid_arg = chown_mock.call_args[0][1]
gid_arg = chown_mock.call_args[0][2]
self.assertEqual(tf_name, path_arg)
self.assertEqual(owner[0], uid_arg)
self.assertEqual(owner[1], gid_arg)
# Verify that os.chmod was called with correct args
self.assertEqual(1, chmod_mock.call_count)
path_arg = chmod_mock.call_args[0][0]
mode_arg = chmod_mock.call_args[0][1]
self.assertEqual(tf_name, path_arg)
self.assertEqual(mode, mode_arg)
def test_separated_user_group_returns_both(self):
name_to_uid = Mock(return_value=12)
name_to_gid = Mock(return_value=34)
@patch("supervisor.datatypes.name_to_uid", name_to_uid)
@patch("supervisor.datatypes.name_to_gid", name_to_gid)
def colon_separated(value):
return self._callFUT(value)
uid, gid = colon_separated("foo:bar")
name_to_uid.assert_called_with("foo")
self.assertEqual(12, uid)
name_to_gid.assert_called_with("bar")
self.assertEqual(34, gid)
