Coverage for tests/test_configOverrides.py: 24%

Shortcuts on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

144 statements  

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.utils.tests 

28import lsst.pex.config as pexConfig 

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., 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 

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

56 """Convenience method for override of single field 

57 

58 Parameters 

59 ---------- 

60 field : `str` 

61 Field name. 

62 value : 

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

64 result : optional 

65 Expected value of the field. 

66 """ 

67 config = ConfigTest() 

68 overrides = ConfigOverrides() 

69 overrides.addValueOverride(field, value) 

70 overrides.applyTo(config) 

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

72 

73 def testSimpleValueStr(self): 

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

75 """ 

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 """ 

88 field = "fBool" 

89 

90 # values of supported type 

91 self.checkSingleFieldOverride(field, True, True) 

92 self.checkSingleFieldOverride(field, False, False) 

93 

94 # supported string conversions 

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

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

97 

98 # parseable but invalid input 

99 with self.assertRaises(pexConfig.FieldValidationError): 

100 self.checkSingleFieldOverride(field, 1) 

101 with self.assertRaises(pexConfig.FieldValidationError): 

102 self.checkSingleFieldOverride(field, []) 

103 with self.assertRaises(pexConfig.FieldValidationError): 

104 self.checkSingleFieldOverride(field, "1") 

105 

106 def testSimpleValueInt(self): 

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

108 """ 

109 field = "fInt" 

110 

111 # values of supported type 

112 self.checkSingleFieldOverride(field, 0, 0) 

113 self.checkSingleFieldOverride(field, 100, 100) 

114 

115 # supported string conversions 

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

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

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

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

120 

121 # parseable but invalid input 

122 with self.assertRaises(pexConfig.FieldValidationError): 

123 self.checkSingleFieldOverride(field, 1.0) 

124 with self.assertRaises(pexConfig.FieldValidationError): 

125 self.checkSingleFieldOverride(field, "1.0") 

126 with self.assertRaises(pexConfig.FieldValidationError): 

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

128 

129 def testSimpleValueFloat(self): 

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

131 """ 

132 field = "fFloat" 

133 

134 # values of supported type 

135 self.checkSingleFieldOverride(field, 0., 0.) 

136 self.checkSingleFieldOverride(field, 100., 100.) 

137 

138 # supported string conversions 

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

140 self.checkSingleFieldOverride(field, "100.0", 100.) 

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

142 

143 # parseable but invalid input 

144 with self.assertRaises(pexConfig.FieldValidationError): 

145 self.checkSingleFieldOverride(field, []) 

146 with self.assertRaises(pexConfig.FieldValidationError): 

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

148 

149 def testListValueStr(self): 

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

151 """ 

152 field = "fListStr" 

153 

154 # values of supported type 

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

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

157 

158 # supported string conversions 

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

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

161 

162 # parseable but invalid input 

163 with self.assertRaises(pexConfig.FieldValidationError): 

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

165 

166 def testListValueBool(self): 

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

168 """ 

169 field = "fListBool" 

170 

171 # values of supported type 

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

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

174 

175 # supported string conversions 

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

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

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

179 

180 with self.assertRaises(pexConfig.FieldValidationError): 

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

182 with self.assertRaises(pexConfig.FieldValidationError): 

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

184 with self.assertRaises(pexConfig.FieldValidationError): 

185 self.checkSingleFieldOverride(field, "5") 

186 

187 def testListValueInt(self): 

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

189 """ 

190 field = "fListInt" 

191 

192 # values of supported type 

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

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

195 

196 # supported string conversions 

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

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

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

200 

201 # parseable but invalid input 

202 with self.assertRaises(pexConfig.FieldValidationError): 

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

204 with self.assertRaises(pexConfig.FieldValidationError): 

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

206 with self.assertRaises(pexConfig.FieldValidationError): 

207 self.checkSingleFieldOverride(field, "5") 

208 

209 def testChoiceValueStr(self): 

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

211 """ 

212 field = "fChoiceStr" 

213 

214 # values of supported type 

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

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

217 

218 # non-allowed value 

219 with self.assertRaises(pexConfig.FieldValidationError): 

220 self.checkSingleFieldOverride(field, "X") 

221 

222 def testChoiceValueInt(self): 

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

224 """ 

225 field = "fChoiceInt" 

226 

227 # values of supported type 

228 self.checkSingleFieldOverride(field, 1, 1) 

229 self.checkSingleFieldOverride(field, 3, 3) 

230 

231 # supported string conversions 

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

233 

234 # parseable but invalid input 

235 with self.assertRaises(pexConfig.FieldValidationError): 

236 self.checkSingleFieldOverride(field, "0") 

237 with self.assertRaises(pexConfig.FieldValidationError): 

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

239 with self.assertRaises(pexConfig.FieldValidationError): 

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

241 

242 def testSettingVar(self): 

243 """Test setting a field with a string that represents a variable name 

244 """ 

245 field = "fChoiceInt" 

246 

247 # verify loading variable 

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

249 

250 # Verify That python importing a variable works 

251 config = ConfigTest() 

252 overrides = ConfigOverrides() 

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

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

255 overrides.applyTo(config) 

256 from math import pi 

257 self.assertEqual(config.fFloat, pi) 

258 

259 def testDictValueInt(self): 

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

261 """ 

262 field = "fDictStrInt" 

263 

264 # values of supported type 

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

266 

267 # supported string conversions 

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

269 

270 # parseable but invalid input 

271 with self.assertRaises(pexConfig.FieldValidationError): 

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

273 with self.assertRaises(pexConfig.FieldValidationError): 

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

275 with self.assertRaises(pexConfig.FieldValidationError): 

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

277 

278 

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

280 pass 

281 

282 

283def setup_module(module): 

284 lsst.utils.tests.init() 

285 

286 

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

288 lsst.utils.tests.init() 

289 unittest.main()