Coverage for tests / tests_config / tests_alias / test_alias.py: 100%

1# SPDX-FileCopyrightText: Copyright INRIA 

2# 

3# SPDX-License-Identifier: LGPL-3.0-only 

4# 

5# Copyright INRIA 

6# 

7# This file is part of PhysioBlocks, a library mostly developed by the 

8# [Ananke project-team](https://team.inria.fr/ananke) at INRIA. 

9# 

10# Authors: 

11# - Colin Drieu 

12# - Dominique Chapelle 

13# - François Kimmig 

14# - Philippe Moireau 

15# 

16# PhysioBlocks is free software: you can redistribute it and/or modify it under the 

17# terms of the GNU Lesser General Public License as published by the Free Software 

18# Foundation, version 3 of the License. 

19# 

20# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY 

21# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 

22# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 

23# 

24# You should have received a copy of the GNU Lesser General Public License along with 

25# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>. 

26 

27from unittest.mock import Mock, patch 

28 

29import pytest 

30 

31import physioblocks.configuration.aliases as aliases 

32from physioblocks.configuration.aliases import ( 

33 add_alias, 

34 get_alias, 

35 has_alias, 

36 remove_alias, 

37 unwrap_aliases, 

38) 

39from physioblocks.configuration.base import Configuration 

40 

41ALIAS_ID = "alias" 

42ALIAS_TYPE = "alias_type" 

43ALIAS_DICT_ID = "alias_dict" 

44ALIAS_REGISTER_ID = "alias_register" 

45ALIAS_REC_ID = "alias_rec" 

46ALIAS_REC_DICT_ID = "alias_rec_dict" 

47OTHER_ID = "other" 

48 

49 

50@pytest.fixture 

51def alias() -> Configuration: 

52 return Configuration(ALIAS_TYPE) 

53 

54 

55@pytest.fixture 

56def alias_dict() -> Configuration: 

57 return {"dict": {"val_a": 0.1, "val_b": 0.2}} 

58 

59 

60@pytest.fixture 

61def alias_register() -> Configuration: 

62 config = Configuration(ALIAS_DICT_ID) 

63 config["dict"] = {"val_a": 0.3, "val_c": 0.4} 

64 config["list"] = [] 

65 config["value"] = 0.0 

66 return config 

67 

68 

69@pytest.fixture 

70def alias_rec(alias_register: dict) -> Configuration: 

71 config = Configuration(ALIAS_ID) 

72 config["dict"] = alias_register 

73 config["list"] = [] 

74 config["value"] = 0.0 

75 return config 

76 

77 

78@pytest.fixture 

79def alias_dict_rec(alias_rec: Configuration, alias_register: dict) -> Configuration: 

80 return {"alias": alias_rec, "list": [alias_rec], "dict": alias_register} 

81 

82 

83@pytest.fixture 

84def unwrapped_alias_register() -> Configuration: 

85 config = { 

86 "dict": {"val_a": 0.3, "val_b": 0.2, "val_c": 0.4}, 

87 "list": [], 

88 "value": 0.0, 

89 } 

90 return config 

91 

92 

93@pytest.fixture 

94def unwrapped_alias_rec(unwrapped_alias_register: dict) -> Configuration: 

95 config = Configuration(ALIAS_TYPE) 

96 config["dict"] = unwrapped_alias_register 

97 config["list"] = [] 

98 config["value"] = 0.0 

99 return config 

100 

101 

102@pytest.fixture 

103def unwrapped_alias_dict_rec( 

104 unwrapped_alias_rec: Configuration, unwrapped_alias_register: dict 

105) -> Configuration: 

106 return { 

107 "alias": unwrapped_alias_rec, 

108 "list": [unwrapped_alias_rec], 

109 "dict": unwrapped_alias_register, 

110 } 

111 

112 

113@patch.object(aliases, attribute="__aliases_register", new={}) 

114def test_manages_aliases(alias: Configuration): 

115 add_alias(ALIAS_ID, alias) 

116 assert has_alias(ALIAS_ID) is True 

117 assert get_alias(ALIAS_ID) == alias 

118 

119 remove_alias(ALIAS_ID) 

120 assert has_alias(ALIAS_ID) is False 

121 

122 

123@patch.object(aliases, attribute="__aliases_register", new={ALIAS_ID: None}) 

124def test_add_alias_exceptions(alias: Configuration): 

125 err_msg = str.format("Alias key {0} is already registered.", ALIAS_ID) 

126 with pytest.raises(KeyError, match=err_msg): 

127 add_alias(ALIAS_ID, alias) 

128 

129 err_msg = str.format( 

130 "Incorrect type for alias: {0}, expected {1}", 

131 float.__name__, 

132 Configuration.__name__, 

133 ) 

134 with pytest.raises(TypeError, match=err_msg): 

135 add_alias(OTHER_ID, 0.0) 

136 

137 

138@patch("physioblocks.configuration.aliases.read_json") 

139def test_get_alias_from_file(mock_read_json: Mock, alias: Configuration): 

140 mock_read_json.return_value = alias 

141 file_alias = get_alias(None) 

142 assert file_alias == alias 

143 

144 

145def test_unwrap_alias( 

146 alias: Configuration, 

147 alias_rec: Configuration, 

148 alias_dict: dict, 

149 alias_dict_rec: dict, 

150 unwrapped_alias_dict_rec: dict, 

151): 

152 with patch.object( 

153 aliases, 

154 attribute="__aliases_register", 

155 new={ 

156 ALIAS_ID: alias, 

157 ALIAS_REC_ID: alias_rec, 

158 ALIAS_DICT_ID: alias_dict, 

159 ALIAS_REC_DICT_ID: alias_dict_rec, 

160 }, 

161 ): 

162 new_alias = get_alias(ALIAS_REC_DICT_ID) 

163 assert new_alias == alias_dict_rec 

164 assert unwrap_aliases(new_alias) == unwrapped_alias_dict_rec 

165 

166 

167def test_unwrap_alias_exception(alias_rec): 

168 err_msg = str.format("Type {0} can not load aliases.", type(None).__name__) 

169 with pytest.raises(TypeError, match=err_msg): 

170 unwrap_aliases(None) 

171 

172 err_msg = str.format("{0} is not a valid alias type.", type(None).__name__) 

173 with ( 

174 patch.object( 

175 aliases, 

176 attribute="__aliases_register", 

177 new={ALIAS_REC_ID: alias_rec, ALIAS_ID: None}, 

178 ), 

179 pytest.raises(TypeError, match=err_msg), 

180 ): 

181 unwrap_aliases(alias_rec)