def testRunTestQuantumPatchMockRun(self): task = PatchTask() dataId = {"skymap": "sky", "tract": 42} data = self._makePatchTestData(dataId) quantum = makeQuantum( task, self.butler, dataId, { # Use lists, not sets, to ensure order agrees with test # assertion. "a": [dataset[0] for dataset in data["PatchA"]], "b": dataId, "out": [dataset[0] for dataset in data["PatchA"]], }, ) run = runTestQuantum(task, self.butler, quantum, mockRun=True) # Can we use the mock to verify that task.run got called with the # correct inputs? run.assert_called_once_with( a=[ butlerTests.MetricsExample(data=dataset[1]) for dataset in data["PatchA"] ], b=butlerTests.MetricsExample(data=data["PatchB"][0][1]), )
def testRunTestQuantumVisitWithRun(self): task = VisitTask() dataId = {"instrument": "notACam", "visit": 102} data = self._makeVisitTestData(dataId) quantum = makeQuantum( task, self.butler, dataId, {key: dataId for key in {"a", "b", "outA", "outB"}}) runTestQuantum(task, self.butler, quantum, mockRun=False) # Can we use runTestQuantum to verify that task.run got called with # correct inputs/outputs? self.assertTrue(self.butler.datasetExists("VisitOutA", dataId)) self.assertEqual( self.butler.get("VisitOutA", dataId), butlerTests.MetricsExample(data=(data["VisitA"] + data["VisitB"])), ) self.assertTrue(self.butler.datasetExists("VisitOutB", dataId)) self.assertEqual( self.butler.get("VisitOutB", dataId), butlerTests.MetricsExample(data=(data["VisitA"] * max(data["VisitB"]))), )
def _makeVisitTestData(self, dataId): """Create dummy datasets suitable for VisitTask. This method updates ``self.butler`` directly. Parameters ---------- dataId : any data ID type The (shared) ID for the datasets to create. Returns ------- datasets : `dict` [`str`, `list`] A dictionary keyed by dataset type. Its values are the list of integers used to create each dataset. The datasets stored in the butler are `lsst.daf.butler.tests.MetricsExample` objects with these lists as their ``data`` argument, but the lists are easier to manipulate in test code. """ inInit = [4, 2] inA = [1, 2, 3] inB = [4, 0, 1] self.butler.put(butlerTests.MetricsExample(data=inA), "VisitA", dataId) self.butler.put(butlerTests.MetricsExample(data=inB), "VisitB", dataId) self.butler.put(butlerTests.MetricsExample(data=inInit), "VisitInitIn", set()) return { "VisitA": inA, "VisitB": inB, "VisitInitIn": inInit, }
def _makePatchTestData(self, dataId): """Create dummy datasets suitable for PatchTask. This method updates ``self.butler`` directly. Parameters ---------- dataId : any data ID type The (shared) ID for the datasets to create. Any patch ID is overridden to create multiple datasets. Returns ------- datasets : `dict` [`str`, `list` [`tuple` [data ID, `list`]]] A dictionary keyed by dataset type. Its values are the data ID of each dataset and the list of integers used to create each. The datasets stored in the butler are `lsst.daf.butler.tests.MetricsExample` objects with these lists as their ``data`` argument, but the lists are easier to manipulate in test code. """ inA = [1, 2, 3] inB = [4, 0, 1] datasets = {"PatchA": [], "PatchB": []} for patch in {0, 1}: self.butler.put(butlerTests.MetricsExample(data=(inA + [patch])), "PatchA", dataId, patch=patch) datasets["PatchA"].append((dict(dataId, patch=patch), inA + [patch])) self.butler.put(butlerTests.MetricsExample(data=inB), "PatchB", dataId) datasets["PatchB"].append((dataId, inB)) return datasets
def testAssertValidOutputPass(self): task = VisitTask() inA = butlerTests.MetricsExample(data=[1, 2, 3]) inB = butlerTests.MetricsExample(data=[4, 0, 1]) result = task.run(inA, inB) # should not throw assertValidOutput(task, result)
def testAssertValidOutputSingle(self): task = PatchTask() def run(a, b): return Struct(out=b) task.run = run inA = butlerTests.MetricsExample(data=[1, 2, 3]) inB = butlerTests.MetricsExample(data=[4, 0, 1]) result = task.run([inA], inB) with self.assertRaises(AssertionError): assertValidOutput(task, result)
def testAssertValidOutputMultiple(self): task = VisitTask() def run(a, b): return Struct(outA=[a], outB=b) task.run = run inA = butlerTests.MetricsExample(data=[1, 2, 3]) inB = butlerTests.MetricsExample(data=[4, 0, 1]) result = task.run(inA, inB) with self.assertRaises(AssertionError): assertValidOutput(task, result)
def testRunTestQuantumVisitMockRun(self): task = VisitTask() dataId = butlerTests.expandUniqueId(self.butler, {"visit": 102}) data = self._makeVisitTestData(dataId) quantum = makeQuantum(task, self.butler, dataId, {key: dataId for key in {"a", "b", "outA", "outB"}}) run = runTestQuantum(task, self.butler, quantum, mockRun=True) # Can we use the mock to verify that task.run got called with the # correct inputs? run.assert_called_once_with(a=butlerTests.MetricsExample(data=data["VisitA"]), b=butlerTests.MetricsExample(data=data["VisitB"]))
def testRunTestQuantumPatchWithRun(self): task = PatchTask() dataId = {"skymap": "sky", "tract": 42} data = self._makePatchTestData(dataId) quantum = makeQuantum( task, self.butler, dataId, { "a": [dataset[0] for dataset in data["PatchA"]], "b": dataId, "out": [dataset[0] for dataset in data["PatchA"]], }, ) runTestQuantum(task, self.butler, quantum, mockRun=False) # Can we use runTestQuantum to verify that task.run got called with # correct inputs/outputs? inB = data["PatchB"][0][1] for dataset in data["PatchA"]: patchId = dataset[0] self.assertTrue(self.butler.datasetExists("PatchOut", patchId)) self.assertEqual( self.butler.get("PatchOut", patchId), butlerTests.MetricsExample(data=(dataset[1] + inB)))
def run(self, a, b=None): if self.config.doUseB: out = [ butlerTests.MetricsExample(data=(oneA.data + b.data)) for oneA in a ] else: out = a return Struct(out=out)
def testMakeQuantumInvalidDimension(self): config = VisitConfig() config.connections.a = "PatchA" task = VisitTask(config=config) dataIdV = butlerTests.expandUniqueId(self.butler, {"visit": 102}) dataIdP = butlerTests.expandUniqueId(self.butler, {"patch": 0}) inA = [1, 2, 3] inB = [4, 0, 1] self.butler.put(butlerTests.MetricsExample(data=inA), "VisitA", dataIdV) self.butler.put(butlerTests.MetricsExample(data=inA), "PatchA", dataIdP) self.butler.put(butlerTests.MetricsExample(data=inB), "VisitB", dataIdV) with self.assertRaises(ValueError): makeQuantum(task, self.butler, dataIdV, { "a": dataIdP, "b": dataIdV, "outA": dataIdV, "outB": dataIdV, })
def testGetInitInputs(self): dataId = {"instrument": "notACam", "visit": 102} data = self._makeVisitTestData(dataId) self.assertEqual(getInitInputs(self.butler, VisitConfig()), {}) config = VisitConfig() config.doUseInitIn = True self.assertEqual( getInitInputs(self.butler, config), {"initIn": butlerTests.MetricsExample(data=data["VisitInitIn"])}, )
def testSkypixHandling(self): task = SkyPixTask() dataId = {"htm7": 157227} # connection declares skypix, but Butler uses htm7 data = butlerTests.MetricsExample(data=[1, 2, 3]) self.butler.put(data, "PixA", dataId) quantum = makeQuantum(task, self.butler, dataId, {key: dataId for key in {"a", "out"}}) run = runTestQuantum(task, self.butler, quantum, mockRun=True) # PixA dataset should have been retrieved by runTestQuantum run.assert_called_once_with(a=data)
def testRunTestQuantumPatchOptionalInput(self): config = PatchConfig() config.doUseB = False task = PatchTask(config=config) dataId = butlerTests.expandUniqueId(self.butler, {"tract": 42}) data = self._makePatchTestData(dataId) quantum = makeQuantum(task, self.butler, dataId, { # Use lists, not sets, to ensure order agrees with test assertion "a": [dataset[0] for dataset in data["PatchA"]], "out": [dataset[0] for dataset in data["PatchA"]], }) run = runTestQuantum(task, self.butler, quantum, mockRun=True) # Can we use the mock to verify that task.run got called with the # correct inputs? run.assert_called_once_with( a=[butlerTests.MetricsExample(data=dataset[1]) for dataset in data["PatchA"]] )
def __init__(self, initInputs=None, **kwargs): super().__init__(initInputs=initInputs, **kwargs) self.initOut = [ butlerTests.MetricsExample(data=[1, 2]), butlerTests.MetricsExample(data=[3, 4]), ]
def testMakeQuantumInvalidDimension(self): config = VisitConfig() config.connections.a = "PatchA" task = VisitTask(config=config) dataIdV = {"instrument": "notACam", "visit": 102} dataIdVExtra = {"instrument": "notACam", "visit": 102, "detector": 42} dataIdP = {"skymap": "sky", "tract": 42, "patch": 0} inA = [1, 2, 3] inB = [4, 0, 1] self.butler.put(butlerTests.MetricsExample(data=inA), "VisitA", dataIdV) self.butler.put(butlerTests.MetricsExample(data=inA), "PatchA", dataIdP) self.butler.put(butlerTests.MetricsExample(data=inB), "VisitB", dataIdV) # dataIdV is correct everywhere, dataIdP should error with self.assertRaises(ValueError): makeQuantum( task, self.butler, dataIdV, { "a": dataIdP, "b": dataIdV, "outA": dataIdV, "outB": dataIdV, }, ) with self.assertRaises(ValueError): makeQuantum( task, self.butler, dataIdP, { "a": dataIdV, "b": dataIdV, "outA": dataIdV, "outB": dataIdV, }, ) # should not accept small changes, either with self.assertRaises(ValueError): makeQuantum( task, self.butler, dataIdV, { "a": dataIdV, "b": dataIdV, "outA": dataIdVExtra, "outB": dataIdV, }, ) with self.assertRaises(ValueError): makeQuantum( task, self.butler, dataIdVExtra, { "a": dataIdV, "b": dataIdV, "outA": dataIdV, "outB": dataIdV, }, )
def __init__(self, **kwargs): PipelineTask.__init__(self, **kwargs) # Bypass VisitTask constructor self.initOut = butlerTests.MetricsExample(data=[1, 2])
def __init__(self, **kwargs): PipelineTask.__init__(self, **kwargs) # Bypass PatchTask constructor self.initOutA = [butlerTests.MetricsExample(data=[1, 2, 4])] self.initOutB = butlerTests.MetricsExample(data=[1, 2, 3])
def __init__(self, **kwargs): super().__init__(**kwargs) self.initOutA = butlerTests.MetricsExample(data=[1, 2, 4]) self.initOutB = butlerTests.MetricsExample(data=[1, 2, 3])
def run(self, a, b): outA = butlerTests.MetricsExample(data=(a.data + b.data)) outB = butlerTests.MetricsExample(data=(a.data * max(b.data))) return Struct(outA=outA, outB=outB)