276 lines
6.2 KiB
Python
276 lines
6.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from benedict.core import keypaths as _keypaths
|
|
|
|
import unittest
|
|
|
|
|
|
class keypaths_test_case(unittest.TestCase):
|
|
|
|
def test_keypaths(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
},
|
|
}
|
|
o = _keypaths(i)
|
|
r = [
|
|
'a',
|
|
'b',
|
|
'b.c',
|
|
'b.c.x',
|
|
'b.c.y',
|
|
'b.d',
|
|
'b.d.x',
|
|
'b.d.y',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_custom_separator(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
},
|
|
}
|
|
o = _keypaths(i, separator='/')
|
|
r = [
|
|
'a',
|
|
'b',
|
|
'b/c',
|
|
'b/c/x',
|
|
'b/c/y',
|
|
'b/d',
|
|
'b/d/x',
|
|
'b/d/y',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_invalid_separator(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
},
|
|
}
|
|
with self.assertRaises(ValueError):
|
|
o = _keypaths(i, separator=True)
|
|
|
|
def test_keypaths_without_separator(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
},
|
|
}
|
|
# with self.assertRaises(ValueError):
|
|
# o = _keypaths(i, separator=None)
|
|
o = _keypaths(i)
|
|
r = [
|
|
'a',
|
|
'b',
|
|
'b.c',
|
|
'b.c.x',
|
|
'b.c.y',
|
|
'b.d',
|
|
'b.d.x',
|
|
'b.d.y',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_non_string_keys(self):
|
|
i = {
|
|
True: {
|
|
True: 1,
|
|
},
|
|
False: {
|
|
False: 1,
|
|
},
|
|
None: {
|
|
None: 1,
|
|
},
|
|
}
|
|
o = _keypaths(i)
|
|
r = [
|
|
'False',
|
|
'False.False',
|
|
'None',
|
|
'None.None',
|
|
'True',
|
|
'True.True',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_lists_and_indexes_included(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
'e': [
|
|
{
|
|
'x': 1,
|
|
'y': -1,
|
|
'z': [1, 2, 3],
|
|
},
|
|
{
|
|
'x': 2,
|
|
'y': -2,
|
|
'z': [2, 3, 4],
|
|
},
|
|
{
|
|
'x': 3,
|
|
'y': -3,
|
|
'z': [3, 4, 5],
|
|
},
|
|
]
|
|
},
|
|
}
|
|
o = _keypaths(i, indexes=True)
|
|
r = [
|
|
'a',
|
|
'b',
|
|
'b.c',
|
|
'b.c.x',
|
|
'b.c.y',
|
|
'b.d',
|
|
'b.d.x',
|
|
'b.d.y',
|
|
'b.e',
|
|
'b.e[0]',
|
|
'b.e[0].x',
|
|
'b.e[0].y',
|
|
'b.e[0].z',
|
|
'b.e[0].z[0]',
|
|
'b.e[0].z[1]',
|
|
'b.e[0].z[2]',
|
|
'b.e[1]',
|
|
'b.e[1].x',
|
|
'b.e[1].y',
|
|
'b.e[1].z',
|
|
'b.e[1].z[0]',
|
|
'b.e[1].z[1]',
|
|
'b.e[1].z[2]',
|
|
'b.e[2]',
|
|
'b.e[2].x',
|
|
'b.e[2].y',
|
|
'b.e[2].z',
|
|
'b.e[2].z[0]',
|
|
'b.e[2].z[1]',
|
|
'b.e[2].z[2]',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_lists_and_indexes_not_included(self):
|
|
i = {
|
|
'a': 1,
|
|
'b': {
|
|
'c': {
|
|
'x': 2,
|
|
'y': 3,
|
|
},
|
|
'd': {
|
|
'x': 4,
|
|
'y': 5,
|
|
},
|
|
'e': [
|
|
{
|
|
'x': 1,
|
|
'y': -1,
|
|
'z': [1, 2, 3],
|
|
},
|
|
{
|
|
'x': 2,
|
|
'y': -2,
|
|
'z': [2, 3, 4],
|
|
},
|
|
{
|
|
'x': 3,
|
|
'y': -3,
|
|
'z': [3, 4, 5],
|
|
},
|
|
]
|
|
},
|
|
}
|
|
o = _keypaths(i, indexes=False)
|
|
r = [
|
|
'a',
|
|
'b',
|
|
'b.c',
|
|
'b.c.x',
|
|
'b.c.y',
|
|
'b.d',
|
|
'b.d.x',
|
|
'b.d.y',
|
|
'b.e',
|
|
]
|
|
self.assertEqual(o, r)
|
|
|
|
def test_keypaths_with_nested_lists_and_indexes_included(self):
|
|
i = {
|
|
'a': {
|
|
'b': [
|
|
[1, 2],
|
|
[3, 4, 5],
|
|
[
|
|
{
|
|
'x': 1,
|
|
'y': -1,
|
|
},
|
|
] ,
|
|
],
|
|
},
|
|
}
|
|
o = _keypaths(i, indexes=True)
|
|
r = [
|
|
'a',
|
|
'a.b',
|
|
'a.b[0]',
|
|
'a.b[0][0]',
|
|
'a.b[0][1]',
|
|
'a.b[1]',
|
|
'a.b[1][0]',
|
|
'a.b[1][1]',
|
|
'a.b[1][2]',
|
|
'a.b[2]',
|
|
'a.b[2][0]',
|
|
'a.b[2][0].x',
|
|
'a.b[2][0].y',
|
|
]
|
|
self.assertEqual(o, r)
|