| import pickle |
| import shutil |
| import tempfile |
| from unittest import mock, TestCase |
|
|
| import unittest |
| import pytest |
|
|
| from main import Deque |
| from diskcache.core import ENOVAL |
|
|
|
|
| def rmdir(directory): |
| try: |
| shutil.rmtree(directory) |
| except OSError: |
| pass |
|
|
|
|
| class TestDeque(TestCase): |
| @pytest.fixture |
| def deque(self): |
| deque_instance = Deque() |
| yield deque_instance |
| rmdir(deque_instance.directory) |
|
|
| def test_init(self): |
| directory = tempfile.mkdtemp() |
| sequence = list('abcde') |
| deque_instance = Deque(sequence, None) |
|
|
| assert deque_instance == sequence |
|
|
| rmdir(deque_instance.directory) |
| del deque_instance |
|
|
| rmdir(directory) |
| deque_instance = Deque(sequence, directory) |
|
|
| assert deque_instance.directory == directory |
| assert deque_instance == sequence |
|
|
| other = Deque(directory=directory) |
|
|
| assert other == deque_instance |
|
|
| del deque_instance |
| del other |
| rmdir(directory) |
|
|
| def test_getsetdel(self, deque): |
| sequence = list('abcde') |
| assert len(deque) == 0 |
|
|
| for key in sequence: |
| deque.append(key) |
|
|
| assert len(deque) == len(sequence) |
|
|
| for index in range(len(sequence)): |
| assert deque[index] == sequence[index] |
|
|
| for index in range(len(sequence)): |
| deque[index] = index |
|
|
| for index in range(len(sequence)): |
| assert deque[index] == index |
|
|
| for index in range(len(sequence)): |
| if index % 2: |
| del deque[-1] |
| else: |
| del deque[0] |
|
|
| assert len(deque) == 0 |
|
|
| def test_append(self, deque): |
| deque.maxlen = 3 |
| for item in 'abcde': |
| deque.append(item) |
| assert deque == 'cde' |
|
|
| def test_appendleft(self, deque): |
| deque.maxlen = 3 |
| for item in 'abcde': |
| deque.appendleft(item) |
| assert deque == 'edc' |
|
|
| def test_index_positive(self, deque): |
| cache = mock.MagicMock() |
| cache.__len__.return_value = 3 |
| cache.iterkeys.return_value = ['a', 'b', 'c'] |
| cache.__getitem__.side_effect = [KeyError, 101, 102] |
| with mock.patch.object(deque, '_cache', cache): |
| assert deque[0] == 101 |
|
|
| def test_index_negative(self, deque): |
| cache = mock.MagicMock() |
| cache.__len__.return_value = 3 |
| cache.iterkeys.return_value = ['c', 'b', 'a'] |
| cache.__getitem__.side_effect = [KeyError, 101, 100] |
| with mock.patch.object(deque, '_cache', cache): |
| assert deque[-1] == 101 |
|
|
| def test_index_out_of_range(self, deque): |
| cache = mock.MagicMock() |
| cache.__len__.return_value = 3 |
| cache.iterkeys.return_value = ['a', 'b', 'c'] |
| cache.__getitem__.side_effect = [KeyError] * 3 |
| with mock.patch.object(deque, '_cache', cache): |
| with pytest.raises(IndexError): |
| deque[0] |
|
|
| def test_iter_keyerror(self, deque): |
| cache = mock.MagicMock() |
| cache.iterkeys.return_value = ['a', 'b', 'c'] |
| cache.__getitem__.side_effect = [KeyError, 101, 102] |
| with mock.patch.object(deque, '_cache', cache): |
| assert list(iter(deque)) == [101, 102] |
|
|
| def test_reversed(self, deque): |
| sequence = list('abcde') |
| deque += sequence |
| assert list(reversed(deque)) == list(reversed(sequence)) |
|
|
| def test_reversed_keyerror(self, deque): |
| cache = mock.MagicMock() |
| cache.iterkeys.return_value = ['c', 'b', 'a'] |
| cache.__getitem__.side_effect = [KeyError, 101, 100] |
| with mock.patch.object(deque, '_cache', cache): |
| assert list(reversed(deque)) == [101, 100] |
|
|
| def test_state(self, deque): |
| sequence = list('abcde') |
| deque.extend(sequence) |
| assert deque == sequence |
| deque.maxlen = 3 |
| assert list(deque) == sequence[-3:] |
| state = pickle.dumps(deque) |
| values = pickle.loads(state) |
| assert values == sequence[-3:] |
| assert values.maxlen == 3 |
|
|
| def test_compare(self, deque): |
| assert not (deque == {}) |
| assert not (deque == [0]) |
| assert deque != [1] |
| deque.append(0) |
| assert deque <= [0] |
| assert deque <= [1] |
|
|
| def test_indexerror_negative(self, deque): |
| with pytest.raises(IndexError): |
| deque[-1] |
|
|
| def test_indexerror(self, deque): |
| with pytest.raises(IndexError): |
| deque[0] |
|
|
| def test_repr(self): |
| directory = tempfile.mkdtemp() |
| deque_instance = Deque(directory=directory) |
| assert repr(deque_instance) == 'Deque(directory=%r)' % directory |
|
|
| def test_copy(self, deque): |
| sequence = list('abcde') |
| deque.extend(sequence) |
| temp = deque.copy() |
| assert deque == sequence |
| assert temp == sequence |
|
|
| def test_count(self, deque): |
| deque += 'abbcccddddeeeee' |
|
|
| for index, value in enumerate('abcde', 1): |
| assert deque.count(value) == index |
|
|
| def test_extend(self, deque): |
| sequence = list('abcde') |
| deque.extend(sequence) |
| assert deque == sequence |
|
|
| def test_extendleft(self, deque): |
| sequence = list('abcde') |
| deque.extendleft(sequence) |
| assert deque == list(reversed(sequence)) |
|
|
| def test_pop(self, deque): |
| sequence = list('abcde') |
| deque.extend(sequence) |
|
|
| while sequence: |
| assert deque.pop() == sequence.pop() |
|
|
| def test_pop_indexerror(self, deque): |
| with pytest.raises(IndexError): |
| deque.pop() |
|
|
| def test_popleft(self, deque): |
| sequence = list('abcde') |
| deque.extend(sequence) |
|
|
| while sequence: |
| value = sequence[0] |
| assert deque.popleft() == value |
| del sequence[0] |
|
|
| def test_popleft_indexerror(self, deque): |
| with pytest.raises(IndexError): |
| deque.popleft() |
|
|
| def test_remove(self, deque): |
| deque.extend('abaca') |
| deque.remove('a') |
| assert deque == 'baca' |
| deque.remove('a') |
| assert deque == 'bca' |
| deque.remove('a') |
| assert deque == 'bc' |
|
|
| def test_remove_valueerror(self, deque): |
| with pytest.raises(ValueError): |
| deque.remove(0) |
|
|
| def test_remove_keyerror(self, deque): |
| cache = mock.MagicMock() |
| cache.iterkeys.return_value = ['a', 'b', 'c'] |
| cache.__getitem__.side_effect = [KeyError, 100, 100] |
| cache.__delitem__.side_effect = [KeyError, None] |
| with mock.patch.object(deque, '_cache', cache): |
| deque.remove(100) |
|
|
| def test_reverse(self, deque): |
| deque += 'abcde' |
| deque.reverse() |
| assert deque == 'edcba' |
|
|
| def test_rotate_typeerror(self, deque): |
| with pytest.raises(TypeError): |
| deque.rotate(0.5) |
|
|
| def test_rotate(self, deque): |
| deque.rotate(1) |
| deque.rotate(-1) |
| deque += 'abcde' |
| deque.rotate(3) |
| assert deque == 'cdeab' |
|
|
| def test_rotate_negative(self, deque): |
| deque += 'abcde' |
| deque.rotate(-2) |
| assert deque == 'cdeab' |
|
|
| def test_rotate_indexerror(self, deque): |
| deque += 'abc' |
|
|
| cache = mock.MagicMock() |
| cache.__len__.return_value = 3 |
| cache.pull.side_effect = [(None, ENOVAL)] |
|
|
| with mock.patch.object(deque, '_cache', cache): |
| deque.rotate(1) |
|
|
| def test_rotate_indexerror_negative(self, deque): |
| deque += 'abc' |
|
|
| cache = mock.MagicMock() |
| cache.__len__.return_value = 3 |
| cache.pull.side_effect = [(None, ENOVAL)] |
|
|
| with mock.patch.object(deque, '_cache', cache): |
| deque.rotate(-1) |
|
|
| def test_peek(self, deque): |
| value = b'x' * 100_000 |
| deque.append(value) |
| assert len(deque) == 1 |
| assert deque.peek() == value |
| assert len(deque) == 1 |
| assert deque.peek() == value |
| assert len(deque) == 1 |
|
|
| if __name__ == '__main__': |
| unittest.main() |
