From eac29c4b1e769c34e2fddf36b08f08f827c4fe6b Mon Sep 17 00:00:00 2001
From: "mr. m" <91018726+mr-cheffy@users.noreply.github.com>
Date: Mon, 24 Aug 2026 22:52:33 +0200
Subject: [PATCH] gh-15085: Import mochitests for remote settings (gh-15086)
---
.gitattributes | 2 +-
.../xpcshell/runxpcshelltests-py.patch | 14 +
.../ZenSpaceRoutingManager.sys.mjs | 2 +-
src/zen/tests/manifest.toml | 25 +
src/zen/tests/mochitests/moz.build | 3 +
.../remote-settings/head_settings.js | 86 +
.../test_attachments_downloader.js | 896 +++++++
.../65650a0f-7c22-4c10-9744-2d67e301f5f4.pem | 26 +
.../error-bucket--bad-zip.zip | 1 +
.../main--some-collection.zip | Bin 0 -> 994 bytes
.../dump-collection/filename-of-dump.txt | 1 +
.../filename-of-dump.txt.meta.json | 10 +
.../filename-without-content.txt.meta.json | 8 +
.../dump-collection/filename-without-meta.txt | 1 +
.../remote-settings/test_remote_settings.js | 1798 ++++++++++++++
.../test_remote_settings_dump_lastmodified.js | 55 +
.../test_remote_settings_jexl_filters.js | 210 ++
.../test_remote_settings_offline.js | 139 ++
.../test_remote_settings_older_than_local.js | 149 ++
.../test_remote_settings_poll.js | 1287 ++++++++++
.../test_remote_settings_recover_broken.js | 138 ++
.../test_remote_settings_release_prefs.js | 252 ++
.../test_remote_settings_signatures.js | 952 ++++++++
.../collection_signing_ee.pem | 16 +
.../collection_signing_ee.pem.certspec | 5 +
.../collection_signing_int.pem | 19 +
.../collection_signing_int.pem.certspec | 4 +
.../test_remote_settings_startup_bundle.js | 152 ++
.../startup.json.mozlz4 | Bin 0 -> 167191 bytes
.../test_remote_settings_sync_history.js | 65 +
.../test_remote_settings_utils.js | 299 +++
.../test_remote_settings_utils_telemetry.js | 79 +
.../test_remote_settings_worker.js | 117 +
.../remote-settings/test_shutdown_handling.js | 132 +
.../remote-settings/test_uptake_telemetry.js | 68 +
.../mochitests/remote-settings/xpcshell.toml | 50 +
.../services-crypto/head_helpers.js | 68 +
.../services-crypto/test_crypto_crypt.js | 226 ++
.../services-crypto/test_crypto_random.js | 52 +
.../services-crypto/test_jwcrypto.js | 51 +
.../services-crypto/test_utils_hawk.js | 346 +++
.../services-crypto/test_utils_httpmac.js | 73 +
.../mochitests/services-crypto/xpcshell.toml | 20 +
.../tests/mochitests/sync/addon1-search.json | 21 +
.../mochitests/sync/bootstrap1-search.json | 21 +
src/zen/tests/mochitests/sync/head_appinfo.js | 58 +
.../sync/head_errorhandler_common.js | 195 ++
src/zen/tests/mochitests/sync/head_helpers.js | 621 +++++
.../tests/mochitests/sync/head_http_server.js | 1268 ++++++++++
.../mochitests/sync/missing-sourceuri.json | 20 +
.../mochitests/sync/missing-xpi-search.json | 21 +
.../mochitests/sync/prefs_test_prefs_store.js | 47 +
.../tests/mochitests/sync/rewrite-search.json | 21 +
.../mochitests/sync/systemaddon-search.json | 21 +
src/zen/tests/mochitests/sync/test_412.js | 60 +
.../tests/mochitests/sync/test_addon_utils.js | 156 ++
.../mochitests/sync/test_addons_engine.js | 277 +++
.../mochitests/sync/test_addons_reconciler.js | 209 ++
.../mochitests/sync/test_addons_store.js | 933 ++++++++
.../mochitests/sync/test_addons_tracker.js | 174 ++
.../mochitests/sync/test_addons_validator.js | 65 +
.../sync/test_bookmark_batch_fail.js | 25 +
.../sync/test_bookmark_decline_undecline.js | 48 +
.../mochitests/sync/test_bookmark_engine.js | 1508 ++++++++++++
.../mochitests/sync/test_bookmark_order.js | 586 +++++
.../test_bookmark_places_query_rewriting.js | 57 +
.../mochitests/sync/test_bookmark_record.js | 64 +
.../mochitests/sync/test_bookmark_store.js | 486 ++++
.../mochitests/sync/test_bookmark_tracker.js | 1264 ++++++++++
.../mochitests/sync/test_bridged_engine.js | 230 ++
.../mochitests/sync/test_clients_engine.js | 2129 +++++++++++++++++
.../mochitests/sync/test_clients_escape.js | 57 +
.../sync/test_collection_getBatched.js | 187 ++
.../sync/test_collections_recovery.js | 95 +
.../mochitests/sync/test_corrupt_keys.js | 248 ++
.../tests/mochitests/sync/test_declined.js | 198 ++
.../sync/test_disconnect_shutdown.js | 104 +
src/zen/tests/mochitests/sync/test_engine.js | 246 ++
.../mochitests/sync/test_engine_abort.js | 79 +
.../sync/test_engine_changes_during_sync.js | 611 +++++
.../mochitests/sync/test_enginemanager.js | 232 ++
.../mochitests/sync/test_errorhandler_1.js | 335 +++
.../mochitests/sync/test_errorhandler_2.js | 529 ++++
.../sync/test_errorhandler_filelog.js | 473 ++++
...test_errorhandler_sync_checkServerError.js | 294 +++
.../sync/test_extension_storage_engine.js | 259 ++
.../test_extension_storage_engine_kinto.js | 136 ++
.../test_extension_storage_tracker_kinto.js | 44 +
.../mochitests/sync/test_form_validator.js | 86 +
.../tests/mochitests/sync/test_forms_store.js | 176 ++
.../mochitests/sync/test_forms_tracker.js | 78 +
.../sync/test_fxa_node_reassignment.js | 399 +++
.../sync/test_fxa_service_cluster.js | 58 +
src/zen/tests/mochitests/sync/test_glean.js | 1387 +++++++++++
.../mochitests/sync/test_history_engine.js | 429 ++++
.../mochitests/sync/test_history_store.js | 560 +++++
.../mochitests/sync/test_history_tracker.js | 251 ++
.../tests/mochitests/sync/test_hmac_error.js | 250 ++
.../mochitests/sync/test_httpd_sync_server.js | 250 ++
.../mochitests/sync/test_interval_triggers.js | 472 ++++
src/zen/tests/mochitests/sync/test_keys.js | 242 ++
.../mochitests/sync/test_load_modules.js | 59 +
.../mochitests/sync/test_node_reassignment.js | 523 ++++
.../mochitests/sync/test_password_engine.js | 1258 ++++++++++
.../mochitests/sync/test_password_store.js | 399 +++
.../mochitests/sync/test_password_tracker.js | 249 ++
.../sync/test_password_validator.js | 237 ++
.../tests/mochitests/sync/test_postqueue.js | 985 ++++++++
.../mochitests/sync/test_prefs_engine.js | 134 ++
.../tests/mochitests/sync/test_prefs_store.js | 402 ++++
.../mochitests/sync/test_prefs_tracker.js | 108 +
.../mochitests/sync/test_records_crypto.js | 189 ++
.../tests/mochitests/sync/test_records_wbo.js | 119 +
.../tests/mochitests/sync/test_resource.js | 554 +++++
.../mochitests/sync/test_resource_header.js | 63 +
.../tests/mochitests/sync/test_resource_ua.js | 96 +
.../test_rust_password_engine_mp_locked.js | 115 +
.../test_rust_password_engine_selection.js | 64 +
.../sync/test_rust_password_tracker.js | 93 +
.../mochitests/sync/test_score_triggers.js | 151 ++
.../sync/test_service_attributes.js | 203 ++
.../mochitests/sync/test_service_cluster.js | 61 +
.../sync/test_service_detect_upgrade.js | 274 +++
.../mochitests/sync/test_service_login.js | 224 ++
.../mochitests/sync/test_service_startOver.js | 91 +
.../mochitests/sync/test_service_startup.js | 60 +
.../mochitests/sync/test_service_sync_401.js | 90 +
.../sync/test_service_sync_locked.js | 47 +
.../sync/test_service_sync_remoteSetup.js | 241 ++
.../sync/test_service_sync_specified.js | 150 ++
.../test_service_sync_updateEnabledEngines.js | 587 +++++
.../sync/test_service_verifyLogin.js | 115 +
.../sync/test_service_wipeClient.js | 78 +
.../sync/test_service_wipeServer.js | 240 ++
src/zen/tests/mochitests/sync/test_status.js | 83 +
.../mochitests/sync/test_status_checkSetup.js | 26 +
.../mochitests/sync/test_sync_auth_manager.js | 810 +++++++
.../tests/mochitests/sync/test_syncedtabs.js | 342 +++
.../tests/mochitests/sync/test_syncengine.js | 329 +++
.../mochitests/sync/test_syncengine_sync.js | 1811 ++++++++++++++
.../mochitests/sync/test_syncscheduler.js | 1207 ++++++++++
.../tests/mochitests/sync/test_tab_engine.js | 195 ++
.../mochitests/sync/test_tab_provider.js | 59 +
.../mochitests/sync/test_tab_quickwrite.js | 220 ++
.../tests/mochitests/sync/test_tab_tracker.js | 371 +++
.../tests/mochitests/sync/test_telemetry.js | 1274 ++++++++++
.../sync/test_tracker_addChanged.js | 59 +
src/zen/tests/mochitests/sync/test_uistate.js | 411 ++++
.../tests/mochitests/sync/test_utils_catch.js | 119 +
.../mochitests/sync/test_utils_deepEquals.js | 51 +
.../mochitests/sync/test_utils_deferGetSet.js | 50 +
.../tests/mochitests/sync/test_utils_json.js | 95 +
.../mochitests/sync/test_utils_keyEncoding.js | 23 +
.../tests/mochitests/sync/test_utils_lock.js | 76 +
.../mochitests/sync/test_utils_makeGUID.js | 44 +
.../mochitests/sync/test_utils_notify.js | 97 +
.../mochitests/sync/test_utils_passphrase.js | 45 +
src/zen/tests/mochitests/sync/xpcshell.toml | 369 +++
158 files changed, 43670 insertions(+), 2 deletions(-)
create mode 100644 src/testing/xpcshell/runxpcshelltests-py.patch
create mode 100644 src/zen/tests/mochitests/remote-settings/head_settings.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/65650a0f-7c22-4c10-9744-2d67e301f5f4.pem
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/error-bucket--bad-zip.zip
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/main--some-collection.zip
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/settings/dump-bucket/dump-collection/filename-of-dump.txt
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/settings/dump-bucket/dump-collection/filename-of-dump.txt.meta.json
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/settings/dump-bucket/dump-collection/filename-without-content.txt.meta.json
create mode 100644 src/zen/tests/mochitests/remote-settings/test_attachments_downloader/settings/dump-bucket/dump-collection/filename-without-meta.txt
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_dump_lastmodified.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_jexl_filters.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_offline.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_older_than_local.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_poll.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_recover_broken.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_release_prefs.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem.certspec
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem.certspec
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle/startup.json.mozlz4
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_sync_history.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_utils.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_utils_telemetry.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_remote_settings_worker.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_shutdown_handling.js
create mode 100644 src/zen/tests/mochitests/remote-settings/test_uptake_telemetry.js
create mode 100644 src/zen/tests/mochitests/remote-settings/xpcshell.toml
create mode 100644 src/zen/tests/mochitests/services-crypto/head_helpers.js
create mode 100644 src/zen/tests/mochitests/services-crypto/test_crypto_crypt.js
create mode 100644 src/zen/tests/mochitests/services-crypto/test_crypto_random.js
create mode 100644 src/zen/tests/mochitests/services-crypto/test_jwcrypto.js
create mode 100644 src/zen/tests/mochitests/services-crypto/test_utils_hawk.js
create mode 100644 src/zen/tests/mochitests/services-crypto/test_utils_httpmac.js
create mode 100644 src/zen/tests/mochitests/services-crypto/xpcshell.toml
create mode 100644 src/zen/tests/mochitests/sync/addon1-search.json
create mode 100644 src/zen/tests/mochitests/sync/bootstrap1-search.json
create mode 100644 src/zen/tests/mochitests/sync/head_appinfo.js
create mode 100644 src/zen/tests/mochitests/sync/head_errorhandler_common.js
create mode 100644 src/zen/tests/mochitests/sync/head_helpers.js
create mode 100644 src/zen/tests/mochitests/sync/head_http_server.js
create mode 100644 src/zen/tests/mochitests/sync/missing-sourceuri.json
create mode 100644 src/zen/tests/mochitests/sync/missing-xpi-search.json
create mode 100644 src/zen/tests/mochitests/sync/prefs_test_prefs_store.js
create mode 100644 src/zen/tests/mochitests/sync/rewrite-search.json
create mode 100644 src/zen/tests/mochitests/sync/systemaddon-search.json
create mode 100644 src/zen/tests/mochitests/sync/test_412.js
create mode 100644 src/zen/tests/mochitests/sync/test_addon_utils.js
create mode 100644 src/zen/tests/mochitests/sync/test_addons_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_addons_reconciler.js
create mode 100644 src/zen/tests/mochitests/sync/test_addons_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_addons_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_addons_validator.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_batch_fail.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_decline_undecline.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_order.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_places_query_rewriting.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_record.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_bookmark_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_bridged_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_clients_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_clients_escape.js
create mode 100644 src/zen/tests/mochitests/sync/test_collection_getBatched.js
create mode 100644 src/zen/tests/mochitests/sync/test_collections_recovery.js
create mode 100644 src/zen/tests/mochitests/sync/test_corrupt_keys.js
create mode 100644 src/zen/tests/mochitests/sync/test_declined.js
create mode 100644 src/zen/tests/mochitests/sync/test_disconnect_shutdown.js
create mode 100644 src/zen/tests/mochitests/sync/test_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_engine_abort.js
create mode 100644 src/zen/tests/mochitests/sync/test_engine_changes_during_sync.js
create mode 100644 src/zen/tests/mochitests/sync/test_enginemanager.js
create mode 100644 src/zen/tests/mochitests/sync/test_errorhandler_1.js
create mode 100644 src/zen/tests/mochitests/sync/test_errorhandler_2.js
create mode 100644 src/zen/tests/mochitests/sync/test_errorhandler_filelog.js
create mode 100644 src/zen/tests/mochitests/sync/test_errorhandler_sync_checkServerError.js
create mode 100644 src/zen/tests/mochitests/sync/test_extension_storage_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_extension_storage_engine_kinto.js
create mode 100644 src/zen/tests/mochitests/sync/test_extension_storage_tracker_kinto.js
create mode 100644 src/zen/tests/mochitests/sync/test_form_validator.js
create mode 100644 src/zen/tests/mochitests/sync/test_forms_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_forms_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_fxa_node_reassignment.js
create mode 100644 src/zen/tests/mochitests/sync/test_fxa_service_cluster.js
create mode 100644 src/zen/tests/mochitests/sync/test_glean.js
create mode 100644 src/zen/tests/mochitests/sync/test_history_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_history_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_history_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_hmac_error.js
create mode 100644 src/zen/tests/mochitests/sync/test_httpd_sync_server.js
create mode 100644 src/zen/tests/mochitests/sync/test_interval_triggers.js
create mode 100644 src/zen/tests/mochitests/sync/test_keys.js
create mode 100644 src/zen/tests/mochitests/sync/test_load_modules.js
create mode 100644 src/zen/tests/mochitests/sync/test_node_reassignment.js
create mode 100644 src/zen/tests/mochitests/sync/test_password_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_password_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_password_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_password_validator.js
create mode 100644 src/zen/tests/mochitests/sync/test_postqueue.js
create mode 100644 src/zen/tests/mochitests/sync/test_prefs_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_prefs_store.js
create mode 100644 src/zen/tests/mochitests/sync/test_prefs_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_records_crypto.js
create mode 100644 src/zen/tests/mochitests/sync/test_records_wbo.js
create mode 100644 src/zen/tests/mochitests/sync/test_resource.js
create mode 100644 src/zen/tests/mochitests/sync/test_resource_header.js
create mode 100644 src/zen/tests/mochitests/sync/test_resource_ua.js
create mode 100644 src/zen/tests/mochitests/sync/test_rust_password_engine_mp_locked.js
create mode 100644 src/zen/tests/mochitests/sync/test_rust_password_engine_selection.js
create mode 100644 src/zen/tests/mochitests/sync/test_rust_password_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_score_triggers.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_attributes.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_cluster.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_detect_upgrade.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_login.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_startOver.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_startup.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_sync_401.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_sync_locked.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_sync_remoteSetup.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_sync_specified.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_sync_updateEnabledEngines.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_verifyLogin.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_wipeClient.js
create mode 100644 src/zen/tests/mochitests/sync/test_service_wipeServer.js
create mode 100644 src/zen/tests/mochitests/sync/test_status.js
create mode 100644 src/zen/tests/mochitests/sync/test_status_checkSetup.js
create mode 100644 src/zen/tests/mochitests/sync/test_sync_auth_manager.js
create mode 100644 src/zen/tests/mochitests/sync/test_syncedtabs.js
create mode 100644 src/zen/tests/mochitests/sync/test_syncengine.js
create mode 100644 src/zen/tests/mochitests/sync/test_syncengine_sync.js
create mode 100644 src/zen/tests/mochitests/sync/test_syncscheduler.js
create mode 100644 src/zen/tests/mochitests/sync/test_tab_engine.js
create mode 100644 src/zen/tests/mochitests/sync/test_tab_provider.js
create mode 100644 src/zen/tests/mochitests/sync/test_tab_quickwrite.js
create mode 100644 src/zen/tests/mochitests/sync/test_tab_tracker.js
create mode 100644 src/zen/tests/mochitests/sync/test_telemetry.js
create mode 100644 src/zen/tests/mochitests/sync/test_tracker_addChanged.js
create mode 100644 src/zen/tests/mochitests/sync/test_uistate.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_catch.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_deepEquals.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_deferGetSet.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_json.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_keyEncoding.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_lock.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_makeGUID.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_notify.js
create mode 100644 src/zen/tests/mochitests/sync/test_utils_passphrase.js
create mode 100644 src/zen/tests/mochitests/sync/xpcshell.toml
diff --git a/.gitattributes b/.gitattributes
index 42b01886c..d18643924 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -5,4 +5,4 @@
*.patch linguist-language=C++
*.d.ts linguist-language=TypeScript
-src/zen/tests/*.js linguist-language=Test
+src/zen/tests/* linguist-language=C++
diff --git a/src/testing/xpcshell/runxpcshelltests-py.patch b/src/testing/xpcshell/runxpcshelltests-py.patch
new file mode 100644
index 000000000..c0aaeea1b
--- /dev/null
+++ b/src/testing/xpcshell/runxpcshelltests-py.patch
@@ -0,0 +1,14 @@
+diff --git a/testing/xpcshell/runxpcshelltests.py b/testing/xpcshell/runxpcshelltests.py
+index 403401613189ffb758037850dc6bbb1d55f194ab..cad28e245155eb54775e551885532026e56c5fa9 100755
+--- a/testing/xpcshell/runxpcshelltests.py
++++ b/testing/xpcshell/runxpcshelltests.py
+@@ -2275,6 +2275,9 @@ class XPCShellTests:
+ appDirKey = None
+ if "appname" in self.mozInfo:
+ appDirKey = self.mozInfo["appname"] + "-appdir"
++ if appDirKey == "zen-appdir":
++ # Inherited manifests use firefox-appdir.
++ appDirKey = "firefox-appdir"
+
+ # We have to do this before we run tests that depend on having the node
+ # http/2 server.
diff --git a/src/zen/space-routing/ZenSpaceRoutingManager.sys.mjs b/src/zen/space-routing/ZenSpaceRoutingManager.sys.mjs
index 7622417d8..0a0c70185 100644
--- a/src/zen/space-routing/ZenSpaceRoutingManager.sys.mjs
+++ b/src/zen/space-routing/ZenSpaceRoutingManager.sys.mjs
@@ -27,7 +27,7 @@ class nsZenSpaceRoutingManager {
const element = window.MozXULElement.parseXULToFragment(`
`);
window.document.getElementById("context_undoCloseTab").after(element);
diff --git a/src/zen/tests/manifest.toml b/src/zen/tests/manifest.toml
index c3f444157..d242dd5ba 100644
--- a/src/zen/tests/manifest.toml
+++ b/src/zen/tests/manifest.toml
@@ -13,10 +13,26 @@ disable = [
"browser_readerMode_colorSchemePref.js",
]
+[remote-settings]
+source = "services/settings/test/unit"
+is_direct_path = true
+xpcshell = true
+
+[remote-settings.replace-manifest]
+"../../../" = "../../../../services/"
+
[safebrowsing]
source = "browser/components/safebrowsing/content/test"
is_direct_path = true
+[services-crypto]
+source = "services/crypto/tests/unit"
+is_direct_path = true
+xpcshell = true
+
+[services-crypto.replace-manifest]
+"../../../" = "../../../../services/"
+
[shell]
source = "browser/components/shell/test"
is_direct_path = true
@@ -25,6 +41,15 @@ disable = [
"browser_setDesktopBackgroundPreview.js",
]
+[sync]
+source = "services/sync/tests/unit"
+is_direct_path = true
+xpcshell = true
+
+[sync.replace-manifest]
+"../../../" = "../../../../services/"
+'"identity.fxaccounts.enabled=true"' = '"identity.fxaccounts.enabled=true", "browser.formfill.enable=true"'
+
[tabMediaIndicator]
source = "browser/components/tabbrowser/test/browser/tabMediaIndicator"
is_direct_path = true
diff --git a/src/zen/tests/mochitests/moz.build b/src/zen/tests/mochitests/moz.build
index bbf85269c..d798a5e2e 100644
--- a/src/zen/tests/mochitests/moz.build
+++ b/src/zen/tests/mochitests/moz.build
@@ -15,4 +15,7 @@ BROWSER_CHROME_MANIFESTS += [
"tooltiptext/browser.toml",
]
XPCSHELL_TESTS_MANIFESTS += [
+ "remote-settings/xpcshell.toml",
+ "services-crypto/xpcshell.toml",
+ "sync/xpcshell.toml",
]
\ No newline at end of file
diff --git a/src/zen/tests/mochitests/remote-settings/head_settings.js b/src/zen/tests/mochitests/remote-settings/head_settings.js
new file mode 100644
index 000000000..f575f276c
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/head_settings.js
@@ -0,0 +1,86 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* import-globals-from ../../../common/tests/unit/head_global.js */
+/* import-globals-from ../../../common/tests/unit/head_helpers.js */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+ AppConstants: "resource://gre/modules/AppConstants.sys.mjs",
+ Database: "resource://services-settings/Database.sys.mjs",
+ RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",
+ RemoteSettingsClient:
+ "resource://services-settings/RemoteSettingsClient.sys.mjs",
+ RemoteSettingsWorker:
+ "resource://services-settings/RemoteSettingsWorker.sys.mjs",
+ setTimeout: "resource://gre/modules/Timer.sys.mjs",
+ SharedUtils: "resource://services-settings/SharedUtils.sys.mjs",
+ SyncHistory: "resource://services-settings/SyncHistory.sys.mjs",
+ TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+ TestUtils: "resource://testing-common/TestUtils.sys.mjs",
+ UptakeTelemetry: "resource://services-settings/UptakeTelemetry.sys.mjs",
+ Utils: "resource://services-settings/Utils.sys.mjs",
+});
+
+const IS_ANDROID = AppConstants.platform == "android";
+
+function arrayEqual(a, b) {
+ return JSON.stringify(a) == JSON.stringify(b);
+}
+
+add_setup(function () {
+ Services.fog.initializeFOG();
+});
+
+function enableUptakeMetric() {
+ Services.fog.applyServerKnobsConfig(
+ JSON.stringify({
+ metrics_enabled: {
+ "uptake.remotecontent.result.uptake_remotesettings": true,
+ },
+ })
+ );
+}
+
+function assertTelemetryEvents(expectedEvents) {
+ if (IS_ANDROID) {
+ /*
+ Since `Services.fog.applyServerKnobsConfig()` has no effect on Android
+ https://searchfox.org/firefox-main/rev/e28b34ab33dbf49364999070168cbb7e11e8e5bd/toolkit/components/glean/xpcom/FOG.cpp#379-390
+ we skip assertions on events on this platform.
+ Alternatively we could have disabled the whole tests suites or introduced `if IS_ANDROID` on each
+ test involving telemetry, but this seems the most reasonable way.
+ See Bug 2028765 and Bug 2042499
+ */
+ Assert.ok(
+ true,
+ "Glean Uptake Telemetry assertions are ALWAYS true on Android"
+ );
+ return;
+ }
+ const events =
+ Glean.uptakeRemotecontentResult.uptakeRemotesettings.testGetValue() ?? [];
+ const receivedValues = events.map(e => e.extra.value);
+ Assert.equal(
+ events.length,
+ expectedEvents.length,
+ `number of uptake events (${receivedValues})`
+ );
+ for (let i = 0; i < expectedEvents.length; i++) {
+ for (const [key, expected] of Object.entries(expectedEvents[i])) {
+ if (typeof expected === "function") {
+ Assert.ok(
+ expected(events[i].extra[key]),
+ `event[${i}].extra.${key} passes validator`
+ );
+ } else {
+ Assert.equal(
+ events[i].extra[key],
+ expected,
+ `event[${i}].extra.${key}`
+ );
+ }
+ }
+ }
+}
diff --git a/src/zen/tests/mochitests/remote-settings/test_attachments_downloader.js b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader.js
new file mode 100644
index 000000000..a2d1ca070
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader.js
@@ -0,0 +1,896 @@
+const { Downloader } = ChromeUtils.importESModule(
+ "resource://services-settings/Attachments.sys.mjs"
+);
+
+const RECORD = {
+ id: "1f3a0802-648d-11ea-bd79-876a8b69c377",
+ attachment: {
+ hash: "f41ed47d0f43325c9f089d03415c972ce1d3f1ecab6e4d6260665baf3db3ccee",
+ size: 1597,
+ filename: "test_file.pem",
+ location:
+ "main-workspace/some-collection/65650a0f-7c22-4c10-9744-2d67e301f5f4.pem",
+ mimetype: "application/x-pem-file",
+ },
+};
+
+const RECORD_OF_DUMP = {
+ id: "filename-of-dump.txt",
+ attachment: {
+ filename: "filename-of-dump.txt",
+ hash: "4c46ef7e4f1951d210fe54c21e07c09bab265fd122580083ed1d6121547a8c6b",
+ size: 25,
+ },
+ last_modified: 1234567,
+ some_key: "some metadata",
+};
+
+let downloader;
+let server;
+
+add_setup(() => {
+ server = new HttpServer();
+ server.start(-1);
+ registerCleanupFunction(() => server.stop(() => {}));
+
+ server.registerDirectory(
+ "/cdn/main-workspace/some-collection/",
+ do_get_file("test_attachments_downloader")
+ );
+ server.registerDirectory(
+ "/cdn/bundles/",
+ do_get_file("test_attachments_downloader")
+ );
+
+ // For this test, we are using a server other than production. Force
+ // LOAD_DUMPS to true so that we can still load attachments from dumps.
+ delete Utils.LOAD_DUMPS;
+ Utils.LOAD_DUMPS = true;
+});
+
+async function clear_state() {
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ downloader = new Downloader("main", "some-collection");
+ downloader.cache = {};
+ const memCacheImpl = {
+ get: async id => {
+ return downloader.cache[id];
+ },
+ set: async (id, obj) => {
+ downloader.cache[id] = obj;
+ },
+ setMultiple: async idsObjs => {
+ idsObjs.forEach(([id, obj]) => (downloader.cache[id] = obj));
+ },
+ delete: async id => {
+ delete downloader.cache[id];
+ },
+ deleteMultiple: async ids => {
+ ids.forEach(id => delete downloader.cache[id]);
+ },
+ hasData: async () => {
+ return !!Object.keys(downloader.cache).length;
+ },
+ };
+ // The download() method requires a cacheImpl, but the Downloader
+ // class does not have one. Define a dummy no-op one.
+ Object.defineProperty(downloader, "cacheImpl", {
+ value: memCacheImpl,
+ // Writable to allow specific tests to override cacheImpl.
+ writable: true,
+ });
+ await downloader.deleteDownloaded(RECORD);
+
+ server.registerPathHandler("/v1/", (request, response) => {
+ response.write(
+ JSON.stringify({
+ capabilities: {
+ attachments: {
+ base_url: `http://localhost:${server.identity.primaryPort}/cdn/`,
+ },
+ },
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ });
+
+ // For tests that use a real client and DB cache, clear the local DB too.
+ const client = RemoteSettings("some-collection");
+ await client.db.clear();
+ await client.db.pruneAttachments([]);
+}
+add_task(clear_state);
+
+add_task(
+ async function test_download_throws_server_info_error_if_invalid_response() {
+ server.registerPathHandler("/v1/", (request, response) => {
+ response.write("{bad json content");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ });
+
+ let error;
+ try {
+ await downloader.download(RECORD);
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.ok(error instanceof Downloader.ServerInfoError);
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_download_is_retried_3_times_if_download_fails() {
+ const record = {
+ id: "abc",
+ attachment: {
+ ...RECORD.attachment,
+ location: "404-error.pem",
+ },
+ };
+
+ let called = 0;
+ const _fetchAttachment = downloader._fetchAttachment;
+ downloader._fetchAttachment = async url => {
+ called++;
+ return _fetchAttachment(url);
+ };
+
+ let error;
+ try {
+ await downloader.download(record);
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.equal(called, 4); // 1 + 3 retries
+ Assert.ok(error instanceof Downloader.DownloadError);
+});
+add_task(clear_state);
+
+add_task(async function test_download_as_bytes() {
+ const bytes = await downloader.downloadAsBytes(RECORD);
+
+ // See *.pem file in tests data.
+ Assert.greater(
+ bytes.byteLength,
+ 1500,
+ `Wrong bytes size: ${bytes.byteLength}`
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_download_is_retried_3_times_if_content_fails() {
+ const record = {
+ id: "abc",
+ attachment: {
+ ...RECORD.attachment,
+ hash: "always-wrong",
+ },
+ };
+ let called = 0;
+ downloader._fetchAttachment = async () => {
+ called++;
+ return new ArrayBuffer();
+ };
+
+ let error;
+ try {
+ await downloader.download(record);
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.equal(called, 4); // 1 + 3 retries
+ Assert.ok(error instanceof Downloader.BadContentError);
+});
+add_task(clear_state);
+
+add_task(async function test_delete_all() {
+ const client = RemoteSettings("some-collection");
+ await client.db.create(RECORD);
+ await downloader.download(RECORD);
+
+ await client.attachments.deleteAll();
+
+ Assert.ok(!(await client.attachments.cacheImpl.get(RECORD.id)));
+});
+add_task(clear_state);
+
+add_task(async function test_downloader_reports_download_errors() {
+ const client = RemoteSettings("some-collection");
+
+ const record = {
+ attachment: {
+ ...RECORD.attachment,
+ location: "404-error.pem",
+ },
+ };
+
+ try {
+ await client.attachments.download(record, { retry: 0 });
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.DOWNLOAD_START,
+ source: client.identifier,
+ },
+ {
+ value: UptakeTelemetry.STATUS.DOWNLOAD_ERROR,
+ source: client.identifier,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_downloader_reports_offline_error() {
+ const backupOffline = Services.io.offline;
+ Services.io.offline = true;
+
+ try {
+ const client = RemoteSettings("some-collection");
+ const record = {
+ attachment: {
+ ...RECORD.attachment,
+ location: "will-try-and-fail.pem",
+ },
+ };
+ try {
+ await client.attachments.download(record, { retry: 0 });
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.DOWNLOAD_START,
+ source: client.identifier,
+ },
+ {
+ value: UptakeTelemetry.STATUS.NETWORK_OFFLINE_ERROR,
+ source: client.identifier,
+ },
+ ]);
+ } finally {
+ Services.io.offline = backupOffline;
+ }
+});
+add_task(clear_state);
+
+// Common code for test_download_cache_hit and test_download_cache_corruption.
+async function doTestDownloadCacheImpl({
+ simulateCorruption,
+ expectedReads = 1,
+ expectedWrites = 1,
+ downloadOptions = {},
+}) {
+ let readCount = 0;
+ let writeCount = 0;
+ const cacheImpl = {
+ async get(attachmentId) {
+ Assert.equal(attachmentId, RECORD.id, "expected attachmentId");
+ ++readCount;
+ if (simulateCorruption) {
+ throw new Error("Simulation of corrupted cache (read)");
+ }
+ },
+ async set(attachmentId, attachment) {
+ Assert.equal(attachmentId, RECORD.id, "expected attachmentId");
+ Assert.deepEqual(attachment.record, RECORD, "expected record");
+ ++writeCount;
+ if (simulateCorruption) {
+ throw new Error("Simulation of corrupted cache (write)");
+ }
+ },
+ async delete() {},
+ };
+ Object.defineProperty(downloader, "cacheImpl", { value: cacheImpl });
+
+ let downloadResult = await downloader.download(RECORD, downloadOptions);
+ Assert.equal(downloadResult._source, "remote_match", "expected source");
+ Assert.equal(downloadResult.buffer.byteLength, 1597, "expected result");
+ Assert.equal(readCount, expectedReads, "expected cache read attempts");
+ Assert.equal(writeCount, expectedWrites, "expected cache write attempts");
+}
+
+add_task(async function test_download_cache_hit() {
+ await doTestDownloadCacheImpl({ simulateCorruption: false });
+});
+add_task(clear_state);
+
+// Verify that the downloader works despite a broken cache implementation.
+add_task(async function test_download_cache_corruption() {
+ await doTestDownloadCacheImpl({ simulateCorruption: true });
+});
+add_task(clear_state);
+
+add_task(async function test_download_with_cache_enabled() {
+ await doTestDownloadCacheImpl({
+ simulateCorruption: false,
+ downloadOptions: {
+ cacheResult: true,
+ },
+ });
+});
+add_task(clear_state);
+
+add_task(async function test_download_with_cache_disabled() {
+ await doTestDownloadCacheImpl({
+ simulateCorruption: false,
+ expectedWrites: 0,
+ downloadOptions: {
+ cacheResult: false,
+ },
+ });
+});
+add_task(clear_state);
+
+add_task(async function test_download_cached() {
+ const client = RemoteSettings("main", "some-collection");
+ const attachmentId = "dummy filename";
+ const badRecord = {
+ attachment: {
+ ...RECORD.attachment,
+ hash: "non-matching hash",
+ location: "non-existing-location-should-fail.bin",
+ },
+ };
+ async function downloadWithCache(record, options) {
+ options = { ...options, useCache: true };
+ return client.attachments.download(record, options);
+ }
+ function checkInfo(downloadResult, expectedSource, msg) {
+ Assert.deepEqual(
+ downloadResult.record,
+ RECORD,
+ `${msg} : expected identical record`
+ );
+ // Simple check: assume that content is identical if the size matches.
+ Assert.equal(
+ downloadResult.buffer.byteLength,
+ RECORD.attachment.size,
+ `${msg} : expected buffer`
+ );
+ Assert.equal(
+ downloadResult._source,
+ expectedSource,
+ `${msg} : expected source of the result`
+ );
+ }
+
+ await Assert.rejects(
+ downloadWithCache(null, { attachmentId }),
+ /DownloadError: Could not download dummy filename/,
+ "Download without record or cache should fail."
+ );
+
+ // Populate cache.
+ const info1 = await downloadWithCache(RECORD, { attachmentId });
+ checkInfo(info1, "remote_match", "first time download");
+
+ await Assert.rejects(
+ downloadWithCache(null, { attachmentId }),
+ /DownloadError: Could not download dummy filename/,
+ "Download without record still fails even if there is a cache."
+ );
+
+ await Assert.rejects(
+ downloadWithCache(badRecord, { attachmentId }),
+ /DownloadError: Could not download .*non-existing-location-should-fail.bin/,
+ "Download with non-matching record still fails even if there is a cache."
+ );
+
+ // Download from cache.
+ const info2 = await downloadWithCache(RECORD, { attachmentId });
+ checkInfo(info2, "cache_match", "download matching record from cache");
+
+ const info3 = await downloadWithCache(RECORD, {
+ attachmentId,
+ fallbackToCache: true,
+ });
+ checkInfo(info3, "cache_match", "fallbackToCache accepts matching record");
+
+ const info4 = await downloadWithCache(null, {
+ attachmentId,
+ fallbackToCache: true,
+ });
+ checkInfo(info4, "cache_fallback", "fallbackToCache accepts null record");
+
+ const info5 = await downloadWithCache(badRecord, {
+ attachmentId,
+ fallbackToCache: true,
+ });
+ checkInfo(info5, "cache_fallback", "fallbackToCache ignores bad record");
+
+ // Bye bye cache.
+ await client.attachments.deleteDownloaded({ id: attachmentId });
+ await Assert.rejects(
+ downloadWithCache(null, { attachmentId, fallbackToCache: true }),
+ /DownloadError: Could not download dummy filename/,
+ "Download without cache should fail again."
+ );
+ await Assert.rejects(
+ downloadWithCache(badRecord, { attachmentId, fallbackToCache: true }),
+ /DownloadError: Could not download .*non-existing-location-should-fail.bin/,
+ "Download should fail to fall back to a download of a non-existing record"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_download_from_dump() {
+ const client = RemoteSettings("dump-collection", {
+ bucketName: "dump-bucket",
+ });
+
+ // Temporarily replace the resource:-URL with another resource:-URL.
+ const orig_RESOURCE_BASE_URL = Downloader._RESOURCE_BASE_URL;
+ Downloader._RESOURCE_BASE_URL = "resource://rs-downloader-test";
+ const resProto = Services.io
+ .getProtocolHandler("resource")
+ .QueryInterface(Ci.nsIResProtocolHandler);
+ resProto.setSubstitution(
+ "rs-downloader-test",
+ Services.io.newFileURI(do_get_file("test_attachments_downloader"))
+ );
+
+ function checkInfo(result, expectedSource, expectedRecord = RECORD_OF_DUMP) {
+ Assert.equal(
+ new TextDecoder().decode(new Uint8Array(result.buffer)),
+ "This would be a RS dump.\n",
+ "expected content from dump"
+ );
+ Assert.deepEqual(result.record, expectedRecord, "expected record for dump");
+ Assert.equal(result._source, expectedSource, "expected source of dump");
+ }
+
+ // If record matches, should happen before network request.
+ const dump1 = await client.attachments.download(RECORD_OF_DUMP, {
+ // Note: attachmentId not set, so should fall back to record.id.
+ fallbackToDump: true,
+ });
+ checkInfo(dump1, "dump_match");
+
+ // If no record given, should try network first, but then fall back to dump.
+ const dump2 = await client.attachments.download(null, {
+ attachmentId: RECORD_OF_DUMP.id,
+ fallbackToDump: true,
+ });
+ checkInfo(dump2, "dump_fallback");
+
+ // Fill the cache with the same data as the dump for the next part.
+ await client.db.saveAttachment(RECORD_OF_DUMP.id, {
+ record: RECORD_OF_DUMP,
+ blob: new Blob([dump1.buffer]),
+ });
+ // The dump should take precedence over the cache.
+ const dump3 = await client.attachments.download(RECORD_OF_DUMP, {
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump3, "dump_match");
+
+ // When the record is not given, the dump takes precedence over the cache
+ // as a fallback (when the cache and dump are identical).
+ const dump4 = await client.attachments.download(null, {
+ attachmentId: RECORD_OF_DUMP.id,
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump4, "dump_fallback");
+
+ // Store a record in the cache that is newer than the dump.
+ const RECORD_NEWER_THAN_DUMP = {
+ ...RECORD_OF_DUMP,
+ last_modified: RECORD_OF_DUMP.last_modified + 1,
+ };
+ await client.db.saveAttachment(RECORD_OF_DUMP.id, {
+ record: RECORD_NEWER_THAN_DUMP,
+ blob: new Blob([dump1.buffer]),
+ });
+
+ // When the record is not given, use the cache if it has a more recent record.
+ const dump5 = await client.attachments.download(null, {
+ attachmentId: RECORD_OF_DUMP.id,
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump5, "cache_fallback", RECORD_NEWER_THAN_DUMP);
+
+ // When a record is given, use whichever that has the matching last_modified.
+ const dump6 = await client.attachments.download(RECORD_OF_DUMP, {
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump6, "dump_match");
+ const dump7 = await client.attachments.download(RECORD_NEWER_THAN_DUMP, {
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump7, "cache_match", RECORD_NEWER_THAN_DUMP);
+
+ await client.attachments.deleteDownloaded(RECORD_OF_DUMP);
+
+ await Assert.rejects(
+ client.attachments.download(null, {
+ attachmentId: "filename-without-meta.txt",
+ fallbackToDump: true,
+ }),
+ /DownloadError: Could not download filename-without-meta.txt/,
+ "Cannot download dump that lacks a .meta.json file"
+ );
+
+ await Assert.rejects(
+ client.attachments.download(null, {
+ attachmentId: "filename-without-content.txt",
+ fallbackToDump: true,
+ }),
+ /Could not download resource:\/\/rs-downloader-test\/settings\/dump-bucket\/dump-collection\/filename-without-content\.txt(?!\.meta\.json)/,
+ "Cannot download dump that is missing, despite the existing .meta.json"
+ );
+
+ // Restore, just in case.
+ Downloader._RESOURCE_BASE_URL = orig_RESOURCE_BASE_URL;
+ resProto.setSubstitution("rs-downloader-test", null);
+});
+// Not really needed because the last test doesn't modify the main collection,
+// but added for consistency with other tests tasks around here.
+add_task(clear_state);
+
+add_task(
+ async function test_download_from_dump_fails_when_load_dumps_is_false() {
+ const client = RemoteSettings("dump-collection", {
+ bucketName: "dump-bucket",
+ });
+
+ // Temporarily replace the resource:-URL with another resource:-URL.
+ const orig_RESOURCE_BASE_URL = Downloader._RESOURCE_BASE_URL;
+ Downloader._RESOURCE_BASE_URL = "resource://rs-downloader-test";
+ const resProto = Services.io
+ .getProtocolHandler("resource")
+ .QueryInterface(Ci.nsIResProtocolHandler);
+ resProto.setSubstitution(
+ "rs-downloader-test",
+ Services.io.newFileURI(do_get_file("test_attachments_downloader"))
+ );
+
+ function checkInfo(
+ result,
+ expectedSource,
+ expectedRecord = RECORD_OF_DUMP
+ ) {
+ Assert.equal(
+ new TextDecoder().decode(new Uint8Array(result.buffer)),
+ "This would be a RS dump.\n",
+ "expected content from dump"
+ );
+ Assert.deepEqual(
+ result.record,
+ expectedRecord,
+ "expected record for dump"
+ );
+ Assert.equal(result._source, expectedSource, "expected source of dump");
+ }
+
+ // Download the dump so that we can use it to fill the cache.
+ const dump1 = await client.attachments.download(RECORD_OF_DUMP, {
+ // Note: attachmentId not set, so should fall back to record.id.
+ fallbackToDump: true,
+ });
+ checkInfo(dump1, "dump_match");
+
+ // Fill the cache with the same data as the dump for the next part.
+ await client.db.saveAttachment(RECORD_OF_DUMP.id, {
+ record: RECORD_OF_DUMP,
+ blob: new Blob([dump1.buffer]),
+ });
+
+ // Now turn off loading dumps, and check we no longer load from the dump,
+ // but use the cache instead.
+ Utils.LOAD_DUMPS = false;
+
+ const dump2 = await client.attachments.download(RECORD_OF_DUMP, {
+ // Note: attachmentId not set, so should fall back to record.id.
+ fallbackToDump: true,
+ });
+ checkInfo(dump2, "cache_match");
+
+ // When the record is not given, the dump would take precedence over the
+ // cache but we have disabled dumps, so we should load from the cache.
+ const dump4 = await client.attachments.download(null, {
+ attachmentId: RECORD_OF_DUMP.id,
+ fallbackToCache: true,
+ fallbackToDump: true,
+ });
+ checkInfo(dump4, "cache_fallback");
+
+ // Restore, just in case.
+ Utils.LOAD_DUMPS = true;
+ Downloader._RESOURCE_BASE_URL = orig_RESOURCE_BASE_URL;
+ resProto.setSubstitution("rs-downloader-test", null);
+ }
+);
+
+add_task(async function test_attachment_get() {
+ // Since get() is largely a wrapper around the same code as download(),
+ // we only test a couple of parts to check it functions as expected, and
+ // rely on the download() testing for the rest.
+
+ await Assert.rejects(
+ downloader.get(RECORD),
+ /NotFoundError: Could not find /,
+ "get() fails when there is no local cache nor dump"
+ );
+
+ const client = RemoteSettings("dump-collection", {
+ bucketName: "dump-bucket",
+ });
+
+ // Temporarily replace the resource:-URL with another resource:-URL.
+ const orig_RESOURCE_BASE_URL = Downloader._RESOURCE_BASE_URL;
+ Downloader._RESOURCE_BASE_URL = "resource://rs-downloader-test";
+ const resProto = Services.io
+ .getProtocolHandler("resource")
+ .QueryInterface(Ci.nsIResProtocolHandler);
+ resProto.setSubstitution(
+ "rs-downloader-test",
+ Services.io.newFileURI(do_get_file("test_attachments_downloader"))
+ );
+
+ function checkInfo(result, expectedSource, expectedRecord = RECORD_OF_DUMP) {
+ Assert.equal(
+ new TextDecoder().decode(new Uint8Array(result.buffer)),
+ "This would be a RS dump.\n",
+ "expected content from dump"
+ );
+ Assert.deepEqual(result.record, expectedRecord, "expected record for dump");
+ Assert.equal(result._source, expectedSource, "expected source of dump");
+ }
+
+ // When a record is given, use whichever that has the matching last_modified.
+ const dump = await client.attachments.get(RECORD_OF_DUMP);
+ checkInfo(dump, "dump_match");
+
+ await client.attachments.deleteDownloaded(RECORD_OF_DUMP);
+
+ await Assert.rejects(
+ client.attachments.get(null, {
+ attachmentId: "filename-without-meta.txt",
+ fallbackToDump: true,
+ }),
+ /NotFoundError: Could not find filename-without-meta.txt in cache or dump/,
+ "Cannot download dump that lacks a .meta.json file"
+ );
+
+ await Assert.rejects(
+ client.attachments.get(null, {
+ attachmentId: "filename-without-content.txt",
+ fallbackToDump: true,
+ }),
+ /Could not download resource:\/\/rs-downloader-test\/settings\/dump-bucket\/dump-collection\/filename-without-content\.txt(?!\.meta\.json)/,
+ "Cannot download dump that is missing, despite the existing .meta.json"
+ );
+
+ // Restore, just in case.
+ Downloader._RESOURCE_BASE_URL = orig_RESOURCE_BASE_URL;
+ resProto.setSubstitution("rs-downloader-test", null);
+});
+// Not really needed because the last test doesn't modify the main collection,
+// but added for consistency with other tests tasks around here.
+add_task(clear_state);
+
+add_task(async function test_obsolete_attachments_are_pruned() {
+ const RECORD2 = {
+ ...RECORD,
+ id: "another-id",
+ };
+ const client = RemoteSettings("some-collection");
+ // Store records and related attachments directly in the cache.
+ await client.db.importChanges({}, 42, [RECORD, RECORD2], { clear: true });
+ await client.db.saveAttachment(RECORD.id, {
+ record: RECORD,
+ blob: new Blob(["123"]),
+ });
+ await client.db.saveAttachment("custom-id", {
+ record: RECORD2,
+ blob: new Blob(["456"]),
+ });
+ // Store an extraneous cached attachment.
+ await client.db.saveAttachment("bar", {
+ record: { id: "bar" },
+ blob: new Blob(["789"]),
+ });
+
+ const recordAttachment = await client.attachments.cacheImpl.get(RECORD.id);
+ Assert.equal(
+ await recordAttachment.blob.text(),
+ "123",
+ "Record has a cached attachment"
+ );
+ const record2Attachment = await client.attachments.cacheImpl.get("custom-id");
+ Assert.equal(
+ await record2Attachment.blob.text(),
+ "456",
+ "Record 2 has a cached attachment"
+ );
+ const { blob: cachedExtra } = await client.attachments.cacheImpl.get("bar");
+ Assert.equal(await cachedExtra.text(), "789", "There is an extra attachment");
+
+ await client.attachments.prune([]);
+
+ Assert.ok(
+ await client.attachments.cacheImpl.get(RECORD.id),
+ "Record attachment was kept"
+ );
+ Assert.ok(
+ await client.attachments.cacheImpl.get("custom-id"),
+ "Record 2 attachment was kept"
+ );
+ Assert.ok(
+ !(await client.attachments.cacheImpl.get("bar")),
+ "Extra was deleted"
+ );
+});
+add_task(clear_state);
+
+add_task(
+ async function test_obsolete_attachments_listed_as_excluded_are_not_pruned() {
+ const client = RemoteSettings("some-collection");
+ // Store records and related attachments directly in the cache.
+ await client.db.importChanges({}, 42, [], { clear: true });
+ await client.db.saveAttachment(RECORD.id, {
+ record: RECORD,
+ blob: new Blob(["123"]),
+ });
+
+ const recordAttachment = await client.attachments.cacheImpl.get(RECORD.id);
+ Assert.equal(
+ await recordAttachment.blob.text(),
+ "123",
+ "Record has a cached attachment"
+ );
+
+ await client.attachments.prune([RECORD.id]);
+
+ Assert.ok(
+ await client.attachments.cacheImpl.get(RECORD.id),
+ "Record attachment was kept"
+ );
+ }
+);
+
+add_task(clear_state);
+
+add_task(async function test_cacheAll_happy_path() {
+ // verify bundle is downloaded succesfully
+ const allSuccess = await downloader.cacheAll();
+ Assert.ok(
+ allSuccess,
+ "Attachments cacheAll succesfully downloaded a bundle and saved all attachments"
+ );
+
+ // verify accuracy of attachments downloaded
+ Assert.equal(
+ downloader.cache["1"].record.title,
+ "test1",
+ "Test record 1 meta content appears accurate."
+ );
+ Assert.equal(
+ await downloader.cache["1"].blob.text(),
+ "test1\n",
+ "Test file 1 content is accurate."
+ );
+ Assert.equal(
+ downloader.cache["2"].record.title,
+ "test2",
+ "Test record 2 meta content appears accurate."
+ );
+ Assert.equal(
+ await downloader.cache["2"].blob.text(),
+ "test2\n",
+ "Test file 2 content is accurate."
+ );
+});
+
+add_task(async function test_cacheAll_using_real_db() {
+ const client = RemoteSettings("some-collection");
+
+ const allSuccess = await client.attachments.cacheAll();
+
+ Assert.ok(
+ allSuccess,
+ "Attachments cacheAll succesfully downloaded a bundle and saved all attachments"
+ );
+
+ Assert.equal(
+ (await client.attachments.cacheImpl.get("2")).record.title,
+ "test2",
+ "Test record 2 meta content appears accurate."
+ );
+ Assert.equal(
+ await (await client.attachments.cacheImpl.get("2")).blob.text(),
+ "test2\n",
+ "Test file 2 content is accurate."
+ );
+});
+
+add_task(clear_state);
+
+add_task(async function test_cacheAll_skips_with_existing_data() {
+ downloader.cache = {
+ 1: "1",
+ };
+ const allSuccess = await downloader.cacheAll();
+ Assert.equal(
+ allSuccess,
+ null,
+ "Attachments cacheAll skips downloads if data already exists"
+ );
+});
+
+add_task(async function test_cacheAll_does_not_skip_if_force_is_true() {
+ downloader.cache = {
+ 1: "1",
+ };
+ const allSuccess = await downloader.cacheAll(true);
+ Assert.equal(
+ allSuccess,
+ true,
+ "Attachments cacheAll does not skip downloads if force is true"
+ );
+});
+
+add_task(clear_state);
+
+add_task(async function test_cacheAll_failed_request() {
+ downloader.bucketName = "fake-bucket";
+ downloader.collectionName = "fake-collection";
+ const allSuccess = await downloader.cacheAll();
+ Assert.equal(
+ allSuccess,
+ false,
+ "Attachments cacheAll request failed to download a bundle and returned false"
+ );
+});
+
+add_task(clear_state);
+
+add_task(async function test_cacheAll_failed_unzip() {
+ downloader.bucketName = "error-bucket";
+ downloader.collectionName = "bad-zip";
+ const allSuccess = await downloader.cacheAll();
+ Assert.equal(
+ allSuccess,
+ false,
+ "Attachments cacheAll request failed to extract a bundle and returned false"
+ );
+});
+
+add_task(clear_state);
+
+add_task(async function test_cacheAll_failed_save() {
+ const client = RemoteSettings("some-collection");
+
+ const backup = client.db.saveAttachments;
+ client.db.saveAttachments = () => {
+ throw new Error("boom");
+ };
+
+ const allSuccess = await client.attachments.cacheAll();
+
+ Assert.equal(
+ allSuccess,
+ false,
+ "Attachments cacheAll failed to save entries in DB and returned false"
+ );
+ client.db.saveAttachments = backup;
+});
+
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/65650a0f-7c22-4c10-9744-2d67e301f5f4.pem b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/65650a0f-7c22-4c10-9744-2d67e301f5f4.pem
new file mode 100644
index 000000000..502e8c9ce
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/65650a0f-7c22-4c10-9744-2d67e301f5f4.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEbjCCA1agAwIBAgIQBg3WwdBnkBtUdfz/wp4xNzANBgkqhkiG9w0BAQsFADBa
+MQswCQYDVQQGEwJJRTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJl
+clRydXN0MSIwIAYDVQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTE1
+MTAxNDEyMDAwMFoXDTIwMTAxNDEyMDAwMFowbzELMAkGA1UEBhMCVVMxCzAJBgNV
+BAgTAkNBMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRkwFwYDVQQKExBDbG91ZEZs
+YXJlLCBJbmMuMSAwHgYDVQQDExdDbG91ZEZsYXJlIEluYyBSU0EgQ0EtMTCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJGiNOIE4s0M4wdhDeV9aMfAYY9l
+yG9cfGQqt7a5UgrRA81bi4istCyhzfzRWUW+NAmf6X2HEnA3xLI1M+pH/xEbk9pw
+jc8/1CPy9jUjBwb89zt5PWh2I1KxZVg/Bnx2yYdVcKTUMKt0GLDXfZXN+RYZHJQo
+lDlzjH5xV0IpDMv/FsMEZWcfx1JorBf08bRnRVkl9RY00y2ujVr+492ze+zYQ9s7
+HcidpR+7ret3jzLSvojsaA5+fOaCG0ctVJcLfnkQ5lWR95ByBdO1NapfqZ1+kmCL
+3baVSeUpYQriBwznxfLuGs8POo4QdviYVtSPBWjOEfb+o1c6Mbo8p4noFzUCAwEA
+AaOCARkwggEVMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgGGMDQG
+CCsGAQUFBwEBBCgwJjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu
+Y29tMDoGA1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9P
+bW5pcm9vdDIwMjUuY3JsMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIB
+FhxodHRwczovL3d3dy5kaWdpY2VydC5jb20vQ1BTMB0GA1UdDgQWBBSRBYrfTCLG
+bYuUTBZFfu5vAvu3wDAfBgNVHSMEGDAWgBTlnVkwgkdYzKz6CFQ2hns6tQRN8DAN
+BgkqhkiG9w0BAQsFAAOCAQEAVJle3ar9NSnTrLAhgfkcpClIY6/kabDIEa8cOnu1
+SOXf4vbtZakSmmIbFbmYDUGIU5XwwVdF/FKNzNBRf9G4EL/S0NXytBKj4A34UGQA
+InaV+DgVLzCifN9cAHi8EFEAfbglUvPvLPFXF0bwffElYm7QBSiHYSZmfOKLCyiv
+3zlQsf7ozNBAxfbmnRMRSUBcIhRwnaFoFgDs7yU6R1Yk4pO7eMgWpdPGhymDTIvv
+RnauKStzKsAli9i5hQ4nTDITUpMAmeJoXodgwRkC3Civw32UR2rxObIyxPpbfODb
+sZKNGO9K5Sjj6turB1zwbd2wI8MhtUCY9tGmSYhe7G6Bkw==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/error-bucket--bad-zip.zip b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/error-bucket--bad-zip.zip
new file mode 100644
index 000000000..5b07782c9
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/error-bucket--bad-zip.zip
@@ -0,0 +1 @@
+not a zip
diff --git a/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/main--some-collection.zip b/src/zen/tests/mochitests/remote-settings/test_attachments_downloader/main--some-collection.zip
new file mode 100644
index 0000000000000000000000000000000000000000..8413ee7ab9412e5d32ea3e31accfdf9cb884ab92
GIT binary patch
literal 994
zcmWIWW@Zs#;9%fjF!OvF!2ktp3=9m63^p*b(?IxGNN-wc1vdjD%L`@(
z1~8%RsjFxBgoz=*o1H`2JhFy^fq?;}8DXr07sA*(3=9n1AY=7%Q%e%{vWoNbz!t0s
z=}kKo)SCvP(JTl(;DM+%b~?r^!DRXZEwG-nlDzr1kW^+FPcl
zi<265U+iMG{bV}rh8thgnpN)=pdA
zz#>wAW|iokWq;*1EtuhRL}Yrj(2~FZDxb5oTBaPh$ir^4_I+u9=e9ke(|_Fx`?@#l
zR?cZVkT><#+P9W?MzT_8i>XldKV29sw6KvaQZ%LPq7o8Qc#{QAg=fOTjumdI-QK~+|=bt^rwde
zNn7@1E>dK%stLZbeaV$Kj~9g5?4EN%#_;j;oEH*OHE|YU@wR)JgaZE>F8BK|Yg_e+
zo~%ur!BOiXCw#m8yjNJHY`S3eW|@x#3$Ht>-u`@b&MWWiSFPDJQ2
zGKnxFQXg^x0;N7^Vr1CT2x1XTivivU<3OnnIif(R4rB-jZ)pr?U|=vr3q?@c!;uD&
z4F<(Ca#W$Z(~gmWfncm78wZMC {
+ // Set up an HTTP Server
+ server = new HttpServer();
+ server.start(-1);
+
+ // Point the blocklist clients to use this local HTTP server.
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ Services.prefs.setStringPref("services.settings.loglevel", "debug");
+
+ client = RemoteSettings("password-fields");
+ clientWithDump = RemoteSettings("language-dictionaries");
+
+ server.registerPathHandler("/v1/", handleResponse);
+ server.registerPathHandler(
+ "/v1/buckets/monitor/collections/changes/changeset",
+ handleResponse
+ );
+ server.registerPathHandler(
+ "/v1/buckets/main/collections/password-fields/changeset",
+ handleResponse
+ );
+ server.registerPathHandler(
+ "/v1/buckets/main/collections/language-dictionaries/changeset",
+ handleResponse
+ );
+ server.registerPathHandler(
+ "/v1/buckets/main/collections/with-local-fields/changeset",
+ handleResponse
+ );
+ server.registerPathHandler("/fake-x5u", handleResponse);
+
+ registerCleanupFunction(() => {
+ server.stop(() => {});
+ });
+});
+add_task(clear_state);
+
+add_task(async function test_records_obtained_from_server_are_stored_in_db() {
+ // Test an empty db populates
+ await client.maybeSync(2000);
+
+ // Open the collection, verify it's been populated:
+ // Our test data has a single record; it should be in the local collection
+ const list = await client.get();
+ equal(list.length, 1);
+
+ const timestamp = await client.db.getLastModified();
+ equal(timestamp, 3000, "timestamp was stored");
+
+ const { signatures } = await client.db.getMetadata();
+ equal(signatures[0].signature, "abcdef", "metadata was stored");
+});
+add_task(clear_state);
+
+add_task(async function test_client_db_throws_if_not_synced() {
+ try {
+ await client.db.list();
+ Assert.ok(false, "db.list() should throw");
+ } catch (e) {
+ Assert.equal(
+ e.toString(),
+ 'EmptyDatabaseError: "main/password-fields" has not been synced yet'
+ );
+ }
+
+ await client.maybeSync(2000);
+
+ const list = await client.db.list();
+ Assert.ok(Array.isArray(list), "data is an array");
+});
+add_task(clear_state);
+
+add_task(
+ async function test_records_from_dump_are_listed_as_created_in_event() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ let received;
+ clientWithDump.on("sync", ({ data }) => (received = data));
+ // Use a timestamp superior to latest record in dump.
+ const timestamp = 5000000000000; // Fri Jun 11 2128
+
+ await clientWithDump.maybeSync(timestamp);
+
+ const list = await clientWithDump.get();
+ Assert.greater(
+ list.length,
+ 20,
+ `The dump was loaded (${list.length} records)`
+ );
+ equal(received.created[0].id, "xx", "Record from the sync come first.");
+
+ const createdById = received.created.reduce((acc, r) => {
+ acc[r.id] = r;
+ return acc;
+ }, {});
+
+ ok(
+ !(received.deleted[0].id in createdById),
+ "Deleted records are not listed as created"
+ );
+ equal(
+ createdById[received.updated[0].new.id],
+ received.updated[0].new,
+ "The records that were updated should appear as created in their newest form."
+ );
+
+ equal(
+ received.created.length,
+ list.length,
+ "The list of created records contains the dump"
+ );
+ equal(received.current.length, received.created.length);
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_throws_when_network_is_offline() {
+ const backupOffline = Services.io.offline;
+ try {
+ Services.io.offline = true;
+ let error;
+ try {
+ await clientWithDump.maybeSync(2000);
+ } catch (e) {
+ error = e;
+ }
+ equal(error.name, "NetworkOfflineError");
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.NETWORK_OFFLINE_ERROR,
+ },
+ ]);
+ } finally {
+ Services.io.offline = backupOffline;
+ }
+});
+add_task(clear_state);
+
+add_task(async function test_sync_event_is_sent_even_if_up_to_date() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ // First, determine what is the dump timestamp. Sync will load it.
+ // Use a timestamp inferior to latest record in dump.
+ await clientWithDump._importJSONDump();
+ const uptodateTimestamp = await clientWithDump.db.getLastModified();
+ await clear_state();
+
+ // Now, simulate that server data wasn't changed since dump was released.
+ let received;
+ clientWithDump.on("sync", ({ data }) => (received = data));
+
+ await clientWithDump.maybeSync(uptodateTimestamp);
+
+ ok(!!received.current.length, "Dump records are listed as created");
+ equal(received.current.length, received.created.length);
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.UP_TO_DATE,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_records_can_have_local_fields() {
+ const c = RemoteSettings("with-local-fields", { localFields: ["accepted"] });
+ c.verifySignature = false;
+
+ await c.maybeSync(2000);
+
+ await c.db.update({
+ id: "c74279ce-fb0a-42a6-ae11-386b567a6119",
+ accepted: true,
+ });
+ await c.maybeSync(3000); // Does not fail.
+});
+add_task(clear_state);
+
+add_task(
+ async function test_records_changes_are_overwritten_by_server_changes() {
+ // Create some local conflicting data, and make sure it syncs without error.
+ await client.db.create({
+ website: "",
+ id: "9d500963-d80e-3a91-6e74-66f3811b99cc",
+ });
+
+ await client.maybeSync(2000);
+
+ const data = await client.get();
+ equal(data[0].website, "https://some-website.com");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_get_returns_an_empty_list_when_database_is_empty() {
+ const data = await client.get({ syncIfEmpty: false });
+
+ ok(Array.isArray(data), "data is an array");
+ equal(data.length, 0, "data is empty");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_get_doesnt_affect_other_calls() {
+ const c1 = RemoteSettings("password-fields");
+ const c2 = RemoteSettings("password-fields");
+
+ const result1 = await c1.get({ syncIfEmpty: false });
+ Assert.deepEqual(result1, [], "data1 is empty");
+
+ try {
+ await c2.get({ syncIfEmpty: false, emptyListFallback: false });
+ Assert.ok(false, "get() should throw");
+ } catch (error) {
+ Assert.equal(
+ error.toString(),
+ 'EmptyDatabaseError: "main/password-fields" has not been synced yet'
+ );
+ }
+});
+add_task(clear_state);
+
+add_task(async function test_get_throws_if_no_empty_fallback_and_no_sync() {
+ try {
+ await client.get({ syncIfEmpty: false, emptyListFallback: false });
+ Assert.ok(false, ".get() should throw");
+ } catch (error) {
+ Assert.equal(
+ error.toString(),
+ 'EmptyDatabaseError: "main/password-fields" has not been synced yet'
+ );
+ }
+});
+add_task(clear_state);
+
+add_task(
+ async function test_get_loads_default_records_from_a_local_dump_when_database_is_empty() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+
+ // When collection has a dump in services/settings/dumps/{bucket}/{collection}.json
+ const data = await clientWithDump.get();
+ notEqual(data.length, 0);
+ // No synchronization happened (responses are not mocked).
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_get_loads_dump_only_once_if_called_in_parallel() {
+ const backup = clientWithDump._importJSONDump;
+ let callCount = 0;
+ clientWithDump._importJSONDump = async () => {
+ callCount++;
+ // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+ await new Promise(resolve => setTimeout(resolve, 100));
+ return 42;
+ };
+ await Promise.all([clientWithDump.get(), clientWithDump.get()]);
+ equal(callCount, 1, "JSON dump was called more than once");
+ clientWithDump._importJSONDump = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_get_falls_back_to_dump_if_db_fails() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ const backup = clientWithDump.db.getLastModified;
+ clientWithDump.db.getLastModified = () => {
+ throw new Error("Unknown error");
+ };
+
+ const records = await clientWithDump.get({ dumpFallback: true });
+ ok(!!records.length, "dump content is returned");
+
+ // If fallback is disabled, error is thrown.
+ let error;
+ try {
+ await clientWithDump.get({ dumpFallback: false });
+ } catch (e) {
+ error = e;
+ }
+ equal(error.message, "Unknown error");
+
+ clientWithDump.db.getLastModified = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_get_sorts_results_if_specified() {
+ await client.db.importChanges(
+ {},
+ 42,
+ [
+ {
+ field: 12,
+ id: "9d500963-d80e-3a91-6e74-66f3811b99cc",
+ },
+ {
+ field: 7,
+ id: "d83444a4-f348-4cd8-8228-842cb927db9f",
+ },
+ ],
+ { clear: true }
+ );
+
+ const records = await client.get({ order: "field" });
+ Assert.less(
+ records[0].field,
+ records[records.length - 1].field,
+ "records are sorted"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_get_falls_back_sorts_results() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ const backup = clientWithDump.db.getLastModified;
+ clientWithDump.db.getLastModified = () => {
+ throw new Error("Unknown error");
+ };
+
+ const records = await clientWithDump.get({
+ dumpFallback: true,
+ order: "-id",
+ });
+
+ // eslint-disable-next-line mozilla/no-comparison-or-assignment-inside-ok
+ ok(records[0].id > records[records.length - 1].id, "records are sorted");
+
+ clientWithDump.db.getLastModified = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_get_falls_back_to_dump_if_db_fails_later() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ const backup = clientWithDump.db.list;
+ clientWithDump.db.list = () => {
+ throw new Error("Unknown error");
+ };
+
+ const records = await clientWithDump.get({ dumpFallback: true });
+ ok(!!records.length, "dump content is returned");
+
+ // If fallback is disabled, error is thrown.
+ let error;
+ try {
+ await clientWithDump.get({ dumpFallback: false });
+ } catch (e) {
+ error = e;
+ }
+ equal(error.message, "Unknown error");
+
+ clientWithDump.db.list = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_get_falls_back_to_dump_if_network_fails() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ const backup = clientWithDump.sync;
+ clientWithDump.sync = () => {
+ throw new Error("Sync error");
+ };
+
+ const records = await clientWithDump.get();
+ ok(!!records.length, "dump content is returned");
+
+ clientWithDump.sync = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_get_does_not_sync_if_empty_dump_is_provided() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+
+ const clientWithEmptyDump = RemoteSettings("example");
+ Assert.ok(!(await Utils.hasLocalData(clientWithEmptyDump)));
+
+ const data = await clientWithEmptyDump.get();
+
+ equal(data.length, 0);
+ Assert.ok(await Utils.hasLocalData(clientWithEmptyDump));
+});
+add_task(clear_state);
+
+add_task(async function test_get_synchronization_can_be_disabled() {
+ const data = await client.get({ syncIfEmpty: false });
+
+ equal(data.length, 0);
+});
+add_task(clear_state);
+
+add_task(
+ async function test_get_triggers_synchronization_when_database_is_empty() {
+ // The "password-fields" collection has no local dump, and no local data.
+ // Therefore a synchronization will happen.
+ const data = await client.get();
+
+ // Data comes from mocked HTTP response (see below).
+ equal(data.length, 1);
+ equal(data[0].selector, "#webpage[field-pwd]");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_get_ignores_synchronization_errors_by_default() {
+ // The monitor endpoint won't contain any information about this collection.
+ let data = await RemoteSettings("some-unknown-key").get();
+ equal(data.length, 0);
+ // The sync endpoints are not mocked, this fails internally.
+ data = await RemoteSettings("no-mocked-responses").get();
+ equal(data.length, 0);
+});
+add_task(clear_state);
+
+add_task(async function test_get_throws_if_no_empty_fallback() {
+ // The monitor endpoint won't contain any information about this collection.
+ try {
+ await RemoteSettings("some-unknown-key").get({
+ emptyListFallback: false,
+ });
+ Assert.ok(false, ".get() should throw");
+ } catch (error) {
+ Assert.ok(
+ error.message.includes("Response from server unparseable"),
+ "Server error was thrown"
+ );
+ }
+});
+add_task(clear_state);
+
+add_task(
+ async function test_get_throws_on_network_error_with_no_empty_fallback() {
+ const backup = Utils.fetch;
+ Utils.fetch = async () => {
+ throw new Error("Fake Network error");
+ };
+
+ const clientEmpty = RemoteSettings("no-dump-no-local-data");
+ let error;
+ try {
+ await clientEmpty.get({
+ emptyListFallback: false,
+ syncIfEmpty: true, // default value
+ });
+ } catch (exc) {
+ error = exc;
+ }
+
+ equal(error.toString(), "Error: Fake Network error");
+ Utils.fetch = backup;
+ }
+);
+
+add_task(async function test_get_verify_signature_empty_no_sync() {
+ client.verifySignature = true;
+ // No data, hence no signature in metadata, and no sync if empty.
+ let error;
+ try {
+ await client.get({
+ verifySignature: true,
+ syncIfEmpty: false,
+ emptyListFallback: false,
+ });
+ Assert.ok(false, "get() should throw");
+ } catch (e) {
+ error = e;
+ }
+ equal(
+ error.toString(),
+ 'EmptyDatabaseError: "main/password-fields" has not been synced yet'
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_get_verify_signature_no_metadata_no_sync() {
+ client.verifySignature = true;
+ // Store records but no metadata.
+ await client.db.importChanges(undefined, 42, []);
+ let error;
+ try {
+ await client.get({
+ verifySignature: true,
+ syncIfEmpty: false,
+ emptyListFallback: false,
+ });
+ Assert.ok(false, "get() should throw");
+ } catch (e) {
+ error = e;
+ }
+ equal(
+ error.toString(),
+ "MissingSignatureError: Missing signature (main/password-fields)"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_get_can_verify_signature_pulled() {
+ // Populate the local DB (only records, eg. loaded from dump previously)
+ await client._importJSONDump();
+
+ let calledSignature;
+ client._verifier = {
+ async asyncVerifyContentSignature(serialized, signature) {
+ calledSignature = signature;
+ return true;
+ },
+ };
+ client.verifySignature = true;
+
+ // No metadata in local DB, but gets pulled and then verifies.
+ ok(ObjectUtils.isEmpty(await client.db.getMetadata()), "Metadata is empty");
+
+ await client.get({ verifySignature: true });
+
+ ok(
+ !ObjectUtils.isEmpty(await client.db.getMetadata()),
+ "Metadata was pulled"
+ );
+ ok(calledSignature.endsWith("some-sig"), "Signature was verified");
+});
+add_task(clear_state);
+
+add_task(async function test_get_can_verify_signature() {
+ // Populate the local DB (record and metadata)
+ await client.maybeSync(2000);
+
+ client.verifySignature = true;
+
+ // It validates signature that was stored in local DB.
+ let calledSignature;
+ client._verifier = {
+ async asyncVerifyContentSignature(serialized, signature) {
+ calledSignature = signature;
+ return JSON.parse(serialized).data.length == 1;
+ },
+ };
+ ok(await Utils.hasLocalData(client), "Local data was populated");
+ await client.get({ verifySignature: true });
+
+ ok(calledSignature.endsWith("abcdef"), "Signature was verified");
+
+ // It throws when signature does not verify.
+ await client.db.delete("9d500963-d80e-3a91-6e74-66f3811b99cc");
+ let error = null;
+ try {
+ await client.get({ verifySignature: true });
+ } catch (e) {
+ error = e;
+ }
+ equal(
+ error.message,
+ "Invalid content signature (main/password-fields) using 'fake-x5u' and signer remote-settings.content-signature.mozilla.org"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_get_does_not_verify_signature_if_load_dump() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+
+ let called;
+ clientWithDump._verifier = {
+ async asyncVerifyContentSignature() {
+ called = true;
+ return true;
+ },
+ };
+
+ // When dump is loaded, signature is not verified.
+ const records = await clientWithDump.get({ verifySignature: true });
+ ok(!!records.length, "dump is loaded");
+ ok(!called, "signature is missing but not verified");
+
+ // If metadata is missing locally, it is not fetched if `syncIfEmpty` is disabled.
+ clientWithDump.verifySignature = true;
+ let error;
+ try {
+ await clientWithDump.get({ verifySignature: true, syncIfEmpty: false });
+ } catch (e) {
+ error = e;
+ }
+ ok(!called, "signer was not called");
+ equal(
+ error.message,
+ "Missing signature (main/language-dictionaries)",
+ "signature is missing locally"
+ );
+
+ // If metadata is missing locally, it is fetched by default (`syncIfEmpty: true`)
+ await clientWithDump.get({ verifySignature: true });
+ const metadata = await clientWithDump.db.getMetadata();
+ ok(!!Object.keys(metadata).length, "metadata was fetched");
+ ok(called, "signature was verified for the data that was in dump");
+ clientWithDump.verifySignature = true;
+});
+add_task(clear_state);
+
+add_task(
+ async function test_get_does_verify_signature_if_json_loaded_in_parallel() {
+ const backup = clientWithDump._verifier;
+ let callCount = 0;
+ clientWithDump._verifier = {
+ async asyncVerifyContentSignature() {
+ callCount++;
+ return true;
+ },
+ };
+ await Promise.all([
+ clientWithDump.get({ verifySignature: true }),
+ clientWithDump.get({ verifySignature: true }),
+ ]);
+ equal(callCount, 0, "No need to verify signatures if JSON dump is loaded");
+ clientWithDump._verifier = backup;
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_get_can_force_a_sync() {
+ const step0 = await client.db.getLastModified();
+ await client.get({ forceSync: true });
+ const step1 = await client.db.getLastModified();
+ await client.get();
+ const step2 = await client.db.getLastModified();
+ await client.get({ forceSync: true });
+ const step3 = await client.db.getLastModified();
+
+ equal(step0, null);
+ equal(step1, 3000);
+ equal(step2, 3000);
+ equal(step3, 3001);
+});
+add_task(clear_state);
+
+add_task(async function test_sync_runs_once_only() {
+ const backup = Utils.log.warn;
+ const messages = [];
+ Utils.log.warn = m => {
+ messages.push(m);
+ };
+
+ await Promise.all([client.maybeSync(2000), client.maybeSync(2000)]);
+
+ ok(
+ messages.includes("main/password-fields sync already running"),
+ "warning is shown about sync already running"
+ );
+ Utils.log.warn = backup;
+});
+add_task(clear_state);
+
+add_task(
+ async function test_sync_pulls_metadata_if_missing_with_dump_is_up_to_date() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+
+ let called;
+ clientWithDump._verifier = {
+ async asyncVerifyContentSignature() {
+ called = true;
+ return true;
+ },
+ };
+ // When dump is loaded, signature is not verified.
+ const records = await clientWithDump.get({ verifySignature: true });
+ ok(!!records.length, "dump is loaded");
+ ok(!called, "signature is missing but not verified");
+
+ // Synchronize the collection (local data is up-to-date).
+ // Signature verification is disabled (see `clear_state()`), so we don't bother with
+ // fetching metadata.
+ const uptodateTimestamp = await clientWithDump.db.getLastModified();
+ await clientWithDump.maybeSync(uptodateTimestamp);
+ let metadata = await clientWithDump.db.getMetadata();
+ ok(!metadata, "metadata was not fetched");
+
+ // Synchronize again the collection (up-to-date, since collection last modified still > 42)
+ clientWithDump.verifySignature = true;
+ await clientWithDump.maybeSync(42);
+
+ // With signature verification, metadata was fetched.
+ metadata = await clientWithDump.db.getMetadata();
+ ok(!!Object.keys(metadata).length, "metadata was fetched");
+ ok(called, "signature was verified for the data that was in dump");
+
+ // Metadata is present, signature will now verified.
+ called = false;
+ await clientWithDump.get({ verifySignature: true });
+ ok(called, "local signature is verified");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_sync_event_provides_information_about_records() {
+ let eventData;
+ client.on("sync", ({ data }) => (eventData = data));
+
+ await client.maybeSync(2000);
+ equal(eventData.current.length, 1);
+
+ await client.maybeSync(3001);
+ equal(eventData.current.length, 2);
+ equal(eventData.created.length, 1);
+ equal(eventData.created[0].website, "https://www.other.org/signin");
+ equal(eventData.updated.length, 1);
+ equal(eventData.updated[0].old.website, "https://some-website.com");
+ equal(eventData.updated[0].new.website, "https://some-website.com/login");
+ equal(eventData.deleted.length, 0);
+
+ await client.maybeSync(4001);
+ equal(eventData.current.length, 1);
+ equal(eventData.created.length, 0);
+ equal(eventData.updated.length, 0);
+ equal(eventData.deleted.length, 1);
+ equal(eventData.deleted[0].website, "https://www.other.org/signin");
+});
+add_task(clear_state);
+
+add_task(async function test_inspect_method() {
+ // Synchronize the `password-fields` collection in order to have
+ // some local data when .inspect() is called.
+ await client.maybeSync(2000);
+
+ const inspected = await RemoteSettings.inspect();
+
+ // Assertion for global attributes.
+ const { mainBucket, serverURL, defaultSigner, collections, serverTimestamp } =
+ inspected;
+ const rsSigner = "remote-settings.content-signature.mozilla.org";
+ equal(mainBucket, "main");
+ equal(serverURL, `http://localhost:${server.identity.primaryPort}/v1`);
+ equal(defaultSigner, rsSigner);
+ equal(serverTimestamp, "5000");
+
+ // A collection is listed in .inspect() if it has local data or if there
+ // is a JSON dump for it.
+ // "password-fields" has no dump but was synchronized above and thus has local data.
+ let col = collections.pop();
+ equal(col.collection, "password-fields");
+ equal(col.serverTimestamp, 3000);
+ equal(col.localTimestamp, 3000);
+
+ if (!IS_ANDROID) {
+ // "language-dictionaries" has a local dump (not on Android)
+ col = collections.pop();
+ equal(col.collection, "language-dictionaries");
+ equal(col.serverTimestamp, 4000);
+ ok(!col.localTimestamp); // not synchronized.
+ }
+});
+add_task(clear_state);
+
+add_task(async function test_inspect_method_uses_a_random_cache_bust() {
+ const backup = Utils.fetchLatestChanges;
+ const cacheBusts = [];
+ Utils.fetchLatestChanges = (url, options) => {
+ cacheBusts.push(options.expected);
+ return { changes: [] };
+ };
+
+ await RemoteSettings.inspect();
+ await RemoteSettings.inspect();
+ await RemoteSettings.inspect();
+
+ notEqual(cacheBusts[0], cacheBusts[1]);
+ notEqual(cacheBusts[1], cacheBusts[2]);
+ notEqual(cacheBusts[0], cacheBusts[2]);
+ Utils.fetchLatestChanges = backup;
+});
+
+add_task(async function test_jexl_context_is_shown_in_inspect() {
+ const { jexlContext } = await RemoteSettings.inspect();
+ deepEqual(Object.keys(jexlContext).sort(), [
+ "appinfo",
+ "channel",
+ "country",
+ "formFactor",
+ "locale",
+ "os",
+ "version",
+ ]);
+ deepEqual(Object.keys(jexlContext.os).sort(), ["name", "version"]);
+ deepEqual(Object.keys(jexlContext.appinfo).sort(), ["ID", "OS"]);
+});
+
+add_task(async function test_clearAll_method() {
+ // Make sure we have some local data.
+ await client.maybeSync(2000);
+ await clientWithDump.maybeSync(2000);
+
+ await RemoteSettings.clearAll();
+
+ ok(!(await Utils.hasLocalData(client)), "Local data was deleted");
+ ok(!(await Utils.hasLocalData(clientWithDump)), "Local data was deleted");
+ ok(
+ !Services.prefs.prefHasUserValue(client.lastCheckTimePref),
+ "Pref was cleaned"
+ );
+
+ // Synchronization is not broken after resuming.
+ await client.maybeSync(2000);
+ await clientWithDump.maybeSync(2000);
+ ok(await Utils.hasLocalData(client), "Local data was populated");
+ ok(await Utils.hasLocalData(clientWithDump), "Local data was populated");
+});
+add_task(clear_state);
+
+add_task(async function test_listeners_are_not_deduplicated() {
+ let count = 0;
+ const plus1 = () => {
+ count += 1;
+ };
+
+ client.on("sync", plus1);
+ client.on("sync", plus1);
+ client.on("sync", plus1);
+
+ await client.maybeSync(2000);
+
+ equal(count, 3);
+});
+add_task(clear_state);
+
+add_task(async function test_listeners_can_be_removed() {
+ let count = 0;
+ const onSync = () => {
+ count += 1;
+ };
+
+ client.on("sync", onSync);
+ client.off("sync", onSync);
+
+ await client.maybeSync(2000);
+
+ equal(count, 0);
+});
+add_task(clear_state);
+
+add_task(async function test_all_listeners_are_executed_if_one_fails() {
+ let count = 0;
+ client.on("sync", () => {
+ count += 1;
+ });
+ client.on("sync", () => {
+ throw new Error("boom");
+ });
+ client.on("sync", () => {
+ count += 2;
+ });
+
+ let error;
+ try {
+ await client.maybeSync(2000);
+ } catch (e) {
+ error = e;
+ }
+
+ equal(count, 3);
+ equal(error.message, "boom");
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_up_to_date() {
+ await client.maybeSync(2000);
+
+ const expectedTelemetry = [
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ ];
+ assertTelemetryEvents(expectedTelemetry);
+
+ await client.maybeSync(3000);
+
+ // No Telemetry was sent.
+ assertTelemetryEvents(
+ expectedTelemetry.concat([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.UP_TO_DATE,
+ },
+ ])
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_if_sync_succeeds() {
+ // We test each client because Telemetry requires preleminary declarations.
+ await client.maybeSync(2000);
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(
+ async function test_synchronization_duration_is_reported_in_uptake_status() {
+ await client.maybeSync(2000);
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: client.identifier,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: client.identifier,
+ trigger: "manual",
+ duration: d => parseInt(d) > 0,
+ },
+ ]);
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_if_application_fails() {
+ client.on("sync", () => {
+ throw new Error("boom");
+ });
+
+ try {
+ await client.maybeSync(2000);
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.APPLY_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_if_sync_fails() {
+ await client.db.importChanges({}, 9999);
+
+ try {
+ await client.maybeSync(10000);
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SERVER_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_if_parsing_fails() {
+ await client.db.importChanges({}, 10000);
+
+ try {
+ await client.maybeSync(10001);
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.PARSE_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_if_fetching_signature_fails() {
+ await client.db.importChanges({}, 11000);
+
+ try {
+ await client.maybeSync(11001);
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SERVER_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_unknown_errors() {
+ const backup = client.db.getLastModified;
+ client.db.getLastModified = () => {
+ throw new Error("Internal");
+ };
+
+ try {
+ await client.maybeSync(2000);
+ } catch (e) {}
+
+ client.db.getLastModified = backup;
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.UNKNOWN_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_indexeddb_as_custom_1() {
+ const backup = client.db.getLastModified;
+ const msg =
+ "IndexedDB getLastModified() The operation failed for reasons unrelated to the database itself";
+ client.db.getLastModified = () => {
+ throw new Error(msg);
+ };
+
+ try {
+ await client.maybeSync(2000);
+ } catch (e) {}
+
+ client.db.getLastModified = backup;
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ },
+ {
+ value: UptakeTelemetry.STATUS.CUSTOM_1_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_telemetry_reports_error_name_as_event_nightly() {
+ const backup = client.db.getLastModified;
+ client.db.getLastModified = () => {
+ const e = new Error("Some unknown error");
+ e.name = "ThrownError";
+ throw e;
+ };
+
+ try {
+ await client.maybeSync(2000);
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: client.identifier,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.UNKNOWN_ERROR,
+ source: client.identifier,
+ trigger: "manual",
+ errorName: "ThrownError",
+ duration: d => parseInt(d) >= 0,
+ },
+ ]);
+
+ client.db.getLastModified = backup;
+});
+add_task(clear_state);
+
+add_task(async function test_bucketname_changes_when_preview_mode_is_enabled() {
+ equal(client.bucketName, "main");
+
+ RemoteSettings.enablePreviewMode(true);
+
+ equal(client.bucketName, "main-preview");
+});
+add_task(clear_state);
+
+add_task(
+ async function test_preview_mode_pref_affects_bucket_names_before_instantiated() {
+ Services.prefs.setBoolPref("services.settings.preview_enabled", true);
+
+ let clientWithDefaultBucket = RemoteSettings("other");
+ let clientWithBucket = RemoteSettings("coll", { bucketName: "buck" });
+
+ equal(clientWithDefaultBucket.bucketName, "main-preview");
+ equal(clientWithBucket.bucketName, "buck-preview");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_preview_enabled_pref_ignored_when_mode_is_set_explicitly() {
+ Services.prefs.setBoolPref("services.settings.preview_enabled", true);
+
+ let clientWithDefaultBucket = RemoteSettings("other");
+ let clientWithBucket = RemoteSettings("coll", { bucketName: "buck" });
+
+ equal(clientWithDefaultBucket.bucketName, "main-preview");
+ equal(clientWithBucket.bucketName, "buck-preview");
+
+ RemoteSettings.enablePreviewMode(false);
+
+ equal(clientWithDefaultBucket.bucketName, "main");
+ equal(clientWithBucket.bucketName, "buck");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_get_loads_default_records_from_a_local_dump_when_preview_mode_is_enabled() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ RemoteSettings.enablePreviewMode(true);
+ // When collection has a dump in services/settings/dumps/{bucket}/{collection}.json
+ const data = await clientWithDump.get();
+ notEqual(data.length, 0);
+ // No synchronization happened (responses are not mocked).
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_local_db_distinguishes_preview_records() {
+ RemoteSettings.enablePreviewMode(true);
+ client.db.importChanges({}, Date.now(), [{ id: "record-1" }], {
+ clear: true,
+ });
+
+ RemoteSettings.enablePreviewMode(false);
+ client.db.importChanges({}, Date.now(), [{ id: "record-2" }], {
+ clear: true,
+ });
+
+ deepEqual(await client.get(), [{ id: "record-2" }]);
+});
+add_task(clear_state);
+
+add_task(
+ async function test_inspect_changes_the_list_when_preview_mode_is_enabled() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest),
+ // and this test relies on the fact that clients are instantiated if a dump is packaged.
+ return;
+ }
+
+ // Register a client only listed in -preview...
+ RemoteSettings("crash-rate");
+
+ const { collections: before, previewMode: previewModeBefore } =
+ await RemoteSettings.inspect();
+
+ Assert.ok(!previewModeBefore, "preview is not enabled");
+
+ // These two collections are listed in the main bucket in monitor/changes (one with dump, one registered).
+ deepEqual(before.map(c => c.collection).sort(), [
+ "language-dictionaries",
+ "password-fields",
+ ]);
+
+ // Switch to preview mode.
+ RemoteSettings.enablePreviewMode(true);
+
+ const {
+ collections: after,
+ mainBucket,
+ previewMode,
+ } = await RemoteSettings.inspect();
+
+ Assert.ok(previewMode, "preview is enabled");
+
+ // These two collections are listed in the main bucket in monitor/changes (both are registered).
+ deepEqual(after.map(c => c.collection).sort(), [
+ "crash-rate",
+ "password-fields",
+ ]);
+ equal(mainBucket, "main-preview");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_sync_event_is_not_sent_from_get_when_no_dump() {
+ let called = false;
+ client.on("sync", () => {
+ called = true;
+ });
+
+ await client.get();
+
+ Assert.ok(!called, "sync event is not sent from .get()");
+});
+add_task(clear_state);
+
+add_task(async function test_get_can_be_called_from_sync_event_callback() {
+ let fromGet;
+ let fromEvent;
+
+ client.on("sync", async ({ data: { current } }) => {
+ // Before fixing Bug 1761953 this would result in a deadlock.
+ fromGet = await client.get();
+ fromEvent = current;
+ });
+
+ await client.maybeSync(2000);
+
+ Assert.ok(fromGet, "sync callback was called");
+ Assert.deepEqual(fromGet, fromEvent, ".get() gives current records list");
+});
+add_task(clear_state);
+
+add_task(async function test_attachments_are_pruned_when_sync_from_timer() {
+ await client.db.saveAttachment("bar", {
+ record: { id: "bar" },
+ blob: new Blob(["456"]),
+ });
+
+ await client.maybeSync(2000, { trigger: "broadcast" });
+
+ Assert.ok(
+ await client.attachments.cacheImpl.get("bar"),
+ "Extra attachment was not deleted on broadcast"
+ );
+
+ await client.maybeSync(3001, { trigger: "timer" });
+
+ Assert.ok(
+ !(await client.attachments.cacheImpl.get("bar")),
+ "Extra attachment was deleted on timer"
+ );
+});
+add_task(clear_state);
+
+function handleResponse(request, response) {
+ try {
+ const sample = getSampleResponse(request, server.identity.primaryPort);
+ if (!sample) {
+ do_throw(
+ `unexpected ${request.method} request for ${request.path}?${request.queryString}`
+ );
+ }
+
+ response.setStatusLine(
+ null,
+ sample.status.status,
+ sample.status.statusText
+ );
+ // send the headers
+ for (let headerLine of sample.sampleHeaders) {
+ let headerElements = headerLine.split(":");
+ response.setHeader(headerElements[0], headerElements[1].trimLeft());
+ }
+ response.setHeader("Date", new Date().toUTCString());
+
+ const body =
+ typeof sample.responseBody == "string"
+ ? sample.responseBody
+ : JSON.stringify(sample.responseBody);
+ response.write(body);
+ response.finish();
+ } catch (e) {
+ info(e);
+ }
+}
+
+function getSampleResponse(req, port) {
+ const responses = {
+ OPTIONS: {
+ sampleHeaders: [
+ "Access-Control-Allow-Headers: Content-Length,Expires,Backoff,Retry-After,Last-Modified,Total-Records,ETag,Pragma,Cache-Control,authorization,content-type,if-none-match,Alert,Next-Page",
+ "Access-Control-Allow-Methods: GET,HEAD,OPTIONS,POST,DELETE,OPTIONS",
+ "Access-Control-Allow-Origin: *",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: null,
+ },
+ "GET:/v1/": {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: {
+ settings: {
+ batch_max_requests: 25,
+ },
+ url: `http://localhost:${port}/v1/`,
+ documentation: "https://kinto.readthedocs.org/",
+ version: "1.5.1",
+ commit: "cbc6f58",
+ hello: "kinto",
+ },
+ },
+ "GET:/v1/buckets/monitor/collections/changes/changeset": {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ `Date: ${new Date().toUTCString()}`,
+ 'Etag: "5000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: {
+ timestamp: 5000,
+ changes: [
+ {
+ id: "4676f0c7-9757-4796-a0e8-b40a5a37a9c9",
+ bucket: "main",
+ collection: "unknown-locally",
+ last_modified: 5000,
+ },
+ {
+ id: "4676f0c7-9757-4796-a0e8-b40a5a37a9c9",
+ bucket: "main",
+ collection: "language-dictionaries",
+ last_modified: 4000,
+ },
+ {
+ id: "0af8da0b-3e03-48fb-8d0d-2d8e4cb7514d",
+ bucket: "main",
+ collection: "password-fields",
+ last_modified: 3000,
+ },
+ {
+ id: "4acda969-3bd3-4074-a678-ff311eeb076e",
+ bucket: "main-preview",
+ collection: "password-fields",
+ last_modified: 2000,
+ },
+ {
+ id: "58697bd1-315f-4185-9bee-3371befc2585",
+ bucket: "main-preview",
+ collection: "crash-rate",
+ last_modified: 1000,
+ },
+ ],
+ },
+ },
+ "GET:/fake-x5u": {
+ sampleHeaders: ["Content-Type: application/octet-stream"],
+ status: { status: 200, statusText: "OK" },
+ responseBody: `-----BEGIN CERTIFICATE-----
+MIIGYTCCBEmgAwIBAgIBATANBgkqhkiG9w0BAQwFADB9MQswCQYDVQQGEwJVU
+ZARKjbu1TuYQHf0fs+GwID8zeLc2zJL7UzcHFwwQ6Nda9OJN4uPAuC/BKaIpxCLL
+26b24/tRam4SJjqpiq20lynhUrmTtt6hbG3E1Hpy3bmkt2DYnuMFwEx2gfXNcnbT
+wNuvFqc=
+-----END CERTIFICATE-----`,
+ },
+ "GET:/v1/buckets/main/collections/password-fields/changeset?_expected=2000":
+ {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ 'Etag: "3000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: {
+ timestamp: 3000,
+ metadata: {
+ id: "password-fields",
+ last_modified: 1234,
+ signatures: [
+ {
+ signature: "abcdef",
+ x5u: `http://localhost:${port}/fake-x5u`,
+ },
+ ],
+ },
+ changes: [
+ {
+ id: "9d500963-d80e-3a91-6e74-66f3811b99cc",
+ last_modified: 3000,
+ website: "https://some-website.com",
+ selector: "#user[password]",
+ },
+ ],
+ },
+ },
+ "GET:/v1/buckets/main/collections/password-fields/changeset?_expected=3001&_since=3000":
+ {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ 'Etag: "4000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: {
+ metadata: {
+ signatures: [{}],
+ },
+ timestamp: 4000,
+ changes: [
+ {
+ id: "aabad965-e556-ffe7-4191-074f5dee3df3",
+ last_modified: 4000,
+ website: "https://www.other.org/signin",
+ selector: "#signinpassword",
+ },
+ {
+ id: "9d500963-d80e-3a91-6e74-66f3811b99cc",
+ last_modified: 3500,
+ website: "https://some-website.com/login",
+ selector: "input#user[password]",
+ },
+ ],
+ },
+ },
+ "GET:/v1/buckets/main/collections/password-fields/changeset?_expected=4001&_since=4000":
+ {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ 'Etag: "5000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: {
+ metadata: {
+ signatures: [{}],
+ },
+ timestamp: 5000,
+ changes: [
+ {
+ id: "aabad965-e556-ffe7-4191-074f5dee3df3",
+ deleted: true,
+ },
+ ],
+ },
+ },
+ "GET:/v1/buckets/main/collections/password-fields/changeset?_expected=10000&_since=9999":
+ {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ ],
+ status: { status: 503, statusText: "Service Unavailable" },
+ responseBody: {
+ code: 503,
+ errno: 999,
+ error: "Service Unavailable",
+ },
+ },
+ "GET:/v1/buckets/main/collections/password-fields/changeset?_expected=10001&_since=10000":
+ {
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ 'Etag: "10001"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: " ({
+ id: `record-${i}`,
+ ...record,
+ })),
+ {
+ clear: true,
+ }
+ );
+}
+
+add_setup(() => {
+ client = RemoteSettings("some-key");
+});
+
+add_task(async function test_returns_all_without_target() {
+ await createRecords([
+ {
+ passwordSelector: "#pass-signin",
+ },
+ {
+ filter_expression: null,
+ },
+ {
+ filter_expression: "",
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 3);
+});
+
+add_task(async function test_filters_can_be_disabled() {
+ const c = RemoteSettings("no-jexl", { filterCreator: null });
+ await c.db.importChanges({}, 42, [
+ {
+ id: "abc",
+ filter_expression: "1 == 2",
+ },
+ ]);
+
+ const list = await c.get();
+ equal(list.length, 1);
+});
+
+add_task(async function test_returns_entries_where_jexl_is_true() {
+ await createRecords([
+ {
+ willMatch: true,
+ filter_expression: "1",
+ },
+ {
+ willMatch: true,
+ filter_expression: "[42]",
+ },
+ {
+ willMatch: true,
+ filter_expression: "1 == 2 || 1 == 1",
+ },
+ {
+ willMatch: true,
+ filter_expression: 'env.appinfo.ID == "xpcshell@tests.mozilla.org"',
+ },
+ {
+ willMatch: false,
+ filter_expression: "env.version == undefined",
+ },
+ {
+ willMatch: true,
+ filter_expression: "env.unknown == undefined",
+ },
+ {
+ willMatch: false,
+ filter_expression: "1 == 2",
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 5);
+ ok(list.every(e => e.willMatch));
+});
+
+add_task(async function test_ignores_entries_where_jexl_is_invalid() {
+ await createRecords([
+ {
+ filter_expression: "true === true", // JavaScript Error: "Invalid expression token: ="
+ },
+ {
+ filter_expression: "Objects.keys({}) == []", // Token ( (openParen) unexpected in expression
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 0);
+});
+
+add_task(async function test_support_of_date_filters() {
+ await createRecords([
+ {
+ willMatch: true,
+ filter_expression: '"1982-05-08"|date < "2016-03-22"|date',
+ },
+ {
+ willMatch: false,
+ filter_expression: '"2000-01-01"|date < "1970-01-01"|date',
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 1);
+ ok(list.every(e => e.willMatch));
+});
+
+add_task(async function test_support_of_preferences_filters() {
+ await createRecords([
+ {
+ willMatch: true,
+ filter_expression: '"services.settings.last_etag"|preferenceValue == 42',
+ },
+ {
+ willMatch: true,
+ filter_expression:
+ '"services.settings.poll_interval"|preferenceExists == true',
+ },
+ {
+ willMatch: true,
+ filter_expression:
+ '"services.settings.poll_interval"|preferenceIsUserSet == false',
+ },
+ {
+ willMatch: true,
+ filter_expression:
+ '"services.settings.last_etag"|preferenceIsUserSet == true',
+ },
+ ]);
+
+ // Set a pref for the user.
+ Services.prefs.setIntPref("services.settings.last_etag", 42);
+
+ const list = await client.get();
+ equal(list.length, 4);
+ ok(list.every(e => e.willMatch));
+});
+
+add_task(async function test_support_of_intersect_operator() {
+ await createRecords([
+ {
+ willMatch: true,
+ filter_expression: '{foo: 1, bar: 2}|keys intersect ["foo"]',
+ },
+ {
+ willMatch: true,
+ filter_expression: '(["a", "b"] intersect ["a", 1, 4]) == "a"',
+ },
+ {
+ willMatch: false,
+ filter_expression: '(["a", "b"] intersect [3, 1, 4]) == "c"',
+ },
+ {
+ willMatch: true,
+ filter_expression: `
+ [1, 2, 3]
+ intersect
+ [3, 4, 5]
+ `,
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 3);
+ ok(list.every(e => e.willMatch));
+});
+
+add_task(async function test_support_of_samples() {
+ await createRecords([
+ {
+ willMatch: true,
+ filter_expression: '"always-true"|stableSample(1)',
+ },
+ {
+ willMatch: false,
+ filter_expression: '"always-false"|stableSample(0)',
+ },
+ {
+ willMatch: true,
+ filter_expression: '"turns-to-true-0"|stableSample(0.5)',
+ },
+ {
+ willMatch: false,
+ filter_expression: '"turns-to-false-1"|stableSample(0.5)',
+ },
+ {
+ willMatch: true,
+ filter_expression: '"turns-to-true-0"|bucketSample(0, 50, 100)',
+ },
+ {
+ willMatch: false,
+ filter_expression: '"turns-to-false-1"|bucketSample(0, 50, 100)',
+ },
+ ]);
+
+ const list = await client.get();
+ equal(list.length, 3);
+ ok(list.every(e => e.willMatch));
+});
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_offline.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_offline.js
new file mode 100644
index 000000000..deea90601
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_offline.js
@@ -0,0 +1,139 @@
+// A collection with a dump that's packaged on all builds where this test runs,
+// including on Android at mobile/android/installer/package-manifest.in
+const TEST_BUCKET = "main";
+const TEST_COLLECTION = "password-recipes";
+
+let client;
+let DUMP_RECORDS;
+let DUMP_LAST_MODIFIED;
+
+add_setup(async () => {
+ // "services.settings.server" pref is not set.
+ // Test defaults to an unreachable server,
+ // and will only load from the dump if any.
+
+ client = new RemoteSettingsClient(TEST_COLLECTION, {
+ bucketName: TEST_BUCKET,
+ });
+
+ const dump = await SharedUtils.loadJSONDump(TEST_BUCKET, TEST_COLLECTION);
+ DUMP_RECORDS = dump.data;
+ DUMP_LAST_MODIFIED = dump.timestamp;
+
+ // Dumps are fetched via the following, which sorts the records, newest first.
+ // https://searchfox.org/mozilla-central/rev/5b3444ad300e244b5af4214212e22bd9e4b7088a/taskcluster/docker/periodic-updates/scripts/periodic_file_updates.sh#304
+ equal(
+ DUMP_LAST_MODIFIED,
+ DUMP_RECORDS[0].last_modified,
+ "records in dump ought to be sorted by last_modified"
+ );
+});
+
+async function importData(records) {
+ await RemoteSettingsWorker._execute("_test_only_import", [
+ TEST_BUCKET,
+ TEST_COLLECTION,
+ records,
+ records[0]?.last_modified || 0,
+ ]);
+}
+
+async function clear_state() {
+ await client.db.clear();
+}
+
+add_task(async function test_load_from_dump_when_offline() {
+ // Baseline: verify that the collection is empty at first,
+ // but non-empty after loading from the dump.
+ const beforeTimestamp = await client.db.getLastModified();
+ equal(beforeTimestamp, null, "collection empty when offline");
+
+ // should import from dump since collection was not initialized.
+ const after = await client.get();
+ equal(after.length, DUMP_RECORDS.length, "collection loaded from dump");
+ equal(await client.getLastModified(), DUMP_LAST_MODIFIED, "dump's timestamp");
+});
+add_task(clear_state);
+
+add_task(async function test_optional_skip_dump_after_empty_import() {
+ // clear_state should have wiped the database.
+ const beforeTimestamp = await client.db.getLastModified();
+ equal(beforeTimestamp, null, "collection empty after clearing");
+
+ // Verify that the dump is not imported again by client.get()
+ // when the database is initialized with an empty dump
+ // with `loadDumpIfNewer` disabled.
+ await importData([]); // <-- Empty set of records.
+
+ const after = await client.get({ loadDumpIfNewer: false });
+ equal(after.length, 0, "collection still empty due to import");
+ equal(await client.getLastModified(), 0, "Empty dump has no timestamp");
+});
+add_task(clear_state);
+
+add_task(async function test_optional_skip_dump_after_non_empty_import() {
+ await importData([{ last_modified: 1234, id: "dummy" }]);
+
+ const after = await client.get({ loadDumpIfNewer: false });
+ equal(after.length, 1, "Imported dummy data");
+ equal(await client.getLastModified(), 1234, "Expected timestamp of import");
+
+ await importData([]);
+ const after2 = await client.get({ loadDumpIfNewer: false });
+ equal(after2.length, 0, "Previous data wiped on duplicate import");
+ equal(await client.getLastModified(), 0, "Timestamp of empty collection");
+});
+add_task(clear_state);
+
+add_task(async function test_load_dump_after_empty_import() {
+ await importData([]); // <-- Empty set of records, i.e. last_modified = 0.
+
+ const after = await client.get();
+ equal(after.length, DUMP_RECORDS.length, "Imported dump");
+ equal(await client.getLastModified(), DUMP_LAST_MODIFIED, "dump's timestamp");
+});
+add_task(clear_state);
+
+add_task(async function test_load_dump_after_non_empty_import() {
+ // Dump is updated regularly, verify that the dump matches our expectations
+ // before running the test.
+ Assert.greater(
+ DUMP_LAST_MODIFIED,
+ 1234,
+ "Assuming dump to be newer than dummy 1234"
+ );
+
+ await importData([{ last_modified: 1234, id: "dummy" }]);
+
+ const after = await client.get();
+ equal(after.length, DUMP_RECORDS.length, "Imported dump");
+ equal(await client.getLastModified(), DUMP_LAST_MODIFIED, "dump's timestamp");
+});
+add_task(clear_state);
+
+add_task(async function test_load_dump_after_import_from_broken_distro() {
+ // Dump is updated regularly, verify that the dump matches our expectations
+ // before running the test.
+ Assert.greater(
+ DUMP_LAST_MODIFIED,
+ 1234,
+ "Assuming dump to be newer than dummy 1234"
+ );
+
+ // No last_modified time.
+ await importData([{ id: "dummy" }]);
+
+ const after = await client.get();
+ equal(after.length, DUMP_RECORDS.length, "Imported dump");
+ equal(await client.getLastModified(), DUMP_LAST_MODIFIED, "dump's timestamp");
+});
+add_task(clear_state);
+
+add_task(async function test_skip_dump_if_same_last_modified() {
+ await importData([{ last_modified: DUMP_LAST_MODIFIED, id: "dummy" }]);
+
+ const after = await client.get();
+ equal(after.length, 1, "Not importing dump when time matches");
+ equal(await client.getLastModified(), DUMP_LAST_MODIFIED, "Same timestamp");
+});
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_older_than_local.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_older_than_local.js
new file mode 100644
index 000000000..682849669
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_older_than_local.js
@@ -0,0 +1,149 @@
+const PREF_SETTINGS_SERVER = "services.settings.server";
+
+let server;
+let client;
+
+async function clear_state() {
+ await client.db.clear();
+}
+
+function setJSONResponse(response, changeset) {
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date().toUTCString());
+ response.write(JSON.stringify(changeset));
+}
+
+add_setup(() => {
+ Services.prefs.setStringPref("services.settings.loglevel", "debug");
+
+ // Set up an HTTP Server
+ server = new HttpServer();
+ server.start(-1);
+
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER,
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ client = RemoteSettings("some-cid");
+
+ const bodies = {
+ // First successful sync at timestamp=333
+ "/v1/buckets/main/collections/some-cid/changeset?_expected=333": {
+ timestamp: 333,
+ metadata: {
+ signatures: [{ signature: "abc", x5u: "data:text/plain;base64,pem" }],
+ },
+ changes: [
+ { id: "rid2", last_modified: 22 },
+ { id: "rid1", last_modified: 11 },
+ ],
+ },
+ // Client fetches with _expected=222&_since=333
+ "/v1/buckets/main/collections/some-cid/changeset?_expected=222&_since=333":
+ {
+ timestamp: 222,
+ metadata: {
+ signatures: [{ signature: "ghi", x5u: "data:text/plain;base64,pem" }],
+ },
+ changes: [{ id: "rid1", last_modified: 11 }],
+ },
+ // Client refetches full collection with _expected=222 after signature fails.
+ "/v1/buckets/main/collections/some-cid/changeset?_expected=222": {
+ timestamp: 222,
+ metadata: {
+ signatures: [{ signature: "ghi", x5u: "data:text/plain;base64,pem" }],
+ },
+ changes: [{ id: "rid1", last_modified: 11 }],
+ },
+ };
+ const handler = (request, response) => {
+ const body = bodies[`${request.path}?${request.queryString}`];
+ if (!body) {
+ const err = new Error(
+ `Unexpected request ${request.path}?${request.queryString}`
+ );
+ console.error(err);
+ throw err;
+ }
+ setJSONResponse(response, body);
+ };
+ Object.keys(bodies).map(path =>
+ server.registerPathHandler(path.split("?")[0], handler)
+ );
+
+ // In this test suite, the only valid data is the one at timestamp=222 or timestamp=333, but not a mix of the two.
+ let backup = client._verifier;
+ client._verifier = {
+ asyncVerifyContentSignature: serialized => {
+ return (
+ serialized ==
+ '{"data":[{"id":"rid2","last_modified":22}],"last_modified":"444"}' ||
+ serialized ==
+ '{"data":[{"id":"rid1","last_modified":11},{"id":"rid2","last_modified":22}],"last_modified":"333"}' ||
+ serialized ==
+ '{"data":[{"id":"rid1","last_modified":11}],"last_modified":"222"}'
+ );
+ },
+ };
+
+ registerCleanupFunction(() => {
+ client._verifier = backup;
+ server.stop(() => {});
+ Services.prefs.clearUserPref(PREF_SETTINGS_SERVER);
+
+ Services.prefs.clearUserPref("services.settings.loglevel");
+ });
+});
+
+add_task(clear_state);
+
+add_task(async function test_ignores_if_local_signature_is_valid() {
+ await client.maybeSync(333);
+ Assert.deepEqual(
+ [
+ await client.db.getLastModified(),
+ (await client.get()).map(({ id }) => id),
+ ],
+ [333, ["rid1", "rid2"]]
+ );
+
+ await client.maybeSync(222);
+
+ // The client should detect that timestamp is older,
+ // but it ignores it because local data is good.
+ Assert.deepEqual(
+ [
+ await client.db.getLastModified(),
+ (await client.get()).map(({ id }) => id),
+ ],
+ [333, ["rid1", "rid2"]]
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_uses_old_data_if_local_signature_is_invalid() {
+ // Import some data in the local DB. Signature will be bad.
+ await client.db.importChanges({}, 333, [{ id: "myid", last_modified: 1234 }]);
+ Assert.deepEqual(
+ [
+ await client.db.getLastModified(),
+ (await client.get()).map(({ id }) => id),
+ ],
+ [333, ["myid"]]
+ );
+
+ await client.maybeSync(222);
+
+ // The client should detect that timestamp is older,
+ // but will replace local data with this old data.
+ Assert.deepEqual(
+ [
+ await client.db.getLastModified(),
+ (await client.get()).map(({ id }) => id),
+ ],
+ [222, ["rid1"]]
+ );
+});
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_poll.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_poll.js
new file mode 100644
index 000000000..927342824
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_poll.js
@@ -0,0 +1,1287 @@
+const { pushBroadcastService } = ChromeUtils.importESModule(
+ "resource://gre/modules/PushBroadcastService.sys.mjs"
+);
+
+const { remoteSettingsBroadcastHandler, BROADCAST_ID } =
+ ChromeUtils.importESModule(
+ "resource://services-settings/remote-settings.sys.mjs"
+ );
+
+const PREF_SETTINGS_SERVER = "services.settings.server";
+const PREF_SETTINGS_SERVER_BACKOFF = "services.settings.server.backoff";
+const PREF_LAST_UPDATE = "services.settings.last_update_seconds";
+const PREF_LAST_ETAG = "services.settings.last_etag";
+const PREF_CLOCK_SKEW_SECONDS = "services.settings.clock_skew_seconds";
+
+// Telemetry report result.
+const TELEMETRY_SOURCE_POLL = "settings-changes-monitoring";
+const TELEMETRY_SOURCE_SYNC = "settings-sync";
+const CHANGES_PATH = "/v1" + Utils.CHANGES_PATH;
+
+var server;
+
+async function clear_state() {
+ // set up prefs so the kinto updater talks to the test server
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER,
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ // set some initial values so we can check these are updated appropriately
+ Services.prefs.setIntPref(PREF_LAST_UPDATE, 0);
+ Services.prefs.setIntPref(PREF_CLOCK_SKEW_SECONDS, 0);
+ Services.prefs.clearUserPref(PREF_LAST_ETAG);
+
+ // Clear events snapshot.
+ Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_ALL_CHANNELS, true);
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ // Clear sync history.
+ await new SyncHistory("").clear();
+}
+
+function serveChangesEntries(serverTime, entriesOrFunc) {
+ return (request, response) => {
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date(serverTime).toUTCString());
+ const entries =
+ typeof entriesOrFunc == "function" ? entriesOrFunc() : entriesOrFunc;
+ const latest = entries[0]?.last_modified ?? 42;
+ if (entries.length) {
+ response.setHeader("ETag", `"${latest}"`);
+ }
+ response.write(JSON.stringify({ timestamp: latest, changes: entries }));
+ };
+}
+
+add_setup(() => {
+ // Set up an HTTP Server
+ server = new HttpServer();
+ server.start(-1);
+
+ registerCleanupFunction(() => {
+ server.stop(() => {});
+ });
+});
+
+add_task(clear_state);
+
+add_task(async function test_an_event_is_sent_on_start() {
+ server.registerPathHandler(CHANGES_PATH, (request, response) => {
+ response.write(JSON.stringify({ timestamp: 42, changes: [] }));
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("ETag", "42");
+ response.setHeader("Date", new Date().toUTCString());
+ response.setStatusLine(null, 200, "OK");
+ });
+ let notificationObserved = null;
+ const observer = {
+ observe(aSubject, aTopic, aData) {
+ Services.obs.removeObserver(this, "remote-settings:changes-poll-start");
+ notificationObserved = JSON.parse(aData);
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:changes-poll-start");
+
+ await RemoteSettings.pollChanges({ expectedTimestamp: 13 });
+
+ Assert.equal(
+ notificationObserved.expectedTimestamp,
+ 13,
+ "start notification should have been observed"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_offline_is_reported_if_relevant() {
+ const offlineBackup = Services.io.offline;
+ try {
+ Services.io.offline = true;
+
+ await RemoteSettings.pollChanges();
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.NETWORK_OFFLINE_ERROR,
+ },
+ ]);
+ } finally {
+ Services.io.offline = offlineBackup;
+ }
+});
+add_task(clear_state);
+
+add_task(async function test_check_success() {
+ const serverTime = 8000;
+
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(serverTime, [
+ {
+ id: "330a0c5f-fadf-ff0b-40c8-4eb0d924ff6a",
+ last_modified: 1100,
+ host: "localhost",
+ bucket: "some-other-bucket",
+ collection: "test-collection",
+ },
+ {
+ id: "254cbb9e-6888-4d9f-8e60-58b74faa8778",
+ last_modified: 1000,
+ host: "localhost",
+ bucket: "test-bucket",
+ collection: "test-collection",
+ },
+ ])
+ );
+
+ // add a test kinto client that will respond to lastModified information
+ // for a collection called 'test-collection'.
+ // Let's use a bucket that is not the default one (`test-bucket`).
+ const c = RemoteSettings("test-collection", {
+ bucketName: "test-bucket",
+ });
+ let maybeSyncCalled = false;
+ c.maybeSync = () => {
+ maybeSyncCalled = true;
+ };
+
+ // Ensure that the remote-settings:changes-poll-end notification works
+ let notificationObserved = false;
+ const observer = {
+ observe() {
+ Services.obs.removeObserver(this, "remote-settings:changes-poll-end");
+ notificationObserved = true;
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:changes-poll-end");
+
+ await RemoteSettings.pollChanges();
+
+ // It didn't fail, hence we are sure that the unknown collection ``some-other-bucket/test-collection``
+ // was ignored, otherwise it would have tried to reach the network.
+
+ Assert.ok(maybeSyncCalled, "maybeSync was called");
+ Assert.ok(notificationObserved, "a notification should have been observed");
+ // Last timestamp was saved. An ETag header value is a quoted string.
+ Assert.equal(Services.prefs.getStringPref(PREF_LAST_ETAG), "1100");
+ // check the last_update is updated
+ Assert.equal(Services.prefs.getIntPref(PREF_LAST_UPDATE), serverTime / 1000);
+
+ // ensure that we've accumulated the correct telemetry
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_POLL,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_SYNC,
+ trigger: "manual",
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_update_timer_interface() {
+ const remoteSettings = Cc["@mozilla.org/services/settings;1"].getService(
+ Ci.nsITimerCallback
+ );
+
+ const serverTime = 8000;
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(serverTime, [
+ {
+ id: "028261ad-16d4-40c2-a96a-66f72914d125",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "whatever-collection",
+ },
+ ])
+ );
+
+ await new Promise(resolve => {
+ const e = "remote-settings:changes-poll-end";
+ const changesPolledObserver = {
+ observe() {
+ Services.obs.removeObserver(this, e);
+ resolve();
+ },
+ };
+ Services.obs.addObserver(changesPolledObserver, e);
+ remoteSettings.notify(null);
+ });
+
+ // Everything went fine.
+ Assert.equal(Services.prefs.getStringPref(PREF_LAST_ETAG), "42");
+ Assert.equal(Services.prefs.getIntPref(PREF_LAST_UPDATE), serverTime / 1000);
+});
+add_task(clear_state);
+
+add_task(async function test_check_up_to_date() {
+ // Simulate a poll with up-to-date collection.
+ const serverTime = 4000;
+ server.registerPathHandler(CHANGES_PATH, serveChangesEntries(serverTime, []));
+
+ Services.prefs.setStringPref(PREF_LAST_ETAG, "1100");
+
+ // Ensure that the remote-settings:changes-poll-end notification is sent.
+ let notificationObserved = false;
+ const observer = {
+ observe() {
+ Services.obs.removeObserver(this, "remote-settings:changes-poll-end");
+ notificationObserved = true;
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:changes-poll-end");
+
+ // If server has no change, maybeSync() is not called.
+ let maybeSyncCalled = false;
+ const c = RemoteSettings("test-collection", {
+ bucketName: "test-bucket",
+ });
+ c.maybeSync = () => {
+ maybeSyncCalled = true;
+ };
+
+ await RemoteSettings.pollChanges();
+
+ Assert.ok(notificationObserved, "a notification should have been observed");
+ Assert.ok(!maybeSyncCalled, "maybeSync should not be called");
+ // Last update is overwritten
+ Assert.equal(Services.prefs.getIntPref(PREF_LAST_UPDATE), serverTime / 1000);
+
+ // ensure that we've accumulated the correct telemetry
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.UP_TO_DATE,
+ source: TELEMETRY_SOURCE_POLL,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_SYNC,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_expected_timestamp() {
+ function withCacheBust(request, response) {
+ const entries = [
+ {
+ id: "695c2407-de79-4408-91c7-70720dd59d78",
+ last_modified: 1100,
+ host: "localhost",
+ bucket: "main",
+ collection: "with-cache-busting",
+ },
+ ];
+ if (
+ request.queryString.includes(`_expected=${encodeURIComponent('"42"')}`)
+ ) {
+ response.write(
+ JSON.stringify({
+ timestamp: 1110,
+ changes: entries,
+ })
+ );
+ }
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("ETag", '"1100"');
+ response.setHeader("Date", new Date().toUTCString());
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, withCacheBust);
+
+ const c = RemoteSettings("with-cache-busting");
+ let maybeSyncCalled = false;
+ c.maybeSync = () => {
+ maybeSyncCalled = true;
+ };
+
+ await RemoteSettings.pollChanges({ expectedTimestamp: '"42"' });
+
+ Assert.ok(maybeSyncCalled, "maybeSync was called");
+});
+add_task(clear_state);
+
+add_task(async function test_client_last_check_is_saved() {
+ server.registerPathHandler(CHANGES_PATH, (request, response) => {
+ response.write(
+ JSON.stringify({
+ timestamp: 42,
+ changes: [
+ {
+ id: "695c2407-de79-4408-91c7-70720dd59d78",
+ last_modified: 1100,
+ host: "localhost",
+ bucket: "main",
+ collection: "models-recipes",
+ },
+ ],
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("ETag", '"42"');
+ response.setHeader("Date", new Date().toUTCString());
+ response.setStatusLine(null, 200, "OK");
+ });
+
+ const c = RemoteSettings("models-recipes");
+ c.maybeSync = () => {};
+
+ equal(
+ c.lastCheckTimePref,
+ "services.settings.main.models-recipes.last_check"
+ );
+ Services.prefs.setIntPref(c.lastCheckTimePref, 0);
+
+ await RemoteSettings.pollChanges({ expectedTimestamp: '"42"' });
+
+ notEqual(Services.prefs.getIntPref(c.lastCheckTimePref), 0);
+});
+add_task(clear_state);
+
+add_task(async function test_age_of_data_is_reported_in_uptake_status() {
+ const serverTime = 1552323900000;
+ const recordsTimestamp = serverTime - 3600 * 1000;
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(serverTime, [
+ {
+ id: "b6ba7fab-a40a-4d03-a4af-6b627f3c5b36",
+ last_modified: recordsTimestamp,
+ host: "localhost",
+ bucket: "main",
+ collection: "some-entry",
+ },
+ ])
+ );
+
+ await RemoteSettings.pollChanges();
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_POLL,
+ age: "3600",
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_SYNC,
+ trigger: "manual",
+ timestamp: `${recordsTimestamp}`,
+ duration: d => !!d,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(
+ async function test_synchronization_duration_is_reported_in_uptake_status() {
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, [
+ {
+ id: "b6ba7fab-a40a-4d03-a4af-6b627f3c5b36",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "some-entry",
+ },
+ ])
+ );
+ const c = RemoteSettings("some-entry");
+ // Simulate a synchronization that lasts 1 sec.
+ // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+ c.maybeSync = () => new Promise(resolve => setTimeout(resolve, 1000));
+
+ await RemoteSettings.pollChanges();
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_POLL,
+ trigger: "manual",
+ age: a => !!a,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE_SYNC,
+ trigger: "manual",
+ duration: d => parseInt(d) >= 1000,
+ },
+ ]);
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_success_with_partial_list() {
+ function partialList(request, response) {
+ const entries = [
+ {
+ id: "028261ad-16d4-40c2-a96a-66f72914d125",
+ last_modified: 43,
+ host: "localhost",
+ bucket: "main",
+ collection: "cid-1",
+ },
+ {
+ id: "98a34576-bcd6-423f-abc2-1d290b776ed8",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "poll-test-collection",
+ },
+ ];
+ if (request.queryString.includes(`_since=42`)) {
+ response.write(
+ JSON.stringify({
+ timestamp: 43,
+ changes: entries.slice(0, 1),
+ })
+ );
+ } else {
+ response.write(
+ JSON.stringify({
+ timestamp: 42,
+ changes: entries,
+ })
+ );
+ }
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date().toUTCString());
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, partialList);
+
+ const c = RemoteSettings("poll-test-collection");
+ let maybeSyncCount = 0;
+ c.maybeSync = () => {
+ maybeSyncCount++;
+ };
+
+ await RemoteSettings.pollChanges();
+ await RemoteSettings.pollChanges();
+
+ // On the second call, the server does not mention the poll-test-collection
+ // and maybeSync() is not called.
+ Assert.equal(maybeSyncCount, 1, "maybeSync should not be called twice");
+});
+add_task(clear_state);
+
+add_task(async function test_full_polling() {
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, [
+ {
+ id: "b6ba7fab-a40a-4d03-a4af-6b627f3c5b36",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "poll-test-collection",
+ },
+ ])
+ );
+
+ const c = RemoteSettings("poll-test-collection");
+ let maybeSyncCount = 0;
+ c.maybeSync = () => {
+ maybeSyncCount++;
+ };
+
+ await RemoteSettings.pollChanges();
+ await RemoteSettings.pollChanges({ full: true });
+
+ // Since the second call is full, clients are called
+ Assert.equal(maybeSyncCount, 2, "maybeSync should be called twice");
+});
+add_task(clear_state);
+
+add_task(async function test_server_bad_json() {
+ function simulateBadJSON(request, response) {
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.write("");
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateBadJSON);
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+ Assert.ok(/JSON.parse: unexpected character/.test(error.message));
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.PARSE_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_server_bad_content_type() {
+ function simulateBadContentType(request, response) {
+ response.setHeader("Content-Type", "text/html");
+ response.write("");
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateBadContentType);
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+ Assert.ok(/Unexpected content-type/.test(error.message));
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.CONTENT_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_server_404_response() {
+ function simulateDummy404(request, response) {
+ response.setHeader("Content-Type", "text/html; charset=UTF-8");
+ response.write("");
+ response.setStatusLine(null, 404, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateDummy404);
+
+ await RemoteSettings.pollChanges(); // Does not fail when running from tests.
+});
+add_task(clear_state);
+
+add_task(async function test_server_error() {
+ // Simulate a server error.
+ function simulateErrorResponse(request, response) {
+ response.setHeader("Date", new Date(3000).toUTCString());
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.write(
+ JSON.stringify({
+ code: 503,
+ errno: 999,
+ error: "Service Unavailable",
+ })
+ );
+ response.setStatusLine(null, 503, "Service Unavailable");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateErrorResponse);
+
+ let notificationObserved = false;
+ const observer = {
+ observe() {
+ Services.obs.removeObserver(this, "remote-settings:changes-poll-end");
+ notificationObserved = true;
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:changes-poll-end");
+ Services.prefs.setIntPref(PREF_LAST_UPDATE, 42);
+
+ // pollChanges() fails with adequate error and no notification.
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.ok(
+ !notificationObserved,
+ "a notification should not have been observed"
+ );
+ Assert.ok(/Polling for changes failed/.test(error.message));
+ // When an error occurs, last update was not overwritten.
+ Assert.equal(Services.prefs.getIntPref(PREF_LAST_UPDATE), 42);
+ // ensure that we've accumulated the correct telemetry
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SERVER_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_server_error_5xx() {
+ function simulateErrorResponse(request, response) {
+ response.setHeader("Date", new Date(3000).toUTCString());
+ response.setHeader("Content-Type", "text/html; charset=UTF-8");
+ response.write("");
+ response.setStatusLine(null, 504, "Gateway Timeout");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateErrorResponse);
+
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {}
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SERVER_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_server_error_4xx() {
+ function simulateErrorResponse(request, response) {
+ response.setHeader("Date", new Date(3000).toUTCString());
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ if (request.queryString.includes(`_since=${encodeURIComponent('"abc"')}`)) {
+ response.setStatusLine(null, 400, "Bad Request");
+ response.write(JSON.stringify({}));
+ } else {
+ response.setStatusLine(null, 200, "OK");
+ response.write(JSON.stringify({ changes: [] }));
+ }
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateErrorResponse);
+
+ Services.prefs.setStringPref(PREF_LAST_ETAG, '"abc"');
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.ok(error.message.includes("400 Bad Request"), "Polling failed");
+ Assert.ok(
+ !Services.prefs.prefHasUserValue(PREF_LAST_ETAG),
+ "Last ETag pref was cleared"
+ );
+
+ await RemoteSettings.pollChanges(); // Does not raise.
+});
+add_task(clear_state);
+
+add_task(async function test_client_error() {
+ const collectionDetails = {
+ id: "b6ba7fab-a40a-4d03-a4af-6b627f3c5b36",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "some-entry",
+ };
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, [collectionDetails])
+ );
+ const c = RemoteSettings("some-entry");
+ c.maybeSync = () => {
+ throw new RemoteSettingsClient.CorruptedDataError("main/some-entry");
+ };
+
+ let notificationsObserved = [];
+ const observer = {
+ observe(aSubject, aTopic) {
+ Services.obs.removeObserver(this, aTopic);
+ notificationsObserved.push([aTopic, aSubject.wrappedJSObject]);
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:changes-poll-end");
+ Services.obs.addObserver(observer, "remote-settings:sync-error");
+ Services.prefs.setIntPref(PREF_LAST_ETAG, 42);
+
+ // pollChanges() fails with adequate error and a sync-error notification.
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.equal(
+ notificationsObserved.length,
+ 1,
+ "only the error notification should not have been observed"
+ );
+ console.log(notificationsObserved);
+ let [topicObserved, subjectObserved] = notificationsObserved[0];
+ Assert.equal(topicObserved, "remote-settings:sync-error");
+ Assert.ok(
+ subjectObserved.error instanceof RemoteSettingsClient.CorruptedDataError,
+ `original error is provided (got ${subjectObserved.error})`
+ );
+ Assert.deepEqual(
+ subjectObserved.error.details,
+ collectionDetails,
+ "information about collection is provided"
+ );
+
+ Assert.ok(/Corrupted/.test(error.message), "original client error is thrown");
+ // When an error occurs, last etag was not overwritten.
+ Assert.equal(Services.prefs.getIntPref(PREF_LAST_ETAG), 42);
+ // ensure that we've accumulated the correct telemetry
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SYNC_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_sync_success_is_stored_in_history() {
+ const collectionDetails = {
+ last_modified: 444,
+ bucket: "main",
+ collection: "desktop-manager",
+ };
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, [collectionDetails])
+ );
+ const c = RemoteSettings("desktop-manager");
+ c.maybeSync = () => {};
+ try {
+ await RemoteSettings.pollChanges({ expectedTimestamp: 555 });
+ } catch (e) {}
+
+ const { history } = await RemoteSettings.inspect();
+
+ Assert.deepEqual(history, {
+ [TELEMETRY_SOURCE_SYNC]: [
+ {
+ timestamp: 444,
+ status: "success",
+ infos: {},
+ datetime: new Date(444),
+ },
+ ],
+ });
+});
+add_task(clear_state);
+
+add_task(async function test_sync_error_is_stored_in_history() {
+ const collectionDetails = {
+ last_modified: 1337,
+ bucket: "main",
+ collection: "desktop-manager",
+ };
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, [collectionDetails])
+ );
+ const c = RemoteSettings("desktop-manager");
+ c.maybeSync = () => {
+ throw new RemoteSettingsClient.MissingSignatureError(
+ "main/desktop-manager"
+ );
+ };
+ try {
+ await RemoteSettings.pollChanges({ expectedTimestamp: 123456 });
+ } catch (e) {}
+
+ const { history } = await RemoteSettings.inspect();
+
+ Assert.deepEqual(history, {
+ [TELEMETRY_SOURCE_SYNC]: [
+ {
+ timestamp: 1337,
+ status: "sync_error",
+ infos: {
+ expectedTimestamp: 123456,
+ errorName: "MissingSignatureError",
+ },
+ datetime: new Date(1337),
+ },
+ ],
+ });
+});
+add_task(clear_state);
+
+add_task(
+ async function test_sync_broken_signal_is_sent_on_consistent_failure() {
+ // Wait for the "sync-broken-error" notification.
+ let notificationObserved = false;
+ const observer = {
+ observe() {
+ notificationObserved = true;
+ },
+ };
+ Services.obs.addObserver(observer, "remote-settings:broken-sync-error");
+ // Register a client with a failing sync method.
+ const c = RemoteSettings("desktop-manager");
+ c.maybeSync = () => {
+ throw new RemoteSettingsClient.InvalidSignatureError(
+ "main/desktop-manager"
+ );
+ };
+ // Simulate a response whose ETag gets incremented on each call
+ // (in order to generate several history entries, indexed by timestamp).
+ let timestamp = 1337;
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(10000, () => {
+ return [
+ {
+ last_modified: ++timestamp,
+ bucket: "main",
+ collection: "desktop-manager",
+ },
+ ];
+ })
+ );
+
+ // Now obtain several failures in a row (less than threshold).
+ for (var i = 0; i < 9; i++) {
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {}
+ }
+ Assert.ok(!notificationObserved, "Not notified yet");
+
+ // Clear events snapshot.
+ Services.telemetry.snapshotEvents(
+ Ci.nsITelemetry.DATASET_ALL_CHANNELS,
+ true
+ );
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ // Fail again once. Will now notify.
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {}
+ Assert.ok(notificationObserved, "Broken sync notified");
+ // Uptake event to notify broken sync is sent.
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SYNC_ERROR,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SYNC_BROKEN_ERROR,
+ },
+ ]);
+
+ // Synchronize successfully.
+ notificationObserved = false;
+ const failingSync = c.maybeSync;
+ c.maybeSync = () => {};
+ await RemoteSettings.pollChanges();
+
+ const { history } = await RemoteSettings.inspect();
+ Assert.equal(
+ history[TELEMETRY_SOURCE_SYNC][0].status,
+ UptakeTelemetry.STATUS.SUCCESS,
+ "Last sync is success"
+ );
+ Assert.ok(!notificationObserved, "Not notified after success");
+
+ // Now fail again. Broken sync isn't notified, we need several in a row.
+ c.maybeSync = failingSync;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {}
+ Assert.ok(!notificationObserved, "Not notified on single error");
+ Services.obs.removeObserver(observer, "remote-settings:broken-sync-error");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_check_clockskew_is_updated() {
+ const serverTime = 2000;
+
+ function serverResponse(request, response) {
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date(serverTime).toUTCString());
+ response.write(JSON.stringify({ timestamp: 42, changes: [] }));
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, serverResponse);
+
+ let startTime = Date.now();
+
+ await RemoteSettings.pollChanges();
+
+ // How does the clock difference look?
+ let endTime = Date.now();
+ let clockDifference = Services.prefs.getIntPref(PREF_CLOCK_SKEW_SECONDS);
+ // we previously set the serverTime to 2 (seconds past epoch)
+ Assert.ok(
+ clockDifference <= endTime / 1000 &&
+ clockDifference >= Math.floor(startTime / 1000) - serverTime / 1000
+ );
+
+ // check negative clock skew times
+ // set to a time in the future
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(Date.now() + 10000, [])
+ );
+
+ await RemoteSettings.pollChanges();
+
+ clockDifference = Services.prefs.getIntPref(PREF_CLOCK_SKEW_SECONDS);
+ // we previously set the serverTime to Date.now() + 10000 ms past epoch
+ Assert.ok(clockDifference <= 0 && clockDifference >= -10);
+});
+add_task(clear_state);
+
+add_task(async function test_check_clockskew_takes_age_into_account() {
+ const currentTime = Date.now();
+ const skewSeconds = 5;
+ const ageCDNSeconds = 3600;
+ const serverTime = currentTime - skewSeconds * 1000 - ageCDNSeconds * 1000;
+
+ function serverResponse(request, response) {
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date(serverTime).toUTCString());
+ response.setHeader("Age", `${ageCDNSeconds}`);
+ response.write(JSON.stringify({ timestamp: 42, changes: [] }));
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, serverResponse);
+
+ await RemoteSettings.pollChanges();
+
+ const clockSkew = Services.prefs.getIntPref(PREF_CLOCK_SKEW_SECONDS);
+ Assert.greaterOrEqual(clockSkew, skewSeconds, `clockSkew is ${clockSkew}`);
+});
+add_task(clear_state);
+
+add_task(async function test_backoff() {
+ function simulateBackoffResponse(request, response) {
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Backoff", "10");
+ response.write(JSON.stringify({ timestamp: 42, changes: [] }));
+ response.setStatusLine(null, 200, "OK");
+ }
+ server.registerPathHandler(CHANGES_PATH, simulateBackoffResponse);
+
+ // First will work.
+ await RemoteSettings.pollChanges();
+ // Second will fail because we haven't waited.
+ try {
+ await RemoteSettings.pollChanges();
+ // The previous line should have thrown an error.
+ Assert.ok(false);
+ } catch (e) {
+ Assert.ok(
+ /Server is asking clients to back off; retry in \d+s./.test(e.message)
+ );
+ }
+
+ // Once backoff time has expired, polling for changes can start again.
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(12000, [
+ {
+ id: "6a733d4a-601e-11e8-837a-0f85257529a1",
+ last_modified: 1300,
+ host: "localhost",
+ bucket: "some-bucket",
+ collection: "some-collection",
+ },
+ ])
+ );
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER_BACKOFF,
+ `${Date.now() - 1000}`
+ );
+
+ await RemoteSettings.pollChanges();
+
+ // Backoff tracking preference was cleared.
+ Assert.ok(!Services.prefs.prefHasUserValue(PREF_SETTINGS_SERVER_BACKOFF));
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.UP_TO_DATE,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ {
+ value: UptakeTelemetry.STATUS.BACKOFF,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_network_error() {
+ // Simulate a network error (to check telemetry report).
+ Services.prefs.setStringPref(PREF_SETTINGS_SERVER, "http://localhost:42/v1");
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {}
+
+ // ensure that we've accumulated the correct telemetry
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.NETWORK_ERROR,
+ },
+ ]);
+});
+add_task(clear_state);
+
+add_task(async function test_syncs_clients_with_local_database() {
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(42000, [
+ {
+ id: "d4a14f44-601f-11e8-8b8a-030f3dc5b844",
+ last_modified: 10000,
+ host: "localhost",
+ bucket: "main",
+ collection: "some-unknown",
+ },
+ {
+ id: "39f57e4e-6023-11e8-8b74-77c8dedfb389",
+ last_modified: 9000,
+ host: "localhost",
+ bucket: "blocklists",
+ collection: "addons",
+ },
+ {
+ id: "9a594c1a-601f-11e8-9c8a-33b2239d9113",
+ last_modified: 8000,
+ host: "localhost",
+ bucket: "main",
+ collection: "recipes",
+ },
+ ])
+ );
+
+ // This simulates what remote-settings would do when initializing a local database.
+ // We don't want to instantiate a client using the RemoteSettings() API
+ // since we want to test «unknown» clients that have a local database.
+ new RemoteSettingsClient("addons", {
+ bucketName: "blocklists",
+ }).db.importChanges({}, 42);
+ new RemoteSettingsClient("recipes").db.importChanges({}, 43);
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ Assert.ok(false, "pollChange() should throw when pulling recipes");
+ } catch (e) {
+ error = e;
+ }
+
+ // The `main/some-unknown` should be skipped because it has no local database.
+ // The `blocklists/addons` should be skipped because it is not the main bucket.
+ // The `recipes` has a local database, and should cause a network error because the test
+ // does not setup the server to receive the requests of `maybeSync()`.
+ Assert.ok(/HTTP 404/.test(error.message), "server will return 404 on sync");
+ Assert.equal(error.details.collection, "recipes");
+});
+add_task(clear_state);
+
+add_task(async function test_syncs_clients_with_local_dump() {
+ if (IS_ANDROID) {
+ // Skip test: we don't ship remote settings dumps on Android (see package-manifest).
+ return;
+ }
+ server.registerPathHandler(
+ CHANGES_PATH,
+ serveChangesEntries(42000, [
+ {
+ id: "d4a14f44-601f-11e8-8b8a-030f3dc5b844",
+ last_modified: 10000,
+ host: "localhost",
+ bucket: "main",
+ collection: "some-unknown",
+ },
+ {
+ id: "39f57e4e-6023-11e8-8b74-77c8dedfb389",
+ last_modified: 9000,
+ host: "localhost",
+ bucket: "blocklists",
+ collection: "addons",
+ },
+ {
+ id: "9a594c1a-601f-11e8-9c8a-33b2239d9113",
+ last_modified: 8000,
+ host: "localhost",
+ bucket: "main",
+ collection: "example",
+ },
+ ])
+ );
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges();
+ } catch (e) {
+ error = e;
+ }
+
+ // The `main/some-unknown` should be skipped because it has no dump.
+ // The `blocklists/addons` should be skipped because it is not the main bucket.
+ // The `example` has a dump, and should cause a network error because the test
+ // does not setup the server to receive the requests of `maybeSync()`.
+ Assert.ok(/HTTP 404/.test(error.message), "server will return 404 on sync");
+ Assert.equal(error.details.collection, "example");
+});
+add_task(clear_state);
+
+add_task(async function test_adding_client_resets_polling() {
+ function serve200(request, response) {
+ const entries = [
+ {
+ id: "aa71e6cc-9f37-447a-b6e0-c025e8eabd03",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "a-collection",
+ },
+ ];
+ if (request.queryString.includes("_since")) {
+ response.write(
+ JSON.stringify({
+ timestamp: 42,
+ changes: [],
+ })
+ );
+ } else {
+ response.write(
+ JSON.stringify({
+ timestamp: 42,
+ changes: entries,
+ })
+ );
+ }
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date().toUTCString());
+ }
+ server.registerPathHandler(CHANGES_PATH, serve200);
+
+ // Poll once, without any client for "a-collection"
+ await RemoteSettings.pollChanges();
+
+ // Register a new client.
+ let maybeSyncCalled = false;
+ const c = RemoteSettings("a-collection");
+ c.maybeSync = () => {
+ maybeSyncCalled = true;
+ };
+
+ // Poll again.
+ await RemoteSettings.pollChanges();
+
+ // The new client was called, even if the server data didn't change.
+ Assert.ok(maybeSyncCalled);
+
+ // Poll again. This time maybeSync() won't be called.
+ maybeSyncCalled = false;
+ await RemoteSettings.pollChanges();
+ Assert.ok(!maybeSyncCalled);
+});
+add_task(clear_state);
+
+add_task(
+ async function test_broadcast_handler_passes_version_and_trigger_values() {
+ // The polling will use the broadcast version as cache busting query param.
+ let passedQueryString;
+ function serveCacheBusted(request, response) {
+ passedQueryString = request.queryString;
+ const entries = [
+ {
+ id: "b6ba7fab-a40a-4d03-a4af-6b627f3c5b36",
+ last_modified: 42,
+ host: "localhost",
+ bucket: "main",
+ collection: "from-broadcast",
+ },
+ ];
+ response.write(
+ JSON.stringify({
+ changes: entries,
+ timestamp: 42,
+ })
+ );
+ response.setHeader("ETag", "42");
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date().toUTCString());
+ }
+ server.registerPathHandler(CHANGES_PATH, serveCacheBusted);
+
+ let passedTrigger;
+ const c = RemoteSettings("from-broadcast");
+ c.maybeSync = (last_modified, { trigger }) => {
+ passedTrigger = trigger;
+ };
+
+ const version = "1337";
+
+ let context = { phase: pushBroadcastService.PHASES.HELLO };
+ await remoteSettingsBroadcastHandler.receivedBroadcastMessage(
+ version,
+ BROADCAST_ID,
+ context
+ );
+ Assert.equal(passedTrigger, "startup");
+ Assert.equal(passedQueryString, `_expected=${version}`);
+
+ clear_state();
+
+ context = { phase: pushBroadcastService.PHASES.REGISTER };
+ await remoteSettingsBroadcastHandler.receivedBroadcastMessage(
+ version,
+ BROADCAST_ID,
+ context
+ );
+ Assert.equal(passedTrigger, "startup");
+
+ clear_state();
+
+ context = { phase: pushBroadcastService.PHASES.BROADCAST };
+ await remoteSettingsBroadcastHandler.receivedBroadcastMessage(
+ version,
+ BROADCAST_ID,
+ context
+ );
+ Assert.equal(passedTrigger, "broadcast");
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_stale_startup_timestamp() {
+ Services.prefs.setStringPref(PREF_LAST_ETAG, 42);
+
+ let error;
+ try {
+ await RemoteSettings.pollChanges({
+ trigger: "startup",
+ expectedTimestamp: "41",
+ });
+ } catch (e) {
+ error = e;
+ }
+
+ Assert.equal(error, undefined);
+ Assert.equal(Services.prefs.getStringPref(PREF_LAST_ETAG), "42");
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.STALE_EXPECTED,
+ },
+ ]);
+});
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_recover_broken.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_recover_broken.js
new file mode 100644
index 000000000..5bb047c8a
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_recover_broken.js
@@ -0,0 +1,138 @@
+const PREF_SETTINGS_SERVER = "services.settings.server";
+const CHANGES_PATH = "/v1" + Utils.CHANGES_PATH;
+const BROKEN_SYNC_THRESHOLD = 10; // See default pref value
+
+let server;
+let client;
+let maybeSyncBackup;
+
+async function clear_state() {
+ // Disable logging output.
+ Services.prefs.setStringPref("services.settings.loglevel", "critical");
+ // Pull data from the test server.
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER,
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ // Clear sync history.
+ await new SyncHistory("").clear();
+
+ // Simulate a response whose ETag gets incremented on each call
+ // (in order to generate several history entries, indexed by timestamp).
+ let timestamp = 1337;
+ server.registerPathHandler(CHANGES_PATH, (request, response) => {
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setHeader("Date", new Date(1000000).toUTCString());
+ response.setHeader("ETag", `"${timestamp}"`);
+ response.write(
+ JSON.stringify({
+ timestamp,
+ changes: [
+ {
+ last_modified: ++timestamp,
+ bucket: "main",
+ collection: "desktop-manager",
+ },
+ ],
+ })
+ );
+ });
+
+ // Restore original maybeSync() method between each test.
+ client.maybeSync = maybeSyncBackup;
+}
+
+function run_test() {
+ // Set up an HTTP Server
+ server = new HttpServer();
+ server.start(-1);
+
+ client = RemoteSettings("desktop-manager");
+ maybeSyncBackup = client.maybeSync;
+
+ run_next_test();
+
+ registerCleanupFunction(() => {
+ server.stop(() => {});
+ // Restore original maybeSync() method when test suite is done.
+ client.maybeSync = maybeSyncBackup;
+ });
+}
+
+add_task(clear_state);
+
+add_task(async function test_db_is_destroyed_when_sync_is_broken() {
+ // Simulate a successful sync.
+ client.maybeSync = async () => {
+ // Store some data in local DB.
+ await client.db.importChanges({}, 1515, []);
+ };
+ await RemoteSettings.pollChanges({ trigger: "timer" });
+
+ // Register a client with a failing sync method.
+ client.maybeSync = () => {
+ throw new RemoteSettingsClient.InvalidSignatureError(
+ "main/desktop-manager"
+ );
+ };
+
+ // Now obtain several failures in a row.
+ for (var i = 0; i < BROKEN_SYNC_THRESHOLD; i++) {
+ try {
+ await RemoteSettings.pollChanges({ trigger: "timer" });
+ } catch (e) {}
+ }
+
+ // Synchronization is in broken state.
+ Assert.equal(
+ await client.db.getLastModified(),
+ 1515,
+ "Local DB was not destroyed yet"
+ );
+
+ // Synchronize again. Broken state will be detected.
+ try {
+ await RemoteSettings.pollChanges({ trigger: "timer" });
+ } catch (e) {}
+
+ // DB was destroyed.
+ Assert.equal(
+ await client.db.getLastModified(),
+ null,
+ "Local DB was destroyed"
+ );
+});
+
+add_task(clear_state);
+
+add_task(async function test_db_is_not_destroyed_when_state_is_server_error() {
+ // Since we don't mock the server endpoints to obtain the changeset of this
+ // collection, the call to `maybeSync()` will fail with network errors.
+
+ // Store some data in local DB.
+ await client.db.importChanges({}, 1515, []);
+
+ // Now obtain several failures in a row.
+ let lastError;
+ for (var i = 0; i < BROKEN_SYNC_THRESHOLD + 1; i++) {
+ try {
+ await RemoteSettings.pollChanges({ trigger: "timer" });
+ } catch (e) {
+ lastError = e;
+ }
+ }
+ Assert.ok(
+ /Cannot parse server content/.test(lastError.message),
+ "Error is about server"
+ );
+ // DB was not destroyed.
+ Assert.equal(
+ await client.db.getLastModified(),
+ 1515,
+ "Local DB was not destroyed"
+ );
+});
+
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_release_prefs.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_release_prefs.js
new file mode 100644
index 000000000..3e1ae7c25
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_release_prefs.js
@@ -0,0 +1,252 @@
+"use strict";
+
+var nextUniqId = 0;
+function getNewUtils() {
+ const { Utils } = ChromeUtils.importESModule(
+ `resource://services-settings/Utils.sys.mjs?_${++nextUniqId}`
+ );
+ return Utils;
+}
+
+// A collection with a dump that's packaged on all builds where this test runs,
+// including on Android at mobile/android/installer/package-manifest.in
+const TEST_BUCKET = "main";
+const TEST_COLLECTION = "password-recipes";
+
+async function importData(records) {
+ await RemoteSettingsWorker._execute("_test_only_import", [
+ TEST_BUCKET,
+ TEST_COLLECTION,
+ records,
+ records[0]?.last_modified || 0,
+ ]);
+}
+
+async function clear_state() {
+ Services.env.set("MOZ_REMOTE_SETTINGS_DEVTOOLS", "0");
+ Services.prefs.clearUserPref("services.settings.server");
+ Services.prefs.clearUserPref("services.settings.preview_enabled");
+}
+
+add_setup(async function () {
+ // Set this env vars in order to test the code path where the
+ // server URL can only be overridden from Dev Tools.
+ // See `isRunningTests` in `services/settings/Utils.sys.mjs`.
+ const before = Services.env.get("MOZ_DISABLE_NONLOCAL_CONNECTIONS");
+ Services.env.set("MOZ_DISABLE_NONLOCAL_CONNECTIONS", "0");
+
+ registerCleanupFunction(() => {
+ clear_state();
+ Services.env.set("MOZ_DISABLE_NONLOCAL_CONNECTIONS", before);
+ });
+});
+
+add_task(clear_state);
+
+add_task(
+ {
+ skip_if: () => !AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_server_url_cannot_be_toggled_in_release() {
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.equal(
+ Utils.SERVER_URL,
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0],
+ "Server url pref was not read in release"
+ );
+ }
+);
+
+add_task(
+ {
+ skip_if: () => AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_server_url_cannot_be_toggled_in_dev_nightly() {
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.notEqual(
+ Utils.SERVER_URL,
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0],
+ "Server url pref was read in nightly/dev"
+ );
+ }
+);
+add_task(clear_state);
+
+add_task(
+ {
+ skip_if: () => !AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_preview_mode_cannot_be_toggled_in_release() {
+ Services.prefs.setBoolPref("services.settings.preview_enabled", true);
+
+ const Utils = getNewUtils();
+
+ Assert.ok(!Utils.PREVIEW_MODE, "Preview mode pref was not read in release");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ {
+ skip_if: () => AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_preview_mode_cannot_be_toggled_in_dev_nightly() {
+ Services.prefs.setBoolPref("services.settings.preview_enabled", true);
+
+ const Utils = getNewUtils();
+
+ Assert.ok(Utils.PREVIEW_MODE, "Preview mode pref is read in dev/nightly");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ {
+ skip_if: () => !AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_load_dumps_will_always_be_loaded_in_release() {
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.equal(
+ Utils.SERVER_URL,
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0],
+ "Server url pref was not read"
+ );
+ Assert.ok(Utils.LOAD_DUMPS, "Dumps will always be loaded");
+ }
+);
+
+add_task(
+ {
+ skip_if: () => AppConstants.RELEASE_OR_BETA,
+ },
+ async function test_load_dumps_can_be_disabled_in_dev_nightly() {
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.notEqual(
+ Utils.SERVER_URL,
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0],
+ "Server url pref was read"
+ );
+ Assert.ok(!Utils.LOAD_DUMPS, "Dumps are not loaded if server is not prod");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_server_url_can_be_changed_in_all_versions_if_running_for_devtools() {
+ Services.env.set("MOZ_REMOTE_SETTINGS_DEVTOOLS", "1");
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.notEqual(
+ Utils.SERVER_URL,
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0],
+ "Server url pref was read"
+ );
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_preview_mode_can_be_changed_in_all_versions_if_running_for_devtools() {
+ Services.env.set("MOZ_REMOTE_SETTINGS_DEVTOOLS", "1");
+ Services.prefs.setBoolPref("services.settings.preview_enabled", true);
+
+ const Utils = getNewUtils();
+
+ Assert.ok(Utils.PREVIEW_MODE, "Preview mode pref was read");
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_dumps_are_not_loaded_if_server_is_not_prod_if_running_for_devtools() {
+ Services.env.set("MOZ_REMOTE_SETTINGS_DEVTOOLS", "1");
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ "http://localhost:8888/v1"
+ );
+
+ const Utils = getNewUtils();
+ Assert.ok(!Utils.LOAD_DUMPS, "Dumps won't be loaded");
+
+ // The section below ensures that the LOAD_DUMPS flag properly takes effect.
+ // The client is set up here rather than add_setup to avoid triggering the
+ // lazy getters that are behind the global Utils.LOAD_DUMPS. If they are
+ // triggered too early, then they will potentially cache different values
+ // for the server urls and environment variables and this test then won't be
+ // testing what we expect it to.
+
+ let client = new RemoteSettingsClient(TEST_COLLECTION);
+
+ const dump = await SharedUtils.loadJSONDump(TEST_BUCKET, TEST_COLLECTION);
+ let DUMP_LAST_MODIFIED = dump.timestamp;
+
+ // Dump is updated regularly, verify that the dump matches our expectations
+ // before running the test.
+ Assert.greater(
+ DUMP_LAST_MODIFIED,
+ 1234,
+ "Assuming dump to be newer than dummy 1234"
+ );
+
+ await client.db.clear();
+ await importData([{ last_modified: 1234, id: "dummy" }]);
+
+ const after = await client.get();
+ Assert.deepEqual(
+ after,
+ [{ last_modified: 1234, id: "dummy" }],
+ "Should have kept the original import"
+ );
+ Assert.equal(
+ await client.getLastModified(),
+ 1234,
+ "Should have kept the import's timestamp"
+ );
+ await client.db.clear();
+ }
+);
+add_task(clear_state);
+
+add_task(
+ async function test_dumps_are_loaded_if_server_is_prod_if_running_for_devtools() {
+ Services.env.set("MOZ_REMOTE_SETTINGS_DEVTOOLS", "1");
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ AppConstants.REMOTE_SETTINGS_SERVER_URLS[0]
+ );
+
+ const Utils = getNewUtils();
+
+ Assert.ok(Utils.LOAD_DUMPS, "dumps are loaded if prod");
+ }
+);
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures.js
new file mode 100644
index 000000000..8b50c3519
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures.js
@@ -0,0 +1,952 @@
+/* import-globals-from ../../../common/tests/unit/head_helpers.js */
+"use strict";
+
+const PREF_SETTINGS_SERVER = "services.settings.server";
+const SIGNER_NAME = "onecrl.content-signature.mozilla.org";
+
+const CERT_DIR = "test_remote_settings_signatures/";
+const CHAIN_FILES = ["collection_signing_ee.pem", "collection_signing_int.pem"];
+
+function getFileData(file) {
+ const stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+ Ci.nsIFileInputStream
+ );
+ stream.init(file, -1, 0, 0);
+ const data = NetUtil.readInputStreamToString(stream, stream.available());
+ stream.close();
+ return data;
+}
+
+function getCertChain() {
+ const chain = [];
+ for (let file of CHAIN_FILES) {
+ chain.push(getFileData(do_get_file(CERT_DIR + file)));
+ }
+ return chain.join("\n");
+}
+
+let server;
+let client;
+
+add_setup(() => {
+ // Signature verification is enabled by default. We use a custom signer
+ // because these tests were originally written for OneCRL.
+ client = RemoteSettings("signed", { signerName: SIGNER_NAME });
+
+ Services.prefs.setStringPref("services.settings.loglevel", "debug");
+
+ // Set up an HTTP Server
+ server = new HttpServer();
+ server.start(-1);
+
+ registerCleanupFunction(() => {
+ Services.prefs.clearUserPref("services.settings.loglevel");
+ Services.prefs.clearUserPref(PREF_SETTINGS_SERVER);
+ server.stop(() => {});
+ });
+});
+
+add_task(async function test_check_signatures() {
+ // First, perform a signature verification with known data and signature
+ // to ensure things are working correctly
+ let verifier = Cc[
+ "@mozilla.org/security/contentsignatureverifier;1"
+ ].createInstance(Ci.nsIContentSignatureVerifier);
+
+ const emptyData = "[]";
+ const emptySignature =
+ "p384ecdsa=zbugm2FDitsHwk5-IWsas1PpWwY29f0Fg5ZHeqD8fzep7AVl2vfcaHA7LdmCZ28qZLOioGKvco3qT117Q4-HlqFTJM7COHzxGyU2MMJ0ZTnhJrPOC1fP3cVQjU1PTWi9";
+
+ ok(
+ await verifier.asyncVerifyContentSignature(
+ emptyData,
+ emptySignature,
+ getCertChain(),
+ SIGNER_NAME,
+ Ci.nsIX509CertDB.AppXPCShellRoot
+ )
+ );
+
+ const collectionData =
+ '[{"details":{"bug":"https://bugzilla.mozilla.org/show_bug.cgi?id=1155145","created":"2016-01-18T14:43:37Z","name":"GlobalSign certs","who":".","why":"."},"enabled":true,"id":"97fbf7c4-3ef2-f54f-0029-1ba6540c63ea","issuerName":"MHExKDAmBgNVBAMTH0dsb2JhbFNpZ24gUm9vdFNpZ24gUGFydG5lcnMgQ0ExHTAbBgNVBAsTFFJvb3RTaWduIFBhcnRuZXJzIENBMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMQswCQYDVQQGEwJCRQ==","last_modified":2000,"serialNumber":"BAAAAAABA/A35EU="},{"details":{"bug":"https://bugzilla.mozilla.org/show_bug.cgi?id=1155145","created":"2016-01-18T14:48:11Z","name":"GlobalSign certs","who":".","why":"."},"enabled":true,"id":"e3bd531e-1ee4-7407-27ce-6fdc9cecbbdc","issuerName":"MIGBMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTElMCMGA1UECxMcUHJpbWFyeSBPYmplY3QgUHVibGlzaGluZyBDQTEwMC4GA1UEAxMnR2xvYmFsU2lnbiBQcmltYXJ5IE9iamVjdCBQdWJsaXNoaW5nIENB","last_modified":3000,"serialNumber":"BAAAAAABI54PryQ="}]';
+ const collectionSignature =
+ "p384ecdsa=f4pA2tYM5jQgWY6YUmhUwQiBLj6QO5sHLD_5MqLePz95qv-7cNCuQoZnPQwxoptDtW8hcWH3kLb0quR7SB-r82gkpR9POVofsnWJRA-ETb0BcIz6VvI3pDT49ZLlNg3p";
+
+ ok(
+ await verifier.asyncVerifyContentSignature(
+ collectionData,
+ collectionSignature,
+ getCertChain(),
+ SIGNER_NAME,
+ Ci.nsIX509CertDB.AppXPCShellRoot
+ )
+ );
+});
+
+add_task(async function test_bad_signature_does_not_lead_to_empty_list() {
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER,
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+ const x5u = `http://localhost:${server.identity.primaryPort}/x5u.pem`;
+
+ const networkCalls = [];
+
+ server.registerPathHandler(
+ "/v1/buckets/monitor/collections/changes/changeset",
+ (request, response) => {
+ response.write(
+ JSON.stringify({
+ changes: [
+ {
+ bucket: "main",
+ collection: "no-dump-no-local-data",
+ last_modified: 42,
+ },
+ ],
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ }
+ );
+ server.registerPathHandler(
+ "/v1/buckets/monitor/collections/changes/changeset",
+ (request, response) => {
+ networkCalls.push(request);
+ response.write(
+ JSON.stringify({
+ changes: [
+ {
+ bucket: "main",
+ collection: "no-dump-no-local-data",
+ last_modified: 42,
+ },
+ ],
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ }
+ );
+ server.registerPathHandler(
+ "/v1/buckets/main/collections/no-dump-no-local-data/changeset",
+ (request, response) => {
+ response.write(
+ JSON.stringify({
+ timestamp: 42,
+ changes: [],
+ metadata: {
+ signatures: [
+ {
+ signature: "bad-signature",
+ x5u,
+ },
+ ],
+ },
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ }
+ );
+ server.registerPathHandler("/x5u.pem", (request, response) => {
+ response.write(getCertChain()); // At least cert will be valid.
+ response.setHeader("Content-Type", "text/plain; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ });
+
+ const clientEmpty = RemoteSettings("no-dump-no-local-data");
+ clientEmpty.verifySignature = true; // default
+
+ // Check that client.get() will initiate a sync,
+ // and that it will throw since the signature is bad,
+ // and not return an empty list (`emptyListFallback: false`)
+ let error;
+ try {
+ await clientEmpty.get({
+ emptyListFallback: false,
+ syncIfEmpty: true, // default value
+ });
+ } catch (exc) {
+ error = exc;
+ }
+ equal(error.name, "InvalidSignatureError");
+
+ // Even running client.sync() will throw and won't leave
+ // anything in the database.
+ error = null;
+ try {
+ await clientEmpty.sync();
+ } catch (exc) {
+ error = exc;
+ }
+ equal(error.name, "InvalidSignatureError");
+ equal(await clientEmpty.db.getLastModified(), null);
+
+ // Call .get() again will initiate another sync.
+ networkCalls.length = 0;
+ try {
+ await clientEmpty.get({
+ emptyListFallback: false,
+ syncIfEmpty: true, // default value
+ });
+ } catch (exc) {
+ error = exc;
+ }
+ Assert.greater(networkCalls.length, 0, "Network calls were made");
+ equal(error.name, "InvalidSignatureError");
+});
+
+add_task(async function test_check_synchronization_with_signatures() {
+ const port = server.identity.primaryPort;
+
+ const x5u = `http://localhost:${port}/test_remote_settings_signatures/test_cert_chain.pem`;
+
+ // Telemetry reports.
+ const TELEMETRY_SOURCE = client.identifier;
+
+ function registerHandlers(responses) {
+ function handleResponse(serverTimeMillis, request, response) {
+ const key = `${request.method}:${request.path}?${request.queryString}`;
+ const available = responses[key];
+ const sampled = available.length > 1 ? available.shift() : available[0];
+ if (!sampled) {
+ do_throw(
+ `unexpected ${request.method} request for ${request.path}?${request.queryString}`
+ );
+ }
+
+ response.setStatusLine(
+ null,
+ sampled.status.status,
+ sampled.status.statusText
+ );
+ // send the headers
+ for (let headerLine of sampled.sampleHeaders) {
+ let headerElements = headerLine.split(":");
+ response.setHeader(headerElements[0], headerElements[1].trimLeft());
+ }
+
+ // set the server date
+ response.setHeader("Date", new Date(serverTimeMillis).toUTCString());
+
+ response.write(sampled.responseBody);
+ }
+
+ for (let key of Object.keys(responses)) {
+ const keyParts = key.split(":");
+ const valueParts = keyParts[1].split("?");
+ const path = valueParts[0];
+
+ server.registerPathHandler(path, handleResponse.bind(null, 2000));
+ }
+ }
+
+ // set up prefs so the kinto updater talks to the test server
+ Services.prefs.setStringPref(
+ PREF_SETTINGS_SERVER,
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+
+ // These are records we'll use in the test collections
+ const RECORD1 = {
+ details: {
+ bug: "https://bugzilla.mozilla.org/show_bug.cgi?id=1155145",
+ created: "2016-01-18T14:43:37Z",
+ name: "GlobalSign certs",
+ who: ".",
+ why: ".",
+ },
+ enabled: true,
+ id: "97fbf7c4-3ef2-f54f-0029-1ba6540c63ea",
+ issuerName:
+ "MHExKDAmBgNVBAMTH0dsb2JhbFNpZ24gUm9vdFNpZ24gUGFydG5lcnMgQ0ExHTAbBgNVBAsTFFJvb3RTaWduIFBhcnRuZXJzIENBMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMQswCQYDVQQGEwJCRQ==",
+ last_modified: 2000,
+ serialNumber: "BAAAAAABA/A35EU=",
+ };
+
+ const RECORD2 = {
+ details: {
+ bug: "https://bugzilla.mozilla.org/show_bug.cgi?id=1155145",
+ created: "2016-01-18T14:48:11Z",
+ name: "GlobalSign certs",
+ who: ".",
+ why: ".",
+ },
+ enabled: true,
+ id: "e3bd531e-1ee4-7407-27ce-6fdc9cecbbdc",
+ issuerName:
+ "MIGBMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTElMCMGA1UECxMcUHJpbWFyeSBPYmplY3QgUHVibGlzaGluZyBDQTEwMC4GA1UEAxMnR2xvYmFsU2lnbiBQcmltYXJ5IE9iamVjdCBQdWJsaXNoaW5nIENB",
+ last_modified: 3000,
+ serialNumber: "BAAAAAABI54PryQ=",
+ };
+
+ const RECORD3 = {
+ details: {
+ bug: "https://bugzilla.mozilla.org/show_bug.cgi?id=1155145",
+ created: "2016-01-18T14:48:11Z",
+ name: "GlobalSign certs",
+ who: ".",
+ why: ".",
+ },
+ enabled: true,
+ id: "c7c49b69-a4ab-418e-92a9-e1961459aa7f",
+ issuerName:
+ "MIGBMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTElMCMGA1UECxMcUHJpbWFyeSBPYmplY3QgUHVibGlzaGluZyBDQTEwMC4GA1UEAxMnR2xvYmFsU2lnbiBQcmltYXJ5IE9iamVjdCBQdWJsaXNoaW5nIENB",
+ last_modified: 4000,
+ serialNumber: "BAAAAAABI54PryQ=",
+ };
+
+ const RECORD1_DELETION = {
+ deleted: true,
+ enabled: true,
+ id: "97fbf7c4-3ef2-f54f-0029-1ba6540c63ea",
+ last_modified: 3500,
+ };
+
+ // Check that a signature on an empty collection is OK
+ // We need to set up paths on the HTTP server to return specific data from
+ // specific paths for each test. Here we prepare data for each response.
+
+ // A cert chain response (this the cert chain that contains the signing
+ // cert, the root and any intermediates in between). This is used in each
+ // sync.
+ const RESPONSE_CERT_CHAIN = {
+ comment: "RESPONSE_CERT_CHAIN",
+ sampleHeaders: ["Content-Type: text/plain; charset=UTF-8"],
+ status: { status: 200, statusText: "OK" },
+ responseBody: getCertChain(),
+ };
+
+ // A server settings response. This is used in each sync.
+ const RESPONSE_SERVER_SETTINGS = {
+ comment: "RESPONSE_SERVER_SETTINGS",
+ sampleHeaders: [
+ "Access-Control-Allow-Origin: *",
+ "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+ "Content-Type: application/json; charset=UTF-8",
+ "Server: waitress",
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ settings: {
+ batch_max_requests: 25,
+ },
+ url: `http://localhost:${port}/v1/`,
+ documentation: "https://kinto.readthedocs.org/",
+ version: "1.5.1",
+ commit: "cbc6f58",
+ hello: "kinto",
+ }),
+ };
+
+ // This is the initial, empty state of the collection. This is only used
+ // for the first sync.
+ const RESPONSE_EMPTY_INITIAL = {
+ comment: "RESPONSE_EMPTY_INITIAL",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "1000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 1000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature:
+ "vxuAg5rDCB-1pul4a91vqSBQRXJG_j7WOYUTswxRSMltdYmbhLRH8R8brQ9YKuNDF56F-w6pn4HWxb076qgKPwgcEBtUeZAO_RtaHXRkRUUgVzAr86yQL4-aJTbv3D6u",
+ },
+ ],
+ },
+ changes: [],
+ }),
+ };
+
+ // Here, we map request method and path to the available responses
+ const emptyCollectionResponses = {
+ "GET:/test_remote_settings_signatures/test_cert_chain.pem?": [
+ RESPONSE_CERT_CHAIN,
+ ],
+ "GET:/v1/?": [RESPONSE_SERVER_SETTINGS],
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=1000": [
+ RESPONSE_EMPTY_INITIAL,
+ ],
+ };
+
+ //
+ // 1.
+ // - collection: undefined -> []
+ // - timestamp: undefined -> 1000
+ //
+
+ // .. and use this map to register handlers for each path
+ registerHandlers(emptyCollectionResponses);
+
+ // Clear events snapshot.
+ Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_ALL_CHANNELS, true);
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ // With all of this set up, we attempt a sync. This will resolve if all is
+ // well and throw if something goes wrong.
+ await client.maybeSync(1000);
+
+ equal((await client.get()).length, 0);
+
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SUCCESS,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ ]);
+
+ //
+ // 2.
+ // - collection: [] -> [RECORD2, RECORD1]
+ // - timestamp: 1000 -> 3000
+ //
+ // Check that some additions (2 records) to the collection have a valid
+ // signature.
+
+ // This response adds two entries (RECORD1 and RECORD2) to the collection
+ const RESPONSE_TWO_ADDED = {
+ comment: "RESPONSE_TWO_ADDED",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "3000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 3000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature:
+ "dwhJeypadNIyzGj3QdI0KMRTPnHhFPF_j73mNrsPAHKMW46S2Ftf4BzsPMvPMB8h0TjDus13wo_R4l432DHe7tYyMIWXY0PBeMcoe5BREhFIxMxTsh9eGVXBD1e3UwRy",
+ },
+ ],
+ },
+ changes: [RECORD2, RECORD1],
+ }),
+ };
+
+ const twoItemsResponses = {
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=3000&_since=1000":
+ [RESPONSE_TWO_ADDED],
+ };
+ registerHandlers(twoItemsResponses);
+ await client.maybeSync(3000);
+
+ equal((await client.get()).length, 2);
+
+ //
+ // 3.
+ // - collection: [RECORD2, RECORD1] -> [RECORD2, RECORD3]
+ // - timestamp: 3000 -> 4000
+ //
+ // Check the collection with one addition and one removal has a valid
+ // signature
+ const THREE_ITEMS_SIG =
+ "MIEmNghKnkz12UodAAIc3q_Y4a3IJJ7GhHF4JYNYmm8avAGyPM9fYU7NzVo94pzjotG7vmtiYuHyIX2rTHTbT587w0LdRWxipgFd_PC1mHiwUyjFYNqBBG-kifYk7kEw";
+
+ // Remove RECORD1, add RECORD3
+ const RESPONSE_ONE_ADDED_ONE_REMOVED = {
+ comment: "RESPONSE_ONE_ADDED_ONE_REMOVED ",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "4000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 4000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: THREE_ITEMS_SIG,
+ },
+ ],
+ },
+ changes: [RECORD3, RECORD1_DELETION],
+ }),
+ };
+
+ const oneAddedOneRemovedResponses = {
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=4000&_since=3000":
+ [RESPONSE_ONE_ADDED_ONE_REMOVED],
+ };
+ registerHandlers(oneAddedOneRemovedResponses);
+ await client.maybeSync(4000);
+
+ equal((await client.get()).length, 2);
+
+ //
+ // 4.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3]
+ // - timestamp: 4000 -> 4100
+ //
+ // Check the signature is still valid with no operation (no changes)
+
+ // Leave the collection unchanged
+ const RESPONSE_EMPTY_NO_UPDATE = {
+ comment: "RESPONSE_EMPTY_NO_UPDATE ",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "4000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 4000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: THREE_ITEMS_SIG,
+ },
+ ],
+ },
+ changes: [],
+ }),
+ };
+
+ const noOpResponses = {
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=4100&_since=4000":
+ [RESPONSE_EMPTY_NO_UPDATE],
+ };
+ registerHandlers(noOpResponses);
+ await client.maybeSync(4100);
+
+ equal((await client.get()).length, 2);
+
+ //
+ // 5.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3]
+ // - timestamp: 4000 -> 5000
+ //
+ // Check the collection is reset when the signature is invalid.
+ // Client will:
+ // - Fetch metadata (with bad signature)
+ // - Perform the sync (fetch empty changes)
+ // - Refetch the metadata and the whole collection
+ // - Validate signature successfully, but with no changes to emit.
+
+ const RESPONSE_COMPLETE_INITIAL = {
+ comment: "RESPONSE_COMPLETE_INITIAL ",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "4000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 4000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: THREE_ITEMS_SIG,
+ },
+ ],
+ },
+ changes: [RECORD2, RECORD3],
+ }),
+ };
+
+ const RESPONSE_EMPTY_NO_UPDATE_BAD_SIG = {
+ ...RESPONSE_EMPTY_NO_UPDATE,
+ responseBody: JSON.stringify({
+ timestamp: 4000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: "aW52YWxpZCBzaWduYXR1cmUK",
+ },
+ ],
+ },
+ changes: [],
+ }),
+ };
+
+ const badSigGoodSigResponses = {
+ // The first collection state is the three item collection (since
+ // there was sync with no updates before) - but, since the signature is wrong,
+ // another request will be made...
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000&_since=4000":
+ [RESPONSE_EMPTY_NO_UPDATE_BAD_SIG],
+ // Subsequent signature returned is a valid one for the three item
+ // collection.
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000": [
+ RESPONSE_COMPLETE_INITIAL,
+ ],
+ };
+
+ registerHandlers(badSigGoodSigResponses);
+ Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_ALL_CHANNELS, true);
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ let syncEventSent = false;
+ client.on("sync", () => {
+ syncEventSent = true;
+ });
+
+ await client.maybeSync(5000);
+
+ equal((await client.get()).length, 2);
+
+ // since we only fixed the signature, and no data was changed, the sync event
+ // was not sent.
+ equal(syncEventSent, false);
+
+ // ensure that the failure count is incremented for a succesful sync with an
+ // (initial) bad signature - only SERVICES_SETTINGS_SYNC_SIG_FAIL should
+ // increment.
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SIGNATURE_ERROR,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ ]);
+
+ //
+ // 6.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3]
+ // - timestamp: 4000 -> 5000
+ //
+ // Check the collection is reset when the signature is invalid.
+ // Client will:
+ // - Fetch metadata (with bad signature)
+ // - Perform the sync (fetch empty changes)
+ // - Refetch the whole collection and metadata
+ // - Sync will be no-op since local is equal to server, no changes to emit.
+
+ const badSigGoodOldResponses = {
+ // The first collection state is the current state (since there's no update
+ // - but, since the signature is wrong, another request will be made)
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000&_since=4000":
+ [RESPONSE_EMPTY_NO_UPDATE_BAD_SIG],
+ // The next request is for the full collection. This will be
+ // checked against the valid signature and last_modified times will be
+ // compared. Sync should be a no-op, even though the signature is good,
+ // because the local collection is newer.
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000": [
+ RESPONSE_EMPTY_INITIAL,
+ ],
+ };
+
+ // ensure our collection hasn't been replaced with an older, empty one
+ equal((await client.get()).length, 2, "collection was restored");
+
+ registerHandlers(badSigGoodOldResponses);
+
+ syncEventSent = false;
+ client.on("sync", () => {
+ syncEventSent = true;
+ });
+
+ await client.maybeSync(5000);
+
+ // Local data was unchanged, since it was never than the one returned by the server,
+ // thus the sync event is not sent.
+ equal(syncEventSent, false, "event was not sent");
+
+ //
+ // 7.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3]
+ // - timestamp: 4000 -> 5000
+ //
+ // Check that a tampered local DB will be overwritten and
+ // sync event contain the appropriate data.
+
+ const RESPONSE_COMPLETE_BAD_SIG = {
+ ...RESPONSE_EMPTY_NO_UPDATE,
+ responseBody: JSON.stringify({
+ timestamp: 5000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: "aW52YWxpZCBzaWduYXR1cmUK",
+ },
+ ],
+ },
+ changes: [RECORD2, RECORD3],
+ }),
+ };
+
+ const badLocalContentGoodSigResponses = {
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000&_since=3900":
+ [RESPONSE_COMPLETE_BAD_SIG],
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=5000": [
+ RESPONSE_COMPLETE_INITIAL,
+ ],
+ };
+
+ registerHandlers(badLocalContentGoodSigResponses);
+
+ // we create a local state manually here, in order to test that the sync event data
+ // properly contains created, updated, and deleted records.
+ // the local DB contains same id as RECORD2 and a fake record.
+ // the final server collection contains RECORD2 and RECORD3
+ const localId = "0602b1b2-12ab-4d3a-b6fb-593244e7b035";
+ await client.db.importChanges(
+ { signatures: [{ x5u, signature: "abc" }] },
+ 3900,
+ [
+ { ...RECORD2, last_modified: 1234567890, serialNumber: "abc" },
+ { id: localId },
+ ],
+ {
+ clear: true,
+ }
+ );
+
+ let syncData = null;
+ client.on("sync", ({ data }) => {
+ syncData = data;
+ });
+
+ // Clear events snapshot.
+ Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_ALL_CHANNELS, true);
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ // Events telemetry is sampled on released, use fake channel.
+ await client.maybeSync(5000);
+
+ // We should report a corruption_error.
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: client.identifier,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.CORRUPTION_ERROR,
+ source: client.identifier,
+ trigger: "manual",
+ duration: d => parseInt(d) > 0,
+ },
+ ]);
+
+ // The local data was corrupted, and the Telemetry status reflects it.
+ // But the sync overwrote the bad data and was eventually a success.
+ // Since local data was replaced, we use records IDs to determine
+ // what was created and deleted. And bad local data will appear
+ // in the sync event as deleted.
+ equal(syncData.current.length, 2);
+ equal(syncData.created.length, 1);
+ equal(syncData.created[0].id, RECORD3.id);
+ equal(syncData.updated.length, 1);
+ equal(syncData.updated[0].old.serialNumber, "abc");
+ equal(syncData.updated[0].new.serialNumber, RECORD2.serialNumber);
+ equal(syncData.deleted.length, 1);
+ equal(syncData.deleted[0].id, localId);
+
+ //
+ // 8.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3] (unchanged because of error)
+ // - timestamp: 4000 -> 6000
+ //
+ // Check that a failing signature throws after retry, and that sync changes
+ // are not applied.
+
+ const RESPONSE_ONLY_RECORD4_BAD_SIG = {
+ comment: "Create RECORD4",
+ sampleHeaders: [
+ "Content-Type: application/json; charset=UTF-8",
+ 'ETag: "6000"',
+ ],
+ status: { status: 200, statusText: "OK" },
+ responseBody: JSON.stringify({
+ timestamp: 6000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: "aaaaaaaaaaaaaaaaaaaaaaaa", // sig verifier wants proper length or will crash.
+ },
+ ],
+ },
+ changes: [
+ {
+ id: "f765df30-b2f1-42f6-9803-7bd5a07b5098",
+ last_modified: 6000,
+ },
+ ],
+ }),
+ };
+ const RESPONSE_EMPTY_NO_UPDATE_BAD_SIG_6000 = {
+ ...RESPONSE_EMPTY_NO_UPDATE,
+ responseBody: JSON.stringify({
+ timestamp: 6000,
+ metadata: {
+ signatures: [
+ {
+ x5u,
+ signature: "aW52YWxpZCBzaWduYXR1cmUK",
+ },
+ ],
+ },
+ changes: [],
+ }),
+ };
+ const allBadSigResponses = {
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=6000&_since=4000":
+ [RESPONSE_EMPTY_NO_UPDATE_BAD_SIG_6000],
+ "GET:/v1/buckets/main/collections/signed/changeset?_expected=6000": [
+ RESPONSE_ONLY_RECORD4_BAD_SIG,
+ ],
+ };
+
+ // Reset telemetry capture.
+ Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_ALL_CHANNELS, true);
+ Services.fog.testResetFOG();
+ enableUptakeMetric();
+
+ registerHandlers(allBadSigResponses);
+ await Assert.rejects(
+ client.maybeSync(6000),
+ RemoteSettingsClient.InvalidSignatureError,
+ "Sync failed as expected (bad signature after retry)"
+ );
+
+ // Ensure that the failure is reflected in the accumulated telemetry:
+ assertTelemetryEvents([
+ {
+ value: UptakeTelemetry.STATUS.SYNC_START,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ {
+ value: UptakeTelemetry.STATUS.SIGNATURE_RETRY_ERROR,
+ source: TELEMETRY_SOURCE,
+ trigger: "manual",
+ },
+ ]);
+
+ // When signature fails after retry, the local data present before sync
+ // should be maintained (if its signature is valid).
+ ok(
+ arrayEqual(
+ (await client.get()).map(r => r.id),
+ [RECORD3.id, RECORD2.id]
+ ),
+ "Local records were not changed"
+ );
+ // And local data should still be valid.
+ await client.get({ verifySignature: true }); // Not raising.
+
+ //
+ // 9.
+ // - collection: [RECORD2, RECORD3] -> [] (cleared)
+ // - timestamp: 4000 -> 6000
+ //
+ // Check that local data is cleared during sync if signature is not valid.
+
+ await client.db.create({
+ id: "c6b19c67-2e0e-4a82-b7f7-1777b05f3e81",
+ last_modified: 42,
+ tampered: true,
+ });
+
+ await Assert.rejects(
+ client.maybeSync(6000),
+ RemoteSettingsClient.InvalidSignatureError,
+ "Sync failed as expected (bad signature after retry)"
+ );
+
+ // Since local data was tampered, it was cleared.
+ equal((await client.get()).length, 0, "Local database is now empty.");
+
+ //
+ // 10.
+ // - collection: [RECORD2, RECORD3] -> [] (cleared)
+ // - timestamp: 4000 -> 6000
+ //
+ // Check that local data is cleared during sync if signature is not valid.
+
+ await client.db.create({
+ id: "c6b19c67-2e0e-4a82-b7f7-1777b05f3e81",
+ last_modified: 42,
+ tampered: true,
+ });
+
+ await Assert.rejects(
+ client.maybeSync(6000),
+ RemoteSettingsClient.InvalidSignatureError,
+ "Sync failed as expected (bad signature after retry)"
+ );
+ // Since local data was tampered, it was cleared.
+ equal((await client.get()).length, 0, "Local database is now empty.");
+
+ //
+ // 11.
+ // - collection: [RECORD2, RECORD3] -> [RECORD2, RECORD3]
+ // - timestamp: 4000 -> 6000
+ //
+ // Check that local data is restored if signature was valid before sync.
+ const sigCalls = [];
+ let i = 0;
+ client._verifier = {
+ async asyncVerifyContentSignature(serialized) {
+ sigCalls.push(serialized);
+ console.log(`verify call ${i}`);
+ return [
+ false, // After importing changes.
+ true, // When checking previous local data.
+ false, // Still fail after retry.
+ true, // When checking previous local data again.
+ ][i++];
+ },
+ };
+ // Create an extra record. It will have a valid signature locally
+ // thanks to the verifier mock.
+ await client.db.importChanges(
+ {
+ signatures: [{ x5u, signature: "aa" }],
+ },
+ 4000,
+ [
+ {
+ id: "extraId",
+ last_modified: 42,
+ },
+ ]
+ );
+
+ equal((await client.get()).length, 1);
+
+ // Now sync, but importing changes will have failing signature,
+ // and so will retry (see `sigResults`).
+ await Assert.rejects(
+ client.maybeSync(6000),
+ RemoteSettingsClient.InvalidSignatureError,
+ "Sync failed as expected (bad signature after retry)"
+ );
+ equal(i, 4, "sync has retried as expected");
+
+ // Make sure that we retried on a blank DB. The extra record should
+ // have been deleted when we validated the signature the second time.
+ // Since local data was tampered, it was cleared.
+ ok(/extraId/.test(sigCalls[0]), "extra record when importing changes");
+ ok(/extraId/.test(sigCalls[1]), "extra record when checking local");
+ ok(!/extraId/.test(sigCalls[2]), "db was flushed before retry");
+ ok(/extraId/.test(sigCalls[3]), "when checking local after retry");
+});
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem
new file mode 100644
index 000000000..9392129f6
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem
@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICdTCCAV2gAwIBAgIUdVZo8xeazUY3Fzm6cy61HaSjFJUwDQYJKoZIhvcNAQEL
+BQAwIzEhMB8GA1UEAwwYY29sbGVjdGlvbi1zaWduZXItaW50LUNBMCIYDzIwMjQx
+MTI3MDAwMDAwWhgPMjAyNzAyMDUwMDAwMDBaMCYxJDAiBgNVBAMMG2NvbGxlY3Rp
+b24tc2lnbmVyLWVlLWludC1DQTB2MBAGByqGSM49AgEGBSuBBAAiA2IABKFockM2
+K1x7GInzeRVGFaHHP7SN7oY+AikV22COJS3ktxMtqM6Y6DFTTmqcDAsJyNY5regy
+BuW6gTRzoR+jMOBdqMluQ4P+J4c9qXEDviiIz/AC8Fr3Gh/dzIN0qm6pzqNIMEYw
+EwYDVR0lBAwwCgYIKwYBBQUHAwMwLwYDVR0RBCgwJoIkb25lY3JsLmNvbnRlbnQt
+c2lnbmF0dXJlLm1vemlsbGEub3JnMA0GCSqGSIb3DQEBCwUAA4IBAQBVHMPKgXKX
+EVVTDRw8lF0MQBHUPA2+4f9JDsaq5AexGpFqfDzFobrzZnzKQyaODeoalhASraWs
+GvhXrXFeSkSLqNpw657JXuIvVOULJjr2h9uA9N837KgFosvLLIIoKs1zeXG0LSYy
+NSJBSme+n8ETV2d8RJ/w575rhnheDz6GcVH0hduvQR0g7dg8ZMtdfi16sjKaJRup
+coH4N8t4YhLqM4PyrEATZyTEW5jOCKCb91FWgPu0ovfQz+t3jjS7TPpUa3IYJS8V
+eFUHXUAXFFgD0xCl7P/V+kopWSijZHT8mwnPfn2z9EmV5ijioIsw2MF+FACkPWa1
+o2NzujCdDAEl
+-----END CERTIFICATE-----
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem.certspec b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem.certspec
new file mode 100644
index 000000000..866c357c5
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_ee.pem.certspec
@@ -0,0 +1,5 @@
+issuer:collection-signer-int-CA
+subject:collection-signer-ee-int-CA
+subjectKey:secp384r1
+extension:extKeyUsage:codeSigning
+extension:subjectAlternativeName:onecrl.content-signature.mozilla.org
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem
new file mode 100644
index 000000000..de3c2ff3c
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDAzCCAeugAwIBAgIUf3MHKqXo3U9dG7tkPLy8t7D+1o4wDQYJKoZIhvcNAQEL
+BQAwKTEnMCUGA1UEAwweeHBjc2hlbGwgc2lnbmVkIGFwcHMgdGVzdCByb290MCIY
+DzIwMjQxMTI3MDAwMDAwWhgPMjAyNzAyMDUwMDAwMDBaMCMxITAfBgNVBAMMGGNv
+bGxlY3Rpb24tc2lnbmVyLWludC1DQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
+AQoCggEBALqIUahEjhbWQf1utogGNhA9PBPZ6uQ1SrTs9WhXbCR7wcclqODYH72x
+nAabbhqG8mvir1p1a2pkcQh6pVqnRYf3HNUknAJ+zUP8HmnQOCApk6sgw0nk27lM
+wmtsDu0Vgg/xfq1pGrHTAjqLKkHup3DgDw2N/WYLK7AkkqR9uYhheZCxV5A90jvF
+4LhIH6g304hD7ycW2FW3ZlqqfgKQLzp7EIAGJMwcbJetlmFbt+KWEsB1MaMMkd20
+yvf8rR0l0wnvuRcOp2jhs3svIm9p47SKlWEd7ibWJZ2rkQhONsscJAQsvxaLL+Xx
+j5kXMbiz/kkj+nJRxDHVA6zaGAo17Y0CAwEAAaMlMCMwDAYDVR0TBAUwAwEB/zAT
+BgNVHSUEDDAKBggrBgEFBQcDAzANBgkqhkiG9w0BAQsFAAOCAQEAjJAZX8SZOh1H
+xLqKHgt2EiFloIW3k3aAnTFQPAEUp+IBXjJdA8cFzEDSHo0dTr8jBhR8V1gwy8+Z
+1i6loA0rgJUdDhUP24SqbfsdF6kcltlBfjR4lBfbZq0BClMiNDL2ZOQS4neF15fN
+WXUv2UE9ooKNUjgIzXHbU/ykbwTKB7Bmsh+r5CYs9LMNF5P/QDAlDNwvZglxiyyq
+61fi06lnBXff0zObSdV/8Wm0PQyHEBfNY3L94wuIFxGsX0YngO7CCtaIFIeymzob
+8SvH4W0vfeqYzDFM4PfgFbDs4KnAzJS+WwWq2HRDsHMZTDZVVXVA61LXYhFEOam1
+ASCDwhnClA==
+-----END CERTIFICATE-----
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem.certspec b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem.certspec
new file mode 100644
index 000000000..2b3eb2d78
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_signatures/collection_signing_int.pem.certspec
@@ -0,0 +1,4 @@
+issuer:xpcshell signed apps test root
+subject:collection-signer-int-CA
+extension:basicConstraints:cA,
+extension:extKeyUsage:codeSigning
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle.js b/src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle.js
new file mode 100644
index 000000000..ba93e2d33
--- /dev/null
+++ b/src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle.js
@@ -0,0 +1,152 @@
+const { Database } = ChromeUtils.importESModule(
+ "resource://services-settings/Database.sys.mjs"
+);
+const { RemoteSettings } = ChromeUtils.importESModule(
+ "resource://services-settings/remote-settings.sys.mjs"
+);
+
+let server;
+let startupClients;
+
+add_setup(async () => {
+ // Disable signature verification of collections listed in test startup.json.mzlz4
+ // since their metadata will eventually expire.
+ startupClients = [
+ "message-groups",
+ "nimbus-desktop-experiments",
+ "search-categorization",
+ "tracking-protection-lists",
+ "query-stripping",
+ "cfr",
+ ].map(id => {
+ const c = RemoteSettings(id);
+ c.verifySignature = false;
+ return c;
+ });
+
+ // Setup an HTTP server to serve the 'startup.json.mzlz4' bundle.
+ server = new HttpServer();
+ server.start(-1);
+ server.registerDirectory(
+ "/cdn/bundles/",
+ do_get_file("test_remote_settings_startup_bundle")
+ );
+ server.registerPathHandler("/v1/", (request, response) => {
+ response.write(
+ JSON.stringify({
+ capabilities: {
+ attachments: {
+ base_url: `http://localhost:${server.identity.primaryPort}/cdn/`,
+ },
+ },
+ })
+ );
+ response.setHeader("Content-Type", "application/json; charset=UTF-8");
+ response.setStatusLine(null, 200, "OK");
+ });
+ Services.prefs.setStringPref(
+ "services.settings.server",
+ `http://localhost:${server.identity.primaryPort}/v1`
+ );
+ registerCleanupFunction(() => {
+ server.stop(() => {});
+ Services.prefs.clearUserPref("services.settings.loglevel");
+ });
+});
+
+async function clear_state() {
+ await Database.destroy();
+ RemoteSettings._ongoingExtractBundlePromise = null;
+}
+
+add_task(async function test_bundle_is_pulled_when_get_needs_sync() {
+ const client = startupClients[0];
+
+ Assert.ok(
+ !(await Utils.hasLocalDump(client.bucketName, client.collectionName)),
+ "Client has no packaged dump"
+ );
+
+ const records = await client.get();
+
+ Assert.equal(records.length, 6, "Records were read from startup bundle");
+});
+add_task(clear_state);
+
+add_task(
+ async function test_signature_of_extracted_data_from_bundle_is_verified() {
+ const c = RemoteSettings("tracking-protection-lists"); // part of startup.json.mzlz4
+ c.verifySignature = true;
+
+ let called = null;
+ c.validateCollectionSignature = (records, timestamp, metadata) => {
+ called = { records, timestamp, metadata };
+ };
+
+ await c.get();
+
+ Assert.ok(!!called.records.length);
+ Assert.greaterOrEqual(called.timestamp, 1694684362860);
+ Assert.ok(called.metadata.flags.includes("startup"));
+ }
+);
+add_task(clear_state);
+
+add_task(async function test_bundle_is_not_importent_when_signature_fails() {
+ const c = RemoteSettings("tracking-protection-lists"); // part of startup.json.mzlz4
+ c.verifySignature = true;
+
+ let called = false;
+ c.validateCollectionSignature = () => {
+ called = true;
+ throw new Error("boom!");
+ };
+
+ let error;
+ try {
+ await c.get({ emptyListFallback: false });
+ Assert.ok(false, ".get() should fail without network");
+ } catch (e) {
+ error = e;
+ }
+ Assert.ok(called, "Signature was verified");
+ Assert.equal(
+ error.name,
+ "UnknownCollectionError",
+ ".get() fails without network and with bad startup bundle"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_sync_occurs_if_collection_not_part_of_bundle() {
+ const c = RemoteSettings("foo");
+
+ let error;
+ try {
+ await c.get({ emptyListFallback: false });
+ Assert.ok(false, ".get() should fail when bundle disabled");
+ } catch (e) {
+ error = e;
+ }
+ Assert.equal(
+ error.name,
+ "UnknownCollectionError",
+ ".get() fails to sync data"
+ );
+});
+add_task(clear_state);
+
+add_task(async function test_several_clients_wait_for_bundle() {
+ // several clients calling .get() in parallel will all take content from bundle.
+ const results = await Promise.allSettled(
+ startupClients.map(c => c.get({ emptyListFallback: false }))
+ );
+
+ Assert.deepEqual(
+ [6, 70, 5, "UnknownCollectionError", 3, 11],
+ results.map(({ status, value, reason }) =>
+ status == "fulfilled" ? value.length : reason.name
+ )
+ );
+});
+add_task(clear_state);
diff --git a/src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle/startup.json.mozlz4 b/src/zen/tests/mochitests/remote-settings/test_remote_settings_startup_bundle/startup.json.mozlz4
new file mode 100644
index 0000000000000000000000000000000000000000..978459dde9fc766e780a7fd56ea9e48f6eddaa86
GIT binary patch
literal 167191
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