Coverage for tests/utils/test_utils.py: 100%

18 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-02-09 12:09 +0100

1from __future__ import annotations 

2 

3from typing import Any 

4 

5import pytest 

6 

7from harbor_cli.utils.utils import replace_none 

8 

9 

10@pytest.mark.parametrize( 

11 "d,expected", 

12 [ 

13 ( 

14 {}, 

15 {}, 

16 ), 

17 ( 

18 {"a": {}}, 

19 {"a": {}}, 

20 ), 

21 ( 

22 {"a": "hello world", "b": {"foo": "bar", "baz": None}}, 

23 {"a": "hello world", "b": {"foo": "bar", "baz": ""}}, 

24 ), 

25 ( 

26 {"a": {"foo": "bar", "baz": None}}, 

27 {"a": {"foo": "bar", "baz": ""}}, 

28 ), 

29 ( 

30 {"a": None}, 

31 {"a": ""}, 

32 ), 

33 ( 

34 {"a": 1, "b": None}, 

35 {"a": 1, "b": ""}, 

36 ), 

37 ( 

38 {"a": 1, "b": None, "c": {"d": None, "e": 4}}, 

39 {"a": 1, "b": "", "c": {"d": "", "e": 4}}, 

40 ), 

41 ], 

42) 

43def test_replace_none(d: dict[str, Any], expected: dict[str, Any]) -> None: 

44 assert replace_none(d) == expected 

45 

46 

47# NOTE: sets can't contain dicts, so we don't test them here 

48@pytest.mark.parametrize( 

49 "inp,expected", 

50 [ 

51 ( 

52 {"a": 1, "b": [{"c": 2}, {"d": None}]}, 

53 {"a": 1, "b": [{"c": 2}, {"d": ""}]}, 

54 ), 

55 ( 

56 {"a": 1, "b": ({"c": 2}, {"d": None})}, 

57 {"a": 1, "b": ({"c": 2}, {"d": ""})}, 

58 ), 

59 ( 

60 # deeply nested list 

61 {"a": 1, "b": [[[{"c": 2}, {"d": None}]]]}, 

62 {"a": 1, "b": [[[{"c": 2}, {"d": ""}]]]}, 

63 ), 

64 ( 

65 # deeply nested tuple 

66 {"a": 1, "b": ((({"c": 2}, {"d": None})))}, 

67 {"a": 1, "b": (((({"c": 2}, {"d": ""}))))}, 

68 ), 

69 ], 

70) 

71def test_replace_none_iterable_of_dict( 

72 inp: dict[str, Any], expected: dict[str, Any] 

73) -> None: 

74 

75 assert replace_none(inp) == expected 

76 

77 

78@pytest.mark.parametrize("iterable_type", [list, tuple, set]) 

79def test_replace_none_iterable(iterable_type: type) -> None: 

80 d = { 

81 "a": 1, 

82 "b": iterable_type([2, None, "foo", 3.14]), 

83 "c": {"d": iterable_type([None, 3, "foo", 3.14]), "e": 4}, 

84 } 

85 expected = { 

86 "a": 1, 

87 "b": iterable_type([2, "", "foo", 3.14]), 

88 "c": {"d": iterable_type(["", 3, "foo", 3.14]), "e": 4}, 

89 } 

90 

91 assert replace_none(d) == expected 

92 

93 

94@pytest.mark.parametrize( 

95 "replacement", 

96 ["", 0, False, None], 

97) 

98def test_replace_none_replacement(replacement: Any) -> None: 

99 assert replace_none(None, replacement=replacement) == replacement # type: ignore