Hide keyboard shortcuts

Hot-keys 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

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 

32class ConfigTest(pexConfig.Config): 

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

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

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

36 fFloat = pexConfig.Field(dtype=float, default=-1., doc="") 

37 

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

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

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

41 

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

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

44 

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

46 

47 

48class ConfigOverridesTestCase(unittest.TestCase): 

49 """A test case for Task 

50 """ 

51 

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

53 """Convenience method for override of single field 

54 

55 Parameters 

56 ---------- 

57 field : `str` 

58 Field name. 

59 value : 

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

61 result : optional 

62 Expected value of the field. 

63 """ 

64 config = ConfigTest() 

65 overrides = ConfigOverrides() 

66 overrides.addValueOverride(field, value) 

67 overrides.applyTo(config) 

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

69 

70 def testSimpleValueStr(self): 

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

72 """ 

73 field = "fStr" 

74 

75 # values of supported type 

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

77 

78 # invalid input 

79 with self.assertRaises(pexConfig.FieldValidationError): 

80 self.checkSingleFieldOverride(field, 1) 

81 

82 def testSimpleValueBool(self): 

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

84 """ 

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 # non-parseable input 

104 with self.assertRaises(RuntimeError): 

105 self.checkSingleFieldOverride(field, "value") 

106 

107 def testSimpleValueInt(self): 

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

109 """ 

110 field = "fInt" 

111 

112 # values of supported type 

113 self.checkSingleFieldOverride(field, 0, 0) 

114 self.checkSingleFieldOverride(field, 100, 100) 

115 

116 # supported string conversions 

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

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

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

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

121 

122 # parseable but invalid input 

123 with self.assertRaises(pexConfig.FieldValidationError): 

124 self.checkSingleFieldOverride(field, 1.0) 

125 with self.assertRaises(pexConfig.FieldValidationError): 

126 self.checkSingleFieldOverride(field, "1.0") 

127 with self.assertRaises(pexConfig.FieldValidationError): 

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

129 

130 # non-parseable input 

131 with self.assertRaises(RuntimeError): 

132 self.checkSingleFieldOverride(field, "value") 

133 

134 def testSimpleValueFloat(self): 

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

136 """ 

137 field = "fFloat" 

138 

139 # values of supported type 

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

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

142 

143 # supported string conversions 

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

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

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

147 

148 # parseable but invalid input 

149 with self.assertRaises(pexConfig.FieldValidationError): 

150 self.checkSingleFieldOverride(field, []) 

151 with self.assertRaises(pexConfig.FieldValidationError): 

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

153 

154 # non-parseable input 

155 with self.assertRaises(RuntimeError): 

156 self.checkSingleFieldOverride(field, "value") 

157 

158 def testListValueStr(self): 

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

160 """ 

161 field = "fListStr" 

162 

163 # values of supported type 

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

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

166 

167 # supported string conversions 

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

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

170 

171 # parseable but invalid input 

172 with self.assertRaises(pexConfig.FieldValidationError): 

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

174 

175 # non-parseable input 

176 with self.assertRaises(RuntimeError): 

177 self.checkSingleFieldOverride(field, "value") 

178 

179 def testListValueBool(self): 

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

181 """ 

182 field = "fListBool" 

183 

184 # values of supported type 

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

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

187 

188 # supported string conversions 

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

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

191 

192 # parseable but invalid input 

193 with self.assertRaises(pexConfig.FieldValidationError): 

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

195 with self.assertRaises(pexConfig.FieldValidationError): 

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

197 with self.assertRaises(pexConfig.FieldValidationError): 

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

199 with self.assertRaises(pexConfig.FieldValidationError): 

200 self.checkSingleFieldOverride(field, "5") 

201 

202 def testListValueInt(self): 

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

204 """ 

205 field = "fListInt" 

206 

207 # values of supported type 

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

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

210 

211 # supported string conversions 

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

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

214 

215 # parseable but invalid input 

216 with self.assertRaises(pexConfig.FieldValidationError): 

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

218 with self.assertRaises(pexConfig.FieldValidationError): 

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

220 with self.assertRaises(pexConfig.FieldValidationError): 

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

222 with self.assertRaises(pexConfig.FieldValidationError): 

223 self.checkSingleFieldOverride(field, "5") 

224 

225 def testChoiceValueStr(self): 

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

227 """ 

228 field = "fChoiceStr" 

229 

230 # values of supported type 

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

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

233 

234 # non-allowed value 

235 with self.assertRaises(pexConfig.FieldValidationError): 

236 self.checkSingleFieldOverride(field, "X") 

237 

238 def testChoiceValueInt(self): 

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

240 """ 

241 field = "fChoiceInt" 

242 

243 # values of supported type 

244 self.checkSingleFieldOverride(field, 1, 1) 

245 self.checkSingleFieldOverride(field, 3, 3) 

246 

247 # supported string conversions 

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

249 

250 # parseable but invalid input 

251 with self.assertRaises(pexConfig.FieldValidationError): 

252 self.checkSingleFieldOverride(field, "0") 

253 with self.assertRaises(pexConfig.FieldValidationError): 

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

255 with self.assertRaises(pexConfig.FieldValidationError): 

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

257 

258 # non-parseable input 

259 with self.assertRaises(RuntimeError): 

260 self.checkSingleFieldOverride(field, "value") 

261 

262 def testDictValueInt(self): 

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

264 """ 

265 field = "fDictStrInt" 

266 

267 # values of supported type 

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

269 

270 # supported string conversions 

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

272 

273 # parseable but invalid input 

274 with self.assertRaises(pexConfig.FieldValidationError): 

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

276 with self.assertRaises(pexConfig.FieldValidationError): 

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

278 with self.assertRaises(pexConfig.FieldValidationError): 

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

280 

281 # non-parseable input 

282 with self.assertRaises(RuntimeError): 

283 self.checkSingleFieldOverride(field, "{1: value}") 

284 

285 

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

287 pass 

288 

289 

290def setup_module(module): 

291 lsst.utils.tests.init() 

292 

293 

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

295 lsst.utils.tests.init() 

296 unittest.main()