Port habit form, session results and sync server tests to Ziran
This commit is contained in:
1 parent
d1b0652f7d
commit
049d82227e
13 files changed
+1011
-96
No files matched your search
@@ -57,8 +57,11 @@ try {
|
||||
http_proxy: '', https_proxy: '', all_proxy: '',
|
||||
NO_PROXY: '127.0.0.1,localhost', no_proxy: '127.0.0.1,localhost',
|
||||
};
|
||||
const client = spawn(resolve('build/bin/tests/sync_server_test'), [url, root, faultUrl], {
|
||||
stdio: 'inherit', env: clientEnv,
|
||||
// The client is the Ziran program built by tests/sync_server_zi_test.sh.
|
||||
const clientBinary = process.env.SYNC_SERVER_TEST_BIN || resolve('build/sync-server-zi-test/test');
|
||||
const client = spawn(clientBinary, [], {
|
||||
stdio: 'inherit',
|
||||
env: { ...clientEnv, SYNC_TEST_URL: url, SYNC_TEST_FAULT_URL: faultUrl, APP_DATA_ROOT: root },
|
||||
});
|
||||
const status = await new Promise((resolve, reject) => {
|
||||
client.on('error', reject); client.on('exit', resolve);
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
// Application-level hooks the route and modal code calls; tests that reach
|
||||
// them do not need their effects. Built as a separate root so no generated
|
||||
// header declares them twice.
|
||||
|
||||
#program_export "app_leave_practice_config"
|
||||
host_leave_practice_config :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "profile_social_load_friends_cache"
|
||||
host_load_friends_cache :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "profile_social_load_leaderboard_cache"
|
||||
host_load_leaderboard_cache :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "app_request_social_refresh"
|
||||
host_request_social_refresh :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
// The clock the date and time helpers read, from the application host.
|
||||
#import, file "../src/app/app_clock_host.zi";
|
||||
@@ -0,0 +1,110 @@
|
||||
#import "byte_text_linux"
|
||||
#import "drawing_props"
|
||||
#import, file "storage_test_support.zi";
|
||||
#import, file "../src/app/text_buffers.zi";
|
||||
#import, file "../src/app/app_types.zi";
|
||||
#import, file "../src/storage/data.zi";
|
||||
#import, file "../src/storage/db.zi";
|
||||
#import, file "../src/storage/storage_core.zi";
|
||||
#import, file "../src/storage/storage_habits.zi";
|
||||
#import, file "../src/habits/habit_types.zi";
|
||||
#import, file "../src/habits/habit_memory.zi";
|
||||
#import, file "../src/habits/habit_model.zi";
|
||||
#import, file "../src/core/types.zi";
|
||||
#import, file "../src/screens/habits/edit.zi";
|
||||
|
||||
using HabitSyncMode;
|
||||
|
||||
app_state: InnerBreeze;
|
||||
syncs: s32;
|
||||
|
||||
// Application hooks the form calls when it saves.
|
||||
#program_export "app_auto_sync"
|
||||
host_auto_sync :: (app: *InnerBreeze) -> s32 {
|
||||
unused app
|
||||
syncs += 1
|
||||
return 0
|
||||
}
|
||||
|
||||
#program_export "save_settings"
|
||||
host_save_settings :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
|
||||
set_text :: (target: []u8, text: string) {
|
||||
unused AppCopyText(text, target)
|
||||
}
|
||||
|
||||
#program_export
|
||||
Check :: () -> s32 {
|
||||
guard := support_begin("/tmp/inbe-habit-form-zi-test/")
|
||||
if guard != 0 { return guard }
|
||||
root := make_root("habit-form")
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
app_state = InnerBreeze.{}
|
||||
app := *app_state
|
||||
|
||||
habit_edit_begin_new(app)
|
||||
check_int("new habit opens the form", app.breathing.screen, ScreenHabitEdit)
|
||||
check_true("the name starts empty", app.habit_edit.text[0] == cast(u8)0)
|
||||
check_int("no reminder by default", app.habit_edit.reminder_hour, -1)
|
||||
check_int("no schedule by default", app.habit_edit.weekdays, HABIT_SCHEDULE_OFF)
|
||||
check_true("first section open", app.habit_edit.sections[0] != 0)
|
||||
check_true("only the routine sections are open by default",
|
||||
app.habit_edit.sections[1] == 0 && app.habit_edit.sections[2] != 0)
|
||||
|
||||
habit_edit_commit(app)
|
||||
check_true("an empty name keeps the form open", app.habit_edit.active != 0 && app.habit_edit.name_error == 1)
|
||||
check_int("nothing was added", app.habits.count, 0)
|
||||
check_int("nothing was stored", storage_habit_count(), 0)
|
||||
|
||||
set_text(app.habit_edit.text[:], " \t ")
|
||||
habit_edit_commit(app)
|
||||
check_true("a blank name keeps the form open", app.habit_edit.active != 0 && app.habits.count == 0)
|
||||
|
||||
set_text(app.habit_edit.text[:], "Test counter")
|
||||
set_text(app.habit_edit.description[:], "Only for testing")
|
||||
app.habit_edit.counter_enabled = 1
|
||||
app.habit_edit.sync_activity = 3
|
||||
app.habit_edit.weekdays = 31
|
||||
app.habit_edit.reminder_hour = 9
|
||||
habit_edit_commit(app)
|
||||
check_true("a valid habit is added and the form closes", app.habits.count == 1 && app.habit_edit.active == 0)
|
||||
check_int("the habit is stored", storage_habit_count(), 1)
|
||||
check_int("sync ran once", syncs, 1)
|
||||
check_int("counter enabled", app.habits.items[0].counter_enabled, 1)
|
||||
check_int("linked activities", app.habits.items[0].sync_activity, 3)
|
||||
check_int("linking is independent of the counter", app.habits.items[0].sync_mode, 1)
|
||||
check_int("weekdays", app.habits.items[0].weekdays, 31)
|
||||
check_int("reminder", app.habits.items[0].reminder_hour, 9)
|
||||
check_true("description", TextFromCString(*app.habits.items[0].description[0]) == "Only for testing")
|
||||
|
||||
habit_edit_begin_new(app)
|
||||
set_text(app.habit_edit.text[:], "Test counter")
|
||||
habit_edit_commit(app)
|
||||
check_true("a duplicate name is refused", app.habit_edit.active != 0 && app.habit_edit.name_error == 2 && app.habits.count == 1)
|
||||
habit_edit_cancel(app)
|
||||
check_int("cancelling stores nothing", storage_habit_count(), 1)
|
||||
check_int("cancelling returns to the overview", app.habits.screen_mode, HABITS_SCREEN_OVERVIEW)
|
||||
|
||||
habit_edit_begin(app, 0)
|
||||
check_true("editing opens the form for the habit", app.breathing.screen == ScreenHabitEdit && app.habit_edit.is_new == 0)
|
||||
check_true("the form shows the habit's settings", app.habit_edit.counter_enabled != 0 && app.habit_edit.sync_activity == 3)
|
||||
set_text(app.habit_edit.text[:], "Unsaved edit")
|
||||
habit_edit_cancel(app)
|
||||
check_true("cancelling an edit keeps the habit", TextFromCString(*app.habits.items[0].name[0]) == "Test counter")
|
||||
|
||||
habit_edit_begin(app, 0)
|
||||
app.habit_edit.counter_enabled = 0
|
||||
app.habit_edit.weekdays = 0
|
||||
app.habit_edit.reminder_hour = -1
|
||||
habit_edit_commit(app)
|
||||
check_true("turning the counter off leaves the linking alone",
|
||||
app.habits.items[0].counter_enabled == 0 && app.habits.items[0].sync_activity == 3)
|
||||
check_true("the schedule and reminder are cleared",
|
||||
app.habits.items[0].weekdays == 0 && app.habits.items[0].reminder_hour == -1)
|
||||
check_int("sync ran for the edit", syncs, 2)
|
||||
habits_free(*app.habits)
|
||||
storage_close()
|
||||
return failures
|
||||
}
|
||||
Executable
+44
@@ -0,0 +1,44 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
# Storage import/export and migration behaviour, run against a real
|
||||
# SQLite database in a temporary directory.
|
||||
root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
ziran=${1:-"$root/build/ziran-toolchain/bin/ziran"}
|
||||
liboqs=${2:-"$root/vendor-builds/linux/x86_64/inbe-liboqs/lib/liboqs.a"}
|
||||
work=$root/build/habit-form-zi-test
|
||||
include=$root/build/packages/ziran/include
|
||||
|
||||
rm -rf "$work"
|
||||
mkdir -p "$work/generated"
|
||||
"$ziran" build --target=c --define PLATFORM_DESKTOP --root "$root/tests" \
|
||||
--module-path "$root/src" \
|
||||
--module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/kryon/src/kss" \
|
||||
--module-path "$root/build/packages/kryon/src/backend" \
|
||||
--module-path "$root/build/packages/game2d/src" \
|
||||
--module-path "$root/build/packages/ziran/std" \
|
||||
--module-path "$root/build/packages/daochi-client" \
|
||||
--entry habit_form_behavior:Check \
|
||||
-o "$work/generated" "$root/tests/habit_form_behavior.zi" \
|
||||
"$root/tests/sync_test_host.zi"
|
||||
cat > "$work/generated/main.c" <<'C'
|
||||
#include "habit_form_behavior.h"
|
||||
#include <stdio.h>
|
||||
int main(void)
|
||||
{
|
||||
int result = Check();
|
||||
if (result != 0) fprintf(stderr, "check failed with code %d\n", result);
|
||||
return result == 0 ? 0 : 1;
|
||||
}
|
||||
C
|
||||
"${CC:-cc}" -std=c11 -O0 -ffunction-sections -fdata-sections \
|
||||
-I"$include" -I"$work/generated" -I"$root/vendor-builds/sqlite" \
|
||||
-I"$root/vendor-builds/linux/x86_64/inbe-liboqs/include" \
|
||||
"$work/generated"/*.c "$root/vendor-builds/sqlite/sqlite3.c" "$liboqs" \
|
||||
-Wl,--gc-sections -ldl -lpthread -lz -lm -o "$work/test"
|
||||
# Storage must never open the real data directory.
|
||||
APP_DATA_ROOT=/tmp/inbe-habit-form-zi-test/data
|
||||
export APP_DATA_ROOT
|
||||
env -u DISPLAY -u WAYLAND_DISPLAY "$work/test"
|
||||
rm -rf /tmp/inbe-habit-form-zi-test
|
||||
@@ -21,7 +21,8 @@ mkdir -p "$work/generated"
|
||||
--module-path "$root/build/packages/daochi-client" \
|
||||
--entry habit_sessions_behavior:Check \
|
||||
-o "$work/generated" "$root/tests/habit_sessions_behavior.zi" \
|
||||
"$root/tests/sync_test_host.zi"
|
||||
"$root/tests/sync_test_host.zi" \
|
||||
"$root/tests/app_hooks_host.zi"
|
||||
cat > "$work/generated/main.c" <<'C'
|
||||
#include "habit_sessions_behavior.h"
|
||||
#include <stdio.h>
|
||||
|
||||
@@ -1,44 +1,143 @@
|
||||
#import "byte_text_linux"
|
||||
#import, file "storage_test_support.zi";
|
||||
#import, file "../src/app/text_buffers.zi";
|
||||
#import, file "../src/app/app_types.zi";
|
||||
#import, file "../src/app/exercise_types.zi";
|
||||
#import, file "../src/storage/data.zi";
|
||||
#import, file "../src/storage/db.zi";
|
||||
#import, file "../src/storage/storage_core.zi";
|
||||
#import, file "../src/storage/storage_sessions.zi";
|
||||
#import, file "../src/storage/session_mood.zi";
|
||||
#import, file "../src/habits/habit_types.zi";
|
||||
#import, file "../src/habits/habit_memory.zi";
|
||||
#import, file "../src/habits/habit_model.zi";
|
||||
#import, file "../src/core/types.zi";
|
||||
#import, file "../src/app/audio_meter_host.zi";
|
||||
#import, file "../src/app/music_library_host.zi";
|
||||
#import, file "../src/platform/notification_host.zi";
|
||||
#import, file "../src/practices/session_results.zi";
|
||||
#import, file "../src/practices/meditation/meditation_practice.zi";
|
||||
#import, file "../src/practices/meditation/meditation_session.zi";
|
||||
|
||||
using ExerciseType;
|
||||
c :: #system_library "c";
|
||||
pause_microseconds :: (microseconds: u32) -> s32 #foreign c "usleep";
|
||||
|
||||
app_state: InnerBreeze;
|
||||
|
||||
// Effects outside the session-result rules; finishing a meditation asks for
|
||||
// a sync directly.
|
||||
#program_export "app_auto_sync"
|
||||
host_auto_sync :: (app: *InnerBreeze) -> s32 {
|
||||
unused app
|
||||
return 1
|
||||
}
|
||||
#program_export "save_settings"
|
||||
host_save_settings :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
#program_export "app_play_bell_cue"
|
||||
host_play_bell_cue :: (app: *InnerBreeze, volume: float32) {
|
||||
unused app
|
||||
unused volume
|
||||
}
|
||||
#program_export "meditation_music_start_session"
|
||||
host_music_start :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
#program_export "meditation_music_stop"
|
||||
host_music_stop :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
#program_export "meditation_music_fade_out"
|
||||
host_music_fade :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
#program_export "practice_background_start"
|
||||
host_background_start :: (app: *InnerBreeze, id: s32) {
|
||||
unused app
|
||||
unused id
|
||||
}
|
||||
#program_export "practice_active_background_stop"
|
||||
host_background_stop :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
#program_export "app_notifications_send_session_complete"
|
||||
host_notify_complete :: (app: *InnerBreeze) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export
|
||||
Answer :: () -> s32 {
|
||||
app: InnerBreeze
|
||||
app.results_scroll = 81
|
||||
detail: [4]u8 = .{97, 98, 99, 0}
|
||||
path: [5]u8 = .{115, 97, 118, 101, 0}
|
||||
rounds: [14]s32
|
||||
index: s32 = 0
|
||||
while index < 14 {
|
||||
rounds[index] = index + 1
|
||||
index += 1
|
||||
}
|
||||
app_prepare_session_results(*app, EXERCISE_PATTERNS, 72, 3,
|
||||
*detail[0], *rounds[0], 14, *path[0])
|
||||
if app.session_result.active != 1 ||
|
||||
app.session_result.activity != EXERCISE_PATTERNS ||
|
||||
app.session_result.primary_value != 72 ||
|
||||
app.session_result.secondary_value != 3 ||
|
||||
app.session_result.round_count != 12 ||
|
||||
app.session_result.round_values[11] != 12 ||
|
||||
app.session_result.detail[2] != 99 ||
|
||||
app.session_result.saved != 1 ||
|
||||
app.session_result.path[3] != 101 ||
|
||||
app.results_scroll != 0 {
|
||||
return 1
|
||||
}
|
||||
app.session_result.write_failed = 1
|
||||
app_prepare_session_results(*app, 99, 0, 0, null, null, 0, null)
|
||||
if app.session_result.activity != EXERCISE_WIM_HOF ||
|
||||
app.session_result.saved != 0 ||
|
||||
app.session_result.write_failed != 0 ||
|
||||
app.session_result.round_count != 0 ||
|
||||
app.session_result.detail[0] != 0 ||
|
||||
app.session_result.path[0] != 0 {
|
||||
return 2
|
||||
}
|
||||
return 42
|
||||
Check :: () -> s32 {
|
||||
guard := support_begin("/tmp/inbe-session-results-zi-test/")
|
||||
if guard != 0 { return guard }
|
||||
root := make_root("session-results")
|
||||
rounds: [1]s32 = .[60]
|
||||
id: [64]u8
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
app_state = InnerBreeze.{}
|
||||
app := *app_state
|
||||
|
||||
check_true("save the session", storage_save_session_for_activity(*rounds[0], 1, 0, 1, *id[0], 64) != 0)
|
||||
app_prepare_session_results(app, 1, 60, 0, null, null, 0, *id[0])
|
||||
app.session_result.mood = 4
|
||||
app_state.breathing.screen = ScreenResults
|
||||
// With storage unavailable the write fails and the results stay open.
|
||||
storage_close()
|
||||
session_result_done(app)
|
||||
check_true("a failed write keeps the results open",
|
||||
app.session_result.active != 0 && app.session_result.write_failed != 0)
|
||||
check_true("the mood is kept and nothing else happens",
|
||||
app.session_result.mood == 4 && app.breathing.screen != ScreenStart && !app.ui.sync_requested)
|
||||
check_true("reopen db", storage_init(root) != 0)
|
||||
session_result_done(app)
|
||||
check_true("done closes the results, leaves and asks for a sync",
|
||||
app.session_result.active == 0 && app.breathing.screen == ScreenStart && app.ui.sync_requested)
|
||||
app.ui.sync_requested = false
|
||||
session_result_done(app)
|
||||
check_true("done again does nothing", !app.ui.sync_requested)
|
||||
|
||||
app_prepare_session_results(app, 2, 3, 0, null, null, 0, *id[0])
|
||||
storage_close()
|
||||
session_result_discard(app)
|
||||
check_true("a failed discard keeps the results open",
|
||||
app.session_result.active != 0 && app.session_result.write_failed != 0)
|
||||
check_true("reopen db again", storage_init(root) != 0)
|
||||
app_state.breathing.screen = ScreenResults
|
||||
session_result_discard(app)
|
||||
check_true("discard closes the results, leaves and asks for a sync",
|
||||
app.session_result.active == 0 && app.breathing.screen == ScreenStart && app.ui.sync_requested)
|
||||
check_int("the discarded session is gone", storage_session_count(), 0)
|
||||
app.ui.sync_requested = false
|
||||
session_result_discard(app)
|
||||
check_true("discard again does nothing", !app.ui.sync_requested)
|
||||
|
||||
app_prepare_session_results(app, 0, 60, 0, null, null, 0, null)
|
||||
session_result_done(app)
|
||||
check_true("results without a saved session close", app.session_result.active == 0)
|
||||
|
||||
// A timed meditation saves once when it ends. Session ids come from the
|
||||
// start time and rounds, so wait out the second the discarded one used.
|
||||
unused pause_microseconds(1100000)
|
||||
// A timed meditation saves once when it ends.
|
||||
app.meditation.duration_mode = 5
|
||||
app.meditation.custom_minutes = 1
|
||||
meditation_start_configured(app)
|
||||
check_int("configured length", app.meditation.remaining_seconds, 60)
|
||||
meditation_advance_elapsed(app, 1500)
|
||||
check_int("time passes", app.meditation.remaining_seconds, 59)
|
||||
app.session_paused = 1
|
||||
meditation_advance_elapsed(app, 30000)
|
||||
check_int("paused time does not count", app.meditation.remaining_seconds, 59)
|
||||
app.session_paused = 0
|
||||
meditation_advance_elapsed(app, 59000)
|
||||
check_true("finishing shows the results", app.breathing.screen == ScreenResults)
|
||||
check_int("the session was saved", storage_session_count(), 1)
|
||||
check_true("results record the saved session",
|
||||
app.session_result.saved != 0 && app.session_result.primary_value == 60)
|
||||
meditation_advance_elapsed(app, 60000)
|
||||
check_int("nothing more is saved", storage_session_count(), 1)
|
||||
app.session_result.mood = 4
|
||||
session_result_done(app)
|
||||
check_true("done returns to the start", app.breathing.screen == ScreenStart && app.session_result.active == 0)
|
||||
storage_close()
|
||||
return failures
|
||||
}
|
||||
Regular → Executable
+37
-33
@@ -1,41 +1,45 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
# Storage import/export and migration behaviour, run against a real
|
||||
# SQLite database in a temporary directory.
|
||||
root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
bin=${1:-"$root/build/ziran-toolchain/bin"}
|
||||
work=$(mktemp -d "$root/build/session-results-test.XXXXXX")
|
||||
trap 'rm -rf "$work"' EXIT HUP INT TERM
|
||||
source=$root/tests/session_results_behavior.zi
|
||||
ziran=${1:-"$root/build/ziran-toolchain/bin/ziran"}
|
||||
liboqs=${2:-"$root/vendor-builds/linux/x86_64/inbe-liboqs/lib/liboqs.a"}
|
||||
work=$root/build/session-results-zi-test
|
||||
include=$root/build/packages/ziran/include
|
||||
|
||||
"$bin/zi2zir" --check-only --root "$root/tests" \
|
||||
--module-path "$root/src" --module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/ziran/std" "$source"
|
||||
"$bin/zi2c" --no-main --root "$root/tests" \
|
||||
--module-path "$root/src" --module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/ziran/std" -o "$work/c" "$source"
|
||||
cat > "$work/c/main.c" <<'C'
|
||||
rm -rf "$work"
|
||||
mkdir -p "$work/generated"
|
||||
"$ziran" build --target=c --define PLATFORM_DESKTOP --root "$root/tests" \
|
||||
--module-path "$root/src" \
|
||||
--module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/kryon/src/kss" \
|
||||
--module-path "$root/build/packages/kryon/src/backend" \
|
||||
--module-path "$root/build/packages/game2d/src" \
|
||||
--module-path "$root/build/packages/ziran/std" \
|
||||
--module-path "$root/build/packages/daochi-client" \
|
||||
--entry session_results_behavior:Check \
|
||||
-o "$work/generated" "$root/tests/session_results_behavior.zi" \
|
||||
"$root/tests/app_hooks_host.zi" "$root/tests/clock_host.zi"
|
||||
cat > "$work/generated/main.c" <<'C'
|
||||
#include "session_results_behavior.h"
|
||||
int main(void) { return Answer() == 42 ? 0 : 1; }
|
||||
#include <stdio.h>
|
||||
int main(void)
|
||||
{
|
||||
int result = Check();
|
||||
if (result != 0) fprintf(stderr, "check failed with code %d\n", result);
|
||||
return result == 0 ? 0 : 1;
|
||||
}
|
||||
C
|
||||
"${CC:-cc}" -std=c11 -ffunction-sections -fdata-sections \
|
||||
-Wl,--gc-sections -I"$root/build/packages/ziran/include" \
|
||||
-I"$work/c" "$work/c"/*.c -o "$work/test"
|
||||
"${CC:-cc}" -std=c11 -O0 -ffunction-sections -fdata-sections \
|
||||
-I"$include" -I"$work/generated" -I"$root/vendor-builds/sqlite" \
|
||||
-I"$root/vendor-builds/linux/x86_64/inbe-liboqs/include" \
|
||||
"$work/generated"/*.c "$root/vendor-builds/sqlite/sqlite3.c" "$liboqs" \
|
||||
"$root/vendor-builds/linux/x86_64/raylib/libraylib.a" \
|
||||
-Wl,--gc-sections -ldl -lpthread -lz -lm -latomic -o "$work/test"
|
||||
# Storage must never open the real data directory.
|
||||
APP_DATA_ROOT=/tmp/inbe-session-results-zi-test/data
|
||||
export APP_DATA_ROOT
|
||||
env -u DISPLAY -u WAYLAND_DISPLAY "$work/test"
|
||||
|
||||
flow=$root/tests/session_results_flow_behavior.zi
|
||||
"$bin/zi2zir" --check-only --root "$root/tests" \
|
||||
--module-path "$root/src" --module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/ziran/std" "$flow"
|
||||
"$bin/zi2c" --no-main --root "$root/tests" \
|
||||
--module-path "$root/src" --module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/ziran/std" -o "$work/flow" "$flow"
|
||||
cat > "$work/flow/main.c" <<'C'
|
||||
#include "session_results_flow_behavior.h"
|
||||
int main(void) { return Answer() == 42 ? 0 : 1; }
|
||||
C
|
||||
"${CC:-cc}" -std=c11 -ffunction-sections -fdata-sections \
|
||||
-Wl,--gc-sections -I"$root/build/packages/ziran/include" \
|
||||
-I"$work/flow" "$work/flow"/*.c \
|
||||
"$root/tests/session_results_flow_host.c" -o "$work/flow-test"
|
||||
env -u DISPLAY -u WAYLAND_DISPLAY "$work/flow-test"
|
||||
echo "Session results Ziran test passed"
|
||||
rm -rf /tmp/inbe-session-results-zi-test
|
||||
@@ -507,6 +507,26 @@ test_meditation_logs_feed_profile_stats :: () {
|
||||
storage_close()
|
||||
}
|
||||
|
||||
// Habit ids that are full UUIDs load intact, with their days.
|
||||
test_uuid_habit_ids_load_days :: () {
|
||||
root := make_root("uuid-habit-load")
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
storage_close()
|
||||
raw_exec(root, "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('940dd8b7-0d60-48ce-9c8f-433b9170b6b1',(SELECT id FROM users LIMIT 1),'Meditation',1,2,3,0,0,1,0,0,1782200000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('940dd8b7-0d60-48ce-9c8f-433b9170b6b1',20260629,1,1,0,1782200000);")
|
||||
check_true("reopen db", storage_init(root) != 0)
|
||||
habits_b = Habits.{}
|
||||
check_true("load habits", storage_habits_load(cast(*void)*habits_b) != 0)
|
||||
check_int("habit count", habits_b.count, 1)
|
||||
check_true("uuid id is not truncated",
|
||||
TextFromCString(*habits_b.items[0].id[0]) == "940dd8b7-0d60-48ce-9c8f-433b9170b6b1")
|
||||
check_int("habit day loaded", habits_b.items[0].day_count, 1)
|
||||
if habits_b.items[0].day_count > 0 {
|
||||
check_int("habit day date", habits_b.items[0].days[0].day_index, 20260629)
|
||||
}
|
||||
habits_free(*habits_b)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
#program_export
|
||||
Check :: () -> s32 {
|
||||
guard := support_begin("/tmp/inbe-storage-habits-zi-test/")
|
||||
@@ -523,5 +543,6 @@ Check :: () -> s32 {
|
||||
test_linked_counts_materialize()
|
||||
test_existing_sessions_materialize()
|
||||
test_meditation_logs_feed_profile_stats()
|
||||
test_uuid_habit_ids_load_days()
|
||||
return failures
|
||||
}
|
||||
@@ -12,6 +12,7 @@
|
||||
#import, file "../src/habits/habit_types.zi";
|
||||
#import, file "../src/habits/habit_memory.zi";
|
||||
#import, file "../src/storage/storage_habits.zi";
|
||||
#import, file "../src/storage/sync_review.zi";
|
||||
#import, file "../src/habits/habit_model.zi";
|
||||
|
||||
c :: #system_library "c";
|
||||
@@ -653,6 +654,223 @@ test_fresh_account_bootstraps_without_tombstones :: () {
|
||||
storage_close()
|
||||
}
|
||||
|
||||
// ---- Full snapshots and the review flow ----------------------------------
|
||||
|
||||
remote_records_text: TextBuffer;
|
||||
|
||||
// The records a remote device would send: its own database seeded with `sql`
|
||||
// and every row queued for upload.
|
||||
remote_records :: (name: string, sql: string) {
|
||||
root := make_root(name)
|
||||
check_true("init remote device", storage_init(root) != 0)
|
||||
set_account()
|
||||
storage_close()
|
||||
raw_exec(root, sql)
|
||||
raw_exec(root, "DELETE FROM sync_outbox;INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'habit',id,0,1782300000 FROM habits;INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'habit_day',habit_id,local_date,1782300000 FROM habit_days;INSERT INTO sync_outbox(entity_type,entity_id,local_date,queued_at) SELECT 'session',id,0,1782300000 FROM sessions;")
|
||||
check_true("reopen remote device", storage_init(root) != 0)
|
||||
check_true("remote payload builds", build_payload())
|
||||
remote_records_text = TextBuffer.{}
|
||||
append(*remote_records_text, records_array())
|
||||
storage_close()
|
||||
}
|
||||
|
||||
snapshot_buffer: TextBuffer;
|
||||
|
||||
// A server response asking the client to take a full snapshot.
|
||||
snapshot_response :: (version: s32, hash: string) -> string {
|
||||
part: [24]u8
|
||||
snapshot_buffer = TextBuffer.{}
|
||||
append(*snapshot_buffer, "{\"protocol_version\":6,\"status\":\"ok\",\"server_version\":")
|
||||
append(*snapshot_buffer, FormatInteger(cast(s64)version, part[:]))
|
||||
append(*snapshot_buffer, ",\"server_state_hash\":\"")
|
||||
append(*snapshot_buffer, hash)
|
||||
append(*snapshot_buffer, "\",\"full_snapshot_required\":true,\"changes_complete\":false,\"changes\":{\"encrypted_records\":")
|
||||
append(*snapshot_buffer, TextFromCString(*remote_records_text.bytes[0]))
|
||||
append(*snapshot_buffer, "}}")
|
||||
return TextFromCString(*snapshot_buffer.bytes[0])
|
||||
}
|
||||
|
||||
REMOTE_SQL :: "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('remote-habit',(SELECT id FROM users LIMIT 1),'Remote Breath',90,80,70,0,0,1,1,0,1782290000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('remote-habit',20260624,1,7,0,1782290000);INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('remote-session',(SELECT id FROM users LIMIT 1),1782290000,20260624,2,2,'sync-test',1782290000,'202',0,1782290000);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('remote-session',0,55);"
|
||||
|
||||
LOCAL_SQL :: "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('local-habit',(SELECT id FROM users LIMIT 1),'Local Breath',10,20,30,0,0,1,1,0,1782300000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('local-habit',20260624,1,4,0,1782300000);INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('local-session',(SELECT id FROM users LIMIT 1),1782300000,20260624,1,1,'test',1782300000,'101',0,1782300000);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('local-session',0,40);"
|
||||
|
||||
LOCAL_PENDING_SQL :: "INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('habit','local-habit',0,1782300000);INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('habit_day','local-habit',20260624,1782300000);INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('session','local-session',0,1782300000);"
|
||||
|
||||
// A local device with its own data and (optionally) everything queued.
|
||||
local_device :: (name: string, seed: string, pending: string) -> string {
|
||||
root := make_root(name)
|
||||
check_true("init local device", storage_init(root) != 0)
|
||||
set_account()
|
||||
storage_close()
|
||||
raw_exec(root, seed)
|
||||
if pending.count > 0 { raw_exec(root, pending) }
|
||||
check_true("reopen local device", storage_init(root) != 0)
|
||||
return root
|
||||
}
|
||||
|
||||
// Starts an upload, so the pending changes are "in flight" when the server
|
||||
// answers.
|
||||
mark_pending_payload_in_flight :: () {
|
||||
check_true("pending payload builds", build_payload())
|
||||
}
|
||||
|
||||
count_of :: (root: string, sql: string) -> s32 {
|
||||
return read_db_count(sql)
|
||||
}
|
||||
|
||||
test_snapshot_with_pending_local_edits_merges :: () {
|
||||
remote_records("review-remote-1", REMOTE_SQL)
|
||||
root := local_device("review-pending", LOCAL_SQL, LOCAL_PENDING_SQL)
|
||||
mark_pending_payload_in_flight()
|
||||
check_true("apply the snapshot", storage_apply_sync_response_json(snapshot_response(12, "remote-hash-001")) != 0)
|
||||
check_true("review is not pending for local edits", storage_sync_review_pending() == 0)
|
||||
check_int("local session kept", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='local-session'"), 1)
|
||||
check_int("remote session merged", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='remote-session'"), 1)
|
||||
check_int("local habit kept", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='local-habit'"), 1)
|
||||
check_int("remote habit merged", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='remote-habit'"), 1)
|
||||
check_int("pending edits cleared after the accepted sync", count_of(root, "SELECT COUNT(*) FROM sync_outbox"), 0)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_tiny_pending_snapshot_merges :: () {
|
||||
remote_records("review-remote-tiny", "INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('tiny-remote-session',(SELECT id FROM users LIMIT 1),1782290300,20260624,1,1,'sync-test',1782290300,'404',0,1782290300);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('tiny-remote-session',0,55);")
|
||||
root := local_device("review-tiny", "INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('tiny-local-session',(SELECT id FROM users LIMIT 1),1782300000,20260624,1,1,'test',1782300000,'101',0,1782300000);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('tiny-local-session',0,40);", "INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('session','tiny-local-session',0,1782300000);")
|
||||
mark_pending_payload_in_flight()
|
||||
check_true("apply the snapshot", storage_apply_sync_response_json(snapshot_response(15, "remote-hash-tiny-session")) != 0)
|
||||
check_true("review is not pending", storage_sync_review_pending() == 0)
|
||||
check_int("local session kept", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='tiny-local-session'"), 1)
|
||||
check_int("remote session merged", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='tiny-remote-session'"), 1)
|
||||
check_int("outbox cleared", count_of(root, "SELECT COUNT(*) FROM sync_outbox"), 0)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_local_habit_without_activity_does_not_force_review :: () {
|
||||
remote_records("review-remote-2", REMOTE_SQL)
|
||||
root := local_device("review-empty-habit", "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('empty-local-habit',(SELECT id FROM users LIMIT 1),'Empty Habit',10,20,30,0,0,1,1,0,1782300000);", "INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('habit','empty-local-habit',0,1782300000);")
|
||||
mark_pending_payload_in_flight()
|
||||
check_true("apply the snapshot", storage_apply_sync_response_json(snapshot_response(12, "remote-hash-001")) != 0)
|
||||
check_true("review is not pending", storage_sync_review_pending() == 0)
|
||||
check_int("remote session applied", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='remote-session'"), 1)
|
||||
check_int("remote habit applied", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='remote-habit'"), 1)
|
||||
check_int("outbox cleared", count_of(root, "SELECT COUNT(*) FROM sync_outbox"), 0)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
// The review works on the visible differences of a snapshot; rows the
|
||||
// server marks deleted are not among them.
|
||||
test_review_ignores_deleted_remote_rows :: () {
|
||||
root := make_root("review-deleted")
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
deleted: string = "{\"server_version\":13,\"server_state_hash\":\"remote-hash-deleted\",\"full_snapshot_required\":true,\"changes_complete\":false,\"changes\":{\"habits\":[],\"habit_days\":[],\"sessions\":[{\"id\":\"deleted-session\",\"started_at\":\"2026-06-24T10:00:00Z\",\"local_date\":20260624,\"topic\":2,\"activity\":3,\"source\":\"sync-test\",\"rounds_hash\":202,\"deleted_at\":1782300000,\"updated_at\":\"2026-06-24T10:00:00Z\",\"rounds\":[{\"round_index\":0,\"hold_seconds\":55}]}],\"meditation_logs\":[]}}"
|
||||
check_true("no visible diff", storage_sync_review_json_has_visible_diff(deleted) == 0)
|
||||
check_true("review not pending", storage_sync_review_pending() == 0)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_remote_additions_apply_without_review :: () {
|
||||
remote_records("review-remote-yoga", "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('yoga',(SELECT id FROM users LIMIT 1),'Yoga',239,178,102,1,4,0,1,0,1782290000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('yoga',20260624,1,1,0,1782290000);INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('sun-session',(SELECT id FROM users LIMIT 1),1782290000,20260624,0,2,'test',1782290000,'303',0,1782290000);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('sun-session',0,1);")
|
||||
root := make_root("review-additive")
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
set_account()
|
||||
check_true("apply additions", storage_apply_sync_response_json(snapshot_response(14, "remote-hash-yoga")) != 0)
|
||||
check_true("review not pending", storage_sync_review_pending() == 0)
|
||||
check_int("sun session applied", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='sun-session'"), 1)
|
||||
check_int("yoga habit applied", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='yoga' AND counter_enabled=0"), 1)
|
||||
check_int("yoga day applied", count_of(root, "SELECT COUNT(*) FROM habit_days WHERE habit_id='yoga' AND count=1"), 1)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_apply_inside_an_outer_transaction :: () {
|
||||
remote_records("review-remote-clean", "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('clean-habit',(SELECT id FROM users LIMIT 1),'Clean Breath',12,34,56,0,0,1,3,0,1782290000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('clean-habit',20260624,1,5,0,1782290000);INSERT INTO sessions(id,user_id,started_at,local_date,topic,activity,source,imported_at,rounds_hash,deleted_at,updated_at) VALUES('clean-session',(SELECT id FROM users LIMIT 1),1782290000,20260624,2,2,'sync-test',1782290000,'505',0,1782290000);INSERT INTO session_rounds(session_id,round_index,seconds) VALUES('clean-session',0,44);")
|
||||
clean := TextBuffer.{}
|
||||
append(*clean, TextFromCString(*remote_records_text.bytes[0]))
|
||||
root := make_root("review-nested")
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
set_account()
|
||||
check_true("begin outer transaction", exec_sql("BEGIN IMMEDIATE") != 0)
|
||||
check_true("apply inside it", storage_apply_sync_response_json(response_with(21, TextFromCString(*clean.bytes[0]))) != 0)
|
||||
check_true("commit outer transaction", exec_sql("COMMIT") != 0)
|
||||
check_int("habit applied", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='clean-habit'"), 1)
|
||||
check_int("day applied", count_of(root, "SELECT COUNT(*) FROM habit_days WHERE habit_id='clean-habit' AND count=5"), 1)
|
||||
check_int("session applied", count_of(root, "SELECT COUNT(*) FROM sessions WHERE id='clean-session'"), 1)
|
||||
check_int("rounds applied", count_of(root, "SELECT COUNT(*) FROM session_rounds WHERE session_id='clean-session' AND seconds=44"), 1)
|
||||
storage_close()
|
||||
|
||||
// A local habit with the same name but another id is replaced by the
|
||||
// remote one, keeping its days.
|
||||
second := make_root("review-id-repair")
|
||||
check_true("init repair db", storage_init(second) != 0)
|
||||
set_account()
|
||||
storage_close()
|
||||
raw_exec(second, "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('local-clean-id',(SELECT id FROM users LIMIT 1),'Clean Breath',9,9,9,0,0,1,3,0,1782200000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('local-clean-id',20260623,1,2,0,1782200000);DELETE FROM sync_outbox;")
|
||||
check_true("reopen repair db", storage_init(second) != 0)
|
||||
check_true("apply the remote habit", storage_apply_sync_response_json(response_with(22, TextFromCString(*clean.bytes[0]))) != 0)
|
||||
check_int("local duplicate id removed", count_of(second, "SELECT COUNT(*) FROM habits WHERE id='local-clean-id'"), 0)
|
||||
check_int("canonical remote id present", count_of(second, "SELECT COUNT(*) FROM habits WHERE id='clean-habit'"), 1)
|
||||
check_int("local day moved to the canonical id", count_of(second, "SELECT COUNT(*) FROM habit_days WHERE habit_id='clean-habit' AND local_date=20260623 AND count=2"), 1)
|
||||
check_int("remote day still applied", count_of(second, "SELECT COUNT(*) FROM habit_days WHERE habit_id='clean-habit' AND local_date=20260624 AND count=5"), 1)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
YOGA_SQL :: "INSERT INTO habits(id,user_id,name,color_r,color_g,color_b,sync_mode,sync_activity,counter_enabled,sort_order,deleted_at,updated_at) VALUES('yoga',(SELECT id FROM users LIMIT 1),'Yoga',239,178,102,1,4,0,1,0,1782300000);INSERT INTO habit_days(habit_id,local_date,completed,count,session_count,updated_at) VALUES('yoga',20260624,1,2,0,1782300000);"
|
||||
|
||||
test_snapshot_removes_absent_local_yoga :: () {
|
||||
remote_records("review-remote-none", "DELETE FROM habits;")
|
||||
root := local_device("review-removes-yoga", YOGA_SQL, "DELETE FROM sync_outbox;")
|
||||
check_true("apply the snapshot", storage_apply_sync_response_json(snapshot_response(13, "remote-hash-deleted")) != 0)
|
||||
check_true("review not pending", storage_sync_review_pending() == 0)
|
||||
check_int("yoga habit removed", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='yoga'"), 0)
|
||||
check_int("yoga day removed", count_of(root, "SELECT COUNT(*) FROM habit_days WHERE habit_id='yoga'"), 0)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_snapshot_keeps_pending_yoga :: () {
|
||||
remote_records("review-remote-none-2", "DELETE FROM habits;")
|
||||
root := local_device("review-keeps-yoga", YOGA_SQL, "INSERT OR REPLACE INTO sync_outbox(entity_type,entity_id,local_date,queued_at) VALUES('habit','yoga',0,1782300000);")
|
||||
mark_pending_payload_in_flight()
|
||||
check_true("apply the snapshot", storage_apply_sync_response_json(snapshot_response(13, "remote-hash-deleted")) != 0)
|
||||
check_true("review not pending", storage_sync_review_pending() == 0)
|
||||
check_int("pending yoga still local after the merge", count_of(root, "SELECT COUNT(*) FROM habits WHERE id='yoga'"), 1)
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_normal_response_records_server_hash :: () {
|
||||
root := make_root("review-normal")
|
||||
status: StorageSyncStatus
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
check_true("apply a normal response", storage_apply_sync_response_json(
|
||||
"{\"protocol_version\":6,\"server_version\":5,\"server_clock\":77,\"server_state_hash\":\"normal-hash-001\",\"account_alias\":\"waozi\",\"changes\":{\"encrypted_records\":[]}}") != 0)
|
||||
check_true("no review", storage_sync_review_pending() == 0)
|
||||
check_true("alias saved", storage_get_setting_text("sync_account_alias") == "waozi")
|
||||
check_true("status loads", storage_sync_status(*status) != 0)
|
||||
check_int("server version recorded", cast(s32)status.server_version, 5)
|
||||
check_int("server clock recorded", cast(s32)status.server_clock, 77)
|
||||
set_account()
|
||||
check_true("payload builds", build_payload())
|
||||
check_true("hash in the next payload", contains(payload(), "\"last_server_state_hash\":\"normal-hash-001\""))
|
||||
check_true("clock in the next payload", contains(payload(), "\"client_clock\":77"))
|
||||
check_true("no full replace requested", !contains(payload(), "full_sync_requested"))
|
||||
storage_close()
|
||||
}
|
||||
|
||||
test_social_cache_is_server_authored :: () {
|
||||
root := make_root("review-social")
|
||||
cached: [512]u8
|
||||
check_true("init db", storage_init(root) != 0)
|
||||
check_true("store a local social cache", storage_set_social_cache_json("friends.list",
|
||||
"{\"friends\":[{\"user_id_hash\":\"local-edit\"}]}") != 0)
|
||||
check_true("a social cache alone is not local syncable data", storage_has_local_syncable_data() == 0)
|
||||
set_account()
|
||||
check_true("payload builds", build_payload())
|
||||
check_true("social cache is not uploaded", !contains(payload(), "social_cache") && !contains(payload(), "friends.list"))
|
||||
check_true("apply the server's social cache", storage_apply_sync_response_json(
|
||||
"{\"protocol_version\":6,\"server_version\":9,\"server_clock\":9,\"server_state_hash\":\"social-hash-001\",\"changes\":{\"encrypted_records\":[],\"social_cache\":[{\"kind\":\"friends.list\",\"json\":{\"friends\":[{\"user_id_hash\":\"server-friend\"}]},\"updated_at\":\"2026-06-28T00:00:00Z\"}]}}") != 0)
|
||||
check_true("load the cache", storage_get_social_cache_json("friends.list", *cached[0], 512) != 0)
|
||||
text := TextFromCString(*cached[0])
|
||||
check_true("the server's cache replaces the local edit", contains(text, "server-friend") && !contains(text, "local-edit"))
|
||||
storage_close()
|
||||
}
|
||||
|
||||
#program_export
|
||||
Check :: () -> s32 {
|
||||
guard := support_begin("/tmp/inbe-storage-sync-zi-test/")
|
||||
@@ -679,5 +897,15 @@ Check :: () -> s32 {
|
||||
test_session_last_write_wins()
|
||||
test_linked_session_delete_syncs()
|
||||
test_fresh_account_bootstraps_without_tombstones()
|
||||
test_snapshot_with_pending_local_edits_merges()
|
||||
test_tiny_pending_snapshot_merges()
|
||||
test_local_habit_without_activity_does_not_force_review()
|
||||
test_review_ignores_deleted_remote_rows()
|
||||
test_remote_additions_apply_without_review()
|
||||
test_apply_inside_an_outer_transaction()
|
||||
test_snapshot_removes_absent_local_yoga()
|
||||
test_snapshot_keeps_pending_yoga()
|
||||
test_normal_response_records_server_hash()
|
||||
test_social_cache_is_server_authored()
|
||||
return failures
|
||||
}
|
||||
@@ -0,0 +1,355 @@
|
||||
#import "byte_text_linux"
|
||||
#import "drawing_props"
|
||||
#import, file "storage_test_support.zi";
|
||||
#import, file "../src/app/text_buffers.zi";
|
||||
#import, file "../src/storage/data.zi";
|
||||
#import, file "../src/storage/state.zi";
|
||||
#import, file "../src/storage/db.zi";
|
||||
#import, file "../src/storage/session_mood.zi";
|
||||
#import, file "../src/storage/storage_core.zi";
|
||||
#import, file "../src/storage/storage_sessions.zi";
|
||||
#import, file "../src/storage/storage_elist.zi";
|
||||
#import, file "../src/storage/sync_review.zi";
|
||||
#import, file "../src/storage/import.zi";
|
||||
#import, file "../src/storage/sync_account.zi";
|
||||
#import, file "../src/storage/sync_account_host.zi";
|
||||
#import, file "../src/storage/sync_runtime.zi";
|
||||
#import, file "../src/storage/account_types.zi";
|
||||
#import, file "../src/screens/elist_types.zi";
|
||||
#import, file "../src/habits/habit_types.zi";
|
||||
#import, file "../src/habits/habit_memory.zi";
|
||||
#import, file "../src/storage/storage_habits.zi";
|
||||
#import, file "../src/habits/habit_model.zi";
|
||||
|
||||
// Two clients, a friend, and fresh installs syncing through a real Daochi
|
||||
// server (with a proxy that drops one response), from the first upload to
|
||||
// backup restore and deletion. The runner passes the server address in
|
||||
// SYNC_TEST_URL and the faulty proxy's in SYNC_TEST_FAULT_URL, and points
|
||||
// APP_DATA_ROOT at a disposable directory.
|
||||
|
||||
c :: #system_library "c";
|
||||
get_environment :: (name: *u8) -> *u8 #foreign c "getenv";
|
||||
pause_microseconds :: (microseconds: u32) -> s32 #foreign c "usleep";
|
||||
|
||||
habits_a: Habits;
|
||||
elists: EListState;
|
||||
requests_text: [8192]u8;
|
||||
friends_text: [8192]u8;
|
||||
|
||||
environment_text :: (name: string) -> string {
|
||||
buffer: TextBuffer
|
||||
append(*buffer, name)
|
||||
value := get_environment(*buffer.bytes[0])
|
||||
if value == null { return "" }
|
||||
return TextFromCString(value)
|
||||
}
|
||||
|
||||
AlbumHabitId :: () -> string { return "00000000-0000-4000-8000-000000000042" }
|
||||
|
||||
sub_root :: (root: string, name: string) -> string {
|
||||
return make_root(join(join("sync-server-", name), ""))
|
||||
}
|
||||
|
||||
open_client :: (root: string) {
|
||||
storage_close()
|
||||
check_true("open client storage", storage_init(root) != 0)
|
||||
}
|
||||
|
||||
expect_habit :: (id: string, name: string, date: s32) {
|
||||
habits_a = Habits.{}
|
||||
check_true("load habits", storage_habits_load(cast(*void)*habits_a) != 0)
|
||||
found: *Habit = null
|
||||
index: s32 = 0
|
||||
while index < habits_a.count {
|
||||
if TextFromCString(*habits_a.items[index].id[0]) == id { found = *habits_a.items[index] }
|
||||
index += 1
|
||||
}
|
||||
check_true(join("habit exists: ", id), found != null)
|
||||
if found != null {
|
||||
check_true("habit name", TextFromCString(*found.name[0]) == name)
|
||||
check_int("habit has one day", found.day_count, 1)
|
||||
if found.day_count > 0 {
|
||||
check_int("habit day date", found.days[0].day_index, date)
|
||||
check_true("habit day completed", found.days[0].completed != 0)
|
||||
check_int("habit day count", found.days[0].count, 1)
|
||||
}
|
||||
}
|
||||
habits_free(*habits_a)
|
||||
}
|
||||
|
||||
seed_default_habits :: () {
|
||||
habits_a = Habits.{}
|
||||
habits_a.count = 2
|
||||
unused AppCopyText("meditation", habits_a.items[0].id[:])
|
||||
unused AppCopyText("Meditation", habits_a.items[0].name[:])
|
||||
unused AppCopyText("yoga", habits_a.items[1].id[:])
|
||||
unused AppCopyText("Yoga", habits_a.items[1].name[:])
|
||||
index: s32 = 0
|
||||
while index < 2 {
|
||||
habits_a.items[index].color = Color.{126, 183, 230, 255}
|
||||
habits_a.items[index].counter_target = 1
|
||||
habits_a.items[index].reminder_hour = -1
|
||||
index += 1
|
||||
}
|
||||
storage_habits_save(cast(*void)*habits_a)
|
||||
check_int("defaults seeded", storage_habit_count(), 2)
|
||||
habits_free(*habits_a)
|
||||
}
|
||||
|
||||
expect_list :: (list_id: string, item_id: string, title: string, comment: string, done: s32) {
|
||||
elists = EListState.{}
|
||||
check_true("load lists", storage_elist_load(cast(*void)*elists) != 0)
|
||||
lists: s32 = 0
|
||||
items: s32 = 0
|
||||
storage_elist_counts(*lists, *items)
|
||||
check_true("lists and items exist", lists > 0 && items > 0)
|
||||
found_list: bool = false
|
||||
found_item: bool = false
|
||||
index: s32 = 0
|
||||
while index < elists.list_count {
|
||||
if TextFromCString(*elists.lists[index].id[0]) == list_id &&
|
||||
TextFromCString(*elists.lists[index].title[0]) == title { found_list = true }
|
||||
index += 1
|
||||
}
|
||||
index = 0
|
||||
while index < elists.item_count {
|
||||
if TextFromCString(*elists.items[index].id[0]) == item_id &&
|
||||
TextFromCString(*elists.items[index].list_id[0]) == list_id &&
|
||||
TextFromCString(*elists.items[index].comment[0]) == comment &&
|
||||
elists.items[index].done == done { found_item = true }
|
||||
index += 1
|
||||
}
|
||||
check_true(join("list ", title), found_list)
|
||||
check_true(join("item in ", title), found_item)
|
||||
}
|
||||
|
||||
// Syncs until nothing is left queued, retrying transient failures.
|
||||
synchronize :: (url: string) {
|
||||
attempt: s32 = 0
|
||||
while attempt < 8 {
|
||||
result: s32 = SyncStoredAccount(url)
|
||||
if result != 0 {
|
||||
check_int("sync attempt result", result, 0)
|
||||
unused pause_microseconds(2000000)
|
||||
attempt += 1
|
||||
continue
|
||||
}
|
||||
if storage_sync_review_pending() != 0 {
|
||||
check_true("apply remote when local is empty",
|
||||
storage_sync_review_apply_remote_if_local_empty() != 0)
|
||||
check_true("review cleared", storage_sync_review_pending() == 0)
|
||||
}
|
||||
status: StorageSyncStatus
|
||||
check_true("status", storage_sync_status(*status) != 0)
|
||||
if status.queued_changes == 0 { return }
|
||||
attempt += 1
|
||||
}
|
||||
check_true("sync drained the queued changes", false)
|
||||
}
|
||||
|
||||
mood_is :: (id: string, want: s32) -> bool {
|
||||
loaded: SessionMoodCheckin
|
||||
return storage_load_session_checkin(id, *loaded) != 0 && loaded.mood_after == want
|
||||
}
|
||||
|
||||
#program_export
|
||||
Check :: () -> s32 {
|
||||
url := environment_text("SYNC_TEST_URL")
|
||||
fault := environment_text("SYNC_TEST_FAULT_URL")
|
||||
if url.count == 0 || fault.count == 0 { return 90 }
|
||||
guard := support_begin("/tmp/inbe-sync-server-")
|
||||
if guard != 0 { return guard }
|
||||
// Keep the URLs, which point into the environment, across storage calls.
|
||||
server: TextBuffer
|
||||
append(*server, url)
|
||||
proxy: TextBuffer
|
||||
append(*proxy, fault)
|
||||
url = TextFromCString(*server.bytes[0])
|
||||
fault = TextFromCString(*proxy.bytes[0])
|
||||
|
||||
ask := SyncAccountLocalDataChoice.SYNC_ACCOUNT_LOCAL_DATA_ASK
|
||||
ok := SyncAccountSaveResult.SYNC_ACCOUNT_SAVE_OK
|
||||
a := make_root("a")
|
||||
b := make_root("b")
|
||||
restored := make_root("restored")
|
||||
friend_root := make_root("friend")
|
||||
defaults_root := make_root("restored_defaults")
|
||||
key_path: TextBuffer
|
||||
append(*key_path, data_root())
|
||||
append(*key_path, "/account.key")
|
||||
backup: TextBuffer
|
||||
append(*backup, data_root())
|
||||
append(*backup, "/backup.zip")
|
||||
alias: string = "restore_test"
|
||||
friend_alias: string = "friend_test"
|
||||
account: SyncAccount
|
||||
friend_account: SyncAccount
|
||||
restored_account: SyncAccount
|
||||
default_account: SyncAccount
|
||||
id: [256]u8
|
||||
other_id: [256]u8
|
||||
duration: [1]s32 = .[60]
|
||||
checkin: SessionMoodCheckin
|
||||
|
||||
open_client(a)
|
||||
check_true("generate account", sync_account_generate(*account) != 0)
|
||||
check_true("save account", sync_account_save(*account, ask) == ok)
|
||||
habit_name: string = "Recovery meditation"
|
||||
habits_a = Habits.{}
|
||||
habits_a.count = 1
|
||||
unused AppCopyText(AlbumHabitId(), habits_a.items[0].id[:])
|
||||
unused AppCopyText(habit_name, habits_a.items[0].name[:])
|
||||
habits_a.items[0].color = Color.{82, 119, 193, 255}
|
||||
habits_a.items[0].counter_target = 1
|
||||
habits_a.items[0].reminder_hour = -1
|
||||
storage_habits_save(cast(*void)*habits_a)
|
||||
habits_free(*habits_a)
|
||||
check_true("save habit day", storage_habit_day_save(AlbumHabitId(), 20260919, 1, 1) != 0)
|
||||
expect_habit(AlbumHabitId(), habit_name, 20260919)
|
||||
check_true("save session", storage_save_session_for_activity(*duration[0], 1, 0, 1, *id[0], 256) != 0)
|
||||
checkin.mood_after = 4
|
||||
session := TextFromCString(*id[0])
|
||||
check_true("save check-in", storage_save_session_checkin(session, *checkin) != 0)
|
||||
check_true("syncing offline fails", SyncStoredAccount("http://127.0.0.1:1") != 0)
|
||||
check_int("an offline failure keeps local work", storage_session_count(), 1)
|
||||
open_client(a)
|
||||
check_true("check-in survives the failure", mood_is(session, 4))
|
||||
// The server commits the upload, but the proxy drops its response.
|
||||
check_true("interrupted upload fails", SyncStoredAccount(fault) != 0)
|
||||
open_client(a)
|
||||
synchronize(url)
|
||||
storage_set_setting_text("sync_server_url", url)
|
||||
storage_set_sync_enabled(1)
|
||||
check_int("register alias", RegisterAliasStored(url, alias), 0)
|
||||
list_id: [37]u8
|
||||
item_id: [37]u8
|
||||
check_true("create list", storage_elist_create_list("Travel", *list_id[0]) != 0)
|
||||
list_text := TextFromCString(*list_id[0])
|
||||
check_true("create item", storage_elist_create_item(list_text, "Pack bag", "Passport", *item_id[0]) != 0)
|
||||
item_text := TextFromCString(*item_id[0])
|
||||
synchronize(url)
|
||||
|
||||
open_client(b)
|
||||
check_true("second device joins", sync_account_save(*account, ask) == ok)
|
||||
synchronize(url)
|
||||
check_true("alias reaches the second device", storage_get_setting_text("sync_account_alias") == alias)
|
||||
check_int("session reaches the second device", storage_session_count(), 1)
|
||||
expect_habit(AlbumHabitId(), habit_name, 20260919)
|
||||
expect_list(list_text, item_text, "Travel", "Passport", 0)
|
||||
check_true("complete the item", storage_elist_update_item(item_text, "Pack bag", "Passport", 1, 0) != 0)
|
||||
synchronize(url)
|
||||
open_client(a)
|
||||
synchronize(url)
|
||||
expect_list(list_text, item_text, "Travel", "Passport", 1)
|
||||
open_client(b)
|
||||
check_true("b sees the check-in", mood_is(session, 4))
|
||||
checkin.mood_after = 2
|
||||
check_true("b edits the check-in", storage_save_session_checkin(session, *checkin) != 0)
|
||||
synchronize(url)
|
||||
open_client(a)
|
||||
synchronize(url)
|
||||
check_true("a sees the edit", mood_is(session, 2))
|
||||
synchronize(url)
|
||||
check_int("retrying an acknowledged upload is idempotent", storage_session_count(), 1)
|
||||
|
||||
// Both clients edit offline; a's second edit is newer.
|
||||
open_client(b)
|
||||
checkin.mood_after = 1
|
||||
check_true("b offline edit", storage_save_session_checkin(session, *checkin) != 0)
|
||||
open_client(a)
|
||||
checkin.mood_after = 3
|
||||
check_true("a first offline edit", storage_save_session_checkin(session, *checkin) != 0)
|
||||
checkin.mood_after = 4
|
||||
check_true("a second offline edit", storage_save_session_checkin(session, *checkin) != 0)
|
||||
open_client(b)
|
||||
synchronize(url)
|
||||
open_client(a)
|
||||
synchronize(url)
|
||||
open_client(b)
|
||||
synchronize(url)
|
||||
check_true("the newer edit wins", mood_is(session, 4))
|
||||
|
||||
// A friend, then restoring the same key on fresh installs.
|
||||
check_true("export the account key",
|
||||
sync_account_export_private_key(*account, *key_path.bytes[0]) != 0)
|
||||
storage_set_setting_text("sync_server_url", url)
|
||||
storage_set_sync_enabled(1)
|
||||
open_client(friend_root)
|
||||
check_true("generate the friend's account", sync_account_generate(*friend_account) != 0)
|
||||
check_true("save the friend's account", sync_account_save(*friend_account, ask) == ok)
|
||||
storage_set_setting_text("sync_server_url", url)
|
||||
storage_set_sync_enabled(1)
|
||||
synchronize(url)
|
||||
check_int("friend registers an alias", RegisterAliasStored(url, friend_alias), 0)
|
||||
check_int("friend sends a request",
|
||||
SendFriendRequestStored(url, TextFromCString(*account.public_id[0])), 0)
|
||||
open_client(b)
|
||||
check_int("b fetches requests", FetchFriendRequests(url, requests_text[:]), 0)
|
||||
request_id: [128]u8
|
||||
check_true("request id", storage_json_array_object_text(TextFromCString(*requests_text[0]),
|
||||
"$.incoming", 0, "id", *request_id[0], 128) != 0)
|
||||
check_int("b accepts the request", AcceptFriendRequestStored(url, TextFromCString(*request_id[0])), 0)
|
||||
|
||||
open_client(restored)
|
||||
check_true("read the key back", sync_account_import_private_key_preview(*restored_account,
|
||||
*key_path.bytes[0]) != 0)
|
||||
check_true("same account id", TextFromCString(*restored_account.public_id[0]) ==
|
||||
TextFromCString(*account.public_id[0]))
|
||||
check_true("restore the key", sync_account_save(*restored_account, ask) == ok)
|
||||
storage_set_setting_text("sync_server_url", url)
|
||||
storage_set_sync_enabled(1)
|
||||
synchronize(url)
|
||||
check_true("alias restored", storage_get_setting_text("sync_account_alias") == alias)
|
||||
check_int("friends fetch", FetchFriends(url, friends_text[:]), 0)
|
||||
check_true("friendship recovered", contains(TextFromCString(*friends_text[0]),
|
||||
TextFromCString(*friend_account.public_id[0])))
|
||||
check_int("session restored", storage_session_count(), 1)
|
||||
check_true("check-in restored", mood_is(session, 4))
|
||||
expect_habit(AlbumHabitId(), habit_name, 20260919)
|
||||
expect_list(list_text, item_text, "Travel", "Passport", 1)
|
||||
|
||||
// A new install may seed the default habits before the key is restored.
|
||||
open_client(defaults_root)
|
||||
seed_default_habits()
|
||||
check_true("read the key for the new install",
|
||||
sync_account_import_private_key_preview(*default_account, *key_path.bytes[0]) != 0)
|
||||
check_true("restore on the new install", sync_account_save(*default_account, ask) == ok)
|
||||
storage_set_setting_text("sync_server_url", url)
|
||||
storage_set_sync_enabled(1)
|
||||
synchronize(url)
|
||||
check_true("alias on the new install", storage_get_setting_text("sync_account_alias") == alias)
|
||||
check_int("session on the new install", storage_session_count(), 1)
|
||||
expect_habit(AlbumHabitId(), habit_name, 20260919)
|
||||
expect_list(list_text, item_text, "Travel", "Passport", 1)
|
||||
check_int("friends on the new install", FetchFriends(url, friends_text[:]), 0)
|
||||
check_true("friendship on the new install", contains(TextFromCString(*friends_text[0]),
|
||||
TextFromCString(*friend_account.public_id[0])))
|
||||
|
||||
// Backup and restore.
|
||||
open_client(b)
|
||||
check_true("export a backup", storage_export_zip(TextFromCString(*backup.bytes[0])) != 0)
|
||||
open_client(restored)
|
||||
check_true("import the backup", storage_import_zip(TextFromCString(*backup.bytes[0])) != 0)
|
||||
check_int("backup session", storage_session_count(), 1)
|
||||
check_true("backup check-in", mood_is(session, 4))
|
||||
|
||||
// Deleting one session leaves the unrelated upload alone.
|
||||
open_client(b)
|
||||
duration[0] = 90
|
||||
check_true("save another session", storage_save_session_for_activity(*duration[0], 1, 0, 1, *other_id[0], 256) != 0)
|
||||
check_true("delete the first session", storage_delete_session(session) != 0)
|
||||
synchronize(url)
|
||||
open_client(a)
|
||||
synchronize(url)
|
||||
check_int("deletion preserves the unrelated upload", storage_session_count(), 1)
|
||||
other := TextFromCString(*other_id[0])
|
||||
loaded: SessionMoodCheckin
|
||||
check_true("the other session loads", storage_load_session_checkin(other, *loaded) != 0)
|
||||
check_true("delete the other session", storage_delete_session(other) != 0)
|
||||
synchronize(url)
|
||||
open_client(b)
|
||||
synchronize(url)
|
||||
check_int("both deletions reached the second device", storage_session_count(), 0)
|
||||
storage_close()
|
||||
return failures
|
||||
}
|
||||
Executable
+47
@@ -0,0 +1,47 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
# Builds the two-client sync scenario as a Ziran program. It runs against a
|
||||
# real Daochi server through scripts/sync-server-test.mjs, which needs
|
||||
# DAOCHI_BIN (a built Daochi server) and node.
|
||||
root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
ziran=${1:-"$root/build/ziran-toolchain/bin/ziran"}
|
||||
liboqs=${2:-"$root/vendor-builds/linux/x86_64/inbe-liboqs/lib/liboqs.a"}
|
||||
work=$root/build/sync-server-zi-test
|
||||
include=$root/build/packages/ziran/include
|
||||
# The system library, linked by name where there is no development symlink.
|
||||
curl=${CURL_LIBRARY:-$(ls /usr/lib/x86_64-linux-gnu/libcurl.so.4 2>/dev/null || echo -lcurl)}
|
||||
|
||||
rm -rf "$work"
|
||||
mkdir -p "$work/generated"
|
||||
"$ziran" build --target=c --define PLATFORM_DESKTOP --root "$root/tests" \
|
||||
--module-path "$root/src" \
|
||||
--module-path "$root/build/packages/kryon/src/ui" \
|
||||
--module-path "$root/build/packages/kryon/src/kss" \
|
||||
--module-path "$root/build/packages/kryon/src/backend" \
|
||||
--module-path "$root/build/packages/game2d/src" \
|
||||
--module-path "$root/build/packages/ziran/std" \
|
||||
--module-path "$root/build/packages/daochi-client" \
|
||||
--entry sync_server_behavior:Check \
|
||||
-o "$work/generated" "$root/tests/sync_server_behavior.zi" \
|
||||
"$root/tests/sync_test_host.zi"
|
||||
cat > "$work/generated/main.c" <<'C'
|
||||
#include <stdio.h>
|
||||
#include "sync_server_behavior.h"
|
||||
int main(void)
|
||||
{
|
||||
int result = Check();
|
||||
if (result != 0) fprintf(stderr, "sync server check failed with code %d\n", result);
|
||||
if (result == 0) puts("PASS two-client sync, habit/session/list/alias/friend recovery, offline retry, conflict, backup restore, deletion");
|
||||
return result == 0 ? 0 : 1;
|
||||
}
|
||||
C
|
||||
"${CC:-cc}" -std=c11 -O0 -ffunction-sections -fdata-sections \
|
||||
-I"$include" -I"$work/generated" -I"$root/vendor-builds/sqlite" \
|
||||
-I"$root/vendor-builds/linux/x86_64/inbe-liboqs/include" \
|
||||
-I"$root/build/packages/monocypher/src" -I"$root/build/packages/monocypher/src/optional" \
|
||||
"$work/generated"/*.c "$root/vendor-builds/sqlite/sqlite3.c" "$liboqs" \
|
||||
"$root/build/packages/monocypher/src/monocypher.c" \
|
||||
"$root/build/packages/monocypher/src/optional/monocypher-ed25519.c" \
|
||||
-Wl,--gc-sections -ldl -lpthread -lz -lm "$curl" -o "$work/test"
|
||||
echo "$work/test"
|
||||
@@ -151,25 +151,3 @@ host_unload_directory_files :: (paths: PathList) {
|
||||
host_is_path_file :: (path: *u8) -> bool {
|
||||
return path != null
|
||||
}
|
||||
|
||||
// Application-level hooks the route and modal code calls; tests that reach
|
||||
// them do not need their effects.
|
||||
#program_export "app_leave_practice_config"
|
||||
host_leave_practice_config :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "profile_social_load_friends_cache"
|
||||
host_load_friends_cache :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "profile_social_load_leaderboard_cache"
|
||||
host_load_leaderboard_cache :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
|
||||
#program_export "app_request_social_refresh"
|
||||
host_request_social_refresh :: (app: *void) {
|
||||
unused app
|
||||
}
|
||||
Reference in new issue
Block a user