async def test_delayed_start_give_up(supervisor: SimulatedSupervisor,
addon_stopper: AddonStopper,
config: Config,
interceptor: RequestInterceptor,
time: FakeTime) -> None:
slug1 = "test_slug_1"
supervisor.installAddon(slug1, "Test decription")
config.override(Setting.STOP_ADDONS, ",".join([slug1]))
addon_stopper.allowRun()
addon_stopper.must_start = set()
assert supervisor.addon(slug1)["state"] == "started"
await addon_stopper.stopAddons("ignore")
assert supervisor.addon(slug1)["state"] == "stopped"
assert getSaved(config) == ({slug1}, set())
# start the addon again, which simluates the supervisor's tendency to report an addon as started right after stopping it.
supervisor.addon(slug1)["state"] = "started"
await addon_stopper.check()
await addon_stopper.startAddons()
assert getSaved(config) == ({slug1}, set())
time.advance(seconds=30)
await addon_stopper.check()
assert getSaved(config) == ({slug1}, set())
time.advance(seconds=30)
await addon_stopper.check()
assert getSaved(config) == ({slug1}, set())
# Should clear saved state after this, since it stops checking after 2 minutes.
time.advance(seconds=100)
await addon_stopper.check()
assert getSaved(config) == (set(), set())
async def test_start_on_boot(ha: HaSource, time,
interceptor: RequestInterceptor, config: Config,
supervisor: SimulatedSupervisor) -> None:
boot_slug = "boot_slug"
supervisor.installAddon(boot_slug,
"Start on boot",
boot=True,
started=False)
no_boot_slug = "no_boot_slug"
supervisor.installAddon(no_boot_slug,
"Don't start on boot",
boot=False,
started=False)
config.override(Setting.STOP_ADDONS, ",".join([boot_slug, no_boot_slug]))
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 0.001)
assert supervisor.addon(boot_slug)["state"] == "stopped"
assert supervisor.addon(no_boot_slug)["state"] == "stopped"
async with supervisor._snapshot_inner_lock:
await ha.create(CreateOptions(time.now(), "Test Name"))
assert supervisor.addon(boot_slug)["state"] == "stopped"
assert supervisor.addon(no_boot_slug)["state"] == "stopped"
await ha._pending_snapshot_task
assert supervisor.addon(boot_slug)["state"] == "started"
assert supervisor.addon(no_boot_slug)["state"] == "stopped"
assert len(await ha.get()) == 1
assert not interceptor.urlWasCalled(URL_MATCH_START_ADDON)
assert not interceptor.urlWasCalled(URL_MATCH_STOP_ADDON)
async def test_cant_reach_refresh_server(drive: DriveSource, server: SimulationServer, config: Config, time):
config.override(Setting.TOKEN_SERVER_HOSTS, "http://lkasdpoiwehjhcty.com")
drive.drivebackend.creds._secret = None
time.advanceDay()
with pytest.raises(CredRefreshMyError) as error:
await drive.get()
assert error.value.data() == {"reason": "Couldn't communicate with lkasdpoiwehjhcty.com"}
async def test_failed_snapshot(time, ha: HaSource,
supervisor: SimulatedSupervisor, config: Config,
interceptor: RequestInterceptor):
# create a blocking snapshot
interceptor.setError(URL_MATCH_SNAPSHOT_FULL, 524)
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 0)
await supervisor.toggleBlockSnapshot()
snapshot_immediate = await ha.create(CreateOptions(time.now(),
"Some Name"))
assert isinstance(snapshot_immediate, PendingSnapshot)
assert snapshot_immediate.name() == "Some Name"
assert not ha.check()
assert not snapshot_immediate.isFailed()
await supervisor.toggleBlockSnapshot()
# let the snapshot attempt to complete
await asyncio.wait({ha._pending_snapshot_task})
# verify it failed with the expected http error
assert snapshot_immediate.isFailed()
assert snapshot_immediate._exception.status == 524
snapshots = list((await ha.get()).values())
assert len(snapshots) == 1
assert snapshots[0] is snapshot_immediate
# verify we can create a new snapshot immediately
interceptor.clear()
await ha.create(CreateOptions(time.now(), "Some Name"))
assert len(await ha.get()) == 1
async def test_only_send_duplicates(time, debug_worker: DebugWorker,
config: Config, global_info: GlobalInfo,
server, error_store: ErrorStore):
config.override(Setting.SEND_ERROR_REPORTS, True)
config.override(Setting.DRIVE_HOST_NAME, "localhost")
global_info.failed(Exception("boom1"))
firstExceptionTime = time.now()
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom1"))
assert report['report']["time"] == firstExceptionTime.isoformat()
# Same exception shouldn't cause us to send the error report again
time.advance(days=1)
global_info.failed(Exception("boom1"))
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom1"))
assert report['report']["time"] == firstExceptionTime.isoformat()
# Btu a new one will send a new report
global_info.failed(Exception("boom2"))
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom2"))
assert report['report']["time"] == time.now().isoformat()
async def test_cred_refresh_upgrade_default_client(drive: DriveSource,
server: SimulationServer,
time: FakeTime,
config: Config):
return
# TODO: Enable this when we start removing the default client_secret
config.override(Setting.DEFAULT_DRIVE_CLIENT_ID,
server.getSetting("drive_client_id"))
creds = server.getCurrentCreds()
creds_with_secret = server.getCurrentCreds()
creds_with_secret._secret = server.getSetting("drive_client_secret")
with open(config.get(Setting.CREDENTIALS_FILE_PATH), "w") as f:
json.dump(creds_with_secret.serialize(), f)
# reload the creds
drive.drivebackend.tryLoadCredentials()
# Verify the "client secret" was removed
with open(config.get(Setting.CREDENTIALS_FILE_PATH)) as f:
saved_creds = json.load(f)
assert saved_creds == creds.serialize()
await drive.get()
old_creds = drive.drivebackend.cred_bearer
await drive.get()
assert old_creds == drive.drivebackend.cred_bearer
time.advanceDay()
await drive.get()
assert old_creds != drive.drivebackend.cred_bearer
async def test_update_ignore(reader: ReaderHelper, time: FakeTime,
coord: Coordinator, config: Config,
supervisor: SimulatedSupervisor, ha: HaSource,
drive: DriveSource):
config.override(Setting.IGNORE_UPGRADE_SNAPSHOTS, True)
config.override(Setting.DAYS_BETWEEN_SNAPSHOTS, 0)
# make an ignored_snapshot
slug = await supervisor.createSnapshot(
{
'name': "Ignore_me",
'folders': ['homeassistant'],
'addons': []
},
date=time.now())
await coord.sync()
assert len(await drive.get()) == 0
assert len(await ha.get()) == 1
assert len(coord.snapshots()) == 1
# Disable Drive Upload
update = {
"ignore": False,
"slug": slug,
}
await reader.postjson("ignore", json=update)
await coord.waitForSyncToFinish()
assert len(coord.snapshots()) == 1
assert len(await drive.get()) == 1
assert len(await ha.get()) == 1
async def test_drive_dns_resolution_error(drive: DriveSource, config: Config,
time):
config.override(Setting.DRIVE_URL,
"http://fsdfsdasdasdf.saasdsdfsdfsd.com:2567")
with pytest.raises(GoogleCantConnect):
await drive.get()
assert time.sleeps == []
async def test_pending_snapshot_replaces_original(
time, ha: HaSource, config: Config, supervisor: SimulatedSupervisor):
# now configure a snapshto to start outside of the addon
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 100)
await supervisor.toggleBlockSnapshot()
with pytest.raises(SnapshotInProgress):
await ha.create(CreateOptions(time.now(), "Ignored"))
snapshot_immediate = (await ha.get())['pending']
await supervisor.toggleBlockSnapshot()
assert isinstance(snapshot_immediate, PendingSnapshot)
assert snapshot_immediate.name() == "Pending Snapshot"
assert ha.check()
assert ha.pending_snapshot is snapshot_immediate
assert await ha.get() == {snapshot_immediate.slug(): snapshot_immediate}
# create a new snapshot behind the scenes, the pending snapshot should get replaced with the new one
slug = (await ha.harequests.createSnapshot({
'name': "Suddenly Appears",
"hardlock": True
}))['slug']
results = await ha.get()
assert len(results) == 1
assert slug in results
assert results[slug].name() == "Suddenly Appears"
assert not results[slug].retained()
async def test_partial_snapshot(ha, time, server, config: Config):
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 100)
for folder in all_folders:
config.override(Setting.EXCLUDE_FOLDERS, folder)
snapshot: HASnapshot = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert snapshot.snapshotType() == "partial"
for search in all_folders:
if search == folder:
assert search not in snapshot.details()['folders']
else:
assert search in snapshot.details()['folders']
for addon in all_addons:
config.override(Setting.EXCLUDE_ADDONS, addon['slug'])
snapshot: HASnapshot = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert snapshot.snapshotType() == "partial"
list_of_addons = []
for included in snapshot.details()['addons']:
list_of_addons.append(included['slug'])
for search in list_of_addons:
if search == addon:
assert search not in list_of_addons
else:
assert search in list_of_addons
# excluding addon/folders that don't exist should actually make a full snapshot
config.override(Setting.EXCLUDE_ADDONS, "none,of.these,are.addons")
config.override(Setting.EXCLUDE_FOLDERS, "not,folders,either")
snapshot: HASnapshot = await ha.create(
CreateOptions(time.now(), "Test Name"))
assert snapshot.snapshotType() == "full"
async def test_failed_backup(time, ha: HaSource,
supervisor: SimulatedSupervisor, config: Config,
interceptor: RequestInterceptor):
# create a blocking backup
interceptor.setError(URL_MATCH_BACKUP_FULL, 524)
config.override(Setting.NEW_BACKUP_TIMEOUT_SECONDS, 0)
await supervisor.toggleBlockBackup()
backup_immediate = await ha.create(CreateOptions(time.now(), "Some Name"))
assert isinstance(backup_immediate, PendingBackup)
assert backup_immediate.name() == "Some Name"
assert not ha.check()
assert not backup_immediate.isFailed()
await supervisor.toggleBlockBackup()
# let the backup attempt to complete
await asyncio.wait({ha._pending_backup_task})
# verify it failed with the expected http error
assert backup_immediate.isFailed()
assert backup_immediate._exception.status == 524
backups = list((await ha.get()).values())
assert len(backups) == 1
assert backups[0] is backup_immediate
# verify we can create a new backup immediately
interceptor.clear()
await ha.create(CreateOptions(time.now(), "Some Name"))
assert len(await ha.get()) == 1
async def test_dont_purge_pending_backup(ha: HaSource, time, config: Config,
supervisor: SimulatedSupervisor,
model: Model, interceptor):
config.override(Setting.MAX_BACKUPS_IN_HA, 4)
await ha.create(CreateOptions(time.now(), "Test Name 1"))
await ha.create(CreateOptions(time.now(), "Test Name 2"))
await ha.create(CreateOptions(time.now(), "Test Name 3"))
await ha.create(CreateOptions(time.now(), "Test Name 4"))
await model.sync(time.now())
config.override(Setting.NEW_BACKUP_TIMEOUT_SECONDS, 0.1)
interceptor.setSleep(URL_MATCH_BACKUP_FULL, sleep=2)
await ha.create(CreateOptions(time.now(), "Test Name"))
backups = list((await ha.get()).values())
assert len(backups) == 5
backup = backups[4]
assert isinstance(backup, PendingBackup)
# no backup should get purged yet because the ending backup isn't considered for purging.
await model.sync(time.now())
backups = list((await ha.get()).values())
assert len(backups) == 5
# Wait for the backup to finish, then verify one gets purged.
await ha._pending_backup_task
await model.sync(time.now())
backups = list((await ha.get()).values())
assert len(backups) == 4
async def test_update_backups_old_names(updater: HaUpdater, server, backup: Backup, time: FakeTime, supervisor: SimulatedSupervisor, config: Config):
config.override(Setting.CALL_BACKUP_SNAPSHOT, True)
await updater.update()
assert not updater._stale()
assert updater._state() == "backed_up"
verifyEntity(supervisor, "binary_sensor.snapshots_stale",
"off", {"friendly_name": "Snapshots Stale",
"device_class": "problem"})
date = '1985-12-06T05:00:00+00:00'
verifyEntity(supervisor, "sensor.snapshot_backup", "backed_up", {
'friendly_name': 'Snapshot State',
'last_snapshot': date,
'snapshots': [{
'date': date,
'name': backup.name(),
'size': backup.sizeString(),
'state': backup.status(),
'slug': backup.slug()
}
],
'snapshots_in_google_drive': 1,
'snapshots_in_home_assistant': 1,
'snapshots_in_hassio': 1,
'size_in_home_assistant': Estimator.asSizeString(backup.size()),
'size_in_google_drive': Estimator.asSizeString(backup.size())
})
async def test_failed_snapshot_retry(ha: HaSource, time: FakeTime,
config: Config,
supervisor: SimulatedSupervisor,
interceptor: RequestInterceptor):
# create a blocking snapshot
interceptor.setError(URL_MATCH_SNAPSHOT_FULL, 524)
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 0)
await supervisor.toggleBlockSnapshot()
snapshot_immediate = await ha.create(CreateOptions(time.now(),
"Some Name"))
assert isinstance(snapshot_immediate, PendingSnapshot)
assert snapshot_immediate.name() == "Some Name"
assert not ha.check()
assert not snapshot_immediate.isFailed()
await supervisor.toggleBlockSnapshot()
# let the snapshot attempt to complete
await asyncio.wait({ha._pending_snapshot_task})
# verify it failed with the expected http error
assert snapshot_immediate.isFailed()
assert snapshot_immediate._exception.status == 524
assert ha.check()
assert not ha.check()
time.advance(seconds=config.get(Setting.FAILED_SNAPSHOT_TIMEOUT_SECONDS))
# should trigger a sync after the failed snapshot timeout
assert ha.check()
await ha.get()
assert not ha.check()
async def test_cant_reach_refresh_server(drive: DriveSource, server: SimulationServer, config: Config, time):
config.override(Setting.REFRESH_URL, "http://lkasdpoiwehjhcty.com")
drive.drivebackend.creds._secret = None
time.advanceDay()
with pytest.raises(CredRefreshMyError) as error:
await drive.get()
assert error.value.data() == {"reason": "Unable to connect to https://habackup.io"}
async def test_dont_purge_pending_snapshot(ha: HaSource, time, config: Config,
supervisor: SimulatedSupervisor,
model: Model, interceptor):
config.override(Setting.MAX_SNAPSHOTS_IN_HASSIO, 4)
await ha.create(CreateOptions(time.now(), "Test Name 1"))
await ha.create(CreateOptions(time.now(), "Test Name 2"))
await ha.create(CreateOptions(time.now(), "Test Name 3"))
await ha.create(CreateOptions(time.now(), "Test Name 4"))
await model.sync(time.now())
config.override(Setting.NEW_SNAPSHOT_TIMEOUT_SECONDS, 0.1)
interceptor.setSleep(URL_MATCH_SNAPSHOT_FULL, sleep=2)
await ha.create(CreateOptions(time.now(), "Test Name"))
snapshots = list((await ha.get()).values())
assert len(snapshots) == 5
snapshot = snapshots[4]
assert isinstance(snapshot, PendingSnapshot)
# no snapshot should get purged yet because the ending snapshot isn't considered for purging.
await model.sync(time.now())
snapshots = list((await ha.get()).values())
assert len(snapshots) == 5
# Wait for the snapshot to finish, then verify one gets purged.
await ha._pending_snapshot_task
await model.sync(time.now())
snapshots = list((await ha.get()).values())
assert len(snapshots) == 4
async def test_purge_before_upload(source: HelperTestSource,
dest: HelperTestSource, time: FakeTime,
model: Model, data_cache: DataCache,
simple_config: Config):
source.setMax(2)
dest.setMax(2)
older = source.insert("older",
time.now() - timedelta(days=7),
slug="older")
oldest = source.insert("oldest",
time.now() - timedelta(days=14),
slug="oldest")
await model.sync(time.now() - timedelta(days=7))
source.allow_create = False
dest.allow_save = False
dest.reset()
source.reset()
# trying to sync now should do nothing.
with pytest.raises(IntentionalFailure):
await model.sync(time.now())
source.assertThat(current=2)
dest.assertThat(current=2)
simple_config.override(Setting.DELETE_BEFORE_NEW_BACKUP, True)
# Trying to sync should delete the backup before syncing and then fail to create a new one.
with pytest.raises(IntentionalFailure):
await model.sync(time.now())
source.assertThat(deleted=1, current=1)
assert oldest.slug() not in (await source.get()).keys()
dest.assertThat(current=2)
# Trying to do it again should do nothing (eg not delete another backup)
with pytest.raises(IntentionalFailure):
await model.sync(time.now())
source.assertThat(deleted=1, current=1)
dest.assertThat(current=2)
# let the new source backup get created, which then deletes the destination but fails to save
source.allow_create = True
with pytest.raises(IntentionalFailure):
await model.sync(time.now())
source.assertThat(deleted=1, current=2, created=1)
dest.assertThat(current=1, deleted=1)
assert oldest.slug() not in (await dest.get()).keys()
# now let the new backup get saved.
dest.allow_save = True
await model.sync(time.now())
source.assertThat(deleted=1, current=2, created=1)
dest.assertThat(current=2, deleted=1, saved=1)
assert oldest.slug() not in (await source.get()).keys()
assert older.slug() in (await source.get()).keys()
assert oldest.slug() not in (await dest.get()).keys()
assert older.slug() in (await dest.get()).keys()
async def test_dont_send_error_report(time, debug_worker: DebugWorker,
config: Config, global_info: GlobalInfo,
server: SimulationServer,
error_store: ErrorStore):
config.override(Setting.SEND_ERROR_REPORTS, False)
config.override(Setting.DRIVE_HOST_NAME, "localhost")
global_info.failed(Exception())
await debug_worker.doWork()
assert error_store.last_error is None
async def test_bad_host(debug_worker: DebugWorker, config: Config):
skipForWindows()
config.override(Setting.DRIVE_HOST_NAME, "dasdfdfgvxcvvsoejbr.com")
await debug_worker.doWork()
assert debug_worker.dns_info == {
'dasdfdfgvxcvvsoejbr.com': {
'dasdfdfgvxcvvsoejbr.com': "Name or service not known"
}
}
async def test_folder_invalid_when_specified(time, drive: DriveSource, config: Config, server):
await drive.get()
config.override(Setting.SPECIFY_SNAPSHOT_FOLDER, "true")
await drive.drivebackend.update(await drive.getFolderId(), {"trashed": True})
time.advanceDay()
with pytest.raises(BackupFolderInaccessible):
await drive.get()
async def test_supervisor_host(ha: HaSource, supervisor: SimulatedSupervisor,
interceptor: RequestInterceptor, config: Config,
server_url):
assert ha.harequests.getSupervisorURL() == server_url
config.override(Setting.SUPERVISOR_URL, "")
assert ha.harequests.getSupervisorURL() == URL("http://hassio")
os.environ['SUPERVISOR_TOKEN'] = "test"
assert ha.harequests.getSupervisorURL() == URL("http://supervisor")
async def test_dns_info(debug_worker: DebugWorker, config: Config):
skipForWindows()
config.override(Setting.SEND_ERROR_REPORTS, True)
config.override(Setting.DRIVE_HOST_NAME, "localhost")
await debug_worker.doWork()
assert debug_worker.dns_info == {
'localhost': {
'127.0.0.1': 'alive',
'localhost': 'alive'
}
}
async def test_empty_name_server(resolver: Resolver, config: Config):
assert resolver._alt_dns.nameservers == ["8.8.8.8", "8.8.4.4"]
assert resolver._resolver is resolver._original_dns
config.override(Setting.ALTERNATE_DNS_SERVERS, "")
resolver.updateConfig()
assert resolver._resolver is resolver._alt_dns
# make sure the value is cached
prev = resolver._alt_dns
resolver.updateConfig()
assert resolver._alt_dns is prev
async def test_ignored_backups(updater: HaUpdater, time: FakeTime, server: SimulationServer, backup: Backup, supervisor: SimulatedSupervisor, coord: Coordinator, config: Config):
config.override(Setting.IGNORE_OTHER_BACKUPS, True)
time.advance(hours=1)
await supervisor.createBackup({'name': "test_backup"}, date=time.now())
await coord.sync()
await updater.update()
state = supervisor.getAttributes("sensor.backup_state")
assert state["backups_in_google_drive"] == 1
assert state["backups_in_home_assistant"] == 1
assert len(state["backups"]) == 1
assert state['last_backup'] == backup.date().isoformat()
async def test_ignored_snapshots(updater: HaUpdater, time: Time,
server: SimulationServer, snapshot,
supervisor: SimulatedSupervisor,
coord: Coordinator, config: Config):
config.override(Setting.IGNORE_OTHER_SNAPSHOTS, True)
await supervisor.createSnapshot({'name': "test_snapshot"}, date=time.now())
await coord.sync()
await updater.update()
state = supervisor.getAttributes("sensor.snapshot_backup")
assert state["snapshots_in_google_drive"] == 1
assert state["snapshots_in_home_assistant"] == 1
assert len(state["snapshots"]) == 2
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_confirm_multiple_deletes(reader, ui_server, server,
config: Config, time: FakeTime,
ha: HaSource):
# reconfigure to only store 1 snapshot
server._options.update({
"max_snapshots_in_hassio": 1,
"max_snapshots_in_google_drive": 1
})
config.override(Setting.MAX_SNAPSHOTS_IN_HASSIO, 1)
config.override(Setting.MAX_SNAPSHOTS_IN_GOOGLE_DRIVE, 1)
# create three snapshots
await ha.create(CreateOptions(time.now(), "Name1"))
await ha.create(CreateOptions(time.now(), "Name2"))
await ha.create(CreateOptions(time.now(), "Name3"))
# verify we have 3 snapshots an the multiple delete error
status = await reader.getjson("sync")
assert len(status['snapshots']) == 3
assert status["last_error"]["error_type"] == ERROR_MULTIPLE_DELETES
assert status["last_error"]["data"] == {
SOURCE_GOOGLE_DRIVE: 0,
SOURCE_HA: 2
}
# request that multiple deletes be allowed
assert await reader.getjson("confirmdelete?always=false") == {
'message': 'Snapshots deleted this one time'
}
assert config.get(Setting.CONFIRM_MULTIPLE_DELETES)
# backup, verify the deletes go through
status = await reader.getjson("sync")
assert status["last_error"] is None
assert len(status["snapshots"]) == 1
# create another snapshot, verify we delete the one
await ha.create(CreateOptions(time.now(), "Name1"))
status = await reader.getjson("sync")
assert len(status['snapshots']) == 1
assert status["last_error"] is None
# create two mroe snapshots, verify we see the error again
await ha.create(CreateOptions(time.now(), "Name1"))
await ha.create(CreateOptions(time.now(), "Name2"))
status = await reader.getjson("sync")
assert len(status['snapshots']) == 3
assert status["last_error"]["error_type"] == ERROR_MULTIPLE_DELETES
assert status["last_error"]["data"] == {
SOURCE_GOOGLE_DRIVE: 0,
SOURCE_HA: 2
}
async def test_expose_extra_server_option(reader, ui_server: UiServer, config: Config):
with pytest.raises(aiohttp.client_exceptions.ClientConnectionError):
await reader.getjson("sync", ingress=False)
config.override(Setting.EXPOSE_EXTRA_SERVER, True)
await ui_server.run()
await reader.getjson("sync", ingress=False)
await ui_server.run()
await reader.getjson("sync", ingress=False)
config.override(Setting.EXPOSE_EXTRA_SERVER, False)
await ui_server.run()
with pytest.raises(aiohttp.client_exceptions.ClientConnectionError):
await reader.getjson("sync", ingress=False)
await reader.getjson("sync")
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(time, drive: DriveSource, config: Config, server: SimulationServer, snapshot_helper):
config.override(Setting.DOWNLOAD_TIMEOUT_SECONDS, 1)
from_snapshot, data = await snapshot_helper.createFile()
snapshot = await drive.save(from_snapshot, data)
# Verify the uploaded bytes are identical
from_snapshot.addSource(snapshot)
server.drive_sleep = 100
download = await drive.read(from_snapshot)
data.position(0)
with pytest.raises(GoogleTimeoutError):
await compareStreams(data, download)
