Coverage for tests/test_pipeline.py: 21%

93 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-02-08 02:43 -0800

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

23""" 

24 

25import pickle 

26import textwrap 

27import unittest 

28 

29import lsst.utils.tests 

30from lsst.pipe.base import Pipeline, PipelineDatasetTypes, TaskDef 

31from lsst.pipe.base.pipelineIR import LabeledSubset 

32from lsst.pipe.base.tests.simpleQGraph import AddTask, makeSimplePipeline 

33 

34 

35class PipelineTestCase(unittest.TestCase): 

36 """A test case for TaskDef and Pipeline.""" 

37 

38 def testTaskDef(self): 

39 """Tests for TaskDef structure""" 

40 task1 = TaskDef(taskClass=AddTask, config=AddTask.ConfigClass()) 

41 self.assertIn("Add", task1.taskName) 

42 self.assertIsInstance(task1.config, AddTask.ConfigClass) 

43 self.assertIsNotNone(task1.taskClass) 

44 self.assertEqual(task1.label, "add_task") 

45 task1a = pickle.loads(pickle.dumps(task1)) 

46 self.assertEqual(task1, task1a) 

47 

48 def testEmpty(self): 

49 """Creating empty pipeline""" 

50 pipeline = Pipeline("test") 

51 self.assertEqual(len(pipeline), 0) 

52 

53 def testInitial(self): 

54 """Testing constructor with initial data""" 

55 pipeline = makeSimplePipeline(2) 

56 self.assertEqual(len(pipeline), 2) 

57 expandedPipeline = list(pipeline.toExpandedPipeline()) 

58 self.assertEqual(expandedPipeline[0].taskName, "lsst.pipe.base.tests.simpleQGraph.AddTask") 

59 self.assertEqual(expandedPipeline[1].taskName, "lsst.pipe.base.tests.simpleQGraph.AddTask") 

60 self.assertEqual(expandedPipeline[0].taskClass, AddTask) 

61 self.assertEqual(expandedPipeline[1].taskClass, AddTask) 

62 self.assertEqual(expandedPipeline[0].label, "task0") 

63 self.assertEqual(expandedPipeline[1].label, "task1") 

64 

65 def testModifySubset(self): 

66 pipeline = makeSimplePipeline(2) 

67 

68 # Test adding labels. 

69 with self.assertRaises(ValueError): 

70 pipeline.addLabelToSubset("test", "new_label") 

71 pipeline._pipelineIR.labeled_subsets["test"] = LabeledSubset("test", set(), None) 

72 with self.assertRaises(ValueError): 

73 pipeline.addLabelToSubset("test", "missing_label") 

74 pipeline.addLabelToSubset("test", "task0") 

75 self.assertEqual(pipeline._pipelineIR.labeled_subsets["test"].subset, set(("task0",))) 

76 

77 # Test removing labels. 

78 with self.assertRaises(ValueError): 

79 pipeline.addLabelToSubset("missing_subset", "task0") 

80 with self.assertRaises(ValueError): 

81 pipeline.addLabelToSubset("test", "missing_label") 

82 pipeline.removeLabelFromSubset("test", "task0") 

83 self.assertEqual(pipeline._pipelineIR.labeled_subsets["test"].subset, set()) 

84 

85 def testMergingPipelines(self): 

86 pipeline1 = makeSimplePipeline(2) 

87 pipeline2 = makeSimplePipeline(4) 

88 pipeline2.removeTask("task0") 

89 pipeline2.removeTask("task1") 

90 

91 pipeline1.mergePipeline(pipeline2) 

92 self.assertEqual(pipeline1._pipelineIR.tasks.keys(), set(("task0", "task1", "task2", "task3"))) 

93 

94 def testFindingSubset(self): 

95 pipeline = makeSimplePipeline(2) 

96 pipeline._pipelineIR.labeled_subsets["test1"] = LabeledSubset("test1", set(), None) 

97 pipeline._pipelineIR.labeled_subsets["test2"] = LabeledSubset("test2", set(), None) 

98 pipeline._pipelineIR.labeled_subsets["test3"] = LabeledSubset("test3", set(), None) 

99 

100 pipeline.addLabelToSubset("test1", "task0") 

101 pipeline.addLabelToSubset("test3", "task0") 

102 

103 with self.assertRaises(ValueError): 

104 pipeline.findSubsetsWithLabel("missing_label") 

105 

106 self.assertEqual(pipeline.findSubsetsWithLabel("task0"), set(("test1", "test3"))) 

107 

108 def testParameters(self): 

109 """Test that parameters can be set and used to format""" 

110 pipeline_str = textwrap.dedent( 

111 """ 

112 description: Test Pipeline 

113 parameters: 

114 testValue: 5 

115 tasks: 

116 add: 

117 class: test_pipeline.AddTask 

118 config: 

119 addend: parameters.testValue 

120 """ 

121 ) 

122 # verify that parameters are used in expanding a pipeline 

123 pipeline = Pipeline.fromString(pipeline_str) 

124 expandedPipeline = list(pipeline.toExpandedPipeline()) 

125 self.assertEqual(expandedPipeline[0].config.addend, 5) 

126 

127 # verify that a parameter can be overridden on the "command line" 

128 pipeline.addConfigOverride("parameters", "testValue", 14) 

129 expandedPipeline = list(pipeline.toExpandedPipeline()) 

130 self.assertEqual(expandedPipeline[0].config.addend, 14) 

131 

132 # verify that a non existing parameter cant be overridden 

133 with self.assertRaises(ValueError): 

134 pipeline.addConfigOverride("parameters", "missingValue", 17) 

135 

136 # verify that parameters does not support files or python overrides 

137 with self.assertRaises(ValueError): 

138 pipeline.addConfigFile("parameters", "fakeFile") 

139 with self.assertRaises(ValueError): 

140 pipeline.addConfigPython("parameters", "fakePythonString") 

141 

142 def testSerialization(self): 

143 pipeline = makeSimplePipeline(2) 

144 dump = str(pipeline) 

145 load = Pipeline.fromString(dump) 

146 self.assertEqual(pipeline, load) 

147 

148 def test_initOutputNames(self): 

149 """Test for PipelineDatasetTypes.initOutputNames method.""" 

150 pipeline = makeSimplePipeline(3) 

151 dsType = set(PipelineDatasetTypes.initOutputNames(pipeline)) 

152 expected = { 

153 "packages", 

154 "add_init_output1", 

155 "add_init_output2", 

156 "add_init_output3", 

157 "task0_config", 

158 "task1_config", 

159 "task2_config", 

160 } 

161 self.assertEqual(dsType, expected) 

162 

163 

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

165 pass 

166 

167 

168def setup_module(module): 

169 lsst.utils.tests.init() 

170 

171 

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

173 lsst.utils.tests.init() 

174 unittest.main()