django-db-anonymiser 0.1.0__py3-none-any.whl

django_db_anonymiser/database_sanitizer/tests/test_dump_postgres.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+import io
+from collections import namedtuple
+
+import mock
+import pytest
+from six.moves.urllib import parse as urlparse
+
+from ..config import Configuration
+from ..dump import postgres as dump_postgres
+from ..dump.postgres import parse_column_names, parse_values, sanitize
+from ..utils.postgres import decode_copy_value
+
+MOCK_PG_DUMP_OUTPUT = b"""
+--- Fake PostgreSQL database dump
+
+COMMENT ON SCHEMA "public" IS 'standard public schema';
+
+CREATE TABLE "public"."test" (
+"id" integer NOT NULL,
+"created_at" timestamp with time zone NOT NULL,
+"notes" character varying(255) NOT NULL
+);
+
+COPY "public"."test" ("id", "created_at", "notes") FROM stdin;
+1\t2018-01-01 00:00:00\tTest data 1
+2\t2018-01-02 00:00:00\tTest data 2
+3\t2018-01-03 00:00:00\tTest data 3
+\\.
+
+--- Final line after `COPY` statement
+""".strip()
+
+
+INVALID_MOCK_PG_DUMP_OUTPUT = b"""
+--- Fake PostgreSQL database dump
+
+COMMENT ON SCHEMA "public" IS 'standard public schema';
+
+COPY "public"."test" ("id", "created_at", "notes") FROM stdin;
+1\t2018-01-01 00:00:00 Test data 1
+2\t2018-01-02 00:00:00 Test data 2
+3\t2018-01-03 00:00:00 Test data 3
+\\.
+
+--- Final line after `COPY` statement
+""".strip()
+
+
+def create_mock_popen(mock_pg_dump_output):
+    def mock_popen(cmd_args, stdout):
+        mock_pipe_type = namedtuple("mock_pipe", ("stdout",))
+        mock_stdout = io.BytesIO(mock_pg_dump_output)
+        return mock_pipe_type(stdout=mock_stdout)
+    return mock_popen
+
+
+def test_sanitize():
+    url = urlparse.urlparse("postgres://localhost/test")
+    config = Configuration()
+    config.sanitizers["test.notes"] = lambda value: "Sanitized"
+
+    with mock.patch("subprocess.Popen", side_effect=create_mock_popen(MOCK_PG_DUMP_OUTPUT)):
+        dump_output_lines = list(sanitize(url, config))
+
+    assert "--- Fake PostgreSQL database dump" in dump_output_lines
+    assert "--- Final line after `COPY` statement" in dump_output_lines
+    assert "2\t2018-01-02 00:00:00\tSanitized" in dump_output_lines
+
+
+def test_skip_table_rows():
+    url = urlparse.urlparse("postgres://localhost/test")
+    config = Configuration()
+    config.skip_rows_for_tables.append('test')
+
+    with mock.patch("subprocess.Popen",
+                    side_effect=create_mock_popen(MOCK_PG_DUMP_OUTPUT)):
+        output = list(sanitize(url, config))
+
+    assert output == [
+        '--- Fake PostgreSQL database dump',
+        '',
+        'COMMENT ON SCHEMA "public" IS \'standard public schema\';',
+        '',
+        'CREATE TABLE "public"."test" (',
+        '"id" integer NOT NULL,',
+        '"created_at" timestamp with time zone NOT NULL,',
+        '"notes" character varying(255) NOT NULL',
+        ');',
+        '',
+        '',
+        '--- Final line after `COPY` statement'
+    ]
+
+
+def test_sanitizer_invalid_input():
+    url = urlparse.urlparse("postgres://localhost/test")
+
+    config = Configuration()
+    config.sanitizers["test.notes"] = lambda value: "Sanitized"
+
+    with mock.patch("subprocess.Popen", side_effect=create_mock_popen(INVALID_MOCK_PG_DUMP_OUTPUT)):
+        with pytest.raises(ValueError):
+            # Yes, we need the list() function there to eat the yields.
+            list(sanitize(url, config))
+
+
+def test_sanitizer_invalid_scheme():
+    url = urlparse.urlparse("http://localhost/test")
+    with pytest.raises(ValueError):
+        list(sanitize(url, None))
+
+
+@pytest.mark.parametrize(
+    "text,expected_column_names",
+    (
+        ("\"test\"", ("test",)),
+        ("\"test\",\"test\"", ("test", "test")),
+        ("\"test\", \"test\"", ("test", "test")),
+    )
+)
+def test_parse_column_names(text, expected_column_names):
+    assert parse_column_names(text) == expected_column_names
+
+
+@pytest.mark.parametrize(
+    "text,expected_values",
+    (
+        ("Test", ("Test",)),
+        ("Test\tTest", ("Test", "Test")),
+        ("Test\tTest\t", ("Test", "Test", "")),
+        ("\\N", (None,)),
+    )
+)
+def test_parse_values(text, expected_values):
+    assert parse_values(text) == expected_values
+
+
+@pytest.mark.parametrize('config_type', [
+    'no-config', 'empty-config', 'single-column-config'])
+@pytest.mark.parametrize('data_label', ['ok', 'invalid'])
+def test_optimizations(config_type, data_label):
+    if config_type == 'no-config':
+        config = None
+        decoder_call_count = 0
+    else:
+        config = Configuration()
+        if config_type == 'empty-config':
+            decoder_call_count = 0
+        else:
+            assert config_type == 'single-column-config'
+            config.sanitizers["test.notes"] = (lambda x: x)
+            decoder_call_count = 3  # Number of rows in test table
+
+    data = {
+        'ok': MOCK_PG_DUMP_OUTPUT,
+        'invalid': INVALID_MOCK_PG_DUMP_OUTPUT,
+    }[data_label]
+
+    should_raise = (
+        config_type == 'single-column-config'
+        and data_label == 'invalid')
+
+    url = urlparse.urlparse("postgres://localhost/test")
+    with mock.patch("subprocess.Popen", side_effect=create_mock_popen(data)):
+        with mock.patch.object(dump_postgres, 'decode_copy_value') as decoder:
+            decoder.side_effect = decode_copy_value
+            if should_raise:
+                with pytest.raises(ValueError):
+                    list(sanitize(url, config))
+            else:
+                expected_output = data.decode('utf-8').splitlines()
+                assert list(sanitize(url, config)) == expected_output
+                assert decoder.call_count == decoder_call_count

django_db_anonymiser/database_sanitizer/tests/test_main.py

@@ -0,0 +1,91 @@
+from __future__ import unicode_literals
+
+import mock
+import pytest
+import six
+
+from database_sanitizer import __main__
+
+main = __main__.main
+
+
+@mock.patch.object(__main__, 'run')
+def test_main_without_args(mocked_run, capsys):
+    with pytest.raises(SystemExit) as excinfo:
+        main(['SANI'])
+    assert excinfo.value.code == 2
+
+    captured = capsys.readouterr()
+    assert captured.out == ''
+    assert captured.err.splitlines() == [
+        'usage: SANI [-h] [--config CONFIG] [--output OUTPUT] url',
+        'SANI: error: the following arguments are required: url' if six.PY3
+        else 'SANI: error: too few arguments',
+    ]
+    assert not mocked_run.called
+
+
+@mock.patch.object(__main__, 'run')
+def test_main_with_url(mocked_run, capsys):
+    main(['SANI', 'some://url'])
+
+    # Output should be empty
+    captured = capsys.readouterr()
+    assert captured.out == ''
+    assert captured.err == ''
+
+    # The run function should have been called with the URL
+    (run_call_args, run_call_kwargs) = mocked_run.call_args
+    assert run_call_args == ()
+    assert set(run_call_kwargs.keys()) == {'config', 'output', 'url'}
+    assert run_call_kwargs['config'] is None
+    assert run_call_kwargs['url'] == 'some://url'
+
+
+@pytest.mark.parametrize('optname', ['-c', '--config'])
+@mock.patch.object(__main__, 'run')
+@mock.patch.object(__main__, 'Configuration')
+def test_main_with_config(mocked_conf, mocked_run, capsys, optname):
+    main(['SANI', optname, 'config_file.yml', 'some://url'])
+
+    # Output should be empty
+    captured = capsys.readouterr()
+    assert captured.out == ''
+    assert captured.err == ''
+
+    # Configuration should have been created with Configuration.from_file
+    (fromfile_args, fromfile_kwargs) = mocked_conf.from_file.call_args
+    assert fromfile_args == ('config_file.yml',)
+    assert fromfile_kwargs == {}
+
+    # The run function should have been called with the config and URL
+    (run_call_args, run_call_kwargs) = mocked_run.call_args
+    assert run_call_args == ()
+    assert set(run_call_kwargs.keys()) == {'config', 'output', 'url'}
+    assert run_call_kwargs['config'] == mocked_conf.from_file.return_value
+    assert run_call_kwargs['url'] == 'some://url'
+
+
+@pytest.mark.parametrize('optname', ['-o', '--output'])
+@mock.patch.object(__main__, 'run')
+@mock.patch.object(__main__, 'open')
+def test_main_with_output(mocked_open, mocked_run, capsys, optname):
+    main(['SANI', optname, 'output_file.sql', 'some://url'])
+
+    # Output should be empty
+    captured = capsys.readouterr()
+    assert captured.out == ''
+    assert captured.err == ''
+
+    # Output file should have been opened
+    (open_args, open_kwargs) = mocked_open.call_args
+    assert open_args == ('output_file.sql', 'w')
+    assert open_kwargs == {}
+
+    # The run function should have been called with the output and URL
+    (run_call_args, run_call_kwargs) = mocked_run.call_args
+    assert run_call_args == ()
+    assert set(run_call_kwargs.keys()) == {'config', 'output', 'url'}
+    assert run_call_kwargs['config'] is None
+    assert run_call_kwargs['output'] == mocked_open.return_value
+    assert run_call_kwargs['url'] == 'some://url'

django_db_anonymiser/database_sanitizer/tests/test_sanitizers_constant.py

@@ -0,0 +1,29 @@
+from database_sanitizer.sanitizers import constant
+
+
+def test_sanitize_null():
+    assert constant.sanitize_null(None) is None
+    assert constant.sanitize_null('') is None
+    assert constant.sanitize_null('whatever') is None
+    assert constant.sanitize_null('test') is None
+
+
+def test_sanitize_invalid_django_password():
+    assert constant.sanitize_invalid_django_password(None) == '!'
+    assert constant.sanitize_invalid_django_password('') == '!'
+    assert constant.sanitize_invalid_django_password('whatever') == '!'
+    assert constant.sanitize_invalid_django_password('test') == '!'
+
+
+def test_sanitize_empty_json_dict():
+    assert constant.sanitize_empty_json_dict(None) == '{}'
+    assert constant.sanitize_empty_json_dict('') == '{}'
+    assert constant.sanitize_empty_json_dict('whatever') == '{}'
+    assert constant.sanitize_empty_json_dict('test') == '{}'
+
+
+def test_sanitize_empty_json_list():
+    assert constant.sanitize_empty_json_list(None) == '[]'
+    assert constant.sanitize_empty_json_list('') == '[]'
+    assert constant.sanitize_empty_json_list('whatever') == '[]'
+    assert constant.sanitize_empty_json_list('test') == '[]'

django_db_anonymiser/database_sanitizer/tests/test_sanitizers_derived.py

@@ -0,0 +1,19 @@
+from database_sanitizer import session
+from database_sanitizer.sanitizers import derived
+
+
+def setup_module():
+    session.reset(b'not-so-secret-key')
+
+
+def test_sanitize_uuid4():
+    assert derived.sanitize_uuid4(None) is None
+    assert derived.sanitize_uuid4('') == ''
+    assert derived.sanitize_uuid4('0') == (
+        'e3a5862f-cffb-4d89-ab3e-5563b27e287a')
+    assert derived.sanitize_uuid4('00000000000000000000000000000000') == (
+        '00000000-0000-0000-0000-000000000000')
+    assert derived.sanitize_uuid4('00000000-0000-0000-0000-000000000000') == (
+        '00000000-0000-0000-0000-000000000000')
+    assert derived.sanitize_uuid4('e3a5862f-cffb-4d89-ab3e-5563b27e287a') == (
+        '88b0225e-6090-459a-999d-9b3a3ab28c53')

django_db_anonymiser/database_sanitizer/tests/test_sanitizers_string.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+import mock
+import pytest
+
+from ..sanitizers.string import sanitize_empty, sanitize_random, sanitize_zfill
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_output",
+    (
+        ("foo", ""),
+        ("bar", ""),
+        ("", ""),
+        ("   ", ""),
+        (None, None),
+    ),
+)
+def test_sanitize_empty(input_value, expected_output):
+    assert sanitize_empty(input_value) == expected_output
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_output",
+    (
+        ("foo", "000"),
+        ("test test", "000000000"),
+        ("", ""),
+        (None, None)
+    ),
+)
+def test_sanitize_zfill(input_value, expected_output):
+    return sanitize_zfill(input_value) == expected_output
+
+
+@mock.patch('random.choice', return_value='x')
+def test_sanitize_random(mocked_random_choice):
+    assert sanitize_random(None) is None
+    assert sanitize_random('') == ''
+    assert sanitize_random('a') == 'x'
+    assert sanitize_random('hello') == 'xxxxx'
+    assert sanitize_random('hello world') == 'xxxxxxxxxxx'

django_db_anonymiser/database_sanitizer/tests/test_sanitizers_times.py

@@ -0,0 +1,18 @@
+import datetime
+
+import mock
+
+from database_sanitizer.sanitizers import times
+
+
+class _FakeDateTime(datetime.datetime):
+    @staticmethod
+    def now():
+        return datetime.datetime(2018, 1, 1, 12, 00, 00)
+
+
+@mock.patch('random.randint', return_value=42005)
+@mock.patch.object(datetime, 'datetime', _FakeDateTime)
+def test_sanitize_random_past_timestamp(randint_mock):
+    assert times.sanitize_random_past_timestamp('old') == (
+        '2018-01-01T11:59:17.995000')

django_db_anonymiser/database_sanitizer/tests/test_sanitizers_user.py

@@ -0,0 +1,67 @@
+from database_sanitizer import session
+from database_sanitizer.sanitizers import user
+
+
+def setup_module():
+    session.reset(b'not-so-secret-key')
+
+
+def test_sanitize_email():
+    assert user.sanitize_email(None) is None
+    assert user.sanitize_email('') == ''
+    assert user.sanitize_email('test@example.com') == (
+        'zoe.burke@xce13103b.sanitized.net')
+    assert user.sanitize_email('test2@example.com') == (
+        'Melanie.Pratt@x4feb7f40.sanitized.net')
+    assert user.sanitize_email('test@example.com') == (
+        'zoe.burke@xce13103b.sanitized.net')
+    assert user.sanitize_email('test3@example.com') == (
+        'irene.archer@x3d2e92ec.sanitized.net')
+    assert user.sanitize_email(' test3@example.com  ') == (
+        'irene.archer@x3d2e92ec.sanitized.net')
+
+
+def test_sanitize_username():
+    assert user.sanitize_username(None) is None
+    assert user.sanitize_username('') == ''
+    assert user.sanitize_username('John.Doe') == 'billyda979417'
+    assert user.sanitize_username('JaneSmith') == 'helena34a7a0b'
+    assert user.sanitize_username('john-smith') == 'arthurc5a84ec'
+    assert user.sanitize_username('john-smith ') == 'douglas8d3b8d5e'
+    assert user.sanitize_username('john smith ') == 'katyfdab90cc'
+
+
+def test_sanitize_full_name_en_gb():
+    assert user.sanitize_full_name_en_gb(None) is None
+    assert user.sanitize_full_name_en_gb('') == ''
+    assert user.sanitize_full_name_en_gb('John Doe') == 'Francis Walker'
+    assert user.sanitize_full_name_en_gb('Jane Smith') == 'Declan Burke'
+    assert user.sanitize_full_name_en_gb('John Smith') == 'Lawrence Norton'
+    assert user.sanitize_full_name_en_gb('john smith ') == 'Lawrence Norton'
+
+
+def test_sanitize_given_name_en_gb():
+    assert user.sanitize_given_name_en_gb(None) is None
+    assert user.sanitize_given_name_en_gb('') == ''
+    assert user.sanitize_given_name_en_gb('John') == 'Cheryl'
+    assert user.sanitize_given_name_en_gb('Jane') == 'Andrea'
+    assert user.sanitize_given_name_en_gb('Foo bar') == 'Elliott'
+    assert user.sanitize_given_name_en_gb('  Foo BAR ') == 'Elliott'
+
+
+def test_sanitize_surname_en_gb():
+    assert user.sanitize_surname_en_gb(None) is None
+    assert user.sanitize_surname_en_gb('') == ''
+    assert user.sanitize_surname_en_gb('Doe') == 'Bibi'
+    assert user.sanitize_surname_en_gb('Smith') == 'Duffy'
+    assert user.sanitize_surname_en_gb('Anderson') == 'Hodgson'
+    assert user.sanitize_surname_en_gb('andersOn ') == 'Hodgson'
+
+
+def test_sanitize_email_resets_on_session_reset():
+    assert user.sanitize_email('test@example.com') == (
+        'zoe.burke@xce13103b.sanitized.net')
+    session.reset()
+    assert user.sanitize_email('test@example.com') != (
+        'zoe.burke@xce13103b.sanitized.net')
+    session.reset(b'not-so-secret-key')

django_db_anonymiser/database_sanitizer/tests/test_session.py

@@ -0,0 +1,36 @@
+from database_sanitizer import session
+
+
+def setup_module():
+    session.reset(b'not-so-secret-key')
+
+
+def test_hash_text_to_int():
+    assert session.hash_text_to_int('hello') == 4100462238
+
+
+def test_hash_text_to_ints():
+    assert session.hash_text_to_ints('hello', [4, 8, 16]) == (15, 70, 33129)
+
+
+def test_hash_text():
+    assert session.hash_text('hello') == (
+        'f468169e17f4dd5d7318bd6099a4e657ceb0a978cddb4f3382be0da7121659bb')
+
+
+def test_hash_bytes():
+    assert session.hash_bytes(b'hello') == (
+        'f468169e17f4dd5d7318bd6099a4e657ceb0a978cddb4f3382be0da7121659bb')
+
+
+def test_get_secret():
+    assert session.get_secret() == b'not-so-secret-key'
+
+
+def test_reset():
+    old_key = session.get_secret()
+    session.reset()
+    new_key = session.get_secret()
+    assert new_key != old_key
+    session.reset(b'not-so-secret-key')
+    assert session.get_secret() == b'not-so-secret-key'

django_db_anonymiser/database_sanitizer/tests/test_utils_mysql.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+import pytest
+from six.moves.urllib import parse as urlparse
+
+from ..utils.mysql import (
+    decode_mysql_literal,
+    decode_mysql_string_literal,
+    get_mysqldump_args_and_env_from_url,
+    unescape_single_character,
+)
+
+
+@pytest.mark.parametrize(
+    "url",
+    (
+        "mysql://test:test@localhost/test",
+        "mysql://localhost:1234/test",
+        "mysql://localhost",
+    ),
+)
+def test_get_mysqldump_args_and_env_from_url(url):
+    parsed_url = urlparse.urlparse(url)
+
+    if not parsed_url.path:
+        with pytest.raises(ValueError):
+            get_mysqldump_args_and_env_from_url(url=parsed_url)
+        return
+
+    args, env = get_mysqldump_args_and_env_from_url(url=parsed_url)
+
+    assert isinstance(args, list)
+    assert isinstance(env, dict)
+
+    assert len(args) > 0
+    assert "--complete-insert" in args
+    assert "--extended-insert" in args
+    assert "--net_buffer_length=10240" in args
+    assert args[-1] == parsed_url.path[1:]
+
+    if parsed_url.username:
+        index = args.index("-u")
+        assert args[index + 1] == parsed_url.username
+
+    if parsed_url.password:
+        assert env["MYSQL_PWD"] == parsed_url.password
+
+
+@pytest.mark.parametrize(
+    "text,expected_value",
+    (
+        ("NULL", None),
+        ("TRUE", True),
+        ("FALSE", False),
+        ("12", 12),
+        ("12.5", 12.5),
+        ("'test'", "test"),
+    ),
+)
+def test_decode_mysql_literal(text, expected_value):
+    assert decode_mysql_literal(text) == expected_value
+
+
+def test_decode_mysql_literal_invalid_input():
+    with pytest.raises(ValueError):
+        decode_mysql_literal("ERROR")
+
+
+@pytest.mark.parametrize(
+    "text,expected_output",
+    (
+        ("'test'", "test"),
+        ("'test\\ntest'", "test\ntest"),
+        ("'\\0'", "\000"),
+        ("'foo", None),
+        ("foo'", None),
+        ("foo", None),
+    ),
+)
+def test_decode_mysql_string_literal(text, expected_output):
+    if expected_output is None:
+        with pytest.raises(AssertionError):
+            decode_mysql_string_literal(text)
+    else:
+        assert decode_mysql_string_literal(text) == expected_output
+
+
+@pytest.mark.parametrize(
+    "text,expected_output",
+    (
+        ("\\\\", "\\"),
+        ("\\n", "\n"),
+        ("\\r", "\r"),
+        ("\\0", "\000"),
+        ("\\Z", "\032"),
+        ("\\'", "'"),
+        ('\\"', '"'),
+    ),
+)
+def test_unescape_single_character(text, expected_output):
+    class MockRegexpMatch(object):
+
+        def __init__(self, text):
+            self.text = text
+
+        def group(self, index):
+            assert index == 0
+            return self.text
+
+    assert unescape_single_character(MockRegexpMatch(text)) == expected_output

django_db_anonymiser/database_sanitizer/tests/test_utils_postgres.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+
+import pytest
+
+from ..utils.postgres import (
+    DECODE_MAP,
+    POSTGRES_COPY_NULL_VALUE,
+    decode_copy_value,
+    encode_copy_value,
+)
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_value",
+    (
+        ("", ""),
+        (POSTGRES_COPY_NULL_VALUE, None),
+        ("Test", "Test"),
+        ("\\\\", "\\"),
+        ("\\b", "\b"),
+        ("\\f", "\f"),
+        ("\\n", "\n"),
+        ("\\r", "\r"),
+        ("\\t", "\t"),
+        ("\\v", "\v"),
+        ("\\xff", "\xff"),
+        ("\\123", "\123"),
+        ("Test\\r\\nTest", "Test\r\nTest"),
+    )
+)
+def test_decode_copy_value(input_value, expected_value):
+    assert decode_copy_value(input_value) == expected_value
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_value",
+    (
+        ("", ""),
+        (None, POSTGRES_COPY_NULL_VALUE),
+        ("Test", "Test"),
+        ("\\", "\\\\"),
+        ("\b", "\\b"),
+        ("\f", "\\f"),
+        ("\n", "\\n"),
+        ("\r", "\\r"),
+        ("\t", "\\t"),
+        ("\v", "\\v"),
+        ("\xff", "\xff"),
+        ("\123", "\123"),
+        ("Test\r\nTest", "Test\\r\\nTest"),
+    )
+)
+def test_encode_copy_value(input_value, expected_value):
+    assert encode_copy_value(input_value) == expected_value
+
+
+def test_invalid_escape_sequence():
+    with pytest.raises(ValueError):
+        decode_copy_value("\\")
+    with pytest.raises(ValueError):
+        decode_copy_value("\\X")
+
+
+def test_decode_map_contents():
+    assert DECODE_MAP['\\b'] == '\b'
+    assert DECODE_MAP['\\n'] == '\n'
+    assert DECODE_MAP['\\t'] == '\t'
+    assert DECODE_MAP['\\\\'] == '\\'
+    assert DECODE_MAP['\\0'] == '\0'
+    assert DECODE_MAP['\\74'] == '\74'
+    assert DECODE_MAP['\\x0'] == '\0'
+    assert DECODE_MAP['\\xa'] == '\x0a'
+    assert DECODE_MAP['\\xA'] == '\x0a'
+    assert DECODE_MAP['\\x00'] == '\0'
+    assert DECODE_MAP['\\xa3'] == '\xa3'
+    assert DECODE_MAP['\\xA3'] == '\xa3'
+    assert DECODE_MAP['\\xAb'] == '\xab'
+    assert DECODE_MAP['\\xaB'] == '\xab'
+    assert DECODE_MAP['\\xff'] == '\xff'
+
+    assert '\\' not in DECODE_MAP,  "Unterminated escape is not mapped"
+    assert '\\z' not in DECODE_MAP,  "Invalid escape sequences are not mapped"
+
+    assert len(DECODE_MAP) == 1097