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)
