def test_flatten_a(self):
'''Structure: [].'''
structure_a = [1, 2, 3]
structure_a_flat = {
None: structure_a,
'some.path': [{'some.path': [1, 2, 3]}]
}
(nested, flat) = (structure_a, structure_a_flat)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
nested
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'])
)
def test_flatten_s(self):
'''Structure: 1.'''
structure_s = 1
structure_s_flat = {
None: structure_s,
'some.path': [{'some.path': 1}]
}
(nested, flat) = (structure_s, structure_s_flat)
self.assertEqual(
flatten.flatten(nested),
flat[None]
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
nested
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'])
)
def prune_branches(
self,
source,
balanced=False,
require_serializable=False
):
'''Prune source and return the branches matching the prune specs.
Arguments:
balanced (bool):
If True, the superset of all keys that occur in any
branch will be included in all branches returned. If a
branch was missing one of these keys it will be added
with a placeholder value of None. Thus all the dicts
in the list returned will have an identical set of
keys.
require_serializable (bool):
This will be passed through to flatten. If True,
flatten raises an exception if an unserializable value
is encountered.
Returns:
(list of dicts): A flattened list of dicts with keys
derived from prune_spec paths for the pruner and values
the corresponding leaf values for those paths.
'''
pruned = self.get_subtree(
source
)
trace("PRUNED: %s" % pruned)
flatten_leaves_path_prefix = [
dotpath(ps['path'], no_lists=True)
for ps in self.prune_specs
if 'flatten_leaves' in ps and ps['flatten_leaves']
]
pruned = flatten.flatten(
pruned,
flatten_leaves=flatten_leaves_path_prefix,
require_serializable=require_serializable
)
if balanced:
all_keys = {
dotpath(ps['path'], no_lists=True): None
for ps in self.prune_specs
}
if pruned is None or pruned == []:
pruned = [{}]
pruned = [dict(all_keys, **p) for p in pruned]
return pruned
def test_flatten_d_saa(self):
'''Structure: {1, [], []}.'''
structure_d_saa = {
's': 'S',
'a': [1, 3, 3],
'b': [4, 5, 6]
}
structure_d_saa_flat = {
None: [
structure_d_saa,
[structure_d_saa],
],
'some.path': [
structure_d_saa,
[{
'some.path.s': 'S',
'some.path.a': [1, 3, 3],
'some.path.b': [4, 5, 6]
}]
],
}
(nested, flat) = (structure_d_saa, structure_d_saa_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][1])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][1])
)
def test_flatten_d(self):
'''Structure: {}.'''
structure_d = {'a': 1, 'b': 2}
structure_d_flat = {
None: [structure_d],
'some.path': [
{'some.path.a': 1, 'some.path.b': 2}
]
}
(nested, flat) = (structure_d, structure_d_flat)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
nested
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'])
)
def test_flatten_a_d(self):
'''Structure: [{}].'''
structure_a_d = [
{'a': 1, 'b': 2},
{'a': 3, 'b': 4}
]
structure_a_d_flat = {
None: [
structure_a_d,
structure_a_d,
],
'some.path': [
structure_a_d,
[
{'some.path.a': 1, 'some.path.b': 2},
{'some.path.a': 3, 'some.path.b': 4},
],
],
}
(nested, flat) = (structure_a_d, structure_a_d_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][1])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][1])
)
def test_flatten_a_ad(self):
'''Structure: [[], {}].'''
structure_a_ad = [
{'a': 1, 'b': 2},
['k', 'l']
]
structure_a_ad_flat = {
None: [
structure_a_ad,
[{'a': 1, 'b': 2}, 'k', 'l']
],
'some.path': [
structure_a_ad,
[]
],
}
(nested, flat) = (structure_a_ad, structure_a_ad_flat)
with self.assertRaises(TypeError):
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=0
)),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][1])
)
def test_flatten_a_aa(self):
'''Structure: [[], []].'''
structure_a_aa = [['a', 'b'], [3, 4]]
structure_a_aa_flat = {
None: [
structure_a_aa,
['a', 'b', 3, 4],
],
'some.path': [
structure_a_aa,
[{'some.path': ['a', 'b', 3, 4]}]
],
}
(nested, flat) = (structure_a_aa, structure_a_aa_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=0
)),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][1])
)
def extract_from(self, informers, flat=True):
'''Extract the fields specified by prune_specs.
Arguments:
informers (list of AWSInformer):
``AWSInformer`` instances from which to extract
report data. Any informer whose ``entity_type``
attribute doesn't match the report definition's
``entity_type`` attribute will be skipped.
flat (bool):
If ``True``, return a *flat* result; if ``False``,
return a nested result. See the documentation for
``utensils.prune`` and ``utensils.flatten``
for more information.
'''
pruner = prune.Pruner(*self.prune_specs)
extractable_informers = [
i for i in informers if i.entity_type == self.entity_type
]
if flat:
records = flatten.flatten([
pruner.prune_branches(informer.to_dict(), balanced=True)
for informer in extractable_informers
])
else:
records = [
pruner.prune_tree(informer.to_dict())
for informer in extractable_informers
]
return records
def test_flatten_deep1(self):
'''Structure: {{[{}, {}}],[{, {}}]}}.'''
structure_deep1 = {
'a': [
{'x': 1, 'y': 2},
{'x': 11, 'y': 12}
],
'b': [
{'x': 3, 'y': 4},
{'x': 13, 'y': 14}
]
}
structure_deep1_flat = {
None: [
structure_deep1,
[structure_deep1],
[
{
'a.x': 1, 'a.y': 2,
'b.x': 3, 'b.y': 4
},
{
'a.x': 1, 'a.y': 2,
'b.x': 13, 'b.y': 14
},
{
'a.x': 11, 'a.y': 12,
'b.x': 3, 'b.y': 4
},
{
'a.x': 11, 'a.y': 12,
'b.x': 13, 'b.y': 14
}
],
],
'some.path': [
structure_deep1,
[{
'some.path.a': [
{'x': 1, 'y': 2},
{'x': 11, 'y': 12}
],
'some.path.b': [
{'x': 3, 'y': 4},
{'x': 13, 'y': 14}
]
}],
[
{
'some.path.a.x': 1, 'some.path.a.y': 2,
'some.path.b.x': 3, 'some.path.b.y': 4
},
{
'some.path.a.x': 1, 'some.path.a.y': 2,
'some.path.b.x': 13, 'some.path.b.y': 14
},
{
'some.path.a.x': 11, 'some.path.a.y': 12,
'some.path.b.x': 3, 'some.path.b.y': 4
},
{
'some.path.a.x': 11, 'some.path.a.y': 12,
'some.path.b.x': 13, 'some.path.b.y': 14
}
],
],
}
(nested, flat) = (structure_deep1, structure_deep1_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][2])
)
def test_flatten_d_saadd(self):
'''Structure: {1, [], [], {}, {}}.'''
structure_d_saadd = {
's': 'S',
'u': {'a': 1, 'b': 2},
'v': {'c': 3, 'd': 4},
'x': ['k', 'l', 'm'],
'y': ['n', 'o']
}
structure_d_saadd_flat = {
None: [
structure_d_saadd,
[structure_d_saadd],
[{
's': 'S',
'u.a': 1, 'u.b': 2, 'v.d': 4, 'v.c': 3,
'y': ['n', 'o'], 'x': ['k', 'l', 'm']
}]
],
'some.path': [
structure_d_saadd,
[{
'some.path.s': 'S',
'some.path.u': {'a': 1, 'b': 2},
'some.path.v': {'c': 3, 'd': 4},
'some.path.x': ['k', 'l', 'm'],
'some.path.y': ['n', 'o']
}],
[{
'some.path.s': 'S',
'some.path.u.a': 1, 'some.path.u.b': 2,
'some.path.v.d': 4, 'some.path.v.c': 3,
'some.path.y': ['n', 'o'],
'some.path.x': ['k', 'l', 'm']
}]
],
}
(nested, flat) = (structure_d_saadd, structure_d_saadd_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][2])
)
def test_flatten_d_ad(self):
'''Structure: {[], {}}.'''
structure_d_ad = {
'u': {'a': 1, 'b': 2},
'y': ['n', 'o']
}
structure_d_ad_flat = {
None: [
structure_d_ad,
[structure_d_ad],
[{'u.a': 1, 'u.b': 2, 'y': ['n', 'o']}],
],
'some.path': [
structure_d_ad,
[{
'some.path.u': {'a': 1, 'b': 2},
'some.path.y': ['n', 'o']}],
[{
'some.path.u.a': 1, 'some.path.u.b': 2,
'some.path.y': ['n', 'o']
}],
],
}
(nested, flat) = (structure_d_ad, structure_d_ad_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][2])
)
def test_flatten_d_aa(self):
'''Structure: {[], []}.'''
structure_d_aa = {
'a': [1, 3, 3],
'b': [4, 5, 6]
}
structure_d_aa_flat = {
None: [
structure_d_aa,
[{'a': [1, 3, 3], 'b': [4, 5, 6]}]
],
'some.path': [
structure_d_aa,
[{'some.path.a': [1, 3, 3], 'some.path.b': [4, 5, 6]}],
],
'flat_leaves': [
structure_d_aa,
[
{'a': 1, 'b': 4}, {'a': 1, 'b': 5}, {'a': 1, 'b': 6},
{'a': 3, 'b': 4}, {'a': 3, 'b': 5}, {'a': 3, 'b': 6},
{'a': 3, 'b': 4}, {'a': 3, 'b': 5}, {'a': 3, 'b': 6}
],
],
}
(nested, flat) = (structure_d_aa, structure_d_aa_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][1])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][1])
)
# self.assertEqual(
# sorted(flatten.flatten(nested, flatten_leaves=True, to_depth=0)),
# sorted(flat['flat_leaves'][0])
# )
self.assertEqual(
sorted(flatten.flatten(nested, flatten_leaves=True)),
sorted(flat['flat_leaves'][1])
)
def test_flatten_d_saadd_with_separator(self):
'''Structure: {1, [], [], {}, {}}.'''
structure_d_saadd = {
's': 'S',
'u': {'a': 1, 'b': 2},
'v': {'c': 3, 'd': 4},
'x': ['k', 'l', 'm'],
'y': ['n', 'o']
}
structure_d_saadd_flat = {
None: [
structure_d_saadd,
[structure_d_saadd],
[{
's': 'S',
'u:a': 1, 'u:b': 2, 'v:d': 4, 'v:c': 3,
'y': ['n', 'o'], 'x': ['k', 'l', 'm']
}]
],
'some:path': [
structure_d_saadd,
[{
'some:path:s': 'S',
'some:path:u': {'a': 1, 'b': 2},
'some:path:v': {'c': 3, 'd': 4},
'some:path:x': ['k', 'l', 'm'],
'some:path:y': ['n', 'o']
}],
# [{
# 'some:path:s': 'S',
# 'some:path:u:a': 1, 'some:path:u:b': 2,
# 'some:path:v:d': 4, 'some:path:v:c': 3,
# 'some:path.y': ['n', 'o'],
# 'some:path.x': ['k', 'l', 'm']
# }]
[{
'some:path:v:d': 4,
'some:path:u:b': 2,
'some:path:u:a': 1,
'some:path:x': ['k', 'l', 'm'],
'some:path:y': ['n', 'o'],
'some:path:s': 'S',
'some:path:v:c': 3,
}]
],
}
(nested, flat) = (structure_d_saadd, structure_d_saadd_flat)
self.assertEqual(
sorted(flatten.flatten(nested, separator=':', to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, separator=':', to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, separator=':', to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, separator=':')),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(
nested, separator=':', path_prefix='some:path', to_depth=0
),
sorted(flat['some:path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, separator=':', path_prefix='some:path', to_depth=1
)),
sorted(flat['some:path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, separator=':', path_prefix='some:path', to_depth=2
)),
sorted(flat['some:path'][2])
)
self.assertEqual(
sorted(flatten.flatten(
nested, separator=':', path_prefix='some:path'
)),
sorted(flat['some:path'][2])
)
import unittest
import json
# import random
from boogio import aws_informer
from boogio import site_boogio
from boogio.utensils import flatten
# Sharing this will mean reducing fetch time when the same resources are needed
# in multiple test cases.
GLOBAL_MEDIATOR = aws_informer.AWSMediator(
region_name=site_boogio.test_region_name,
profile_name=site_boogio.test_profile_name)
FLATTEN_COLLAPSES = (flatten.flatten({'a': {'b': {}}, 'c': 1}) == [])
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class TestAWSInformerJSONDumps(unittest.TestCase):
'''Basic test cases for AWSInformer and subclasses JSON output.'''
# Some of the test case function names get pretty long.
# pylint: disable=invalid-name
# TODO: Add skiptest based on os.environ['TEST_DURATION_LIMIT']
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@classmethod
def setUpClass(cls):
'''Test class level common fixture.'''
def test_flatten_deep2(self):
'''Structure: {[{}, {}], [{}, {}], 1, 1}.'''
structure_deep2 = {
'a': [
{'x': 1, 'y': 2},
{'x': 11, 'y': 12}
],
'b': [
{'x': 3, 'y': 4},
{'x': 13, 'y': 14}
],
'c': 42,
'd': 66
}
structure_deep2_flat = {
None: [
structure_deep2,
[structure_deep2],
[
{
'a.x': 1, 'a.y': 2,
'b.x': 3, 'b.y': 4,
'c': 42, 'd': 66
},
{
'a.x': 1, 'a.y': 2,
'b.x': 13, 'b.y': 14,
'c': 42, 'd': 66
},
{
'a.x': 11, 'a.y': 12,
'b.x': 3, 'b.y': 4,
'c': 42, 'd': 66
},
{
'a.x': 11, 'a.y': 12,
'b.x': 13, 'b.y': 14,
'c': 42, 'd': 66
}
]
],
'some.path': [
structure_deep2,
[{
'some.path.a': [
{'x': 1, 'y': 2},
{'x': 11, 'y': 12}
],
'some.path.b': [
{'x': 3, 'y': 4},
{'x': 13, 'y': 14}
],
'some.path.c': 42,
'some.path.d': 66
}],
[
{
'some.path.a.x': 1, 'some.path.a.y': 2,
'some.path.b.x': 3, 'some.path.b.y': 4,
'some.path.c': 42, 'some.path.d': 66
},
{
'some.path.a.x': 1, 'some.path.a.y': 2,
'some.path.b.x': 13, 'some.path.b.y': 14,
'some.path.c': 42, 'some.path.d': 66
},
{
'some.path.a.x': 11, 'some.path.a.y': 12,
'some.path.b.x': 3, 'some.path.b.y': 4,
'some.path.c': 42, 'some.path.d': 66
},
{
'some.path.a.x': 11, 'some.path.a.y': 12,
'some.path.b.x': 13, 'some.path.b.y': 14,
'some.path.c': 42, 'some.path.d': 66
}
],
],
}
(nested, flat) = (structure_deep2, structure_deep2_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
sorted(flat['some.path'][0])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][2])
)
def test_flatten_d_dd(self):
'''Structure: {{}, {}}.'''
structure_d_dd = {
'u': {'a': 1, 'b': 2},
'v': {'a': 3, 'b': 4}
}
structure_d_dd_flat = {
None: [
structure_d_dd,
[{'u': {'a': 1, 'b': 2}, 'v': {'a': 3, 'b': 4}}],
[{'u.a': 1, 'u.b': 2, 'v.a': 3, 'v.b': 4}]
],
'some.path': [
structure_d_dd,
[{
'some.path.u': {'a': 1, 'b': 2},
'some.path.v': {'a': 3, 'b': 4}
}],
[{
'some.path.u.a': 1, 'some.path.u.b': 2,
'some.path.v.a': 3, 'some.path.v.b': 4
}]
]
}
(nested, flat) = (structure_d_dd, structure_d_dd_flat)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=0)),
sorted(flat[None][0])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=1)),
sorted(flat[None][1])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=2)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, to_depth=3)),
sorted(flat[None][2])
)
self.assertEqual(
sorted(flatten.flatten(nested)),
sorted(flat[None][2])
)
self.assertEqual(
flatten.flatten(nested, path_prefix='some.path', to_depth=0),
flat['some.path'][0]
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=1
)),
sorted(flat['some.path'][1])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=2
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(
nested, path_prefix='some.path', to_depth=3
)),
sorted(flat['some.path'][2])
)
self.assertEqual(
sorted(flatten.flatten(nested, path_prefix='some.path')),
sorted(flat['some.path'][2])
)
