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

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://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"""Helpers for writing tests against subclassses of Instrument. 

23 

24These are not tests themselves, but can be subclassed (plus unittest.TestCase) 

25to get a functional test of an Instrument. 

26""" 

27 

28import abc 

29import dataclasses 

30 

31from lsst.obs.base import Instrument 

32from lsst.obs.base.gen2to3 import TranslatorFactory 

33from lsst.daf.butler import Registry 

34from lsst.daf.butler import ButlerConfig 

35 

36 

37@dataclasses.dataclass 

38class InstrumentTestData: 

39 """Values to test against in sublcasses of `InstrumentTests`. 

40 """ 

41 

42 name: str 

43 """The name of the Camera this instrument describes.""" 

44 

45 nDetectors: int 

46 """The number of detectors in the Camera.""" 

47 

48 firstDetectorName: str 

49 """The name of the first detector in the Camera.""" 

50 

51 physical_filters: {str} 

52 """A subset of the physical filters should be registered.""" 

53 

54 

55class InstrumentTests(metaclass=abc.ABCMeta): 

56 """Tests of sublcasses of Instrument. 

57 

58 TestCase subclasses must derive from this, then `TestCase`, and override 

59 ``data`` and ``instrument``. 

60 """ 

61 

62 data = None 

63 """`InstrumentTestData` containing the values to test against.""" 

64 

65 instrument = None 

66 """The `~lsst.obs.base.Instrument` to be tested.""" 

67 

68 def test_name(self): 

69 self.assertEqual(self.instrument.getName(), self.data.name) 

70 

71 def test_getCamera(self): 

72 """Test that getCamera() returns a reasonable Camera definition. 

73 """ 

74 camera = self.instrument.getCamera() 

75 self.assertEqual(camera.getName(), self.instrument.getName()) 

76 self.assertEqual(len(camera), self.data.nDetectors) 

77 self.assertEqual(next(iter(camera)).getName(), self.data.firstDetectorName) 

78 

79 def test_register(self): 

80 """Test that register() sets appropriate Dimensions. 

81 """ 

82 registry = Registry.fromConfig(ButlerConfig()) 

83 # check that the registry starts out empty 

84 self.assertEqual(list(registry.queryDimensions(["instrument"])), []) 

85 self.assertEqual(list(registry.queryDimensions(["detector"])), []) 

86 self.assertEqual(list(registry.queryDimensions(["physical_filter"])), []) 

87 

88 # register the instrument and check that certain dimensions appear 

89 self.instrument.register(registry) 

90 instrumentDataIds = list(registry.queryDimensions(["instrument"])) 

91 self.assertEqual(len(instrumentDataIds), 1) 

92 instrumentNames = {dataId["instrument"] for dataId in instrumentDataIds} 

93 self.assertEqual(instrumentNames, {self.data.name}) 

94 detectorDataIds = list(registry.queryDimensions(["detector"])) 

95 self.assertEqual(len(detectorDataIds), self.data.nDetectors) 

96 detectorNames = {dataId.records["detector"].full_name for dataId in detectorDataIds} 

97 self.assertIn(self.data.firstDetectorName, detectorNames) 

98 physicalFilterDataIds = list(registry.queryDimensions(["physical_filter"])) 

99 filterNames = {dataId['physical_filter'] for dataId in physicalFilterDataIds} 

100 self.assertGreaterEqual(filterNames, self.data.physical_filters) 

101 

102 # Check that the instrument class can be retrieved 

103 registeredInstrument = Instrument.fromName(self.instrument.getName(), registry) 

104 self.assertEqual(type(registeredInstrument), type(self.instrument)) 

105 

106 def testMakeTranslatorFactory(self): 

107 factory = self.instrument.makeDataIdTranslatorFactory() 

108 self.assertIsInstance(factory, TranslatorFactory) 

109 str(factory) # just make sure this doesn't raise.