Esempio n. 1
0
    def test_normalize_dotted_fields(self):
        def compare_recursive(a, b):
            for key, value in a.items():
                if key not in b:
                    return False
                if isinstance(value, dict):
                    compare_recursive(value, b[key])
            return True

        document = {
            'a.b': 1,
            'c.d': {
                'e.f': {
                    'g': 1,
                    'h': 2,
                },
                'e.f.i': {
                    'j.k': 3,
                },
            },
            'l': [
                {
                    'm.n': 4,
                },
            ],
        }
        expected_result = {
            'a': {
                'b': 1,
            },
            'c': {
                'd': {
                    'e': {
                        'f': {
                            'g': 1,
                            'h': 2,
                            'i': {
                                'j': {
                                    'k': 3,
                                },
                            },
                        },
                    },
                },
            },
            'l': [
                {
                    'm': {
                        'n': 4,
                    },
                },
            ],
        }
        normalize_dotted_fields(document)
        self.assertTrue(compare_recursive(document, expected_result))
Esempio n. 2
0
    def test_normalize_dotted_fields(self):
        def compare_recursive(a, b):
            for key, value in a.items():
                if key not in b:
                    return False
                if isinstance(value, dict):
                    compare_recursive(value, b[key])
            return True

        document = {
            'a.b': 1,
            'c.d': {
                'e.f': {
                    'g': 1,
                    'h': 2,
                },
                'e.f.i': {'j.k': 3,
                          },
            },
            'l': [
                {
                    'm.n': 4,
                },
            ],
        }
        expected_result = {
            'a': {
                'b': 1,
            },
            'c': {
                'd': {
                    'e': {
                        'f': {
                            'g': 1,
                            'h': 2,
                            'i': {
                                'j': {
                                    'k': 3,
                                },
                            },
                        },
                    },
                },
            },
            'l': [
                {
                    'm': {
                        'n': 4,
                    },
                },
            ],
        }
        normalize_dotted_fields(document)
        self.assertTrue(compare_recursive(document, expected_result))
    def test_normalize_dotted_fields(self):
        def compare_recursive(a, b):
            for key, value in a.items():
                if key not in b:
                    return False
                if isinstance(value, dict):
                    compare_recursive(value, b[key])
            return True

        document = {
            "a.b": 1,
            "c.d": {
                "e.f": {
                    "g": 1,
                    "h": 2
                },
                "e.f.i": {
                    "j.k": 3
                }
            },
            "l": [{
                "m.n": 4
            }],
        }
        expected_result = {
            "a": {
                "b": 1
            },
            "c": {
                "d": {
                    "e": {
                        "f": {
                            "g": 1,
                            "h": 2,
                            "i": {
                                "j": {
                                    "k": 3
                                }
                            }
                        }
                    }
                }
            },
            "l": [{
                "m": {
                    "n": 4
                }
            }],
        }
        normalize_dotted_fields(document)
        self.assertTrue(compare_recursive(document, expected_result))