Files
breeze/tests/account_activity_behavior.zi

220 lines
11 KiB
Ziran

#import "keys"
#import "text_buffer"
#import "byte_text_linux"
#import "authorization"
#import "wire"
#import, file "storage_test_support.zi";
#import, file "../src/app/account_activity.zi";
#import, file "../src/app/account_activity_model.zi";
#import, file "../src/app/activity_start.zi";
#import, file "../src/app/app_types.zi";
#import, file "../src/core/types.zi";
#import, file "../src/storage/sync_state.zi";
#import, file "../src/storage/bundled_app_records.zi";
#import, file "../src/storage/sync_account.zi";
#import, file "../src/storage/account_types.zi";
#import, file "../src/storage/data.zi";
#import, file "../src/storage/state.zi";
#import, file "../src/storage/db.zi";
#import, file "../src/storage/storage_sessions.zi";
#import, file "../src/storage/sql_query.zi";
#import, file "../src/storage/delegate_store.zi";
#import, file "../src/apps/package_files.zi";
#import, file "../src/app/text_buffers.zi";
#import, file "background_audio_stub.zi";
c :: #system_library "c";
FixtureAdvance :: (seconds: s64) #foreign c;
FixtureSchedules :: () -> s32 #foreign c;
FixtureFrame :: () #foreign c;
FixtureQueries :: () -> s32 #foreign c;
fixture_app: InnerBreeze;
WriteControl :: (activity: AccountActivity, id: string, revision: s64, now: s64) {
document: [1024]u8
writer := Writer.{document[:], 0, true}
writer = WriteByte(writer, cast(u8)123)
writer = JsonTextField(writer, "id", id)
writer = WriteByte(writer, cast(u8)44)
writer = JsonTextField(writer, "session_id", TextUntilNul(activity.session_id[:]))
writer = WriteByte(writer, cast(u8)44)
writer = JsonTextField(writer, "device_id", TextUntilNul(activity.device_id[:]))
writer = WriteByte(writer, cast(u8)44)
writer = JsonNumberField(writer, "time", now)
writer = WriteByte(writer, cast(u8)44)
writer = JsonNumberField(writer, "revision", revision)
writer = WriteText(writer, ",\"paused\":1}")
check_true("write control", writer.valid && BundledAppRecordWrite(ActivityControlKey, TextUntilNul(document[:])))
}
ReadStored :: () -> AccountActivity {
value: AccountActivity
document := BundledAppRecordRead(ActivityRecordKey)
check_true("read activity record", ActivityRead(document, *value))
PackageFree(document)
return value
}
#program_export
Check :: () -> s32 {
guard := support_begin("/tmp/inbe-account-activity.")
if guard != 0 {
return guard
}
root := make_root("runner")
check_true("open activity fixture", storage_init(root) != 0)
account: AccountKeys
check_true("generate owner", sync_account_generate(*account) != 0)
check_true("save owner", sync_account_save(*account,
SyncAccountLocalDataChoice.SYNC_ACCOUNT_LOCAL_DATA_ASK) == SyncAccountSaveResult.SYNC_ACCOUNT_SAVE_OK)
storage_set_sync_enabled(1)
fixture_app.breathing.screen = ScreenMeditation
fixture_app.meditation.duration_seconds = 600
fixture_app.meditation.remaining_seconds = 480
ActivityPump(*fixture_app)
first := ReadStored()
check_true("meditation snapshot", first.active == 1 && first.duration == 600 &&
first.remaining == 480 && first.elapsed == 120 && first.paused == 0)
check_true("private activity queued", db_select_int64_text(
"SELECT COUNT(*) FROM sync_outbox WHERE entity_type='cell_record' AND entity_id='cell.lumi.activity.current'", 0) == 1)
check_true("sync scheduled", FixtureSchedules() > 0)
check_true("own session is not remote", !ActivityRemoteVisible())
check_true("fresh activity", ActivityFresh(first, ActivityCurrentTime()))
check_true("stale activity is not fresh", !ActivityFresh(first, first.time + ActivityFreshSeconds + 1))
check_true("future activity is not fresh", !ActivityFresh(first, first.time - 6))
queries_before := FixtureQueries()
for frame: cast(s32)0..cast(s32)11 {
FixtureFrame()
ActivityPump(*fixture_app)
unused ActivityRemoteVisible()
}
check_true("unchanged animation frames perform no activity SQL queries",
FixtureQueries() == queries_before)
fixture_app.breathing.screen = ScreenSunSalutation
fixture_app.sun_salutation.repetitions = 3
FixtureAdvance(1)
ActivityPump(*fixture_app)
sun := ReadStored()
check_true("direct practice switch gets a new session", sun.screen == ScreenSunSalutation &&
TextUntilNul(sun.session_id[:]) != TextUntilNul(first.session_id[:]))
fixture_app.sun_salutation.step = 1
FixtureAdvance(1)
ActivityPump(*fixture_app)
step := ReadStored()
check_true("phase boundary publishes before periodic heartbeat", step.phase == 1 && step.time == sun.time + 1)
fixture_app.breathing.screen = ScreenMeditation
FixtureAdvance(1)
ActivityPump(*fixture_app)
first = ReadStored()
invalid: AccountActivity
check_true("malformed record rejected", !ActivityRead("{\"active\":true}", *invalid))
control_id := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
WriteControl(first, control_id, first.revision, first.time)
FixtureAdvance(1)
ActivityPump(*fixture_app)
paused := ReadStored()
check_true("remote pause applied to originating session", fixture_app.session_paused == 1 && paused.paused == 1 &&
paused.revision == first.revision + 1 && TextUntilNul(paused.control_id[:]) == control_id)
FixtureAdvance(3)
ActivityPump(*fixture_app)
repeated := ReadStored()
check_true("control replay ignored", repeated.revision == paused.revision)
fixture_app.session_paused = 0
FixtureAdvance(1)
ActivityPump(*fixture_app)
resumed := ReadStored()
WriteControl(resumed, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", paused.revision, resumed.time)
FixtureAdvance(1)
ActivityPump(*fixture_app)
check_true("control for old state ignored", fixture_app.session_paused == 0)
WriteControl(resumed, "cccccccccccccccccccccccccccccccc", resumed.revision,
ActivityCurrentTime() - ActivityFreshSeconds - 1)
FixtureAdvance(1)
ActivityPump(*fixture_app)
check_true("delayed offline control ignored", fixture_app.session_paused == 0)
fixture_app.breathing.screen = ScreenStart
FixtureAdvance(1)
ActivityPump(*fixture_app)
ended := ReadStored()
check_true("completion clears active state", ended.active == 0 && TextUntilNul(ended.session_id[:]) == TextUntilNul(first.session_id[:]))
check_int("observer never writes a practice result", storage_session_count(), 0)
fixture_app.breathing.screen = ScreenPatterns
fixture_app.patterns.elapsed_seconds = 91
fixture_app.patterns.duration_minutes = 5
fixture_app.patterns.phase = 2
fixture_app.patterns.cycle = 7
fixture_app.patterns.paused = 1
FixtureAdvance(1)
ActivityPump(*fixture_app)
patterns := ReadStored()
check_true("patterns snapshot retains phase, cycles and pause", patterns.phase == 2 && patterns.cycles == 7 &&
patterns.elapsed == 91 && patterns.remaining == 209 && patterns.paused == 1)
check_true("replacement session has a new identity", TextUntilNul(patterns.session_id[:]) != TextUntilNul(first.session_id[:]))
WriteControl(first, "dddddddddddddddddddddddddddddddd", patterns.revision, ActivityCurrentTime())
FixtureAdvance(1)
fixture_app.patterns.paused = 0
ActivityPump(*fixture_app)
check_true("control cannot reach replacement practice", fixture_app.patterns.paused == 0)
fixture_app.breathing.screen = ScreenStart
FixtureAdvance(1)
ActivityPump(*fixture_app)
remote := first
remote.time = ActivityCurrentTime()
remote.device_id[0] = ifx remote.device_id[0] == cast(u8)97 then cast(u8)98 else cast(u8)97
output: [2048]u8
check_true("serialize remote record", ActivityWrite(remote, output[:]))
check_true("receive remote record", BundledAppRecordWrite(ActivityRecordKey, TextUntilNul(output[:])))
FixtureAdvance(1)
ActivityPump(*fixture_app)
check_true("remote session visible", ActivityRemoteVisible() && !ActivityStartAllowed())
check_true("remote request queued", ActivityRequestPause(*fixture_app, 1))
check_true("duplicate pending control not sent", !ActivityRequestPause(*fixture_app, 1))
FixtureAdvance(ActivityFreshSeconds + 1)
ActivityPump(*fixture_app)
check_true("stale remote session cannot receive control", !ActivityRequestPause(*fixture_app, 0))
// A practice whose device stopped publishing long ago, for example
// because its app closed during it, no longer occupies Practice.
FixtureAdvance(ActivityAbandonedSeconds)
ActivityPump(*fixture_app)
check_true("abandoned remote session leaves Practice", !ActivityRemoteVisible() && ActivityStartAllowed())
// This device's own session left running by a closed app is ended for
// the account's other devices once the app runs again.
leftover := first
leftover.time = ActivityCurrentTime()
leftover.active = 1
check_true("serialize leftover record", ActivityWrite(leftover, output[:]))
check_true("keep leftover record", BundledAppRecordWrite(ActivityRecordKey, TextUntilNul(output[:])))
FixtureAdvance(1)
ActivityPump(*fixture_app)
leftover_document := BundledAppRecordRead(ActivityRecordKey)
ended_leftover: AccountActivity
check_true("own leftover session is ended", ActivityRead(leftover_document, *ended_leftover) &&
ended_leftover.active == 0 && TextUntilNul(ended_leftover.session_id[:]) == TextUntilNul(first.session_id[:]))
PackageFree(leftover_document)
// Another device's session that stopped updating can be ended from here
// for every device; one still updating cannot.
other := remote
other.time = ActivityCurrentTime()
other.active = 1
other.revision = 5
check_true("serialize other record", ActivityWrite(other, output[:]))
check_true("receive other record", BundledAppRecordWrite(ActivityRecordKey, TextUntilNul(output[:])))
FixtureAdvance(1)
ActivityPump(*fixture_app)
check_true("updating session cannot be ended here", ActivityRemoteVisible() && !ActivityEndRemote(*fixture_app))
FixtureAdvance(ActivityFreshSeconds + 1)
ActivityPump(*fixture_app)
check_true("stale session ends for every device", ActivityEndRemote(*fixture_app) && !ActivityRemoteVisible())
ended_document := BundledAppRecordRead(ActivityRecordKey)
ended_other: AccountActivity
check_true("ended record is shared", ActivityRead(ended_document, *ended_other) && ended_other.active == 0 &&
TextUntilNul(ended_other.session_id[:]) == TextUntilNul(other.session_id[:]))
PackageFree(ended_document)
storage_set_sync_data_owner_public_id("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
check_true("switch clears prior remote account", ActivityInitialize() && account_activity.remote.active == 0)
storage_set_sync_enabled(0)
check_true("disconnect removes activity access", !ActivityInitialize() && !ActivityRemoteVisible())
storage_close()
return failures
}