|
|
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() |
