From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../xpcshell/test_AboutHomeStartupCacheWorker.js | 251 +++++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 browser/components/newtab/test/xpcshell/test_AboutHomeStartupCacheWorker.js (limited to 'browser/components/newtab/test/xpcshell/test_AboutHomeStartupCacheWorker.js') diff --git a/browser/components/newtab/test/xpcshell/test_AboutHomeStartupCacheWorker.js b/browser/components/newtab/test/xpcshell/test_AboutHomeStartupCacheWorker.js new file mode 100644 index 0000000000..0cbb81351b --- /dev/null +++ b/browser/components/newtab/test/xpcshell/test_AboutHomeStartupCacheWorker.js @@ -0,0 +1,251 @@ +/* Any copyright is dedicated to the Public Domain. +http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * This test ensures that the about:home startup cache worker + * script can correctly convert a state object from the Activity + * Stream Redux store into an HTML document and script. + */ + +const { AddonTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/AddonTestUtils.sys.mjs" +); +const { SearchTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SearchTestUtils.sys.mjs" +); +const { TestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TestUtils.sys.mjs" +); + +SearchTestUtils.init(this); +AddonTestUtils.init(this); +AddonTestUtils.createAppInfo( + "xpcshell@tests.mozilla.org", + "XPCShell", + "42", + "42" +); + +const { AboutNewTab } = ChromeUtils.import( + "resource:///modules/AboutNewTab.jsm" +); +const { PREFS_CONFIG } = ChromeUtils.import( + "resource://activity-stream/lib/ActivityStream.jsm" +); + +ChromeUtils.defineESModuleGetters(this, { + BasePromiseWorker: "resource://gre/modules/PromiseWorker.sys.mjs", +}); + +const CACHE_WORKER_URL = "resource://activity-stream/lib/cache-worker.js"; +const NEWTAB_RENDER_URL = + "resource://activity-stream/data/content/newtab-render.js"; + +/** + * In order to make this test less brittle, much of Activity Stream is + * initialized here in order to generate a state object at runtime, rather + * than hard-coding one in. This requires quite a bit of machinery in order + * to work properly. Specifically, we need to launch an HTTP server to serve + * a dynamic layout, and then have that layout point to a local feed rather + * than one from the Pocket CDN. + */ +add_setup(async function () { + do_get_profile(); + // The SearchService is also needed in order to construct the initial state, + // which means that the AddonManager needs to be available. + await AddonTestUtils.promiseStartupManager(); + + // The example.com domain will be used to host the dynamic layout JSON and + // the top stories JSON. + let server = AddonTestUtils.createHttpServer({ hosts: ["example.com"] }); + server.registerDirectory("/", do_get_cwd()); + + // Top Stories are disabled by default in our testing profiles. + Services.prefs.setBoolPref( + "browser.newtabpage.activity-stream.feeds.section.topstories", + true + ); + Services.prefs.setBoolPref( + "browser.newtabpage.activity-stream.feeds.system.topstories", + true + ); + + let defaultDSConfig = JSON.parse( + PREFS_CONFIG.get("discoverystream.config").getValue({ + geo: "US", + locale: "en-US", + }) + ); + + let newConfig = Object.assign(defaultDSConfig, { + show_spocs: false, + hardcoded_layout: false, + layout_endpoint: "http://example.com/ds_layout.json", + }); + + // Configure Activity Stream to query for the layout JSON file that points + // at the local top stories feed. + Services.prefs.setCharPref( + "browser.newtabpage.activity-stream.discoverystream.config", + JSON.stringify(newConfig) + ); + + // We need to allow example.com as a place to get both the layout and the + // top stories from. + Services.prefs.setCharPref( + "browser.newtabpage.activity-stream.discoverystream.endpoints", + `http://example.com` + ); + + Services.prefs.setBoolPref( + "browser.newtabpage.activity-stream.telemetry.structuredIngestion", + false + ); + Services.prefs.setBoolPref("browser.ping-centre.telemetry", false); + + // We need a default search engine set up for rendering the search input. + await SearchTestUtils.installSearchExtension( + { + name: "Test engine", + keyword: "@testengine", + search_url_get_params: "s={searchTerms}", + }, + { setAsDefault: true } + ); + + // Initialize Activity Stream, and pretend that a new window has been loaded + // to kick off initializing all of the feeds. + AboutNewTab.init(); + AboutNewTab.onBrowserReady(); + + // Much of Activity Stream initializes asynchronously. This is the easiest way + // I could find to ensure that enough of the feeds had initialized to produce + // a meaningful cached document. + await TestUtils.waitForCondition(() => { + let feed = AboutNewTab.activityStream.store.feeds.get( + "feeds.discoverystreamfeed" + ); + return feed?.loaded; + }); +}); + +/** + * Gets the Activity Stream Redux state from Activity Stream and sends it + * into an instance of the cache worker to ensure that the resulting markup + * and script makes sense. + */ +add_task(async function test_cache_worker() { + Services.prefs.setBoolPref( + "security.allow_parent_unrestricted_js_loads", + true + ); + registerCleanupFunction(() => { + Services.prefs.clearUserPref("security.allow_parent_unrestricted_js_loads"); + }); + + let state = AboutNewTab.activityStream.store.getState(); + + let cacheWorker = new BasePromiseWorker(CACHE_WORKER_URL); + let { page, script } = await cacheWorker.post("construct", [state]); + ok(!!page.length, "Got page content"); + ok(!!script.length, "Got script content"); + + // The template strings should have been replaced. + equal( + page.indexOf("{{ MARKUP }}"), + -1, + "Page template should have {{ MARKUP }} replaced" + ); + equal( + page.indexOf("{{ CACHE_TIME }}"), + -1, + "Page template should have {{ CACHE_TIME }} replaced" + ); + equal( + script.indexOf("{{ STATE }}"), + -1, + "Script template should have {{ STATE }} replaced" + ); + + // Now let's make sure that the generated script makes sense. We'll + // evaluate it in a sandbox to make sure broken JS doesn't break the + // test. + let sandbox = Cu.Sandbox(Cu.getGlobalForObject({})); + let passedState = null; + + // window.NewtabRenderUtils.renderCache is the exposed API from + // activity-stream.jsx that the script is expected to call to hydrate + // the pre-rendered markup. We'll implement that, and use that to ensure + // that the passed in state object matches the state we sent into the + // worker. + sandbox.window = { + NewtabRenderUtils: { + renderCache(aState) { + passedState = aState; + }, + }, + }; + Cu.evalInSandbox(script, sandbox); + + // The NEWTAB_RENDER_URL script is what ultimately causes the state + // to be passed into the renderCache function. + Services.scriptloader.loadSubScript(NEWTAB_RENDER_URL, sandbox); + + equal( + sandbox.window.__FROM_STARTUP_CACHE__, + true, + "Should have set __FROM_STARTUP_CACHE__ to true" + ); + + // The worker is expected to modify the state slightly before running + // it through ReactDOMServer by setting App.isForStartupCache to true. + // This allows React components to change their behaviour if the cache + // is being generated. + state.App.isForStartupCache = true; + + // Some of the properties on the state might have values set to undefined. + // There is no way to express a named undefined property on an object in + // JSON, so we filter those out by stringifying and re-parsing. + state = JSON.parse(JSON.stringify(state)); + + Assert.deepEqual( + passedState, + state, + "Should have called renderCache with the expected state" + ); + + // Now let's do a quick smoke-test on the markup to ensure that the + // one Top Story from topstories.json is there. + let parser = new DOMParser(); + let doc = parser.parseFromString(page, "text/html"); + let root = doc.getElementById("root"); + ok(root.childElementCount, "There are children on the root node"); + + // There should be the 1 top story, and 2 placeholders. + equal( + Array.from(root.querySelectorAll(".ds-card")).length, + 3, + "There are 3 DSCards" + ); + let cardHostname = doc.querySelector( + "[data-section-id='topstories'] .source" + ).innerText; + equal(cardHostname, "bbc.com", "Card hostname is bbc.com"); + + let placeholders = doc.querySelectorAll(".ds-card.placeholder"); + equal(placeholders.length, 2, "There should be 2 placeholders"); +}); + +/** + * Tests that if the cache-worker construct method throws an exception + * that the construct Promise still resolves. Passing a null state should + * be enough to get it to throw. + */ +add_task(async function test_cache_worker_exception() { + let cacheWorker = new BasePromiseWorker(CACHE_WORKER_URL); + let { page, script } = await cacheWorker.post("construct", [null]); + equal(page, null, "Should have gotten a null page nsIInputStream"); + equal(script, null, "Should have gotten a null script nsIInputStream"); +}); -- cgit v1.2.3