You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
9.4 KiB
245 lines
9.4 KiB
# Copyright 2016 Google Inc. All rights reserved.
|
|
#
|
|
# 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 errno
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
|
|
import mock
|
|
import unittest2
|
|
|
|
from oauth2client.contrib import locked_file
|
|
|
|
|
|
class TestOpener(unittest2.TestCase):
|
|
def _make_one(self):
|
|
_filehandle, filename = tempfile.mkstemp()
|
|
os.close(_filehandle)
|
|
return locked_file._Opener(filename, 'r+', 'r'), filename
|
|
|
|
def test_ctor(self):
|
|
instance, filename = self._make_one()
|
|
self.assertFalse(instance._locked)
|
|
self.assertEqual(instance._filename, filename)
|
|
self.assertEqual(instance._mode, 'r+')
|
|
self.assertEqual(instance._fallback_mode, 'r')
|
|
self.assertIsNone(instance._fh)
|
|
self.assertIsNone(instance._lock_fd)
|
|
|
|
def test_is_locked(self):
|
|
instance, _ = self._make_one()
|
|
self.assertFalse(instance.is_locked())
|
|
instance._locked = True
|
|
self.assertTrue(instance.is_locked())
|
|
|
|
def test_file_handle(self):
|
|
instance, _ = self._make_one()
|
|
self.assertIsNone(instance.file_handle())
|
|
fh = mock.Mock()
|
|
instance._fh = fh
|
|
self.assertEqual(instance.file_handle(), fh)
|
|
|
|
def test_filename(self):
|
|
instance, filename = self._make_one()
|
|
self.assertEqual(instance.filename(), filename)
|
|
|
|
def test_open_and_lock(self):
|
|
instance, _ = self._make_one()
|
|
instance.open_and_lock(1, 1)
|
|
|
|
def test_unlock_and_close(self):
|
|
instance, _ = self._make_one()
|
|
instance.unlock_and_close()
|
|
|
|
|
|
class TestPosixOpener(TestOpener):
|
|
def _make_one(self):
|
|
_filehandle, filename = tempfile.mkstemp()
|
|
os.close(_filehandle)
|
|
return locked_file._PosixOpener(filename, 'r+', 'r'), filename
|
|
|
|
def test_relock_fail(self):
|
|
instance, _ = self._make_one()
|
|
instance.open_and_lock(1, 1)
|
|
|
|
self.assertTrue(instance.is_locked())
|
|
self.assertIsNotNone(instance.file_handle())
|
|
with self.assertRaises(locked_file.AlreadyLockedException):
|
|
instance.open_and_lock(1, 1)
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
def test_lock_access_error_fallback_mode(self, mock_open):
|
|
# NOTE: This is a bad case. The behavior here should be that the
|
|
# error gets re-raised, but the module lets the if statement fall
|
|
# through.
|
|
instance, _ = self._make_one()
|
|
mock_open.side_effect = [IOError(errno.ENOENT, '')]
|
|
instance.open_and_lock(1, 1)
|
|
|
|
self.assertIsNone(instance.file_handle())
|
|
self.assertTrue(instance.is_locked())
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
def test_lock_non_access_error(self, mock_open):
|
|
instance, _ = self._make_one()
|
|
fh_mock = mock.Mock()
|
|
mock_open.side_effect = [IOError(errno.EACCES, ''), fh_mock]
|
|
instance.open_and_lock(1, 1)
|
|
|
|
self.assertEqual(instance.file_handle(), fh_mock)
|
|
self.assertFalse(instance.is_locked())
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
def test_lock_unexpected_error(self, mock_open):
|
|
instance, _ = self._make_one()
|
|
|
|
with mock.patch('os.open') as mock_os_open:
|
|
mock_os_open.side_effect = [OSError(errno.EPERM, '')]
|
|
with self.assertRaises(OSError):
|
|
instance.open_and_lock(1, 1)
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
@mock.patch('oauth2client.contrib.locked_file.logger')
|
|
@mock.patch('time.time')
|
|
def test_lock_timeout_error(self, mock_time, mock_logger, mock_open):
|
|
instance, _ = self._make_one()
|
|
# Make it seem like 10 seconds have passed between calls.
|
|
mock_time.side_effect = [0, 10]
|
|
|
|
with mock.patch('os.open') as mock_os_open:
|
|
# Raising EEXIST should cause it to try to retry locking.
|
|
mock_os_open.side_effect = [OSError(errno.EEXIST, '')]
|
|
instance.open_and_lock(1, 1)
|
|
self.assertFalse(instance.is_locked())
|
|
self.assertTrue(mock_logger.warn.called)
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
@mock.patch('oauth2client.contrib.locked_file.logger')
|
|
@mock.patch('time.time')
|
|
def test_lock_timeout_error_no_fh(self, mock_time, mock_logger, mock_open):
|
|
instance, _ = self._make_one()
|
|
# Make it seem like 10 seconds have passed between calls.
|
|
mock_time.side_effect = [0, 10]
|
|
# This will cause the retry loop to enter without a file handle.
|
|
fh_mock = mock.Mock()
|
|
mock_open.side_effect = [IOError(errno.ENOENT, ''), fh_mock]
|
|
|
|
with mock.patch('os.open') as mock_os_open:
|
|
# Raising EEXIST should cause it to try to retry locking.
|
|
mock_os_open.side_effect = [OSError(errno.EEXIST, '')]
|
|
instance.open_and_lock(1, 1)
|
|
self.assertFalse(instance.is_locked())
|
|
self.assertTrue(mock_logger.warn.called)
|
|
self.assertEqual(instance.file_handle(), fh_mock)
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.open', create=True)
|
|
@mock.patch('time.time')
|
|
@mock.patch('time.sleep')
|
|
def test_lock_retry_success(self, mock_sleep, mock_time, mock_open):
|
|
instance, _ = self._make_one()
|
|
# Make it seem like 1 second has passed between calls. Extra values
|
|
# are needed by the logging module.
|
|
mock_time.side_effect = [0, 1]
|
|
|
|
with mock.patch('os.open') as mock_os_open:
|
|
# Raising EEXIST should cause it to try to retry locking.
|
|
mock_os_open.side_effect = [
|
|
OSError(errno.EEXIST, ''), mock.Mock()]
|
|
instance.open_and_lock(10, 1)
|
|
print(mock_os_open.call_args_list)
|
|
self.assertTrue(instance.is_locked())
|
|
mock_sleep.assert_called_with(1)
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file.os')
|
|
def test_unlock(self, os_mock):
|
|
instance, _ = self._make_one()
|
|
instance._locked = True
|
|
lock_fd_mock = instance._lock_fd = mock.Mock()
|
|
instance._fh = mock.Mock()
|
|
|
|
instance.unlock_and_close()
|
|
|
|
self.assertFalse(instance.is_locked())
|
|
os_mock.close.assert_called_once_with(lock_fd_mock)
|
|
self.assertTrue(os_mock.unlink.called)
|
|
self.assertTrue(instance._fh.close.called)
|
|
|
|
|
|
class TestLockedFile(unittest2.TestCase):
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file._PosixOpener')
|
|
def _make_one(self, opener_ctor_mock):
|
|
opener_mock = mock.Mock()
|
|
opener_ctor_mock.return_value = opener_mock
|
|
return locked_file.LockedFile(
|
|
'a_file', 'r+', 'r', use_native_locking=False), opener_mock
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file._PosixOpener')
|
|
def test_ctor_minimal(self, opener_mock):
|
|
locked_file.LockedFile(
|
|
'a_file', 'r+', 'r', use_native_locking=False)
|
|
opener_mock.assert_called_with('a_file', 'r+', 'r')
|
|
|
|
@mock.patch.dict('sys.modules', {
|
|
'oauth2client.contrib._win32_opener': mock.Mock()})
|
|
def test_ctor_native_win32(self):
|
|
_win32_opener_mock = sys.modules['oauth2client.contrib._win32_opener']
|
|
locked_file.LockedFile(
|
|
'a_file', 'r+', 'r', use_native_locking=True)
|
|
_win32_opener_mock._Win32Opener.assert_called_with('a_file', 'r+', 'r')
|
|
|
|
@mock.patch.dict('sys.modules', {
|
|
'oauth2client.contrib._win32_opener': None,
|
|
'oauth2client.contrib._fcntl_opener': mock.Mock()})
|
|
def test_ctor_native_fcntl(self):
|
|
_fnctl_opener_mock = sys.modules['oauth2client.contrib._fcntl_opener']
|
|
locked_file.LockedFile(
|
|
'a_file', 'r+', 'r', use_native_locking=True)
|
|
_fnctl_opener_mock._FcntlOpener.assert_called_with('a_file', 'r+', 'r')
|
|
|
|
@mock.patch('oauth2client.contrib.locked_file._PosixOpener')
|
|
@mock.patch.dict('sys.modules', {
|
|
'oauth2client.contrib._win32_opener': None,
|
|
'oauth2client.contrib._fcntl_opener': None})
|
|
def test_ctor_native_posix_fallback(self, opener_mock):
|
|
locked_file.LockedFile(
|
|
'a_file', 'r+', 'r', use_native_locking=True)
|
|
opener_mock.assert_called_with('a_file', 'r+', 'r')
|
|
|
|
def test_filename(self):
|
|
instance, opener = self._make_one()
|
|
opener._filename = 'some file'
|
|
self.assertEqual(instance.filename(), 'some file')
|
|
|
|
def test_file_handle(self):
|
|
instance, opener = self._make_one()
|
|
self.assertEqual(instance.file_handle(), opener.file_handle())
|
|
self.assertTrue(opener.file_handle.called)
|
|
|
|
def test_is_locked(self):
|
|
instance, opener = self._make_one()
|
|
self.assertEqual(instance.is_locked(), opener.is_locked())
|
|
self.assertTrue(opener.is_locked.called)
|
|
|
|
def test_open_and_lock(self):
|
|
instance, opener = self._make_one()
|
|
instance.open_and_lock()
|
|
opener.open_and_lock.assert_called_with(0, 0.05)
|
|
|
|
def test_unlock_and_close(self):
|
|
instance, opener = self._make_one()
|
|
instance.unlock_and_close()
|
|
opener.unlock_and_close.assert_called_with()
|