Remove contrib.multistore_file (#589)

Remove dependent modules as well. Resolves #470.

2 files changed, 0 insertions, 625 deletions

diff --git a/tests/contrib/test_locked_file.py b/tests/contrib/test_locked_file.py
deleted file mode 100644
index 384bef3..0000000
--- a/tests/contrib/test_locked_file.py
+++ /dev/null
@@ -1,244 +0,0 @@
-# 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()
diff --git a/tests/contrib/test_multistore_file.py b/tests/contrib/test_multistore_file.py
deleted file mode 100644
index ae0664d..0000000
--- a/tests/contrib/test_multistore_file.py
+++ /dev/null
@@ -1,381 +0,0 @@
-# Copyright 2015 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.
-
-"""Unit tests for oauth2client.multistore_file."""
-
-import datetime
-import errno
-import os
-import stat
-import tempfile
-
-import mock
-import unittest2
-
-from oauth2client import client
-from oauth2client import util
-from oauth2client.contrib import multistore_file
-
-_filehandle, FILENAME = tempfile.mkstemp('oauth2client_test.data')
-os.close(_filehandle)
-
-
-class _MockLockedFile(object):
-
-    def __init__(self, filename_str, error_class, error_code):
-        self.filename_str = filename_str
-        self.error_class = error_class
-        self.error_code = error_code
-        self.open_and_lock_called = False
-
-    def open_and_lock(self):
-        self.open_and_lock_called = True
-        raise self.error_class(self.error_code, '')
-
-    def is_locked(self):
-        return False
-
-    def filename(self):
-        return self.filename_str
-
-
-class Test__dict_to_tuple_key(unittest2.TestCase):
-
-    def test_key_conversions(self):
-        key1, val1 = 'somekey', 'some value'
-        key2, val2 = 'another', 'something else'
-        key3, val3 = 'onemore', 'foo'
-        test_dict = {
-            key1: val1,
-            key2: val2,
-            key3: val3,
-        }
-        tuple_key = multistore_file._dict_to_tuple_key(test_dict)
-
-        # the resulting key should be naturally sorted
-        expected_output = (
-            (key2, val2),
-            (key3, val3),
-            (key1, val1),
-        )
-        self.assertTupleEqual(expected_output, tuple_key)
-        # check we get the original dictionary back
-        self.assertDictEqual(test_dict, dict(tuple_key))
-
-
-class MultistoreFileTests(unittest2.TestCase):
-
-    def tearDown(self):
-        try:
-            os.unlink(FILENAME)
-        except OSError:
-            pass
-
-    def setUp(self):
-        try:
-            os.unlink(FILENAME)
-        except OSError:
-            pass
-
-    def _create_test_credentials(self, client_id='some_client_id',
-                                 expiration=None):
-        access_token = 'foo'
-        client_secret = 'cOuDdkfjxxnv+'
-        refresh_token = '1/0/a.df219fjls0'
-        token_expiry = expiration or datetime.datetime.utcnow()
-        token_uri = 'https://www.google.com/accounts/o8/oauth2/token'
-        user_agent = 'refresh_checker/1.0'
-
-        credentials = client.OAuth2Credentials(
-            access_token, client_id, client_secret,
-            refresh_token, token_expiry, token_uri,
-            user_agent)
-        return credentials
-
-    def test_lock_file_raises_ioerror(self):
-        filehandle, filename = tempfile.mkstemp()
-        os.close(filehandle)
-
-        try:
-            for error_code in (errno.EDEADLK, errno.ENOSYS, errno.ENOLCK,
-                               errno.EACCES):
-                for error_class in (IOError, OSError):
-                    multistore = multistore_file._MultiStore(filename)
-                    multistore._file = _MockLockedFile(
-                        filename, error_class, error_code)
-                    # Should not raise though the underlying file class did.
-                    multistore._lock()
-                    self.assertTrue(multistore._file.open_and_lock_called)
-        finally:
-            os.unlink(filename)
-
-    def test_lock_file_raise_unexpected_error(self):
-        filehandle, filename = tempfile.mkstemp()
-        os.close(filehandle)
-
-        try:
-            multistore = multistore_file._MultiStore(filename)
-            multistore._file = _MockLockedFile(filename, IOError, errno.EBUSY)
-            with self.assertRaises(IOError):
-                multistore._lock()
-            self.assertTrue(multistore._file.open_and_lock_called)
-        finally:
-            os.unlink(filename)
-
-    def test_read_only_file_fail_lock(self):
-        credentials = self._create_test_credentials()
-
-        open(FILENAME, 'a+b').close()
-        os.chmod(FILENAME, 0o400)
-
-        store = multistore_file.get_credential_storage(
-            FILENAME,
-            credentials.client_id,
-            credentials.user_agent,
-            ['some-scope', 'some-other-scope'])
-
-        store.put(credentials)
-        if os.name == 'posix':  # pragma: NO COVER
-            self.assertTrue(store._multistore._read_only)
-        os.chmod(FILENAME, 0o600)
-
-    def test_read_only_file_fail_lock_no_warning(self):
-        open(FILENAME, 'a+b').close()
-        os.chmod(FILENAME, 0o400)
-
-        multistore = multistore_file._MultiStore(FILENAME)
-
-        with mock.patch.object(multistore_file.logger, 'warn') as mock_warn:
-            multistore._warn_on_readonly = False
-            multistore._lock()
-            self.assertFalse(mock_warn.called)
-
-    def test_lock_skip_refresh(self):
-        with open(FILENAME, 'w') as f:
-            f.write('123')
-        os.chmod(FILENAME, 0o400)
-
-        multistore = multistore_file._MultiStore(FILENAME)
-
-        refresh_patch = mock.patch.object(
-            multistore, '_refresh_data_cache')
-
-        with refresh_patch as refresh_mock:
-            multistore._data = {}
-            multistore._lock()
-            self.assertFalse(refresh_mock.called)
-
-    @unittest2.skipIf(not hasattr(os, 'symlink'), 'No symlink available')
-    def test_multistore_no_symbolic_link_files(self):
-        SYMFILENAME = FILENAME + 'sym'
-        os.symlink(FILENAME, SYMFILENAME)
-        store = multistore_file.get_credential_storage(
-            SYMFILENAME,
-            'some_client_id',
-            'user-agent/1.0',
-            ['some-scope', 'some-other-scope'])
-        try:
-            with self.assertRaises(IOError):
-                store.get()
-        finally:
-            os.unlink(SYMFILENAME)
-
-    def test_multistore_non_existent_file(self):
-        store = multistore_file.get_credential_storage(
-            FILENAME,
-            'some_client_id',
-            'user-agent/1.0',
-            ['some-scope', 'some-other-scope'])
-
-        credentials = store.get()
-        self.assertIsNone(credentials)
-
-    def test_multistore_file(self):
-        credentials = self._create_test_credentials()
-
-        store = multistore_file.get_credential_storage(
-            FILENAME,
-            credentials.client_id,
-            credentials.user_agent,
-            ['some-scope', 'some-other-scope'])
-
-        # Save credentials
-        store.put(credentials)
-        credentials = store.get()
-
-        self.assertIsNotNone(credentials)
-        self.assertEquals('foo', credentials.access_token)
-
-        # Delete credentials
-        store.delete()
-        credentials = store.get()
-
-        self.assertIsNone(credentials)
-
-        if os.name == 'posix':  # pragma: NO COVER
-            self.assertEquals(
-                0o600, stat.S_IMODE(os.stat(FILENAME).st_mode))
-
-    def test_multistore_file_custom_key(self):
-        credentials = self._create_test_credentials()
-
-        custom_key = {'myapp': 'testing', 'clientid': 'some client'}
-        store = multistore_file.get_credential_storage_custom_key(
-            FILENAME, custom_key)
-
-        store.put(credentials)
-        stored_credentials = store.get()
-
-        self.assertIsNotNone(stored_credentials)
-        self.assertEqual(credentials.access_token,
-                         stored_credentials.access_token)
-
-        store.delete()
-        stored_credentials = store.get()
-
-        self.assertIsNone(stored_credentials)
-
-    def test_multistore_file_custom_string_key(self):
-        credentials = self._create_test_credentials()
-
-        # store with string key
-        store = multistore_file.get_credential_storage_custom_string_key(
-            FILENAME, 'mykey')
-
-        store.put(credentials)
-        stored_credentials = store.get()
-
-        self.assertIsNotNone(stored_credentials)
-        self.assertEqual(credentials.access_token,
-                         stored_credentials.access_token)
-
-        # try retrieving with a dictionary
-        multistore_file.get_credential_storage_custom_string_key(
-            FILENAME, {'key': 'mykey'})
-        stored_credentials = store.get()
-        self.assertIsNotNone(stored_credentials)
-        self.assertEqual(credentials.access_token,
-                         stored_credentials.access_token)
-
-        store.delete()
-        stored_credentials = store.get()
-
-        self.assertIsNone(stored_credentials)
-
-    def test_multistore_file_backwards_compatibility(self):
-        credentials = self._create_test_credentials()
-        scopes = ['scope1', 'scope2']
-
-        # store the credentials using the legacy key method
-        store = multistore_file.get_credential_storage(
-            FILENAME, 'client_id', 'user_agent', scopes)
-        store.put(credentials)
-
-        # retrieve the credentials using a custom key that matches the
-        # legacy key
-        key = {'clientId': 'client_id', 'userAgent': 'user_agent',
-               'scope': util.scopes_to_string(scopes)}
-        store = multistore_file.get_credential_storage_custom_key(
-            FILENAME, key)
-        stored_credentials = store.get()
-
-        self.assertEqual(credentials.access_token,
-                         stored_credentials.access_token)
-
-    def test_multistore_file_get_all_keys(self):
-        # start with no keys
-        keys = multistore_file.get_all_credential_keys(FILENAME)
-        self.assertEquals([], keys)
-
-        # store credentials
-        credentials = self._create_test_credentials(client_id='client1')
-        custom_key = {'myapp': 'testing', 'clientid': 'client1'}
-        store1 = multistore_file.get_credential_storage_custom_key(
-            FILENAME, custom_key)
-        store1.put(credentials)
-
-        keys = multistore_file.get_all_credential_keys(FILENAME)
-        self.assertEquals([custom_key], keys)
-
-        # store more credentials
-        credentials = self._create_test_credentials(client_id='client2')
-        string_key = 'string_key'
-        store2 = multistore_file.get_credential_storage_custom_string_key(
-            FILENAME, string_key)
-        store2.put(credentials)
-
-        keys = multistore_file.get_all_credential_keys(FILENAME)
-        self.assertEquals(2, len(keys))
-        self.assertTrue(custom_key in keys)
-        self.assertTrue({'key': string_key} in keys)
-
-        # back to no keys
-        store1.delete()
-        store2.delete()
-        keys = multistore_file.get_all_credential_keys(FILENAME)
-        self.assertEquals([], keys)
-
-    def _refresh_data_cache_helper(self):
-        multistore = multistore_file._MultiStore(FILENAME)
-        json_patch = mock.patch.object(multistore, '_locked_json_read')
-
-        return multistore, json_patch
-
-    def test__refresh_data_cache_bad_json(self):
-        multistore, json_patch = self._refresh_data_cache_helper()
-
-        with json_patch as json_mock:
-            json_mock.side_effect = ValueError('')
-            multistore._refresh_data_cache()
-            self.assertTrue(json_mock.called)
-            self.assertEqual(multistore._data, {})
-
-    def test__refresh_data_cache_bad_version(self):
-        multistore, json_patch = self._refresh_data_cache_helper()
-
-        with json_patch as json_mock:
-            json_mock.return_value = {}
-            multistore._refresh_data_cache()
-            self.assertTrue(json_mock.called)
-            self.assertEqual(multistore._data, {})
-
-    def test__refresh_data_cache_newer_version(self):
-        multistore, json_patch = self._refresh_data_cache_helper()
-
-        with json_patch as json_mock:
-            json_mock.return_value = {'file_version': 5}
-            with self.assertRaises(multistore_file.NewerCredentialStoreError):
-                multistore._refresh_data_cache()
-            self.assertTrue(json_mock.called)
-
-    def test__refresh_data_cache_bad_credentials(self):
-        multistore, json_patch = self._refresh_data_cache_helper()
-
-        with json_patch as json_mock:
-            json_mock.return_value = {
-                'file_version': 1,
-                'data': [
-                    {'lol': 'this is a bad credential object.'}
-                ]}
-            multistore._refresh_data_cache()
-            self.assertTrue(json_mock.called)
-            self.assertEqual(multistore._data, {})
-
-    def test__delete_credential_nonexistent(self):
-        multistore = multistore_file._MultiStore(FILENAME)
-
-        with mock.patch.object(multistore, '_write') as write_mock:
-            multistore._data = {}
-            multistore._delete_credential('nonexistent_key')
-            self.assertTrue(write_mock.called)