[mirror_frr.git] / tests / topotests / lib / test / test_json.py

#!/usr/bin/env python
# SPDX-License-Identifier: ISC

#
# test_json.py
# Tests for library function: json_cmp().
#
# Copyright (c) 2017 by
# Network Device Education Foundation, Inc. ("NetDEF")
#

"""
Tests for the json_cmp() function.
"""

import os
import sys
import pytest

# Save the Current Working Directory to find lib files.
CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, "../../"))

# pylint: disable=C0413
from lib.topotest import json_cmp


def test_json_intersect_true():
    "Test simple correct JSON intersections"

    dcomplete = {
        "i1": "item1",
        "i2": "item2",
        "i3": "item3",
        "i100": "item4",
    }

    dsub1 = {
        "i1": "item1",
        "i3": "item3",
    }
    dsub2 = {
        "i1": "item1",
        "i2": "item2",
    }
    dsub3 = {
        "i100": "item4",
        "i2": "item2",
    }
    dsub4 = {
        "i50": None,
        "i100": "item4",
    }

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None
    assert json_cmp(dcomplete, dsub4) is None


def test_json_intersect_false():
    "Test simple incorrect JSON intersections"

    dcomplete = {
        "i1": "item1",
        "i2": "item2",
        "i3": "item3",
        "i100": "item4",
    }

    # Incorrect value for 'i1'
    dsub1 = {
        "i1": "item3",
        "i3": "item3",
    }
    # Non-existing key 'i5'
    dsub2 = {
        "i1": "item1",
        "i5": "item2",
    }
    # Key should not exist
    dsub3 = {
        "i100": None,
    }

    assert json_cmp(dcomplete, dsub1) is not None
    assert json_cmp(dcomplete, dsub2) is not None
    assert json_cmp(dcomplete, dsub3) is not None


def test_json_intersect_multilevel_true():
    "Test multi level correct JSON intersections"

    dcomplete = {
        "i1": "item1",
        "i2": "item2",
        "i3": {
            "i100": "item100",
        },
        "i4": {
            "i41": {
                "i411": "item411",
            },
            "i42": {
                "i421": "item421",
                "i422": "item422",
            },
        },
    }

    dsub1 = {
        "i1": "item1",
        "i3": {
            "i100": "item100",
        },
        "i10": None,
    }
    dsub2 = {
        "i1": "item1",
        "i2": "item2",
        "i3": {},
    }
    dsub3 = {
        "i2": "item2",
        "i4": {
            "i41": {
                "i411": "item411",
            },
            "i42": {
                "i422": "item422",
                "i450": None,
            },
        },
    }
    dsub4 = {
        "i2": "item2",
        "i4": {
            "i41": {},
            "i42": {
                "i450": None,
            },
        },
    }
    dsub5 = {
        "i2": "item2",
        "i3": {
            "i100": "item100",
        },
        "i4": {
            "i42": {
                "i450": None,
            }
        },
    }

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None
    assert json_cmp(dcomplete, dsub4) is None
    assert json_cmp(dcomplete, dsub5) is None


def test_json_intersect_multilevel_false():
    "Test multi level incorrect JSON intersections"

    dcomplete = {
        "i1": "item1",
        "i2": "item2",
        "i3": {
            "i100": "item100",
        },
        "i4": {
            "i41": {
                "i411": "item411",
            },
            "i42": {
                "i421": "item421",
                "i422": "item422",
            },
        },
    }

    # Incorrect sub-level value
    dsub1 = {
        "i1": "item1",
        "i3": {
            "i100": "item00",
        },
        "i10": None,
    }
    # Inexistent sub-level
    dsub2 = {
        "i1": "item1",
        "i2": "item2",
        "i3": None,
    }
    # Inexistent sub-level value
    dsub3 = {
        "i1": "item1",
        "i3": {
            "i100": None,
        },
    }
    # Inexistent sub-sub-level value
    dsub4 = {
        "i4": {
            "i41": {
                "i412": "item412",
            },
            "i42": {
                "i421": "item421",
            },
        }
    }
    # Invalid sub-sub-level value
    dsub5 = {
        "i4": {
            "i41": {
                "i411": "item411",
            },
            "i42": {
                "i421": "item420000",
            },
        }
    }
    # sub-sub-level should be value
    dsub6 = {
        "i4": {
            "i41": {
                "i411": "item411",
            },
            "i42": "foobar",
        }
    }

    assert json_cmp(dcomplete, dsub1) is not None
    assert json_cmp(dcomplete, dsub2) is not None
    assert json_cmp(dcomplete, dsub3) is not None
    assert json_cmp(dcomplete, dsub4) is not None
    assert json_cmp(dcomplete, dsub5) is not None
    assert json_cmp(dcomplete, dsub6) is not None


def test_json_with_list_sucess():
    "Test successful json comparisons that have lists."

    dcomplete = {
        "list": [
            {
                "i1": "item 1",
                "i2": "item 2",
            },
            {
                "i10": "item 10",
            },
        ],
        "i100": "item 100",
    }

    # Test list type
    dsub1 = {
        "list": [],
    }
    # Test list correct list items
    dsub2 = {
        "list": [
            {
                "i1": "item 1",
            },
        ],
        "i100": "item 100",
    }
    # Test list correct list size
    dsub3 = {
        "list": [
            {},
            {},
        ],
    }

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None


def test_json_with_list_failure():
    "Test failed json comparisons that have lists."

    dcomplete = {
        "list": [
            {
                "i1": "item 1",
                "i2": "item 2",
            },
            {
                "i10": "item 10",
            },
        ],
        "i100": "item 100",
    }

    # Test list type
    dsub1 = {
        "list": {},
    }
    # Test list incorrect list items
    dsub2 = {
        "list": [
            {
                "i1": "item 2",
            },
        ],
        "i100": "item 100",
    }
    # Test list correct list size
    dsub3 = {
        "list": [
            {},
            {},
            {},
        ],
    }

    assert json_cmp(dcomplete, dsub1) is not None
    assert json_cmp(dcomplete, dsub2) is not None
    assert json_cmp(dcomplete, dsub3) is not None


def test_json_list_start_success():
    "Test JSON encoded data that starts with a list that should succeed."

    dcomplete = [
        {
            "id": 100,
            "value": "abc",
        },
        {
            "id": 200,
            "value": "abcd",
        },
        {
            "id": 300,
            "value": "abcde",
        },
    ]

    dsub1 = [
        {
            "id": 100,
            "value": "abc",
        }
    ]

    dsub2 = [
        {
            "id": 100,
            "value": "abc",
        },
        {
            "id": 200,
            "value": "abcd",
        },
    ]

    dsub3 = [
        {
            "id": 300,
            "value": "abcde",
        }
    ]

    dsub4 = []

    dsub5 = [
        {
            "id": 100,
        }
    ]

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None
    assert json_cmp(dcomplete, dsub4) is None
    assert json_cmp(dcomplete, dsub5) is None


def test_json_list_start_failure():
    "Test JSON encoded data that starts with a list that should fail."

    dcomplete = [
        {"id": 100, "value": "abc"},
        {"id": 200, "value": "abcd"},
        {"id": 300, "value": "abcde"},
    ]

    dsub1 = [
        {
            "id": 100,
            "value": "abcd",
        }
    ]

    dsub2 = [
        {
            "id": 100,
            "value": "abc",
        },
        {
            "id": 200,
            "value": "abc",
        },
    ]

    dsub3 = [
        {
            "id": 100,
            "value": "abc",
        },
        {
            "id": 350,
            "value": "abcde",
        },
    ]

    dsub4 = [
        {
            "value": "abcx",
        },
        {
            "id": 300,
            "value": "abcde",
        },
    ]

    assert json_cmp(dcomplete, dsub1) is not None
    assert json_cmp(dcomplete, dsub2) is not None
    assert json_cmp(dcomplete, dsub3) is not None
    assert json_cmp(dcomplete, dsub4) is not None


def test_json_list_ordered():
    "Test JSON encoded data that should be ordered using the '__ordered__' tag."

    dcomplete = [
        {"id": 1, "value": "abc"},
        "some string",
        123,
    ]

    dsub1 = [
        "__ordered__",
        "some string",
        {"id": 1, "value": "abc"},
        123,
    ]

    assert json_cmp(dcomplete, dsub1) is not None


def test_json_list_exact_matching():
    "Test JSON array on exact matching using the 'exact' parameter."

    dcomplete = [
        {"id": 1, "value": "abc"},
        "some string",
        123,
        [1, 2, 3],
    ]

    dsub1 = [
        "some string",
        {"id": 1, "value": "abc"},
        123,
        [1, 2, 3],
    ]

    dsub2 = [
        {"id": 1},
        "some string",
        123,
        [1, 2, 3],
    ]

    dsub3 = [
        {"id": 1, "value": "abc"},
        "some string",
        123,
        [1, 3, 2],
    ]

    assert json_cmp(dcomplete, dsub1, exact=True) is not None
    assert json_cmp(dcomplete, dsub2, exact=True) is not None


def test_json_object_exact_matching():
    "Test JSON object on exact matching using the 'exact' parameter."

    dcomplete = {
        "a": {"id": 1, "value": "abc"},
        "b": "some string",
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub1 = {
        "a": {"id": 1, "value": "abc"},
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub2 = {
        "a": {"id": 1},
        "b": "some string",
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub3 = {
        "a": {"id": 1, "value": "abc"},
        "b": "some string",
        "c": 123,
        "d": [1, 3],
    }

    assert json_cmp(dcomplete, dsub1, exact=True) is not None
    assert json_cmp(dcomplete, dsub2, exact=True) is not None
    assert json_cmp(dcomplete, dsub3, exact=True) is not None


def test_json_list_asterisk_matching():
    "Test JSON array elements on matching '*' as a placeholder for arbitrary data."

    dcomplete = [
        {"id": 1, "value": "abc"},
        "some string",
        123,
        [1, 2, 3],
    ]

    dsub1 = [
        "*",
        "some string",
        123,
        [1, 2, 3],
    ]

    dsub2 = [
        {"id": "*", "value": "abc"},
        "some string",
        123,
        [1, 2, 3],
    ]

    dsub3 = [
        {"id": 1, "value": "abc"},
        "some string",
        123,
        [1, "*", 3],
    ]

    dsub4 = [
        "*",
        "some string",
        "*",
        [1, 2, 3],
    ]

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None
    assert json_cmp(dcomplete, dsub4) is None


def test_json_object_asterisk_matching():
    "Test JSON object value elements on matching '*' as a placeholder for arbitrary data."

    dcomplete = {
        "a": {"id": 1, "value": "abc"},
        "b": "some string",
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub1 = {
        "a": "*",
        "b": "some string",
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub2 = {
        "a": {"id": 1, "value": "abc"},
        "b": "some string",
        "c": 123,
        "d": [1, "*", 3],
    }

    dsub3 = {
        "a": {"id": "*", "value": "abc"},
        "b": "some string",
        "c": 123,
        "d": [1, 2, 3],
    }

    dsub4 = {
        "a": "*",
        "b": "some string",
        "c": "*",
        "d": [1, 2, 3],
    }

    assert json_cmp(dcomplete, dsub1) is None
    assert json_cmp(dcomplete, dsub2) is None
    assert json_cmp(dcomplete, dsub3) is None
    assert json_cmp(dcomplete, dsub4) is None


def test_json_list_nested_with_objects():

    dcomplete = [{"key": 1, "list": [123]}, {"key": 2, "list": [123]}]

    dsub1 = [{"key": 2, "list": [123]}, {"key": 1, "list": [123]}]

    assert json_cmp(dcomplete, dsub1) is None


if __name__ == "__main__":
    sys.exit(pytest.main())
Commit	Line	Data
09e21b44	1	#!/usr/bin/env python
acddc0ed	2	# SPDX-License-Identifier: ISC
09e21b44 RZ	3
	4	#
	5	# test_json.py
	6	# Tests for library function: json_cmp().
	7	#
	8	# Copyright (c) 2017 by
	9	# Network Device Education Foundation, Inc. ("NetDEF")
	10	#
09e21b44 RZ	11
	12	"""
	13	Tests for the json_cmp() function.
	14	"""
	15
	16	import os
	17	import sys
	18	import pytest
	19
	20	# Save the Current Working Directory to find lib files.
	21	CWD = os.path.dirname(os.path.realpath(__file__))
787e7624	22	sys.path.append(os.path.join(CWD, "../../"))
09e21b44 RZ	23
	24	# pylint: disable=C0413
	25	from lib.topotest import json_cmp
	26
787e7624	27
09e21b44 RZ	28	def test_json_intersect_true():
	29	"Test simple correct JSON intersections"
	30
	31	dcomplete = {
787e7624	32	"i1": "item1",
	33	"i2": "item2",
	34	"i3": "item3",
	35	"i100": "item4",
09e21b44 RZ	36	}
	37
	38	dsub1 = {
787e7624	39	"i1": "item1",
787e7624	40	"i3": "item3",
09e21b44 RZ	41	}
09e21b44 RZ	42	dsub2 = {
787e7624	43	"i1": "item1",
787e7624	44	"i2": "item2",
09e21b44 RZ	45	}
09e21b44 RZ	46	dsub3 = {
787e7624	47	"i100": "item4",
787e7624	48	"i2": "item2",
09e21b44 RZ	49	}
09e21b44 RZ	50	dsub4 = {
787e7624	51	"i50": None,
787e7624	52	"i100": "item4",
09e21b44 RZ	53	}
	54
	55	assert json_cmp(dcomplete, dsub1) is None
	56	assert json_cmp(dcomplete, dsub2) is None
	57	assert json_cmp(dcomplete, dsub3) is None
	58	assert json_cmp(dcomplete, dsub4) is None
	59
787e7624	60
09e21b44 RZ	61	def test_json_intersect_false():
	62	"Test simple incorrect JSON intersections"
	63
	64	dcomplete = {
787e7624	65	"i1": "item1",
	66	"i2": "item2",
	67	"i3": "item3",
	68	"i100": "item4",
09e21b44 RZ	69	}
	70
	71	# Incorrect value for 'i1'
	72	dsub1 = {
787e7624	73	"i1": "item3",
787e7624	74	"i3": "item3",
09e21b44 RZ	75	}
	76	# Non-existing key 'i5'
	77	dsub2 = {
787e7624	78	"i1": "item1",
787e7624	79	"i5": "item2",
09e21b44 RZ	80	}
	81	# Key should not exist
	82	dsub3 = {
787e7624	83	"i100": None,
09e21b44 RZ	84	}
	85
	86	assert json_cmp(dcomplete, dsub1) is not None
	87	assert json_cmp(dcomplete, dsub2) is not None
	88	assert json_cmp(dcomplete, dsub3) is not None
	89
787e7624	90
09e21b44 RZ	91	def test_json_intersect_multilevel_true():
	92	"Test multi level correct JSON intersections"
	93
	94	dcomplete = {
787e7624	95	"i1": "item1",
787e7624	96	"i2": "item2",
9fa6ec14	97	"i3": {
	98	"i100": "item100",
	99	},
787e7624	100	"i4": {
9fa6ec14	101	"i41": {
	102	"i411": "item411",
	103	},
	104	"i42": {
	105	"i421": "item421",
	106	"i422": "item422",
	107	},
09e21b44	108	},
09e21b44 RZ	109	}
	110
	111	dsub1 = {
787e7624	112	"i1": "item1",
9fa6ec14	113	"i3": {
	114	"i100": "item100",
	115	},
787e7624	116	"i10": None,
09e21b44 RZ	117	}
09e21b44 RZ	118	dsub2 = {
787e7624	119	"i1": "item1",
	120	"i2": "item2",
	121	"i3": {},
09e21b44 RZ	122	}
09e21b44 RZ	123	dsub3 = {
787e7624	124	"i2": "item2",
9fa6ec14	125	"i4": {
	126	"i41": {
	127	"i411": "item411",
	128	},
	129	"i42": {
	130	"i422": "item422",
	131	"i450": None,
	132	},
	133	},
	134	}
	135	dsub4 = {
	136	"i2": "item2",
	137	"i4": {
	138	"i41": {},
	139	"i42": {
	140	"i450": None,
	141	},
	142	},
	143	}
	144	dsub5 = {
	145	"i2": "item2",
	146	"i3": {
	147	"i100": "item100",
	148	},
	149	"i4": {
	150	"i42": {
	151	"i450": None,
	152	}
	153	},
09e21b44 RZ	154	}
	155
	156	assert json_cmp(dcomplete, dsub1) is None
	157	assert json_cmp(dcomplete, dsub2) is None
	158	assert json_cmp(dcomplete, dsub3) is None
	159	assert json_cmp(dcomplete, dsub4) is None
	160	assert json_cmp(dcomplete, dsub5) is None
	161
787e7624	162
09e21b44 RZ	163	def test_json_intersect_multilevel_false():
	164	"Test multi level incorrect JSON intersections"
	165
	166	dcomplete = {
787e7624	167	"i1": "item1",
787e7624	168	"i2": "item2",
9fa6ec14	169	"i3": {
	170	"i100": "item100",
	171	},
787e7624	172	"i4": {
9fa6ec14	173	"i41": {
	174	"i411": "item411",
	175	},
	176	"i42": {
	177	"i421": "item421",
	178	"i422": "item422",
	179	},
09e21b44	180	},
09e21b44 RZ	181	}
	182
	183	# Incorrect sub-level value
	184	dsub1 = {
787e7624	185	"i1": "item1",
9fa6ec14	186	"i3": {
	187	"i100": "item00",
	188	},
787e7624	189	"i10": None,
09e21b44 RZ	190	}
	191	# Inexistent sub-level
	192	dsub2 = {
787e7624	193	"i1": "item1",
	194	"i2": "item2",
	195	"i3": None,
09e21b44 RZ	196	}
	197	# Inexistent sub-level value
	198	dsub3 = {
787e7624	199	"i1": "item1",
9fa6ec14	200	"i3": {
	201	"i100": None,
	202	},
09e21b44 RZ	203	}
09e21b44 RZ	204	# Inexistent sub-sub-level value
9fa6ec14	205	dsub4 = {
	206	"i4": {
	207	"i41": {
	208	"i412": "item412",
	209	},
	210	"i42": {
	211	"i421": "item421",
	212	},
	213	}
	214	}
09e21b44	215	# Invalid sub-sub-level value
9fa6ec14	216	dsub5 = {
	217	"i4": {
	218	"i41": {
	219	"i411": "item411",
	220	},
	221	"i42": {
	222	"i421": "item420000",
	223	},
	224	}
	225	}
09e21b44	226	# sub-sub-level should be value
9fa6ec14	227	dsub6 = {
	228	"i4": {
	229	"i41": {
	230	"i411": "item411",
	231	},
	232	"i42": "foobar",
	233	}
	234	}
09e21b44 RZ	235
	236	assert json_cmp(dcomplete, dsub1) is not None
	237	assert json_cmp(dcomplete, dsub2) is not None
	238	assert json_cmp(dcomplete, dsub3) is not None
	239	assert json_cmp(dcomplete, dsub4) is not None
	240	assert json_cmp(dcomplete, dsub5) is not None
	241	assert json_cmp(dcomplete, dsub6) is not None
	242
787e7624	243
dc0d3fc5 RZ	244	def test_json_with_list_sucess():
	245	"Test successful json comparisons that have lists."
	246
	247	dcomplete = {
9fa6ec14	248	"list": [
	249	{
	250	"i1": "item 1",
	251	"i2": "item 2",
	252	},
	253	{
	254	"i10": "item 10",
	255	},
	256	],
787e7624	257	"i100": "item 100",
dc0d3fc5 RZ	258	}
	259
	260	# Test list type
	261	dsub1 = {
787e7624	262	"list": [],
dc0d3fc5 RZ	263	}
	264	# Test list correct list items
	265	dsub2 = {
9fa6ec14	266	"list": [
	267	{
	268	"i1": "item 1",
	269	},
	270	],
787e7624	271	"i100": "item 100",
dc0d3fc5 RZ	272	}
	273	# Test list correct list size
	274	dsub3 = {
9fa6ec14	275	"list": [
	276	{},
	277	{},
	278	],
dc0d3fc5 RZ	279	}
	280
	281	assert json_cmp(dcomplete, dsub1) is None
	282	assert json_cmp(dcomplete, dsub2) is None
	283	assert json_cmp(dcomplete, dsub3) is None
	284
787e7624	285
dc0d3fc5 RZ	286	def test_json_with_list_failure():
	287	"Test failed json comparisons that have lists."
	288
	289	dcomplete = {
9fa6ec14	290	"list": [
	291	{
	292	"i1": "item 1",
	293	"i2": "item 2",
	294	},
	295	{
	296	"i10": "item 10",
	297	},
	298	],
787e7624	299	"i100": "item 100",
dc0d3fc5 RZ	300	}
	301
	302	# Test list type
	303	dsub1 = {
787e7624	304	"list": {},
dc0d3fc5 RZ	305	}
	306	# Test list incorrect list items
	307	dsub2 = {
9fa6ec14	308	"list": [
	309	{
	310	"i1": "item 2",
	311	},
	312	],
787e7624	313	"i100": "item 100",
dc0d3fc5 RZ	314	}
	315	# Test list correct list size
	316	dsub3 = {
9fa6ec14	317	"list": [
	318	{},
	319	{},
	320	{},
	321	],
dc0d3fc5 RZ	322	}
	323
	324	assert json_cmp(dcomplete, dsub1) is not None
	325	assert json_cmp(dcomplete, dsub2) is not None
	326	assert json_cmp(dcomplete, dsub3) is not None
	327
3e379f6e RZ	328
	329	def test_json_list_start_success():
	330	"Test JSON encoded data that starts with a list that should succeed."
	331
	332	dcomplete = [
9fa6ec14	333	{
	334	"id": 100,
	335	"value": "abc",
	336	},
	337	{
	338	"id": 200,
	339	"value": "abcd",
	340	},
	341	{
	342	"id": 300,
	343	"value": "abcde",
	344	},
3e379f6e RZ	345	]
3e379f6e RZ	346
9fa6ec14	347	dsub1 = [
	348	{
	349	"id": 100,
	350	"value": "abc",
	351	}
	352	]
3e379f6e	353
9fa6ec14	354	dsub2 = [
	355	{
	356	"id": 100,
	357	"value": "abc",
	358	},
	359	{
	360	"id": 200,
	361	"value": "abcd",
	362	},
	363	]
3e379f6e	364
9fa6ec14	365	dsub3 = [
	366	{
	367	"id": 300,
	368	"value": "abcde",
	369	}
	370	]
3e379f6e	371
787e7624	372	dsub4 = []
3e379f6e	373
9fa6ec14	374	dsub5 = [
	375	{
	376	"id": 100,
	377	}
	378	]
3e379f6e RZ	379
	380	assert json_cmp(dcomplete, dsub1) is None
	381	assert json_cmp(dcomplete, dsub2) is None
	382	assert json_cmp(dcomplete, dsub3) is None
	383	assert json_cmp(dcomplete, dsub4) is None
	384	assert json_cmp(dcomplete, dsub5) is None
	385
	386
	387	def test_json_list_start_failure():
	388	"Test JSON encoded data that starts with a list that should fail."
	389
	390	dcomplete = [
787e7624	391	{"id": 100, "value": "abc"},
	392	{"id": 200, "value": "abcd"},
	393	{"id": 300, "value": "abcde"},
3e379f6e RZ	394	]
3e379f6e RZ	395
9fa6ec14	396	dsub1 = [
	397	{
	398	"id": 100,
	399	"value": "abcd",
	400	}
	401	]
3e379f6e	402
9fa6ec14	403	dsub2 = [
	404	{
	405	"id": 100,
	406	"value": "abc",
	407	},
	408	{
	409	"id": 200,
	410	"value": "abc",
	411	},
	412	]
3e379f6e	413
9fa6ec14	414	dsub3 = [
	415	{
	416	"id": 100,
	417	"value": "abc",
	418	},
	419	{
	420	"id": 350,
	421	"value": "abcde",
	422	},
	423	]
3e379f6e	424
9fa6ec14	425	dsub4 = [
	426	{
	427	"value": "abcx",
	428	},
	429	{
	430	"id": 300,
	431	"value": "abcde",
	432	},
	433	]
3e379f6e RZ	434
	435	assert json_cmp(dcomplete, dsub1) is not None
	436	assert json_cmp(dcomplete, dsub2) is not None
	437	assert json_cmp(dcomplete, dsub3) is not None
	438	assert json_cmp(dcomplete, dsub4) is not None
	439
	440
849224d4 G	441	def test_json_list_ordered():
	442	"Test JSON encoded data that should be ordered using the '__ordered__' tag."
	443
	444	dcomplete = [
	445	{"id": 1, "value": "abc"},
	446	"some string",
	447	123,
	448	]
	449
	450	dsub1 = [
701a0192	451	"__ordered__",
849224d4 G	452	"some string",
	453	{"id": 1, "value": "abc"},
	454	123,
	455	]
	456
	457	assert json_cmp(dcomplete, dsub1) is not None
	458
	459
	460	def test_json_list_exact_matching():
	461	"Test JSON array on exact matching using the 'exact' parameter."
	462
	463	dcomplete = [
	464	{"id": 1, "value": "abc"},
	465	"some string",
	466	123,
701a0192	467	[1, 2, 3],
849224d4 G	468	]
	469
	470	dsub1 = [
	471	"some string",
	472	{"id": 1, "value": "abc"},
	473	123,
701a0192	474	[1, 2, 3],
849224d4 G	475	]
	476
	477	dsub2 = [
	478	{"id": 1},
	479	"some string",
	480	123,
701a0192	481	[1, 2, 3],
849224d4 G	482	]
	483
	484	dsub3 = [
	485	{"id": 1, "value": "abc"},
	486	"some string",
	487	123,
701a0192	488	[1, 3, 2],
849224d4 G	489	]
	490
	491	assert json_cmp(dcomplete, dsub1, exact=True) is not None
	492	assert json_cmp(dcomplete, dsub2, exact=True) is not None
	493
	494
	495	def test_json_object_exact_matching():
	496	"Test JSON object on exact matching using the 'exact' parameter."
	497
	498	dcomplete = {
701a0192	499	"a": {"id": 1, "value": "abc"},
	500	"b": "some string",
	501	"c": 123,
	502	"d": [1, 2, 3],
849224d4 G	503	}
	504
	505	dsub1 = {
701a0192	506	"a": {"id": 1, "value": "abc"},
	507	"c": 123,
	508	"d": [1, 2, 3],
849224d4 G	509	}
	510
	511	dsub2 = {
701a0192	512	"a": {"id": 1},
	513	"b": "some string",
	514	"c": 123,
	515	"d": [1, 2, 3],
849224d4 G	516	}
	517
	518	dsub3 = {
701a0192	519	"a": {"id": 1, "value": "abc"},
	520	"b": "some string",
	521	"c": 123,
	522	"d": [1, 3],
849224d4 G	523	}
	524
	525	assert json_cmp(dcomplete, dsub1, exact=True) is not None
	526	assert json_cmp(dcomplete, dsub2, exact=True) is not None
	527	assert json_cmp(dcomplete, dsub3, exact=True) is not None
	528
	529
	530	def test_json_list_asterisk_matching():
	531	"Test JSON array elements on matching '*' as a placeholder for arbitrary data."
	532
	533	dcomplete = [
	534	{"id": 1, "value": "abc"},
	535	"some string",
	536	123,
701a0192	537	[1, 2, 3],
849224d4 G	538	]
	539
	540	dsub1 = [
701a0192	541	"*",
849224d4 G	542	"some string",
849224d4 G	543	123,
701a0192	544	[1, 2, 3],
849224d4 G	545	]
	546
	547	dsub2 = [
701a0192	548	{"id": "*", "value": "abc"},
849224d4 G	549	"some string",
849224d4 G	550	123,
701a0192	551	[1, 2, 3],
849224d4 G	552	]
	553
	554	dsub3 = [
	555	{"id": 1, "value": "abc"},
	556	"some string",
	557	123,
701a0192	558	[1, "*", 3],
849224d4 G	559	]
	560
	561	dsub4 = [
701a0192	562	"*",
849224d4	563	"some string",
701a0192	564	"*",
701a0192	565	[1, 2, 3],
849224d4 G	566	]
	567
	568	assert json_cmp(dcomplete, dsub1) is None
	569	assert json_cmp(dcomplete, dsub2) is None
	570	assert json_cmp(dcomplete, dsub3) is None
	571	assert json_cmp(dcomplete, dsub4) is None
	572
	573
	574	def test_json_object_asterisk_matching():
	575	"Test JSON object value elements on matching '*' as a placeholder for arbitrary data."
	576
	577	dcomplete = {
701a0192	578	"a": {"id": 1, "value": "abc"},
	579	"b": "some string",
	580	"c": 123,
	581	"d": [1, 2, 3],
849224d4 G	582	}
	583
	584	dsub1 = {
701a0192	585	"a": "*",
	586	"b": "some string",
	587	"c": 123,
	588	"d": [1, 2, 3],
849224d4 G	589	}
	590
	591	dsub2 = {
701a0192	592	"a": {"id": 1, "value": "abc"},
	593	"b": "some string",
	594	"c": 123,
	595	"d": [1, "*", 3],
849224d4 G	596	}
	597
	598	dsub3 = {
701a0192	599	"a": {"id": "*", "value": "abc"},
	600	"b": "some string",
	601	"c": 123,
	602	"d": [1, 2, 3],
849224d4 G	603	}
	604
	605	dsub4 = {
701a0192	606	"a": "*",
	607	"b": "some string",
	608	"c": "*",
	609	"d": [1, 2, 3],
849224d4 G	610	}
	611
	612	assert json_cmp(dcomplete, dsub1) is None
	613	assert json_cmp(dcomplete, dsub2) is None
	614	assert json_cmp(dcomplete, dsub3) is None
	615	assert json_cmp(dcomplete, dsub4) is None
	616
	617
b3100f6c G	618	def test_json_list_nested_with_objects():
b3100f6c G	619
701a0192	620	dcomplete = [{"key": 1, "list": [123]}, {"key": 2, "list": [123]}]
b3100f6c	621
701a0192	622	dsub1 = [{"key": 2, "list": [123]}, {"key": 1, "list": [123]}]
b3100f6c G	623
	624	assert json_cmp(dcomplete, dsub1) is None
	625
701a0192	626
787e7624	627	if __name__ == "__main__":
09e21b44	628	sys.exit(pytest.main())