def _load(self):
if not os.path.isfile(self._config.get(Setting.DATA_CACHE_FILE_PATH)):
self._data = {KEY_SNPASHOTS: {}}
else:
with open(self._config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
self._data = json.load(f)
# Check for an upgrade.
if KEY_LAST_VERSION in self._data:
self._last_version = Version.parse(self._data[KEY_LAST_VERSION])
if self.previousVersion != self.currentVersion:
# add an upgrade marker
if KEY_UPGRADES not in self._data:
self._data[KEY_UPGRADES] = []
self._data[KEY_UPGRADES].append({
'prev_version':
str(self.previousVersion),
'new_version':
str(self.currentVersion),
'date':
self._time.now().isoformat()
})
self._data[KEY_LAST_VERSION] = str(self.currentVersion)
self.makeDirty()
self.saveIfDirty()
if self.previousVersion == Version.default(
) and self.currentVersion > Version.parse("0.103"):
self._flags.add(UpgradeFlags.DONT_IGNORE_LEGACY_SNAPSHOTS)
def __init__(self, config: Config, time: Time):
self._config = config
self._data = {}
self._dirty = {}
self._time = time
self._last_version = Version.default()
self._flags = set()
self._load()
def test_broken_versions():
assert Version.parse("") == Version.default()
assert Version.parse(".") == Version.default()
assert Version.parse("empty") == Version.default()
assert Version.parse("no.version.here") == Version.default()
async def test_version_upgrades(time: Time, injector: Injector,
config: Config) -> None:
# Simluate upgrading from an un-tracked version
assert not os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
cache = injector.get(DataCache)
upgrade_time = time.now()
assert cache.previousVersion == Version.default()
assert cache.currentVersion == Version.parse(VERSION)
assert cache.checkFlag(UpgradeFlags.DONT_IGNORE_LEGACY_SNAPSHOTS)
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}]
# Reload the data cache, verify there is no upgrade.
time.advance(days=1)
cache = DataCache(config, time)
assert cache.previousVersion == Version.parse(VERSION)
assert cache.currentVersion == Version.parse(VERSION)
assert not cache.checkFlag(UpgradeFlags.DONT_IGNORE_LEGACY_SNAPSHOTS)
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}]
# simulate upgrading to a new version, verify an upgrade gets identified.
upgrade_version = Version.parse("200")
class UpgradeCache(DataCache):
def __init__(self):
super().__init__(config, time)
@property
def currentVersion(self):
return upgrade_version
cache = UpgradeCache()
assert cache.previousVersion == Version.parse(VERSION)
assert cache.currentVersion == upgrade_version
assert os.path.exists(config.get(Setting.DATA_CACHE_FILE_PATH))
with open(config.get(Setting.DATA_CACHE_FILE_PATH)) as f:
data = json.load(f)
assert data["upgrades"] == [{
"prev_version": str(Version.default()),
"new_version": VERSION,
"date": upgrade_time.isoformat()
}, {
"prev_version": VERSION,
"new_version": str(upgrade_version),
"date": time.now().isoformat()
}]
next_upgrade_time = time.now()
time.advance(days=1)
# Verify version upgrade time queries work as expected
assert cache.getUpgradeTime(Version.parse(VERSION)) == upgrade_time
assert cache.getUpgradeTime(Version.default()) == upgrade_time
assert cache.getUpgradeTime(upgrade_version) == next_upgrade_time
# degenerate case, should never happen but a sensible value needs to be returned
assert cache.getUpgradeTime(Version.parse("201")) == time.now()
def test_default():
assert Version.default() == Version.default()
assert not Version.default() > Version.default()
assert not Version.default() < Version.default()
assert not Version.default() != Version.default()
assert Version.default() >= Version.default()
assert Version.default() <= Version.default()
