async def test_pending_snapshot_timeout(time: FakeTime, ha: HaSource,
config: Config,
interceptor: RequestInterceptor):
interceptor.setSleep(URL_MATCH_SNAPSHOT_FULL, sleep=5)
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 1)
config.override(Setting.FAILED_SNAPSHOT_TIMEOUT_SECONDS, 1)
config.override(Setting.PENDING_SNAPSHOT_TIMEOUT_SECONDS, 1)
snapshot_immediate: PendingSnapshot = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert isinstance(snapshot_immediate, PendingSnapshot)
assert snapshot_immediate.name() == "Test Name"
assert not ha.check()
assert ha.pending_snapshot is snapshot_immediate
await asyncio.wait({ha._pending_snapshot_task})
assert ha.pending_snapshot is snapshot_immediate
assert ha.check()
assert not ha.check()
time.advance(minutes=1)
assert ha.check()
assert len(await ha.get()) == 0
assert not ha.check()
assert ha.pending_snapshot is None
assert snapshot_immediate.isStale()
async def test_pending_snapshot_nowait(ha: HaSource, time,
supervisor: SimulatedSupervisor,
interceptor: RequestInterceptor,
config: Config):
interceptor.setSleep(URL_MATCH_SNAPSHOT_FULL, sleep=5)
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 0.1)
snapshot_immediate: PendingSnapshot = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert isinstance(snapshot_immediate, PendingSnapshot)
snapshot_pending: HASnapshot = (await ha.get())['pending']
assert isinstance(snapshot_immediate, PendingSnapshot)
assert isinstance(snapshot_pending, PendingSnapshot)
assert snapshot_immediate is snapshot_pending
assert snapshot_immediate.name() == "Test Name"
assert snapshot_immediate.slug() == "pending"
assert not snapshot_immediate.uploadable()
assert snapshot_immediate.snapshotType() == "Full"
assert snapshot_immediate.source() == SOURCE_HA
assert snapshot_immediate.date() == time.now()
assert not snapshot_immediate.protected()
# Might be a little flaky but...whatever
await asyncio.wait({ha._pending_snapshot_task})
snapshots = await ha.get()
assert 'pending' not in snapshots
assert isinstance(next(iter(snapshots.values())), HASnapshot)
return
# ignroe events for now
assert supervisor.getEvents() == [(EVENT_SNAPSHOT_START, {
'snapshot_name':
snapshot_immediate.name(),
'snapshot_time':
str(snapshot_immediate.date())
})]
ha.snapshot_thread.join()
assert supervisor.getEvents() == [(EVENT_SNAPSHOT_START, {
'snapshot_name':
snapshot_immediate.name(),
'snapshot_time':
str(snapshot_immediate.date())
}),
(EVENT_SNAPSHOT_END, {
'completed':
True,
'snapshot_name':
snapshot_immediate.name(),
'snapshot_time':
str(snapshot_immediate.date())
})]
async def test_download_timeout(time, drive: DriveSource, config: Config, interceptor: RequestInterceptor, backup_helper):
config.override(Setting.DOWNLOAD_TIMEOUT_SECONDS, 0.1)
from_backup, data = await backup_helper.createFile()
backup = await drive.save(from_backup, data)
# Verify the uploaded bytes are identical
from_backup.addSource(backup)
interceptor.setSleep(URL_MATCH_FILE, sleep=100)
download = await drive.read(from_backup)
data.position(0)
with pytest.raises(GoogleTimeoutError):
await compareStreams(data, download)
async def test_download_timeout(ha: HaSource, time,
interceptor: RequestInterceptor,
config: Config) -> None:
config.override(Setting.NEW_BACKUP_TIMEOUT_SECONDS, 100)
backup: HABackup = await ha.create(CreateOptions(time.now(), "Test Name"))
from_ha = await ha.harequests.backup(backup.slug())
full = DummyBackup(from_ha.name(), from_ha.date(), from_ha.size(),
from_ha.slug(), "dummy")
full.addSource(backup)
interceptor.setSleep(URL_MATCH_BACKUP_DOWNLOAD, sleep=100)
config.override(Setting.DOWNLOAD_TIMEOUT_SECONDS, 1)
direct_download = await ha.harequests.download(backup.slug())
with pytest.raises(SupervisorTimeoutError):
await direct_download.setup()
await direct_download.read(1)
async def test_pending_backup_nowait(ha: HaSource, time: Time,
supervisor: SimulatedSupervisor,
interceptor: RequestInterceptor,
config: Config, data_cache: DataCache):
interceptor.setSleep(URL_MATCH_BACKUP_FULL, sleep=5)
config.override(Setting.NEW_BACKUP_TIMEOUT_SECONDS, 0.1)
backup_immediate: PendingBackup = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert isinstance(backup_immediate, PendingBackup)
backup_pending: HABackup = (await ha.get())['pending']
assert isinstance(backup_immediate, PendingBackup)
assert isinstance(backup_pending, PendingBackup)
assert backup_immediate is backup_pending
assert backup_immediate.name() == "Test Name"
assert backup_immediate.slug() == "pending"
assert not backup_immediate.uploadable()
assert backup_immediate.backupType() == "Full"
assert backup_immediate.source() == SOURCE_HA
assert backup_immediate.date() == time.now()
assert not backup_immediate.protected()
assert not backup_immediate.ignore()
assert backup_immediate.madeByTheAddon()
assert data_cache.backup("pending") == {
KEY_CREATED: time.now().isoformat(),
KEY_LAST_SEEN: time.now().isoformat(),
KEY_NAME: "Test Name"
}
# Might be a little flaky but...whatever
await asyncio.wait({ha._pending_backup_task})
backups = await ha.get()
assert 'pending' not in backups
assert len(backups) == 1
backup = next(iter(backups.values()))
assert isinstance(backup, HABackup)
assert not backup.ignore()
assert backup.madeByTheAddon()
assert data_cache.backup(
backup.slug())[KEY_LAST_SEEN] == time.now().isoformat()
assert "pending" not in data_cache.backups
return
# ignroe events for now
assert supervisor.getEvents() == [(EVENT_BACKUP_START, {
'backup_name':
backup_immediate.name(),
'backup_time':
str(backup_immediate.date())
})]
ha.backup_thread.join()
assert supervisor.getEvents() == [(EVENT_BACKUP_START, {
'backup_name':
backup_immediate.name(),
'backup_time':
str(backup_immediate.date())
}),
(EVENT_BACKUP_END, {
'completed':
True,
'backup_name':
backup_immediate.name(),
'backup_time':
str(backup_immediate.date())
})]
