Coverage for tests/test_configOverrides.py: 17%

140 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-07-12 11:14 -0700

1# This file is part of pipe_base. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (http://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# This program is free software: you can redistribute it and/or modify 

10# it under the terms of the GNU General Public License as published by 

11# the Free Software Foundation, either version 3 of the License, or 

12# (at your option) any later version. 

13# 

14# This program is distributed in the hope that it will be useful, 

15# but WITHOUT ANY WARRANTY; without even the implied warranty of 

16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

17# GNU General Public License for more details. 

18# 

19# You should have received a copy of the GNU General Public License 

20# along with this program. If not, see <http://www.gnu.org/licenses/>. 

21 

22"""Simple unit test for configOverrides. 

23""" 

24 

25import unittest 

26 

27import lsst.pex.config as pexConfig 

28import lsst.utils.tests 

29from lsst.pipe.base.configOverrides import ConfigOverrides 

30 

31# This is used in testSettingVar unit test 

32TEST_CHOICE_VALUE = 1 

33 

34 

35class ConfigTest(pexConfig.Config): 

36 """Configuration used for testing.""" 

37 

38 fStr = pexConfig.Field(dtype=str, default="default", doc="test") 

39 fBool = pexConfig.Field(dtype=bool, default=False, doc="test") 

40 fInt = pexConfig.Field(dtype=int, default=-1, doc="test") 

41 fFloat = pexConfig.Field(dtype=float, default=-1.0, doc="test") 

42 

43 fListStr = pexConfig.ListField(dtype=str, default=[], doc="test") 

44 fListBool = pexConfig.ListField(dtype=bool, default=[], doc="test") 

45 fListInt = pexConfig.ListField(dtype=int, default=[], doc="test") 

46 

47 fChoiceStr = pexConfig.ChoiceField(dtype=str, allowed=dict(A="a", B="b", C="c"), doc="test") 

48 fChoiceInt = pexConfig.ChoiceField(dtype=int, allowed={1: "a", 2: "b", 3: "c"}, doc="test") 

49 

50 fDictStrInt = pexConfig.DictField(keytype=str, itemtype=int, doc="test") 

51 

52 

53class ConfigOverridesTestCase(unittest.TestCase): 

54 """A test case for Task""" 

55 

56 def checkSingleFieldOverride(self, field, value, result=None): 

57 """Apply overrides of a single field. 

58 

59 Parameters 

60 ---------- 

61 field : `str` 

62 Field name. 

63 value : 

64 Field value to set, can be a string or anything else. 

65 result : optional 

66 Expected value of the field. 

67 """ 

68 config = ConfigTest() 

69 overrides = ConfigOverrides() 

70 overrides.addValueOverride(field, value) 

71 overrides.applyTo(config) 

72 self.assertEqual(getattr(config, field), result) 

73 

74 def testSimpleValueStr(self): 

75 """Test for applying value override to a string field""" 

76 field = "fStr" 

77 

78 # values of supported type 

79 self.checkSingleFieldOverride(field, "string", "string") 

80 

81 # invalid input 

82 with self.assertRaises(pexConfig.FieldValidationError): 

83 self.checkSingleFieldOverride(field, 1) 

84 

85 def testSimpleValueBool(self): 

86 """Test for applying value override to a boolean field""" 

87 field = "fBool" 

88 

89 # values of supported type 

90 self.checkSingleFieldOverride(field, True, True) 

91 self.checkSingleFieldOverride(field, False, False) 

92 

93 # supported string conversions 

94 self.checkSingleFieldOverride(field, "True", True) 

95 self.checkSingleFieldOverride(field, "False", False) 

96 

97 # parseable but invalid input 

98 with self.assertRaises(pexConfig.FieldValidationError): 

99 self.checkSingleFieldOverride(field, 1) 

100 with self.assertRaises(pexConfig.FieldValidationError): 

101 self.checkSingleFieldOverride(field, []) 

102 with self.assertRaises(pexConfig.FieldValidationError): 

103 self.checkSingleFieldOverride(field, "1") 

104 

105 def testSimpleValueInt(self): 

106 """Test for applying value override to a int field""" 

107 field = "fInt" 

108 

109 # values of supported type 

110 self.checkSingleFieldOverride(field, 0, 0) 

111 self.checkSingleFieldOverride(field, 100, 100) 

112 

113 # supported string conversions 

114 self.checkSingleFieldOverride(field, "0", 0) 

115 self.checkSingleFieldOverride(field, "100", 100) 

116 self.checkSingleFieldOverride(field, "-100", -100) 

117 self.checkSingleFieldOverride(field, "0x100", 0x100) 

118 

119 # parseable but invalid input 

120 with self.assertRaises(pexConfig.FieldValidationError): 

121 self.checkSingleFieldOverride(field, 1.0) 

122 with self.assertRaises(pexConfig.FieldValidationError): 

123 self.checkSingleFieldOverride(field, "1.0") 

124 with self.assertRaises(pexConfig.FieldValidationError): 

125 self.checkSingleFieldOverride(field, "[]") 

126 

127 def testSimpleValueFloat(self): 

128 """Test for applying value override to a float field""" 

129 field = "fFloat" 

130 

131 # values of supported type 

132 self.checkSingleFieldOverride(field, 0.0, 0.0) 

133 self.checkSingleFieldOverride(field, 100.0, 100.0) 

134 

135 # supported string conversions 

136 self.checkSingleFieldOverride(field, "0.", 0.0) 

137 self.checkSingleFieldOverride(field, "100.0", 100.0) 

138 self.checkSingleFieldOverride(field, "-1.2e10", -1.2e10) 

139 

140 # parseable but invalid input 

141 with self.assertRaises(pexConfig.FieldValidationError): 

142 self.checkSingleFieldOverride(field, []) 

143 with self.assertRaises(pexConfig.FieldValidationError): 

144 self.checkSingleFieldOverride(field, "(1, 1)") 

145 

146 def testListValueStr(self): 

147 """Test for applying value override to a list field""" 

148 field = "fListStr" 

149 

150 # values of supported type 

151 self.checkSingleFieldOverride(field, ["a", "b"], ["a", "b"]) 

152 self.checkSingleFieldOverride(field, ("a", "b"), ["a", "b"]) 

153 

154 # supported string conversions 

155 self.checkSingleFieldOverride(field, '["a", "b"]', ["a", "b"]) 

156 self.checkSingleFieldOverride(field, '("a", "b")', ["a", "b"]) 

157 

158 # parseable but invalid input 

159 with self.assertRaises(pexConfig.FieldValidationError): 

160 self.checkSingleFieldOverride(field, "['a', []]") 

161 

162 def testListValueBool(self): 

163 """Test for applying value override to a list field""" 

164 field = "fListBool" 

165 

166 # values of supported type 

167 self.checkSingleFieldOverride(field, [True, False], [True, False]) 

168 self.checkSingleFieldOverride(field, (True, False), [True, False]) 

169 

170 # supported string conversions 

171 self.checkSingleFieldOverride(field, "[True, False]", [True, False]) 

172 self.checkSingleFieldOverride(field, "(True, False)", [True, False]) 

173 self.checkSingleFieldOverride(field, "['True', 'False']", [True, False]) 

174 

175 with self.assertRaises(pexConfig.FieldValidationError): 

176 self.checkSingleFieldOverride(field, "[1, 2]") 

177 with self.assertRaises(pexConfig.FieldValidationError): 

178 self.checkSingleFieldOverride(field, [0, 1]) 

179 with self.assertRaises(pexConfig.FieldValidationError): 

180 self.checkSingleFieldOverride(field, "5") 

181 

182 def testListValueInt(self): 

183 """Test for applying value override to a list field""" 

184 field = "fListInt" 

185 

186 # values of supported type 

187 self.checkSingleFieldOverride(field, [1, 2], [1, 2]) 

188 self.checkSingleFieldOverride(field, (1, 2), [1, 2]) 

189 

190 # supported string conversions 

191 self.checkSingleFieldOverride(field, "[1, 2]", [1, 2]) 

192 self.checkSingleFieldOverride(field, "(1, 2)", [1, 2]) 

193 self.checkSingleFieldOverride(field, "['1', '2']", [1, 2]) 

194 

195 # parseable but invalid input 

196 with self.assertRaises(pexConfig.FieldValidationError): 

197 self.checkSingleFieldOverride(field, "[1.0, []]") 

198 with self.assertRaises(pexConfig.FieldValidationError): 

199 self.checkSingleFieldOverride(field, [[], []]) 

200 with self.assertRaises(pexConfig.FieldValidationError): 

201 self.checkSingleFieldOverride(field, "5") 

202 

203 def testChoiceValueStr(self): 

204 """Test for applying value override to a choice field""" 

205 field = "fChoiceStr" 

206 

207 # values of supported type 

208 self.checkSingleFieldOverride(field, "A", "A") 

209 self.checkSingleFieldOverride(field, "B", "B") 

210 

211 # non-allowed value 

212 with self.assertRaises(pexConfig.FieldValidationError): 

213 self.checkSingleFieldOverride(field, "X") 

214 

215 def testChoiceValueInt(self): 

216 """Test for applying value override to a choice field""" 

217 field = "fChoiceInt" 

218 

219 # values of supported type 

220 self.checkSingleFieldOverride(field, 1, 1) 

221 self.checkSingleFieldOverride(field, 3, 3) 

222 

223 # supported string conversions 

224 self.checkSingleFieldOverride(field, "1", 1) 

225 

226 # parseable but invalid input 

227 with self.assertRaises(pexConfig.FieldValidationError): 

228 self.checkSingleFieldOverride(field, "0") 

229 with self.assertRaises(pexConfig.FieldValidationError): 

230 self.checkSingleFieldOverride(field, "[1]") 

231 with self.assertRaises(pexConfig.FieldValidationError): 

232 self.checkSingleFieldOverride(field, [0, 1]) 

233 

234 def testSettingVar(self): 

235 """Test setting a field with a string that represents a variable.""" 

236 field = "fChoiceInt" 

237 

238 # verify loading variable 

239 self.checkSingleFieldOverride(field, "TEST_CHOICE_VALUE", 1) 

240 

241 # Verify That python importing a variable works 

242 config = ConfigTest() 

243 overrides = ConfigOverrides() 

244 overrides.addPythonOverride("from math import pi") 

245 overrides.addValueOverride("fFloat", "pi") 

246 overrides.applyTo(config) 

247 from math import pi 

248 

249 self.assertEqual(config.fFloat, pi) 

250 

251 def testDictValueInt(self): 

252 """Test for applying value override to a dict field""" 

253 field = "fDictStrInt" 

254 

255 # values of supported type 

256 self.checkSingleFieldOverride(field, dict(a=1, b=2), dict(a=1, b=2)) 

257 

258 # supported string conversions 

259 self.checkSingleFieldOverride(field, "{'a': 1, 'b': 2}", dict(a=1, b=2)) 

260 

261 # parseable but invalid input 

262 with self.assertRaises(pexConfig.FieldValidationError): 

263 self.checkSingleFieldOverride(field, "{1: 2}") 

264 with self.assertRaises(pexConfig.FieldValidationError): 

265 self.checkSingleFieldOverride(field, "{'a': 'b'}") 

266 with self.assertRaises(pexConfig.FieldValidationError): 

267 self.checkSingleFieldOverride(field, {"a": "b"}) 

268 

269 

270class MyMemoryTestCase(lsst.utils.tests.MemoryTestCase): 

271 """Check for memory leaks.""" 

272 

273 

274def setup_module(module): 

275 """Configure pytest.""" 

276 lsst.utils.tests.init() 

277 

278 

279if __name__ == "__main__": 

280 lsst.utils.tests.init() 

281 unittest.main()