def test_all_child_single_optional_fail(self): """ When an Element is optional, its rules and all descendent Element's rules must be considered optional """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["optional"] = True all_copy["children"].append(single_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) optional_outputs = [ { "items": [ { "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" } ] }, {}, ] for out in optional_outputs: self.assertFalse(compare(out, flattened))
def test_all_child_all_optional_fail(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) alt_all_copy["optional"] = True all_copy["children"].append(alt_all_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) bad_outputs = [ { "items": [ { "paragraphs": [ { "description": "foo" }, { "description": "bar" } ] } ] }, {} ] for o in bad_outputs: self.assertIsNotNone(differences(o, flattened))
def test_all_optional(self): """ for an optional AllElement, the dict for it will be optional as will all rules from it and its children """ all_copy = copy.deepcopy(ALL_ELEMENT) all_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [("count", int, True)] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_single_child_all_optional_fail(self): all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["children"].append(all_copy) all_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) bad_outputs = [ { "url": "http://www.isaacasimov.com/nightfall", "items": [ { "count": 7, }, { "count": 12, } ] }, { "title": "Nightfall", "items": [ { "count": 7, }, { "count": 12, } ] } ] for o in bad_outputs: self.assertFalse(compare(o, flattened))
def test_all_child_single_optional_fail(self): """ When an Element is optional, its rules and all descendent Element's rules must be considered optional """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["optional"] = True all_copy["children"].append(single_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) optional_outputs = [ { "items": [ { "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" } ] }, {}, ] for out in optional_outputs: self.assertIsNotNone(differences(out, flattened))
def test_all_child_single(self): """ When a SingleElement is nested within an AllELement (or RangeElement), all of its rules will be added to the dict of the AllElement's rules. """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) all_copy["children"].append(single_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ { "count": 7, "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" }, { "count": 12, "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" } ] } self.assertIsNone(differences(output, flattened))
def test_single_child_all_optional_fail(self): all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["children"].append(all_copy) all_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) bad_outputs = [ { "url": "http://www.isaacasimov.com/nightfall", "items": [ { "count": 7, }, { "count": 12, } ] }, { "title": "Nightfall", "items": [ { "count": 7, }, { "count": 12, } ] } ] for o in bad_outputs: self.assertIsNotNone(differences(o, flattened))
def test_single_child_all(self): """ when an AllElement (or RangeElement) is nested within a SingleElement, a key/value pair with the AllElement's spec name and a dict containing it (and its children's) rules will be created """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["children"].append(all_copy) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall", "items": [ { "count": 7, }, { "count": 12, } ] } self.assertIsNone(differences(output, flattened))
def test_single_child_all(self): """ when an AllElement (or RangeElement) is nested within a SingleElement, a key/value pair with the AllElement's spec name and a dict containing it (and its children's) rules will be created """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["children"].append(all_copy) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall", "items": [ { "count": 7, }, { "count": 12, } ] } self.assertTrue(compare(output, flattened))
def test_range_element(self): range_copy = copy.deepcopy(RANGE_ELEMENT) ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) output = {"items": [{"count": 7}, {"count": 12}]} self.assertIsNone(differences(output, flattened))
def test_all_child_all_optional_fail(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) alt_all_copy["optional"] = True all_copy["children"].append(alt_all_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) bad_outputs = [ { "items": [ { "paragraphs": [ { "description": "foo" }, { "description": "bar" } ] } ] }, {} ] for o in bad_outputs: self.assertFalse(compare(o, flattened))
def test_range_optional(self): """ the RangeElement flattens the same as an AllElement """ range_copy = copy.deepcopy(RANGE_ELEMENT) range_copy["optional"] = True ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [ ("count", int, True) ] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all_child_single_optional(self): all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) all_copy["children"].append(single_copy) single_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, False items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, False) expected_item_keys = [ ("count", int, False), ("title", str, True), ("url", str, True) ] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_range_optional(self): """ the RangeElement flattens the same as an AllElement """ range_copy = copy.deepcopy(RANGE_ELEMENT) range_copy["optional"] = True ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [("count", int, True)] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all_child_all_optional(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) alt_all_copy["optional"] = True all_copy["children"].append(alt_all_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) outputs = [{ "items": [{ "count": 6, "paragraphs": [{ "description": "foo" }, { "description": "bar" }] }] }, { "items": [{ "count": 6, "paragraphs": [] }] }, { "items": [{ "count": 6 }] }] for o in outputs: self.assertIsNone(differences(o, flattened))
def test_all_element_fail(self): all_copy = copy.deepcopy(ALL_ELEMENT) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = {"items": [{"count": 7}, {}]} self.assertIsNotNone(differences(output, flattened))
def test_all_optional(self): """ for an optional AllElement, the dict for it will be optional as will all rules from it and its children """ all_copy = copy.deepcopy(ALL_ELEMENT) all_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [ ("count", int, True) ] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all_child_single_fail(self): """ When a SingleElement is nested within an AllELement (or RangeElement), all of its rules will be added to the dict of the AllElement's rules. """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) all_copy["children"].append(single_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) bad_outputs = [{ "items": [{ "count": "12", "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" }] }, { "items": [{ "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" }] }, { "items": [{ "count": 12, "url": "http://www.isaacasimov.com/foundation" }] }, {}] for out in bad_outputs: self.assertIsNotNone(differences(out, flattened))
def test_all_child_single(self): """ When a SingleElement is nested within an AllELement (or RangeElement), all of its rules will be added to the dict of the AllElement's rules. """ all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) all_copy["children"].append(single_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ { "count": 7, "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" }, { "count": 12, "title": "Foundation", "url": "http://www.isaacasimov.com/foundation" } ] } self.assertTrue(compare(output, flattened))
def test_all_child_single_optional(self): all_copy = copy.deepcopy(ALL_ELEMENT) single_copy = copy.deepcopy(SINGLE_ELEMENT) all_copy["children"].append(single_copy) single_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, False items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, False) expected_item_keys = [("count", int, False), ("title", str, True), ("url", str, True)] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_single_element(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" } self.assertIsNone(differences(output, flattened))
def test_single_element(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" } self.assertTrue(compare(output, flattened))
def test_single_child_single_optional_fail(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) alt_single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [{"title": "The Dark Forest", "text": "The Second Novel"}] for o in outputs: self.assertIsNotNone(differences(o, flattened))
def test_all_element(self): all_copy = copy.deepcopy(ALL_ELEMENT) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ {"count": 7}, {"count": 12} ] } self.assertIsNone(differences(output, flattened))
def test_range_element_fail(self): range_copy = copy.deepcopy(RANGE_ELEMENT) ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) output = { "items": [ {"count": 7}, {} ] } self.assertIsNotNone(differences(output, flattened))
def test_all_element(self): all_copy = copy.deepcopy(ALL_ELEMENT) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ {"count": 7}, {"count": 12} ] } self.assertTrue(compare(output, flattened))
def test_range_element_fail(self): range_copy = copy.deepcopy(RANGE_ELEMENT) ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) output = { "items": [ {"count": 7}, {} ] } self.assertFalse(compare(output, flattened))
def test_optional_all_element(self): """ for an optional AllElement, the dict for it will be optional as will all rules from it and its children """ all_copy = copy.deepcopy(ALL_ELEMENT) all_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = {} self.assertIsNone(differences(output, flattened))
def test_optional_range_element(self): """ for an optional RangeElement, the dict for it will be optional as will all rules from it and its children """ range_copy = copy.deepcopy(RANGE_ELEMENT) range_copy["optional"] = True ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) output = {} self.assertIsNone(differences(output, flattened))
def test_optional_range_element(self): """ for an optional RangeElement, the dict for it will be optional as will all rules from it and its children """ range_copy = copy.deepcopy(RANGE_ELEMENT) range_copy["optional"] = True ele = ElementFactory.from_json(range_copy) flattened = flatten_element(ele) output = {} self.assertTrue(compare(output, flattened))
def test_single_child_single(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "The Dark Forest", "url": "http://www.liucixin.com/the_dark_forest", "text": "The Second Novel" } self.assertTrue(compare(output, flattened))
def test_single_child_single(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) output = { "title": "The Dark Forest", "url": "http://www.liucixin.com/the_dark_forest", "text": "The Second Novel" } self.assertIsNone(differences(output, flattened))
def test_single_element_fail(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [{ "title": "Nightfall" }, { "url": "http://www.isaacasimov.com/nightfall" }, { "title": "Nightfall", "url": 7 }, {}] for o in outputs: self.assertIsNotNone(differences(o, flattened))
def test_single(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) expected = [("url", str, False), ("title", str, False)] for item in expected: name, expected_type, expected_optional = item rule = flattened.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_single_child_single_optional_fail(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) alt_single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [ { "title": "The Dark Forest", "text": "The Second Novel" } ] for o in outputs: self.assertIsNotNone(differences(o, flattened))
def test_single_child_single_fail(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [{ "title": "The Dark Forest", "url": "http://www.liucixin.com/the_dark_forest", }, { "url": "http://www.liucixin.com/the_dark_forest", "text": "The Second Novel" }] for o in outputs: self.assertIsNotNone(differences(o, flattened))
def test_all_optional_child_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) all_copy["children"].append(alt_all_copy) all_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [ ("count", int, True) ] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional) # "paragraphs", dict, True paragraphs_tuple = items.get("paragraphs") paragraphs, paragraphs_optional = paragraphs_tuple self.assertIsInstance(paragraphs, dict) self.assertEqual(paragraphs_optional, True) expected_paragraph_keys = [ ("description", str, True) ] for item in expected_paragraph_keys: name, expected_type, expected_optional = item rule = paragraphs.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_single(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) expected = [ ("url", str, False), ("title", str, False) ] for item in expected: name, expected_type, expected_optional = item rule = flattened.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_single_child_single_optional(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) alt_single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) expected = [("url", str, False), ("title", str, False), ("text", str, True)] for item in expected: name, expected_type, expected_optional = item rule = flattened.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all_optional_child_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) all_copy["children"].append(alt_all_copy) all_copy["optional"] = True ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, True items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, True) expected_item_keys = [("count", int, True)] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional) # "paragraphs", dict, True paragraphs_tuple = items.get("paragraphs") paragraphs, paragraphs_optional = paragraphs_tuple self.assertIsInstance(paragraphs, dict) self.assertEqual(paragraphs_optional, True) expected_paragraph_keys = [("description", str, True)] for item in expected_paragraph_keys: name, expected_type, expected_optional = item rule = paragraphs.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_optional_single_element(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [ { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" }, { "url": "http://www.isaacasimov.com/nightfall" }, { "title": "Nightfall", }, {} ] for o in outputs: self.assertTrue(compare(o, flattened))
def test_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, False items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, False) expected_item_keys = [("count", int, False)] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_optional_single_element(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) outputs = [ { "title": "Nightfall", "url": "http://www.isaacasimov.com/nightfall" }, { "url": "http://www.isaacasimov.com/nightfall" }, { "title": "Nightfall", }, {} ] for o in outputs: self.assertIsNone(differences(o, flattened))
def test_single_child_single_optional(self): single_copy = copy.deepcopy(SINGLE_ELEMENT) alt_single_copy = copy.deepcopy(ALT_SINGLE_ELEMENT) single_copy["children"].append(alt_single_copy) alt_single_copy["optional"] = True ele = ElementFactory.from_json(single_copy) flattened = flatten_element(ele) expected = [ ("url", str, False), ("title", str, False), ("text", str, True) ] for item in expected: name, expected_type, expected_optional = item rule = flattened.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) # "items", dict, False items_tuple = flattened.get("items") items, items_optional = items_tuple self.assertIsInstance(items, dict) self.assertEqual(items_optional, False) expected_item_keys = [ ("count", int, False) ] for item in expected_item_keys: name, expected_type, expected_optional = item rule = items.get(name) self.assertIsNotNone(rule) _type, optional = rule self.assertIs(_type, expected_type) self.assertEqual(optional, expected_optional)
def test_all_child_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) all_copy["children"].append(alt_all_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ { "count": 6, "paragraphs": [ { "description": "foo" }, { "description": "bar" } ] } ] } self.assertTrue(compare(output, flattened))
def test_all_child_all(self): all_copy = copy.deepcopy(ALL_ELEMENT) alt_all_copy = copy.deepcopy(ALT_ALL_ELEMENT) all_copy["children"].append(alt_all_copy) ele = ElementFactory.from_json(all_copy) flattened = flatten_element(ele) output = { "items": [ { "count": 6, "paragraphs": [ { "description": "foo" }, { "description": "bar" } ] } ] } self.assertIsNone(differences(output, flattened))