Exemple #1
0
def test_unescape_chars(benchmark, fixture_file: str) -> None:
    with open(os.path.join(FIXTURES_DIR, fixture_file), "r") as fp:
        content = fp.read()

    data = json.loads(content)
    escaped_data = mongoescape.escape_chars(data)

    def run_benchmark():
        result = mongoescape.unescape_chars(escaped_data)
        return result

    unescaped_data = benchmark(run_benchmark)
    escaped_data = mongoescape.escape_chars(escaped_data)
    assert unescaped_data != escaped_data
Exemple #2
0
    def test_complex(self):
        field = {
            'k1.k2': [{
                'l1.l2': '123'
            }, {
                'l3.l4': '456'
            }],
            'k3': [{
                'l5.l6': '789'
            }],
            'k4.k5': [1, 2, 3],
            'k6': ['a', 'b']
        }

        expected = {
            u'k1\uff0ek2': [{
                u'l1\uff0el2': '123'
            }, {
                u'l3\uff0el4': '456'
            }],
            'k3': [{
                u'l5\uff0el6': '789'
            }],
            u'k4\uff0ek5': [1, 2, 3],
            'k6': ['a', 'b']
        }

        escaped = mongoescape.escape_chars(field)
        self.assertDictEqual(expected, escaped)

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertDictEqual(field, unescaped)
Exemple #3
0
    def test_complex(self):
        field = {
            "k1.k2": [{
                "l1.l2": "123"
            }, {
                "l3.l4": "456"
            }],
            "k3": [{
                "l5.l6": "789"
            }],
            "k4.k5": [1, 2, 3],
            "k6": ["a", "b"],
        }

        expected = {
            "k1\uff0ek2": [{
                "l1\uff0el2": "123"
            }, {
                "l3\uff0el4": "456"
            }],
            "k3": [{
                "l5\uff0el6": "789"
            }],
            "k4\uff0ek5": [1, 2, 3],
            "k6": ["a", "b"],
        }

        escaped = mongoescape.escape_chars(field)
        self.assertDictEqual(expected, escaped)

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertDictEqual(field, unescaped)
 def test_unnested(self):
     field = {'k1.k1.k1': 'v1', 'k2$': 'v2', '$k3.': 'v3'}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(escaped, {u'k1\uff0ek1\uff0ek1': 'v1',
                                u'k2\uff04': 'v2',
                                u'\uff04k3\uff0e': 'v3'}, 'Escaping failed.')
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, 'Unescaping failed.')
Exemple #5
0
 def test_unnested(self):
     field = {'k1.k1.k1': 'v1', 'k2$': 'v2', '$k3.': 'v3'}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(escaped, {u'k1\uff0ek1\uff0ek1': 'v1',
                                u'k2\uff04': 'v2',
                                u'\uff04k3\uff0e': 'v3'}, 'Escaping failed.')
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, 'Unescaping failed.')
Exemple #6
0
    def test_original_value(self):
        field = {'k1.k2.k3': 'v1'}

        escaped = mongoescape.escape_chars(field)
        self.assertIn('k1.k2.k3', list(field.keys()))
        self.assertIn(u'k1\uff0ek2\uff0ek3', list(escaped.keys()))

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertIn('k1.k2.k3', list(unescaped.keys()))
        self.assertIn(u'k1\uff0ek2\uff0ek3', list(escaped.keys()))
Exemple #7
0
    def test_original_value(self):
        field = {"k1.k2.k3": "v1"}

        escaped = mongoescape.escape_chars(field)
        self.assertIn("k1.k2.k3", list(field.keys()))
        self.assertIn("k1\uff0ek2\uff0ek3", list(escaped.keys()))

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertIn("k1.k2.k3", list(unescaped.keys()))
        self.assertIn("k1\uff0ek2\uff0ek3", list(escaped.keys()))
    def test_original_value(self):
        field = {'k1.k2.k3': 'v1'}

        escaped = mongoescape.escape_chars(field)
        self.assertIn('k1.k2.k3', field.keys())
        self.assertIn(u'k1\uff0ek2\uff0ek3', escaped.keys())

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertIn('k1.k2.k3', unescaped.keys())
        self.assertIn(u'k1\uff0ek2\uff0ek3', escaped.keys())
 def test_nested(self):
     nested_field = {'nk1.nk1.nk1': 'v1', 'nk2$': 'v2', '$nk3.': 'v3'}
     field = {'k1.k1.k1': nested_field, 'k2$': 'v2', '$k3.': 'v3'}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(escaped, {u'k1\uff0ek1\uff0ek1': {u'\uff04nk3\uff0e': 'v3',
                                                        u'nk1\uff0enk1\uff0enk1': 'v1',
                                                        u'nk2\uff04': 'v2'},
                                u'k2\uff04': 'v2',
                                u'\uff04k3\uff0e': 'v3'}, 'un-escaping failed.')
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, 'Unescaping failed.')
Exemple #10
0
 def test_nested(self):
     nested_field = {'nk1.nk1.nk1': 'v1', 'nk2$': 'v2', '$nk3.': 'v3'}
     field = {'k1.k1.k1': nested_field, 'k2$': 'v2', '$k3.': 'v3'}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(escaped, {u'k1\uff0ek1\uff0ek1': {u'\uff04nk3\uff0e': 'v3',
                                                        u'nk1\uff0enk1\uff0enk1': 'v1',
                                                        u'nk2\uff04': 'v2'},
                                u'k2\uff04': 'v2',
                                u'\uff04k3\uff0e': 'v3'}, 'un-escaping failed.')
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, 'Unescaping failed.')
Exemple #11
0
 def test_unnested(self):
     field = {"k1.k1.k1": "v1", "k2$": "v2", "$k3.": "v3"}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(
         escaped,
         {
             "k1\uff0ek1\uff0ek1": "v1",
             "k2\uff04": "v2",
             "\uff04k3\uff0e": "v3"
         },
         "Escaping failed.",
     )
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, "Unescaping failed.")
Exemple #12
0
 def test_nested(self):
     nested_field = {"nk1.nk1.nk1": "v1", "nk2$": "v2", "$nk3.": "v3"}
     field = {"k1.k1.k1": nested_field, "k2$": "v2", "$k3.": "v3"}
     escaped = mongoescape.escape_chars(field)
     self.assertEqual(
         escaped,
         {
             "k1\uff0ek1\uff0ek1": {
                 "\uff04nk3\uff0e": "v3",
                 "nk1\uff0enk1\uff0enk1": "v1",
                 "nk2\uff04": "v2",
             },
             "k2\uff04": "v2",
             "\uff04k3\uff0e": "v3",
         },
         "un-escaping failed.",
     )
     unescaped = mongoescape.unescape_chars(escaped)
     self.assertEqual(unescaped, field, "Unescaping failed.")
Exemple #13
0
    def test_complex(self):
        field = {
            'k1.k2': [{'l1.l2': '123'}, {'l3.l4': '456'}],
            'k3': [{'l5.l6': '789'}],
            'k4.k5': [1, 2, 3],
            'k6': ['a', 'b']
        }

        expected = {
            u'k1\uff0ek2': [{u'l1\uff0el2': '123'}, {u'l3\uff0el4': '456'}],
            'k3': [{u'l5\uff0el6': '789'}],
            u'k4\uff0ek5': [1, 2, 3],
            'k6': ['a', 'b']
        }

        escaped = mongoescape.escape_chars(field)
        self.assertDictEqual(expected, escaped)

        unescaped = mongoescape.unescape_chars(escaped)
        self.assertDictEqual(field, unescaped)
Exemple #14
0
 def to_mongo(self, value):
     value = mongoescape.escape_chars(value)
     return super(EscapedDictField, self).to_mongo(value)
Exemple #15
0
 def to_mongo(self, value):
     value = mongoescape.escape_chars(value)
     return super(EscapedDynamicField, self).to_mongo(value)
Exemple #16
0
 def to_mongo(self, value, use_db_field=True, fields=None):
     value = mongoescape.escape_chars(value)
     return super(EscapedDynamicField, self).to_mongo(value=value, use_db_field=use_db_field,
                                                      fields=fields)
Exemple #17
0
 def to_mongo(self, value, use_db_field=True, fields=None):
     value = mongoescape.escape_chars(value)
     return super(EscapedDynamicField,
                  self).to_mongo(value=value,
                                 use_db_field=use_db_field,
                                 fields=fields)
Exemple #18
0
 def run_benchmark():
     result = mongoescape.escape_chars(data)
     return result