Coverage for tests/test_configOverrides.py: 18%

144 statements  

« prev     ^ index     » next       coverage.py v7.2.3, created at 2023-04-27 02:47 -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 # noqa: F841 

33 

34 

35class ConfigTest(pexConfig.Config): 

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

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

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

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

40 

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

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

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

44 

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

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

47 

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

49 

50 

51class ConfigOverridesTestCase(unittest.TestCase): 

52 """A test case for Task""" 

53 

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

55 """Convenience method for override of single field 

56 

57 Parameters 

58 ---------- 

59 field : `str` 

60 Field name. 

61 value : 

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

63 result : optional 

64 Expected value of the field. 

65 """ 

66 config = ConfigTest() 

67 overrides = ConfigOverrides() 

68 overrides.addValueOverride(field, value) 

69 overrides.applyTo(config) 

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

71 

72 def testSimpleValueStr(self): 

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

74 field = "fStr" 

75 

76 # values of supported type 

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

78 

79 # invalid input 

80 with self.assertRaises(pexConfig.FieldValidationError): 

81 self.checkSingleFieldOverride(field, 1) 

82 

83 def testSimpleValueBool(self): 

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

85 field = "fBool" 

86 

87 # values of supported type 

88 self.checkSingleFieldOverride(field, True, True) 

89 self.checkSingleFieldOverride(field, False, False) 

90 

91 # supported string conversions 

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

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

94 

95 # parseable but invalid input 

96 with self.assertRaises(pexConfig.FieldValidationError): 

97 self.checkSingleFieldOverride(field, 1) 

98 with self.assertRaises(pexConfig.FieldValidationError): 

99 self.checkSingleFieldOverride(field, []) 

100 with self.assertRaises(pexConfig.FieldValidationError): 

101 self.checkSingleFieldOverride(field, "1") 

102 

103 def testSimpleValueInt(self): 

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

105 field = "fInt" 

106 

107 # values of supported type 

108 self.checkSingleFieldOverride(field, 0, 0) 

109 self.checkSingleFieldOverride(field, 100, 100) 

110 

111 # supported string conversions 

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

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

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

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

116 

117 # parseable but invalid input 

118 with self.assertRaises(pexConfig.FieldValidationError): 

119 self.checkSingleFieldOverride(field, 1.0) 

120 with self.assertRaises(pexConfig.FieldValidationError): 

121 self.checkSingleFieldOverride(field, "1.0") 

122 with self.assertRaises(pexConfig.FieldValidationError): 

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

124 

125 def testSimpleValueFloat(self): 

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

127 field = "fFloat" 

128 

129 # values of supported type 

130 self.checkSingleFieldOverride(field, 0.0, 0.0) 

131 self.checkSingleFieldOverride(field, 100.0, 100.0) 

132 

133 # supported string conversions 

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

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

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

137 

138 # parseable but invalid input 

139 with self.assertRaises(pexConfig.FieldValidationError): 

140 self.checkSingleFieldOverride(field, []) 

141 with self.assertRaises(pexConfig.FieldValidationError): 

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

143 

144 def testListValueStr(self): 

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

146 field = "fListStr" 

147 

148 # values of supported type 

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

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

151 

152 # supported string conversions 

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

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

155 

156 # parseable but invalid input 

157 with self.assertRaises(pexConfig.FieldValidationError): 

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

159 

160 def testListValueBool(self): 

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

162 field = "fListBool" 

163 

164 # values of supported type 

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

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

167 

168 # supported string conversions 

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

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

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

172 

173 with self.assertRaises(pexConfig.FieldValidationError): 

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

175 with self.assertRaises(pexConfig.FieldValidationError): 

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

177 with self.assertRaises(pexConfig.FieldValidationError): 

178 self.checkSingleFieldOverride(field, "5") 

179 

180 def testListValueInt(self): 

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

182 field = "fListInt" 

183 

184 # values of supported type 

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

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

187 

188 # supported string conversions 

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

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

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

192 

193 # parseable but invalid input 

194 with self.assertRaises(pexConfig.FieldValidationError): 

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

196 with self.assertRaises(pexConfig.FieldValidationError): 

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

198 with self.assertRaises(pexConfig.FieldValidationError): 

199 self.checkSingleFieldOverride(field, "5") 

200 

201 def testChoiceValueStr(self): 

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

203 field = "fChoiceStr" 

204 

205 # values of supported type 

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

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

208 

209 # non-allowed value 

210 with self.assertRaises(pexConfig.FieldValidationError): 

211 self.checkSingleFieldOverride(field, "X") 

212 

213 def testChoiceValueInt(self): 

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

215 field = "fChoiceInt" 

216 

217 # values of supported type 

218 self.checkSingleFieldOverride(field, 1, 1) 

219 self.checkSingleFieldOverride(field, 3, 3) 

220 

221 # supported string conversions 

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

223 

224 # parseable but invalid input 

225 with self.assertRaises(pexConfig.FieldValidationError): 

226 self.checkSingleFieldOverride(field, "0") 

227 with self.assertRaises(pexConfig.FieldValidationError): 

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

229 with self.assertRaises(pexConfig.FieldValidationError): 

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

231 

232 def testSettingVar(self): 

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

234 field = "fChoiceInt" 

235 

236 # verify loading variable 

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

238 

239 # Verify That python importing a variable works 

240 config = ConfigTest() 

241 overrides = ConfigOverrides() 

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

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

244 overrides.applyTo(config) 

245 from math import pi 

246 

247 self.assertEqual(config.fFloat, pi) 

248 

249 def testDictValueInt(self): 

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

251 field = "fDictStrInt" 

252 

253 # values of supported type 

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

255 

256 # supported string conversions 

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

258 

259 # parseable but invalid input 

260 with self.assertRaises(pexConfig.FieldValidationError): 

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

262 with self.assertRaises(pexConfig.FieldValidationError): 

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

264 with self.assertRaises(pexConfig.FieldValidationError): 

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

266 

267 

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

269 pass 

270 

271 

272def setup_module(module): 

273 lsst.utils.tests.init() 

274 

275 

276if __name__ == "__main__": 276 ↛ 277line 276 didn't jump to line 277, because the condition on line 276 was never true

277 lsst.utils.tests.init() 

278 unittest.main()