Coverage for tests/test_butlerAlias.py: 30%

92 statements  

« prev     ^ index     » next       coverage.py v6.4.4, created at 2022-08-23 02:30 -0700

1# 

2# LSST Data Management System 

3# Copyright 2015 LSST Corporation. 

4# 

5# This product includes software developed by the 

6# LSST Project (http://www.lsst.org/). 

7# 

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

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

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

11# (at your option) any later version. 

12# 

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

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

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

16# GNU General Public License for more details. 

17# 

18# You should have received a copy of the LSST License Statement and 

19# the GNU General Public License along with this program. If not, 

20# see <http://www.lsstcorp.org/LegalNotices/>. 

21# 

22 

23import lsst.daf.persistence as dafPersist 

24import lsst.utils.tests 

25import astropy.io.fits 

26import unittest 

27import os 

28 

29# Define the root of the tests relative to this file 

30ROOT = os.path.abspath(os.path.dirname(__file__)) 

31 

32 

33class MinMapper(dafPersist.Mapper): 

34 

35 def map_raw(self, dataId, write): 

36 python = 'astropy.io.fits.HDUList' 

37 persistable = None 

38 storage = 'FitsStorage' 

39 path = 'butlerAlias/data/input/raw/raw_v' + \ 

40 str(dataId['visit']) + '_f' + dataId['filter'] + '.fits.gz' 

41 return dafPersist.ButlerLocation(python, persistable, storage, path, 

42 dataId, self, dafPersist.Storage.makeFromURI(ROOT)) 

43 

44 def bypass_raw(self, datasetType, pythonType, location, dataId): 

45 return astropy.io.fits.open(location.getLocationsWithRoot()[0]) 

46 

47 def query_raw(self, format, dataId): 

48 values = [{'visit': 1, 'filter': 'g'}, {'visit': 2, 'filter': 'g'}, {'visit': 3, 'filter': 'r'}] 

49 matches = [] 

50 for value in values: 

51 match = True 

52 for item in dataId: 

53 if value[item] != dataId[item]: 

54 match = False 

55 break 

56 if match: 

57 matches.append(value) 

58 results = set() 

59 for match in matches: 

60 tempTup = [] 

61 for word in format: 

62 tempTup.append(match[word]) 

63 results.add(tuple(tempTup)) 

64 return results 

65 

66 def getDefaultLevel(self): 

67 return 'visit' 

68 

69 def getKeys(self, datasetType, level): 

70 return {'filter': str, 'visit': int} 

71 

72 

73class ButlerTestCase(unittest.TestCase): 

74 """A test case for the basic butler api""" 

75 

76 datasetType = '@foo' 

77 

78 def setUp(self): 

79 self.butler = dafPersist.Butler(os.path.join(ROOT, 'butlerAlias/data/input'), MinMapper) 

80 self.butler.defineAlias(self.datasetType, 'raw') 

81 

82 def tearDown(self): 

83 del self.butler 

84 

85 def testGet(self): 

86 raw_image = self.butler.get(self.datasetType, {'visit': '2', 'filter': 'g'}) 

87 # in this case the width is known to be 1026: 

88 self.assertEqual(raw_image[1].header["NAXIS1"], 1026) # raw_image is an lsst.afw.ExposureU 

89 

90 def testSubset(self): 

91 subset = self.butler.subset(self.datasetType) 

92 self.assertEqual(len(subset), 3) 

93 

94 def testGetKeys(self): 

95 keys = self.butler.getKeys(self.datasetType) 

96 self.assertIn('filter', keys) 

97 self.assertIn('visit', keys) 

98 self.assertEqual(keys['filter'], str) 

99 self.assertEqual(keys['visit'], int) 

100 

101 def testQueryMetadata(self): 

102 keys = self.butler.getKeys(self.datasetType) 

103 expectedKeyValues = {'filter': ['g', 'r'], 'visit': [1, 2, 3]} 

104 for key in keys: 

105 val = self.butler.queryMetadata(self.datasetType, key) 

106 self.assertEqual(val.sort(), expectedKeyValues[key].sort()) 

107 

108 def testDatasetExists(self): 

109 # test the valeus that are expected to be true: 

110 self.assertTrue(self.butler.datasetExists(self.datasetType, {'filter': 'g', 'visit': 1})) 

111 self.assertTrue(self.butler.datasetExists(self.datasetType, {'filter': 'g', 'visit': 2})) 

112 self.assertTrue(self.butler.datasetExists(self.datasetType, {'filter': 'r', 'visit': 3})) 

113 

114 # test a few values that are expected to be false: 

115 self.assertFalse(self.butler.datasetExists(self.datasetType, {'filter': 'f', 'visit': 1})) 

116 self.assertFalse(self.butler.datasetExists(self.datasetType, {'filter': 'r', 'visit': 1})) 

117 self.assertFalse(self.butler.datasetExists(self.datasetType, {'filter': 'g', 'visit': 3})) 

118 

119 def testDataRef(self): 

120 print(self.butler.dataRef(self.datasetType, dataId={'filter': 'g', 'visit': 1})) 

121 

122 def testUnregisteredAlias(self): 

123 with self.assertRaises(RuntimeError): 

124 self.butler.getKeys('@bar') 

125 

126 def testOverlappingAlias(self): 

127 self.butler = dafPersist.Butler(inputs=[], outputs=[]) 

128 

129 self.butler.defineAlias('foo', 'raw') 

130 with self.assertRaises(RuntimeError): 

131 self.butler.defineAlias('foobar', 'calexp') 

132 self.butler.defineAlias('barbaz', 'qux') 

133 with self.assertRaises(RuntimeError): 

134 self.butler.defineAlias('bar', 'quux') 

135 

136 def testBadlyFormattedAlias(self): 

137 with self.assertRaises(RuntimeError): 

138 self.butler.defineAlias('abc@xyz', 'calexp') 

139 

140 

141class TestMemory(lsst.utils.tests.MemoryTestCase): 

142 pass 

143 

144 

145def setup_module(module): 

146 lsst.utils.tests.init() 

147 

148 

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

150 lsst.utils.tests.init() 

151 unittest.main()