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()) })]