Fixed test compatibility issues, and added tests for the bread and bwrite functions

Author: fuzeman

tests/bencode_tests.py

@@ -3,103 +3,156 @@
 
 """bencode.py tests."""
 
-from collections import OrderedDict
-
-from bencode import BTFailure, bencode, bdecode
-
-import unittest
-
-
-class KnownValues(unittest.TestCase):
-    """
-    Test known bencode values.
-
-    Example values partially taken from http://en.wikipedia.org/wiki/Bencode, test case inspired
-    by Mark Pilgrim's examples: http://diveintopython.org/unit_testing/romantest.html
-    """
-
-    knownValues = (
-        (0, 'i0e'.encode('utf-8')),
-        (1, 'i1e'.encode('utf-8')),
-        (10, 'i10e'.encode('utf-8')),
-        (42, 'i42e'.encode('utf-8')),
-        (-42, 'i-42e'.encode('utf-8')),
-        (True, 'i1e'.encode('utf-8')),
-        (False, 'i0e'.encode('utf-8')),
-        ('spam', '4:spam'.encode('utf-8')),
-        ('parrot sketch', '13:parrot sketch'.encode('utf-8')),
-        (['parrot sketch', 42], 'l13:parrot sketchi42ee'.encode('utf-8')),
-        ({
-            'foo': 42,
-            'bar': 'spam'
-        }, 'd3:bar4:spam3:fooi42ee'.encode('utf-8')),
-        (OrderedDict((
-            ('bar', 'spam'),
-            ('foo', 42)
-        )), 'd3:bar4:spam3:fooi42ee'.encode('utf-8')),
-    )
-
-    def testBencodeKnownValues(self):
-        """Encode should give known result with known input."""
-        for plain, encoded in self.knownValues:
-            result = bencode(plain)
-            self.assertEqual(encoded, result)
-
-    def testBdecodeKnownValues(self):
-        """Decode should give known result with known input."""
-        for plain, encoded in self.knownValues:
-            result = bdecode(encoded)
-            self.assertEqual(plain, result)
-
-    def testRoundtripEncoded(self):
-        """Consecutive calls to decode and encode should deliver the original data again."""
-        for plain, encoded in self.knownValues:
-            result = bdecode(encoded)
-            self.assertEqual(encoded, bencode(result))
-
-    def testRoundtripDecoded(self):
-        """Consecutive calls to encode and decode should deliver the original data again."""
-        for plain, encoded in self.knownValues:
-            result = bencode(plain)
-            self.assertEqual(plain, bdecode(result))
-
-
-class IllegalValues(unittest.TestCase):
-    """Test handling of illegal values."""
+from bencode import Bencached, BTFailure, bencode, bdecode
 
+import pytest
+import sys
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    OrderedDict = None
+
+
+VALUES = [
+    (0, 'i0e'),
+    (1, 'i1e'),
+    (10, 'i10e'),
+    (42, 'i42e'),
+    (-42, 'i-42e'),
+    (True, 'i1e'),
+    (False, 'i0e'),
+    ('spam', '4:spam'),
+    ('parrot sketch', '13:parrot sketch'),
+    (['parrot sketch', 42], 'l13:parrot sketchi42ee'),
+    ({'foo': 42, 'bar': 'spam'}, 'd3:bar4:spam3:fooi42ee')
+]
+
+if OrderedDict is not None:
+    VALUES.append((OrderedDict((
+        ('bar', 'spam'),
+        ('foo', 42)
+    )), 'd3:bar4:spam3:fooi42ee'))
+
+
+@pytest.mark.skipif(sys.version_info[0] < 3, reason="Requires: Python 3+")
+def test_encode():
+    """Encode should give known result with known input."""
+    for plain, encoded in VALUES:
+        assert encoded.encode('utf-8') == bencode(plain)
+
+
+@pytest.mark.skipif(sys.version_info[0] != 2, reason="Requires: Python 2")
+def test_encode_py2():
+    """Encode should give known result with known input."""
+    for plain, encoded in VALUES:
+        assert encoded == bencode(plain)
+
+
+@pytest.mark.skipif(sys.version_info[0] < 3, reason="Requires: Python 3+")
+def test_encode_bencached():
+    """Ensure Bencached objects can be encoded."""
+    assert bencode([Bencached(bencode('test'))]) == b'l4:teste'
+
+
+@pytest.mark.skipif(sys.version_info[0] != 2, reason="Requires: Python 2")
+def test_encode_bencached_py2():
+    """Ensure Bencached objects can be encoded."""
+    assert bencode([Bencached(bencode('test'))]) == 'l4:teste'
+
+
+def test_encode_bytes():
+    """Ensure bytes can be encoded."""
+    assert bencode(b'\x9c') == b'1:\x9c'
+
+
+@pytest.mark.skipif(sys.version_info[0] < 3, reason="Requires: Python 3+")
+def test_decode():
+    """Decode should give known result with known input."""
+    for plain, encoded in VALUES:
+        assert plain == bdecode(encoded.encode('utf-8'))
+
+
+@pytest.mark.skipif(sys.version_info[0] != 2, reason="Requires: Python 2")
+def test_decode_py2():
+    """Decode should give known result with known input."""
+    for plain, encoded in VALUES:
+        assert plain == bdecode(encoded)
+
+
+def test_decode_bytes():
+    """Ensure bytes can be decoded."""
+    assert bdecode(b'1:\x9c') == b'\x9c'
+
+
+@pytest.mark.skipif(sys.version_info[0] < 3, reason="Requires: Python 3+")
+def test_encode_roundtrip():
+    """Consecutive calls to decode and encode should deliver the original data again."""
+    for plain, encoded in VALUES:
+        assert encoded.encode('utf-8') == bencode(bdecode(encoded.encode('utf-8')))
+
+
+@pytest.mark.skipif(sys.version_info[0] != 2, reason="Requires: Python 2")
+def test_encode_roundtrip_py2():
+    """Consecutive calls to decode and encode should deliver the original data again."""
+    for plain, encoded in VALUES:
+        assert encoded == bencode(bdecode(encoded))
+
+
+def test_decode_roundtrip():
+    """Consecutive calls to encode and decode should deliver the original data again."""
+    for plain, encoded in VALUES:
+        assert plain == bdecode(bencode(plain))
+
+
+# TODO: BTL implementation currently chokes on this type of input
+# def test_encode_float_error(self):
+#     """ floats cannot be encoded. """
+#     self.assertRaises(BTFailure, bencode, 1.0)
+
+def test_decode_parameter():
+    """Ensure non-strings raise an exception."""
     # TODO: BTL implementation currently chokes on this type of input
-    # def testFloatRaisesIllegalForEncode(self):
-    #     """ floats cannot be encoded. """
-    #     self.assertRaises(BTFailure, bencode, 1.0)
-
-    def testNonStringsRaiseIllegalInputForDecode(self):
-        """Ensure non-strings raise an exception."""
-        # TODO: BTL implementation currently chokes on this type of input
-        # self.assertRaises(BTFailure, bdecode, 0)
-        # self.assertRaises(BTFailure, bdecode, None)
-        # self.assertRaises(BTFailure, bdecode, 1.0)
-        self.assertRaises(BTFailure, bdecode, [1, 2])
-        self.assertRaises(BTFailure, bdecode, {'foo': 'bar'})
-
-    def testRaiseIllegalInputForDecode(self):
-        """Illegally formatted strings should raise an exception when decoded."""
-        self.assertRaises(BTFailure, bdecode, "foo")
-        self.assertRaises(BTFailure, bdecode, "x:foo")
-        self.assertRaises(BTFailure, bdecode, "x42e")
-
-
-class Dictionaries(unittest.TestCase):
-    """Test handling of dictionaries."""
-
-    def testSortedKeysForDicts(self):
-        """Ensure the keys of a dictionary are sorted before being encoded."""
-        encoded = bencode({'zoo': 42, 'bar': 'spam'})
-
-        self.assertTrue(encoded.index(b'zoo') > encoded.index(b'bar'))
-
-    def testNestedDictionary(self):
-        """Test the handling of nested dicts."""
-        self.assertEqual(
-            bencode({'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}}),
-            'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'.encode('utf-8')
-        )
+    # self.assertRaises(BTFailure, bdecode, 0)
+    # self.assertRaises(BTFailure, bdecode, None)
+    # self.assertRaises(BTFailure, bdecode, 1.0)
+    with pytest.raises(BTFailure):
+        bdecode([1, 2])
+
+    with pytest.raises(BTFailure):
+        bdecode({'foo': 'bar'})
+
+
+def test_decode_errors():
+    """Illegally formatted strings should raise an exception when decoded."""
+    with pytest.raises(BTFailure):
+        bdecode("foo")
+
+    with pytest.raises(BTFailure):
+        bdecode("x:foo")
+
+    with pytest.raises(BTFailure):
+        bdecode("x42e")
+
+
+def test_dictionary_sorted():
+    """Ensure the keys of a dictionary are sorted before being encoded."""
+    encoded = bencode({'zoo': 42, 'bar': 'spam'})
+
+    assert encoded.index(b'zoo') > encoded.index(b'bar')
+
+
+@pytest.mark.skipif(sys.version_info[0] < 3, reason="Requires: Python 3+")
+def test_dictionary_nested():
+    """Test the handling of nested dictionaries."""
+    encoded = bencode({'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}})
+
+    assert encoded == 'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'.encode('utf-8')
+
+
+@pytest.mark.skipif(sys.version_info[0] != 2, reason="Requires: Python 2")
+def test_dictionary_nested_py2():
+    """Test the handling of nested dictionaries."""
+    encoded = bencode({'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}})
+
+    assert encoded == 'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'

tests/file_tests.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+"""bencode.py - file tests."""
+
+from bencode import bread, bwrite
+
+import os
+import pytest
+import sys
+
+FIXTURE_DIR = os.path.join(os.path.dirname(__file__), 'fixtures')
+TEMP_DIR = os.path.join(os.path.dirname(__file__), '.tmp')
+
+# Ensure temp directory exists
+if not os.path.exists(TEMP_DIR):
+    os.makedirs(TEMP_DIR)
+
+
+def test_read_file():
+    """Test the reading of bencode files."""
+    with open(os.path.join(FIXTURE_DIR, 'alpha'), 'rb') as fp:
+        data = bread(fp)
+
+        assert data == {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}}
+
+
+def test_read_path():
+    """Test the reading of bencode paths."""
+    data = bread(os.path.join(FIXTURE_DIR, 'alpha'))
+
+    assert data == {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}}
+
+
+@pytest.mark.skipif(sys.version_info < (3, 4), reason="Requires: Python 3.4+")
+def test_read_pathlib():
+    """Test the reading of bencode paths."""
+    from pathlib import Path
+
+    data = bread(Path(FIXTURE_DIR, 'alpha'))
+
+    assert data == {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}}
+
+
+def test_write_file():
+    """Test the writing of bencode paths."""
+    with open(os.path.join(TEMP_DIR, 'beta'), 'wb') as fp:
+        bwrite(
+            {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}},
+            fp
+        )
+
+    with open(os.path.join(TEMP_DIR, 'beta'), 'r') as fp:
+        assert fp.read() == 'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'
+
+
+def test_write_path():
+    """Test the writing of bencode files."""
+    bwrite(
+        {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}},
+        os.path.join(TEMP_DIR, 'beta')
+    )
+
+    with open(os.path.join(TEMP_DIR, 'beta'), 'r') as fp:
+        assert fp.read() == 'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'
+
+
+@pytest.mark.skipif(sys.version_info < (3, 4), reason="Requires: Python 3.4+")
+def test_write_pathlib():
+    """Test the reading of bencode paths."""
+    from pathlib import Path
+
+    bwrite(
+        {'foo': 42, 'bar': {'sketch': 'parrot', 'foobar': 23}},
+        Path(TEMP_DIR, 'beta')
+    )
+
+    with open(os.path.join(TEMP_DIR, 'beta'), 'r') as fp:
+        assert fp.read() == 'd3:bard6:foobari23e6:sketch6:parrote3:fooi42ee'

tests/fixtures/alpha

@@ -0,0 +1 @@
+d3:bard6:foobari23e6:sketch6:parrote3:fooi42ee