Coverage for tests/test_versioning.py: 23%
113 statements
« prev ^ index » next coverage.py v6.5.0, created at 2023-04-04 02:06 -0700
« prev ^ index » next coverage.py v6.5.0, created at 2023-04-04 02:06 -0700
1# This file is part of daf_butler.
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/>.
22import os
23import os.path
24import tempfile
25import unittest
27from lsst.daf.butler.registry.attributes import DefaultButlerAttributeManager
28from lsst.daf.butler.registry.databases.sqlite import SqliteDatabase
29from lsst.daf.butler.registry.interfaces import (
30 Database,
31 IncompatibleVersionError,
32 VersionedExtension,
33 VersionTuple,
34)
35from lsst.daf.butler.registry.versions import ButlerVersionsManager
36from lsst.daf.butler.tests.utils import makeTestTempDir, removeTestTempDir
38TESTDIR = os.path.abspath(os.path.dirname(__file__))
40# Assorted version numbers used throughout the tests
41V_1_0_0 = VersionTuple(major=1, minor=0, patch=0)
42V_1_0_1 = VersionTuple(major=1, minor=0, patch=1)
43V_1_1_0 = VersionTuple(major=1, minor=1, patch=0)
44V_2_0_0 = VersionTuple(major=2, minor=0, patch=0)
45V_2_0_1 = VersionTuple(major=2, minor=0, patch=1)
48class Manager0(VersionedExtension):
49 """Versioned extension implementation for tests."""
51 @classmethod
52 def currentVersions(cls) -> list[VersionTuple]:
53 return []
56class Manager1(VersionedExtension):
57 """Versioned extension implementation for tests."""
59 @classmethod
60 def currentVersions(cls) -> list[VersionTuple]:
61 return [V_1_0_0]
64class Manager1_1(VersionedExtension): # noqa: N801
65 """Versioned extension implementation for tests."""
67 @classmethod
68 def currentVersions(cls) -> list[VersionTuple]:
69 return [V_1_1_0]
72class Manager2(VersionedExtension):
73 """Versioned extension implementation for tests.
75 This extension supports two schema versions.
76 """
78 @classmethod
79 def currentVersions(cls) -> list[VersionTuple]:
80 return [V_1_0_0, V_2_0_0]
82 def newSchemaVersion(self) -> VersionTuple | None:
83 if self._registry_schema_version is None:
84 return V_1_0_0
85 elif self._registry_schema_version.major == 1:
86 return V_1_0_0
87 elif self._registry_schema_version.major == 2:
88 return V_2_0_0
89 else:
90 raise ValueError(f"Unexpected registry_schema_version: {self._registry_schema_version}")
93class SchemaVersioningTestCase(unittest.TestCase):
94 """Tests for schema versioning classes."""
96 def setUp(self):
97 self.root = makeTestTempDir(TESTDIR)
99 def tearDown(self):
100 removeTestTempDir(self.root)
102 def makeEmptyDatabase(self, origin: int = 0) -> Database:
103 _, filename = tempfile.mkstemp(dir=self.root, suffix=".sqlite3")
104 engine = SqliteDatabase.makeEngine(filename=filename)
105 return SqliteDatabase.fromEngine(engine=engine, origin=origin)
107 def test_new_schema(self) -> None:
108 """Test for creating new database schema."""
110 # Check that managers know what schema versions they can make.
111 Manager1.checkNewSchemaVersion(V_1_0_0)
112 Manager2.checkNewSchemaVersion(V_1_0_0)
113 Manager2.checkNewSchemaVersion(V_2_0_0)
114 with self.assertRaises(IncompatibleVersionError):
115 Manager1.checkNewSchemaVersion(V_1_0_1)
116 with self.assertRaises(IncompatibleVersionError):
117 Manager1.checkNewSchemaVersion(V_1_1_0)
118 with self.assertRaises(IncompatibleVersionError):
119 Manager2.checkNewSchemaVersion(V_1_0_1)
121 manager_versions = (
122 ((None, V_1_0_0), (None, V_1_0_0)),
123 ((V_1_0_0, V_1_0_0), (V_1_0_0, V_1_0_0)),
124 ((None, V_1_0_0), (V_2_0_0, V_2_0_0)),
125 )
127 for (v1, result1), (v2, result2) in manager_versions:
128 # This is roughly what RegistryManagerTypes.makeRepo does.
129 if v1 is not None:
130 Manager1.checkNewSchemaVersion(v1)
131 if v2 is not None:
132 Manager2.checkNewSchemaVersion(v2)
133 manager0 = Manager0()
134 manager1 = Manager1(registry_schema_version=v1)
135 manager2 = Manager2(registry_schema_version=v2)
136 self.assertEqual(manager1.newSchemaVersion(), result1)
137 self.assertEqual(manager2.newSchemaVersion(), result2)
139 database = self.makeEmptyDatabase()
140 with database.declareStaticTables(create=True) as context:
141 attributes = DefaultButlerAttributeManager.initialize(database, context)
143 vmgr = ButlerVersionsManager(attributes)
144 vmgr.storeManagersConfig({"manager0": manager0, "manager1": manager1, "manager2": manager2})
146 attr_dict = {key: value for key, value in attributes.items()}
147 expected = {
148 "config:registry.managers.manager0": Manager0.extensionName(),
149 "config:registry.managers.manager1": Manager1.extensionName(),
150 "config:registry.managers.manager2": Manager2.extensionName(),
151 f"version:{Manager1.extensionName()}": str(result1),
152 f"version:{Manager2.extensionName()}": str(result2),
153 }
154 self.assertEqual(attr_dict, expected)
156 def test_existing_schema(self) -> None:
157 """Test for reading manager versions from existing database."""
159 manager_versions = (
160 ((None, V_1_0_0), (None, V_1_0_0)),
161 ((V_1_0_0, V_1_0_0), (V_1_0_0, V_1_0_0)),
162 )
164 for (v1, result1), (v2, result2) in manager_versions:
165 # This is roughly what RegistryManagerTypes.loadRepo does.
166 if v1 is not None:
167 Manager1.checkNewSchemaVersion(v1)
168 if v2 is not None:
169 Manager2.checkNewSchemaVersion(v2)
170 manager0 = Manager0()
171 manager1 = Manager1(registry_schema_version=v1)
172 manager2 = Manager2(registry_schema_version=v2)
174 # Create new schema first.
175 database = self.makeEmptyDatabase()
176 with database.declareStaticTables(create=True) as context:
177 attributes = DefaultButlerAttributeManager.initialize(database, context)
179 vmgr = ButlerVersionsManager(attributes)
180 vmgr.storeManagersConfig({"manager0": manager0, "manager1": manager1, "manager2": manager2})
182 # Switch to reading existing manager configs/versions.
183 with database.declareStaticTables(create=False) as context:
184 attributes = DefaultButlerAttributeManager.initialize(database, context)
186 vmgr = ButlerVersionsManager(attributes)
187 vmgr.checkManagersConfig({"manager0": Manager0, "manager1": Manager1, "manager2": Manager2})
188 versions = vmgr.managerVersions()
190 Manager1.checkCompatibility(result1, database.isWriteable())
191 Manager2.checkCompatibility(result2, database.isWriteable())
193 # Make manager instances using versions from registry.
194 manager0 = Manager1(registry_schema_version=versions.get("manager0"))
195 manager1 = Manager1(registry_schema_version=versions.get("manager1"))
196 manager2 = Manager2(registry_schema_version=versions.get("manager2"))
197 self.assertIsNone(manager0._registry_schema_version)
198 self.assertEqual(manager1._registry_schema_version, result1)
199 self.assertEqual(manager2._registry_schema_version, result2)
201 def test_compatibility(self) -> None:
202 """Test for version compatibility rules."""
204 # Manager, version, update, compatible
205 compat_matrix = (
206 (Manager0, V_1_0_0, False, True),
207 (Manager0, V_1_0_0, True, True),
208 (Manager1, V_1_0_0, False, True),
209 (Manager1, V_1_0_0, True, True),
210 (Manager1, V_1_0_1, False, True),
211 (Manager1, V_1_0_1, True, True),
212 (Manager1, V_1_1_0, False, False),
213 (Manager1, V_1_1_0, True, False),
214 (Manager1, V_2_0_0, False, False),
215 (Manager1, V_2_0_0, True, False),
216 (Manager1_1, V_1_0_0, False, True),
217 (Manager1_1, V_1_0_0, True, False),
218 (Manager1_1, V_1_0_1, False, True),
219 (Manager1_1, V_1_0_1, True, False),
220 (Manager1_1, V_1_1_0, False, True),
221 (Manager1_1, V_1_1_0, True, True),
222 (Manager2, V_1_0_0, False, True),
223 (Manager2, V_1_0_0, True, True),
224 (Manager2, V_1_0_1, False, True),
225 (Manager2, V_1_0_1, True, True),
226 (Manager2, V_1_1_0, False, False),
227 (Manager2, V_1_1_0, True, False),
228 (Manager2, V_2_0_0, False, True),
229 (Manager2, V_2_0_0, True, True),
230 )
232 for Manager, version, update, compatible in compat_matrix:
233 with self.subTest(test=(Manager, version, update, compatible)):
234 if compatible:
235 Manager.checkCompatibility(version, update)
236 else:
237 with self.assertRaises(IncompatibleVersionError):
238 Manager.checkCompatibility(version, update)
241if __name__ == "__main__":
242 unittest.main()