tor-browser

test_SearchBrowsingHistory.js (9338B)

---

/**
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

const { searchBrowsingHistory } = ChromeUtils.importESModule(
 "moz-src:///browser/components/aiwindow/models/SearchBrowsingHistory.sys.mjs"
);

const { sinon } = ChromeUtils.importESModule(
 "resource://testing-common/Sinon.sys.mjs"
);

let sb;

// setup
add_task(async function setup() {
 sb = sinon.createSandbox();
 registerCleanupFunction(() => {
   sb.restore();
   Services.prefs.clearUserPref("browser.ml.enable");
   Services.prefs.clearUserPref("places.semanticHistory.featureGate");
   Services.prefs.clearUserPref("browser.search.region");
 });

 Services.prefs.setBoolPref("browser.ml.enable", true);
 Services.prefs.setBoolPref("places.semanticHistory.featureGate", true);
 Services.prefs.setCharPref("browser.search.region", "US");

 await PlacesUtils.history.clear();
});

// test: empty searchTerm, no time window
add_task(async function test_basic_history_fetch_and_shape() {
 await PlacesUtils.history.clear();

 const now = Date.now();

 const seeded = [
   {
     url: "https://www.google.com/search?q=firefox+history",
     title: "Google Search: firefox history",
     visits: [{ date: new Date(now - 5 * 60 * 1000) }], // 5 min ago
   },
   {
     url: "https://developer.mozilla.org/en-US/docs/Web/JavaScript",
     title: "JavaScript | MDN",
     visits: [{ date: new Date(now - 10 * 60 * 1000) }], // 10 min ago
   },
   {
     url: "https://news.ycombinator.com/",
     title: "Hacker News",
     visits: [{ date: new Date(now - 15 * 60 * 1000) }],
   },
   {
     url: "https://search.brave.com/search?q=mozsqlite",
     title: "Brave Search: mozsqlite",
     visits: [{ date: new Date(now - 20 * 60 * 1000) }],
   },
   {
     url: "https://mozilla.org/en-US/",
     title: "Internet for people, not profit — Mozilla",
     visits: [{ date: new Date(now - 25 * 60 * 1000) }],
   },
 ];

 await PlacesUtils.history.insertMany(seeded);

 const allRowsStr = await searchBrowsingHistory({
   searchTerm: "",
   startTs: null,
   endTs: null,
   historyLimit: 15,
 });
 const allRowsObj = JSON.parse(allRowsStr);

 // check count match
 Assert.equal(
   allRowsObj.count,
   seeded.length,
   "Should return all seeded records"
 );

 // check all url match
 const urls = allRowsObj.results.map(r => r.url).sort();
 const expectedUrls = seeded.map(s => s.url).sort();
 Assert.deepEqual(urls, expectedUrls, "Should return all seeded URLs");

 // check title and url match
 const byUrl = new Map(allRowsObj.results.map(r => [r.url, r]));
 for (const { url, title } of seeded) {
   Assert.ok(byUrl.has(url), `Has entry for ${url}`);
   Assert.equal(byUrl.get(url).title, title, `Title matches for ${url}`);
 }

 // check visitDate iso string
 for (const r of allRowsObj.results) {
   Assert.ok(
     !isNaN(Date.parse(r.visitDate)),
     "visitDate is a valid ISO timestamp"
   );
 }
});

// test: startTs only
add_task(async function test_time_range_only_startTs() {
 await PlacesUtils.history.clear();

 const now = Date.now();

 const older = {
   url: "https://example.com/older",
   title: "Older Page",
   visits: [{ date: new Date(now - 60 * 60 * 1000) }], // 60 min ago
 };
 const recent = {
   url: "https://example.com/recent",
   title: "Recent Page",
   visits: [{ date: new Date(now - 5 * 60 * 1000) }], // 5 min ago
 };

 await PlacesUtils.history.insertMany([older, recent]);

 // records after last 10 minutes
 const startTs = new Date(now - 10 * 60 * 1000).toISOString(); // ISO input

 const rowsStr = await searchBrowsingHistory({
   searchTerm: "",
   startTs,
   endTs: null,
   historyLimit: 15,
 });
 const rows = JSON.parse(rowsStr);
 const urls = rows.results.map(r => r.url);

 Assert.ok(
   urls.includes(recent.url),
   "Recent entry should be included when only startTs is set"
 );
 Assert.ok(
   !urls.includes(older.url),
   "Older entry should be excluded when only startTs is set"
 );
});

// test: endTs only
add_task(async function test_time_range_only_endTs() {
 await PlacesUtils.history.clear();

 const now = Date.now();

 const older = {
   url: "https://example.com/older",
   title: "Older Page",
   visits: [{ date: new Date(now - 60 * 60 * 1000) }], // 60 min ago
 };
 const recent = {
   url: "https://example.com/recent",
   title: "Recent Page",
   visits: [{ date: new Date(now - 5 * 60 * 1000) }], // 5 min ago
 };

 await PlacesUtils.history.insertMany([older, recent]);

 // Anything before last 10 minutes
 const endTs = new Date(now - 10 * 60 * 1000).toISOString(); // ISO input

 const rowsStr = await searchBrowsingHistory({
   searchTerm: "",
   startTs: null,
   endTs,
   historyLimit: 15,
 });
 const rows = JSON.parse(rowsStr);
 const urls = rows.results.map(r => r.url);

 Assert.ok(
   urls.includes(older.url),
   "Older entry should be included when only endTs is set"
 );
 Assert.ok(
   !urls.includes(recent.url),
   "Recent entry should be excluded when only endTs is set"
 );
});

// test: startTs + endTs
add_task(async function test_time_range_start_and_endTs() {
 await PlacesUtils.history.clear();

 const now = Date.now();

 const beforeWindow = {
   url: "https://example.com/before-window",
   title: "Before Window",
   visits: [{ date: new Date(now - 3 * 60 * 60 * 1000) }], // 3h ago
 };
 const inWindow = {
   url: "https://example.com/in-window",
   title: "In Window",
   visits: [{ date: new Date(now - 30 * 60 * 1000) }], // 30 min ago
 };
 const afterWindow = {
   url: "https://example.com/after-window",
   title: "After Window",
   visits: [{ date: new Date(now - 5 * 60 * 1000) }], // 5 min ago
 };

 await PlacesUtils.history.insertMany([beforeWindow, inWindow, afterWindow]);

 // Time window: [45min ago,  15min ago]
 const startTs = new Date(now - 45 * 60 * 1000).toISOString();
 const endTs = new Date(now - 15 * 60 * 1000).toISOString();

 const rowsStr = await searchBrowsingHistory({
   searchTerm: "",
   startTs,
   endTs,
   historyLimit: 15,
 });
 const rows = JSON.parse(rowsStr);
 const urls = rows.results.map(r => r.url);

 Assert.ok(urls.includes(inWindow.url), "In window entry should be included");
 Assert.ok(
   !urls.includes(beforeWindow.url),
   "Before window entry should be excluded"
 );
 Assert.ok(
   !urls.includes(afterWindow.url),
   "After window entry should be excluded"
 );
});

/**
* Test no results behavior: empty history with and without searchTerm.
*
* We don't try to force the semantic here (that would require a
* running ML engine). Instead we just assert the wrapper's messaging
* when there are no rows.
*/
add_task(async function test_no_results_messages() {
 await PlacesUtils.history.clear();

 // No search term: time range message.
 let outputStr = await searchBrowsingHistory({
   searchTerm: "",
   startTs: null,
   endTs: null,
   historyLimit: 15,
 });
 let output = JSON.parse(outputStr);

 Assert.equal(output.results.length, 0, "No results when history is empty");
 Assert.ok(
   output.message.includes("requested time range"),
   "Message explains empty time-range search"
 );

 // With search term: search specific message.
 outputStr = await searchBrowsingHistory({
   searchTerm: "mozilla",
   startTs: null,
   endTs: null,
   historyLimit: 15,
 });
 output = JSON.parse(outputStr);

 Assert.equal(output.results.length, 0, "No results for semantic search");
 Assert.ok(
   output.message.includes("mozilla"),
   "Message mentions the search term when there are no matches"
 );
});

// test: non-empty searchTerm falls back to basic history search
// when semantic search is disabled via prefs.
add_task(async function test_basic_text_search_when_semantic_disabled() {
 await PlacesUtils.history.clear();

 const now = Date.now();

 const seeded = [
   {
     url: "https://www.mozilla.org/en-US/",
     title: "Internet for people, not profit — Mozilla",
     visits: [{ date: new Date(now - 5 * 60 * 1000) }], // 5 min ago
   },
   {
     url: "https://example.com/other",
     title: "Some Other Site",
     visits: [{ date: new Date(now - 10 * 60 * 1000) }], // 10 min ago
   },
 ];

 await PlacesUtils.history.insertMany(seeded);

 // Disable semantic search so searchBrowsingHistory must fall back
 // to the basic history search.
 Services.prefs.setBoolPref("browser.ml.enable", false);
 Services.prefs.setBoolPref("places.semanticHistory.featureGate", false);

 const outputStr = await searchBrowsingHistory({
   searchTerm: "mozilla",
   startTs: null,
   endTs: null,
   historyLimit: 15,
 });
 const output = JSON.parse(outputStr);

 Assert.equal(output.searchTerm, "mozilla", "searchTerm match");
 Assert.equal(output.results.length, 1, "One history entry is returned");

 const urls = output.results.map(r => r.url);
 Assert.ok(
   urls.includes("https://www.mozilla.org/en-US/"),
   "Basic history search should find the Mozilla entry"
 );

 // Restore prefs
 Services.prefs.setBoolPref("browser.ml.enable", true);
 Services.prefs.setBoolPref("places.semanticHistory.featureGate", true);
});