Coverage for tests/test_cliCmdQueryDatasetTypes.py: 23%

90 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-06-28 10:10 +0000

1# This file is part of daf_butler. 

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"""Unit tests for daf_butler CLI query-collections command. 

23""" 

24 

25import unittest 

26 

27from astropy.table import Table as AstropyTable 

28from lsst.daf.butler.cli.butler import cli 

29from lsst.daf.butler.cli.cmd import query_dataset_types 

30from lsst.daf.butler.cli.utils import LogCliRunner, clickResultMsg 

31from lsst.daf.butler.tests import CliCmdTestBase 

32from lsst.daf.butler.tests.utils import ButlerTestHelper, readTable 

33from numpy import array 

34 

35 

36class QueryDatasetTypesCmdTest(CliCmdTestBase, unittest.TestCase): 

37 """Test the query-dataset-types command line.""" 

38 

39 mockFuncName = "lsst.daf.butler.cli.cmd.commands.script.queryDatasetTypes" 

40 

41 @staticmethod 

42 def defaultExpected(): 

43 return dict(repo=None, verbose=False, glob=(), components=None) 

44 

45 @staticmethod 

46 def command(): 

47 return query_dataset_types 

48 

49 def test_minimal(self): 

50 """Test only required parameters.""" 

51 self.run_test(["query-dataset-types", "here"], self.makeExpected(repo="here")) 

52 

53 def test_requiredMissing(self): 

54 """Test that if the required parameter is missing it fails""" 

55 self.run_missing(["query-dataset-types"], r"Error: Missing argument ['\"]REPO['\"].") 

56 

57 def test_all(self): 

58 """Test all parameters.""" 

59 self.run_test( 

60 ["query-dataset-types", "here", "--verbose", "foo*", "--components"], 

61 self.makeExpected(repo="here", verbose=True, glob=("foo*",), components=True), 

62 ) 

63 self.run_test( 

64 ["query-dataset-types", "here", "--verbose", "foo*", "--no-components"], 

65 self.makeExpected(repo="here", verbose=True, glob=("foo*",), components=False), 

66 ) 

67 

68 

69class QueryDatasetTypesScriptTest(ButlerTestHelper, unittest.TestCase): 

70 """Test the query-dataset-types script interface.""" 

71 

72 def testQueryDatasetTypes(self): 

73 self.maxDiff = None 

74 datasetName = "test" 

75 instrumentDimension = "instrument" 

76 visitDimension = "visit" 

77 storageClassName = "StructuredDataDict" 

78 expectedNotVerbose = AstropyTable((("test",),), names=("name",)) 

79 runner = LogCliRunner() 

80 with runner.isolated_filesystem(): 

81 result = runner.invoke(cli, ["create", "here"]) 

82 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

83 # Create the dataset type. 

84 result = runner.invoke( 

85 cli, 

86 [ 

87 "register-dataset-type", 

88 "here", 

89 datasetName, 

90 storageClassName, 

91 instrumentDimension, 

92 visitDimension, 

93 ], 

94 ) 

95 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

96 # Okay to create it again identically. 

97 result = runner.invoke( 

98 cli, 

99 [ 

100 "register-dataset-type", 

101 "here", 

102 datasetName, 

103 storageClassName, 

104 instrumentDimension, 

105 visitDimension, 

106 ], 

107 ) 

108 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

109 # Not okay to create a different version of it. 

110 result = runner.invoke( 

111 cli, ["register-dataset-type", "here", datasetName, storageClassName, instrumentDimension] 

112 ) 

113 self.assertNotEqual(result.exit_code, 0, clickResultMsg(result)) 

114 # Not okay to try to create a component dataset type. 

115 result = runner.invoke( 

116 cli, ["register-dataset-type", "here", "a.b", storageClassName, instrumentDimension] 

117 ) 

118 self.assertNotEqual(result.exit_code, 0, clickResultMsg(result)) 

119 # check not-verbose output: 

120 result = runner.invoke(cli, ["query-dataset-types", "here"]) 

121 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

122 self.assertAstropyTablesEqual(readTable(result.output), expectedNotVerbose) 

123 # check glob output: 

124 result = runner.invoke(cli, ["query-dataset-types", "here", "t*"]) 

125 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

126 self.assertAstropyTablesEqual(readTable(result.output), expectedNotVerbose) 

127 # check verbose output: 

128 result = runner.invoke(cli, ["query-dataset-types", "here", "--verbose"]) 

129 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

130 expected = AstropyTable( 

131 array( 

132 ( 

133 "test", 

134 "['band', 'instrument', 'physical_filter', 'visit']", 

135 storageClassName, 

136 ) 

137 ), 

138 names=("name", "dimensions", "storage class"), 

139 ) 

140 self.assertAstropyTablesEqual(readTable(result.output), expected) 

141 

142 # Now remove and check that it was removed 

143 # First a non-existent one 

144 result = runner.invoke(cli, ["remove-dataset-type", "here", "unreal"]) 

145 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

146 

147 # Now one we now has been registered 

148 result = runner.invoke(cli, ["remove-dataset-type", "here", datasetName]) 

149 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

150 

151 # and check that it has gone 

152 result = runner.invoke(cli, ["query-dataset-types", "here"]) 

153 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

154 self.assertIn("No results", result.output) 

155 

156 def testRemoveDatasetTypes(self): 

157 self.maxDiff = None 

158 datasetName = "test" 

159 instrumentDimension = "instrument" 

160 visitDimension = "visit" 

161 storageClassName = "StructuredDataDict" 

162 runner = LogCliRunner() 

163 with runner.isolated_filesystem(): 

164 result = runner.invoke(cli, ["create", "here"]) 

165 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

166 for name in ( 

167 datasetName, 

168 "testA", 

169 "testB", 

170 "testC", 

171 "testD", 

172 "other", 

173 "another", 

174 "option", 

175 "option2", 

176 "placeholder", 

177 ): 

178 # Create the dataset type. 

179 result = runner.invoke( 

180 cli, 

181 [ 

182 "register-dataset-type", 

183 "here", 

184 name, 

185 storageClassName, 

186 instrumentDimension, 

187 visitDimension, 

188 ], 

189 ) 

190 

191 # Check wildcard / literal combination. 

192 result = runner.invoke(cli, ["remove-dataset-type", "here", "*other", "testA"]) 

193 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

194 self.assertDatasetTypes( 

195 runner, 

196 "*", 

197 ( 

198 "option", 

199 "option2", 

200 "placeholder", 

201 "test", 

202 "testB", 

203 "testC", 

204 "testD", 

205 ), 

206 ) 

207 

208 # Check literal / literal combination. 

209 result = runner.invoke(cli, ["remove-dataset-type", "here", "option", "testB"]) 

210 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

211 self.assertDatasetTypes( 

212 runner, 

213 "*", 

214 ( 

215 "option2", 

216 "placeholder", 

217 "test", 

218 "testC", 

219 "testD", 

220 ), 

221 ) 

222 

223 # Check wildcard. 

224 result = runner.invoke(cli, ["remove-dataset-type", "here", "test*"]) 

225 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

226 self.assertDatasetTypes( 

227 runner, 

228 "*", 

229 ( 

230 "option2", 

231 "placeholder", 

232 ), 

233 ) 

234 

235 # Check literal. 

236 result = runner.invoke(cli, ["remove-dataset-type", "here", "option2"]) 

237 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

238 self.assertDatasetTypes(runner, "*", ("placeholder",)) 

239 

240 def assertDatasetTypes(self, runner: LogCliRunner, query: str, expected: tuple[str, ...]) -> None: 

241 result = runner.invoke(cli, ["query-dataset-types", "here", query]) 

242 self.assertEqual(result.exit_code, 0, clickResultMsg(result)) 

243 expected = AstropyTable( 

244 (expected,), 

245 names=("name",), 

246 ) 

247 self.assertAstropyTablesEqual(readTable(result.output), expected) 

248 

249 

250if __name__ == "__main__": 

251 unittest.main()