def test_composites(self):
"""Test components within composite DatasetTypes."""
storageClassA = StorageClass("compA")
storageClassB = StorageClass("compB")
storageClass = StorageClass("test_composite", components={"compA": storageClassA,
"compB": storageClassB})
self.assertTrue(storageClass.isComposite())
self.assertFalse(storageClassA.isComposite())
self.assertFalse(storageClassB.isComposite())
dimensions = self.universe.extract(("instrument", "visit"))
datasetTypeComposite = DatasetType("composite", dimensions, storageClass)
datasetTypeComponentA = datasetTypeComposite.makeComponentDatasetType("compA")
datasetTypeComponentB = datasetTypeComposite.makeComponentDatasetType("compB")
self.assertTrue(datasetTypeComposite.isComposite())
self.assertFalse(datasetTypeComponentA.isComposite())
self.assertTrue(datasetTypeComponentB.isComponent())
self.assertFalse(datasetTypeComposite.isComponent())
self.assertEqual(datasetTypeComposite.name, "composite")
self.assertEqual(datasetTypeComponentA.name, "composite.compA")
self.assertEqual(datasetTypeComponentB.component(), "compB")
self.assertEqual(datasetTypeComposite.nameAndComponent(), ("composite", None))
self.assertEqual(datasetTypeComponentA.nameAndComponent(), ("composite", "compA"))
self.assertEqual(datasetTypeComponentA.parentStorageClass, storageClass)
self.assertEqual(datasetTypeComponentB.parentStorageClass, storageClass)
self.assertIsNone(datasetTypeComposite.parentStorageClass)
def testNameValidation(self):
"""Test that dataset type names only contain certain characters
in certain positions.
"""
dimensions = self.universe.extract(("instrument", "visit"))
goodNames = ("a", "A", "z1", "Z1", "a_1B", "A_1b")
badNames = ("1", "_", "a%b", "B+Z", "T[0]")
# Construct storage class with all the good names included as
# components so that we can test internal consistency
storageClass = StorageClass("test_StructuredData",
components={n: StorageClass("component") for n in goodNames})
for name in goodNames:
composite = DatasetType(name, dimensions, storageClass)
self.assertEqual(composite.name, name)
for suffix in goodNames:
full = DatasetType.nameWithComponent(name, suffix)
component = composite.makeComponentDatasetType(suffix)
self.assertEqual(component.name, full)
self.assertEqual(component.parentStorageClass.name, "test_StructuredData")
for suffix in badNames:
full = DatasetType.nameWithComponent(name, suffix)
with self.subTest(full=full):
with self.assertRaises(ValueError):
DatasetType(full, dimensions, storageClass)
for name in badNames:
with self.subTest(name=name):
with self.assertRaises(ValueError):
DatasetType(name, dimensions, storageClass)
class DatasetRefTestCase(unittest.TestCase):
"""Test for DatasetRef.
"""
def setUp(self):
self.universe = DimensionUniverse()
datasetTypeName = "test"
self.componentStorageClass1 = StorageClass("Component1")
self.componentStorageClass2 = StorageClass("Component2")
self.parentStorageClass = StorageClass("Parent", components={"a": self.componentStorageClass1,
"b": self.componentStorageClass2})
dimensions = self.universe.extract(("instrument", "visit"))
self.dataId = dict(instrument="DummyCam", visit=42)
self.datasetType = DatasetType(datasetTypeName, dimensions, self.parentStorageClass)
def testConstructor(self):
"""Test that construction preserves and validates values.
"""
# Construct an unresolved ref.
ref = DatasetRef(self.datasetType, self.dataId)
self.assertEqual(ref.datasetType, self.datasetType)
self.assertEqual(ref.dataId, self.dataId, msg=ref.dataId)
self.assertIsInstance(ref.dataId, DataCoordinate)
self.assertIsNone(ref.components)
# Constructing an unresolved ref with run and/or components should
# fail.
run = "somerun"
with self.assertRaises(ValueError):
DatasetRef(self.datasetType, self.dataId, run=run)
components = {
"a": DatasetRef(self.datasetType.makeComponentDatasetType("a"), self.dataId, id=2, run=run)
}
with self.assertRaises(ValueError):
DatasetRef(self.datasetType, self.dataId, components=components)
# Passing a data ID that is missing dimensions should fail.
with self.assertRaises(KeyError):
DatasetRef(self.datasetType, {"instrument": "DummyCam"})
# Constructing a resolved ref should preserve run and components,
# as well as everything else.
ref = DatasetRef(self.datasetType, self.dataId, id=1, run=run, components=components)
self.assertEqual(ref.datasetType, self.datasetType)
self.assertEqual(ref.dataId, self.dataId, msg=ref.dataId)
self.assertIsInstance(ref.dataId, DataCoordinate)
self.assertEqual(ref.id, 1)
self.assertEqual(ref.run, run)
self.assertEqual(ref.components, components)
# Constructing a resolved ref with bad component storage classes
# should fail.
with self.assertRaises(ValueError):
DatasetRef(self.datasetType, self.dataId, id=1, run=run, components={"b": components["a"]})
# Constructing a resolved ref with unresolved components should fail.
with self.assertRaises(ValueError):
DatasetRef(self.datasetType, self.dataId, id=1, run=run,
components={"a": components["a"].unresolved()})
# Constructing a resolved ref with bad component names should fail.
with self.assertRaises(ValueError):
DatasetRef(self.datasetType, self.dataId, id=1, run=run,
components={"c": components["a"]})
def testResolving(self):
ref = DatasetRef(self.datasetType, self.dataId, id=1, run="somerun")
unresolvedRef = ref.unresolved()
self.assertIsNotNone(ref.id)
self.assertIsNone(unresolvedRef.id)
self.assertIsNone(unresolvedRef.run)
self.assertIsNone(unresolvedRef.components)
self.assertNotEqual(ref, unresolvedRef)
self.assertEqual(ref.unresolved(), unresolvedRef)
self.assertEqual(ref.datasetType, unresolvedRef.datasetType)
self.assertEqual(ref.dataId, unresolvedRef.dataId)
reresolvedRef = unresolvedRef.resolved(id=1, run="somerun")
self.assertEqual(ref, reresolvedRef)
self.assertEqual(reresolvedRef.unresolved(), unresolvedRef)
self.assertIsNotNone(reresolvedRef.run)
self.assertIsNotNone(reresolvedRef.components)
def testPickle(self):
ref = DatasetRef(self.datasetType, self.dataId, id=1, run="somerun")
s = pickle.dumps(ref)
self.assertEqual(pickle.loads(s), ref)
