Пример #1
0
    def test_merge_list_of_keys_into_dict(self):
        data = {}
        keys = []

        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, 'something')

        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, 'something',
                                                     -1)

        keys = ['key']
        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, 'something',
                                                     1)

        keys = ['a']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'O-N-E')
        self.assertEquals(data, {'a': 'O-N-E'})

        keys = ['one', 'two', 'three']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'T-H-R-E-E')
        self.assertEquals(data, {
            'one': {
                'two': {
                    'three': 'T-H-R-E-E'
                }
            },
            'a': 'O-N-E'
        })

        keys = ['one', 'two', 'a']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'L-A')
        self.assertEquals(data, {
            'one': {
                'two': {
                    'a': 'L-A',
                    'three': 'T-H-R-E-E'
                }
            },
            'a': 'O-N-E'
        })

        keys = ['c', 'd', 'e', 'f']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'F-O-U-R')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E'
                    }
                },
                'a': 'O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R'
                        }
                    }
                }
            })

        keys = ['one', 'two', 'x', 'y']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'W-H-Y')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y'
                        }
                    }
                },
                'a': 'O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R'
                        }
                    }
                }
            })

        keys = ['c', 'd', 'e', 'g', 'h']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'H-E-L-L-O')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y'
                        }
                    }
                },
                'a': 'O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R',
                            'g': {
                                'h': 'H-E-L-L-O'
                            }
                        }
                    }
                }
            })

        keys = ['one', 'two', 'x', 'z']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'Z-E-D')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y',
                            'z': 'Z-E-D'
                        }
                    }
                },
                'a': 'O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R',
                            'g': {
                                'h': 'H-E-L-L-O'
                            }
                        }
                    }
                }
            })

        keys = ['c', 'd', 'e', 'g', 'i']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'E-Y-E')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y',
                            'z': 'Z-E-D'
                        }
                    }
                },
                'a': 'O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R',
                            'g': {
                                'h': 'H-E-L-L-O',
                                'i': 'E-Y-E'
                            }
                        }
                    }
                }
            })

        keys = ['a']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'new O-N-E')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y',
                            'z': 'Z-E-D'
                        }
                    }
                },
                'a': 'new O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R',
                            'g': {
                                'h': 'H-E-L-L-O',
                                'i': 'E-Y-E'
                            }
                        }
                    }
                }
            })

        keys = ['one', 'two', 'a']
        RunTracker._merge_list_of_keys_into_dict(data, keys, 'L-A-L-A')
        self.assertEquals(
            data, {
                'one': {
                    'two': {
                        'a': 'L-A-L-A',
                        'three': 'T-H-R-E-E',
                        'x': {
                            'y': 'W-H-Y',
                            'z': 'Z-E-D'
                        }
                    }
                },
                'a': 'new O-N-E',
                'c': {
                    'd': {
                        'e': {
                            'f': 'F-O-U-R',
                            'g': {
                                'h': 'H-E-L-L-O',
                                'i': 'E-Y-E'
                            }
                        }
                    }
                }
            })

        keys = ['one', 'two', 'a', 'b', 'c']
        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, 'new A')
Пример #2
0
    def test_merge_list_of_keys_into_dict(self):
        data = {}
        keys = []

        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, "something")

        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, "something",
                                                     -1)

        keys = ["key"]
        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, "something",
                                                     1)

        keys = ["a"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "O-N-E")
        self.assertEqual(data, {"a": "O-N-E"})

        keys = ["one", "two", "three"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "T-H-R-E-E")
        self.assertEqual(data, {
            "one": {
                "two": {
                    "three": "T-H-R-E-E"
                }
            },
            "a": "O-N-E"
        })

        keys = ["one", "two", "a"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "L-A")
        self.assertEqual(data, {
            "one": {
                "two": {
                    "a": "L-A",
                    "three": "T-H-R-E-E"
                }
            },
            "a": "O-N-E"
        })

        keys = ["c", "d", "e", "f"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "F-O-U-R")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E"
                    }
                },
                "a": "O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R"
                        }
                    }
                },
            },
        )

        keys = ["one", "two", "x", "y"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "W-H-Y")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y"
                        }
                    }
                },
                "a": "O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R"
                        }
                    }
                },
            },
        )

        keys = ["c", "d", "e", "g", "h"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "H-E-L-L-O")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y"
                        }
                    }
                },
                "a": "O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R",
                            "g": {
                                "h": "H-E-L-L-O"
                            }
                        }
                    }
                },
            },
        )

        keys = ["one", "two", "x", "z"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "Z-E-D")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y",
                            "z": "Z-E-D"
                        }
                    }
                },
                "a": "O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R",
                            "g": {
                                "h": "H-E-L-L-O"
                            }
                        }
                    }
                },
            },
        )

        keys = ["c", "d", "e", "g", "i"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "E-Y-E")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y",
                            "z": "Z-E-D"
                        }
                    }
                },
                "a": "O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R",
                            "g": {
                                "h": "H-E-L-L-O",
                                "i": "E-Y-E"
                            }
                        }
                    }
                },
            },
        )

        keys = ["a"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "new O-N-E")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y",
                            "z": "Z-E-D"
                        }
                    }
                },
                "a": "new O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R",
                            "g": {
                                "h": "H-E-L-L-O",
                                "i": "E-Y-E"
                            }
                        }
                    }
                },
            },
        )

        keys = ["one", "two", "a"]
        RunTracker._merge_list_of_keys_into_dict(data, keys, "L-A-L-A")
        self.assertEqual(
            data,
            {
                "one": {
                    "two": {
                        "a": "L-A-L-A",
                        "three": "T-H-R-E-E",
                        "x": {
                            "y": "W-H-Y",
                            "z": "Z-E-D"
                        }
                    }
                },
                "a": "new O-N-E",
                "c": {
                    "d": {
                        "e": {
                            "f": "F-O-U-R",
                            "g": {
                                "h": "H-E-L-L-O",
                                "i": "E-Y-E"
                            }
                        }
                    }
                },
            },
        )

        keys = ["one", "two", "a", "b", "c"]
        with self.assertRaises(ValueError):
            RunTracker._merge_list_of_keys_into_dict(data, keys, "new A")
Пример #3
0
  def test_merge_list_of_keys_into_dict(self):
    data = {}
    keys = []

    with self.assertRaises(ValueError):
      RunTracker._merge_list_of_keys_into_dict(data, keys, 'something')

    with self.assertRaises(ValueError):
      RunTracker._merge_list_of_keys_into_dict(data, keys, 'something', -1)

    keys = ['key']
    with self.assertRaises(ValueError):
      RunTracker._merge_list_of_keys_into_dict(data, keys, 'something', 1)

    keys = ['a']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'O-N-E')
    self.assertEquals(data, {'a': 'O-N-E'})

    keys = ['one', 'two', 'three']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'T-H-R-E-E')
    self.assertEquals(data, {'one': {'two': {'three': 'T-H-R-E-E'}}, 'a': 'O-N-E'})

    keys = ['one', 'two', 'a']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'L-A')
    self.assertEquals(data, {'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E'}}, 'a': 'O-N-E'})

    keys = ['c', 'd', 'e', 'f']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'F-O-U-R')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E'}}, 'a': 'O-N-E',
      'c': {'d': {'e': {'f': 'F-O-U-R'}}}
    })

    keys = ['one', 'two', 'x', 'y']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'W-H-Y')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y'}}}, 'a': 'O-N-E',
      'c': {'d': {'e': {'f': 'F-O-U-R'}}}
    })

    keys = ['c', 'd', 'e', 'g', 'h']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'H-E-L-L-O')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y'}}}, 'a': 'O-N-E',
      'c': {'d': {'e': {'f': 'F-O-U-R', 'g': {'h': 'H-E-L-L-O'}}}}
    })

    keys = ['one', 'two', 'x', 'z']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'Z-E-D')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y', 'z': 'Z-E-D'}}},
      'a': 'O-N-E', 'c': {'d': {'e': {'f': 'F-O-U-R', 'g': {'h': 'H-E-L-L-O'}}}}
    })

    keys = ['c', 'd', 'e', 'g', 'i']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'E-Y-E')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y', 'z': 'Z-E-D'}}},
      'a': 'O-N-E', 'c': {'d': {'e': {'f': 'F-O-U-R', 'g': {'h': 'H-E-L-L-O', 'i': 'E-Y-E'}}}}
    })

    keys = ['a']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'new O-N-E')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y', 'z': 'Z-E-D'}}},
      'a': 'new O-N-E', 'c': {'d': {'e': {'f': 'F-O-U-R', 'g': {'h': 'H-E-L-L-O', 'i': 'E-Y-E'}}}}
    })

    keys = ['one', 'two', 'a']
    RunTracker._merge_list_of_keys_into_dict(data, keys, 'L-A-L-A')
    self.assertEquals(data, {
      'one': {'two': {'a': 'L-A-L-A', 'three': 'T-H-R-E-E', 'x': {'y': 'W-H-Y', 'z': 'Z-E-D'}}},
      'a': 'new O-N-E', 'c': {'d': {'e': {'f': 'F-O-U-R', 'g': {'h': 'H-E-L-L-O', 'i': 'E-Y-E'}}}}
    })

    keys = ['one', 'two', 'a', 'b', 'c']
    with self.assertRaises(ValueError):
      RunTracker._merge_list_of_keys_into_dict(data, keys, 'new A')