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)