tor-browser

test_ListsFeed.js (5317B)

---

/* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

ChromeUtils.defineESModuleGetters(this, {
 actionTypes: "resource://newtab/common/Actions.mjs",
 ListsFeed: "resource://newtab/lib/Widgets/ListsFeed.sys.mjs",
 sinon: "resource://testing-common/Sinon.sys.mjs",
});

const PREF_LISTS_ENABLED = "widgets.lists.enabled";
const PREF_SYSTEM_LISTS_ENABLED = "widgets.system.lists.enabled";

add_task(async function test_construction() {
 let feed = new ListsFeed();

 feed.store = {
   getState() {
     return this.state;
   },
   dispatch: sinon.spy(),
   state: {
     Prefs: {
       values: {
         [PREF_SYSTEM_LISTS_ENABLED]: false,
       },
     },
   },
 };

 info("ListsFeed constructor should create initial values");

 Assert.ok(feed, "Could construct a ListsFeed");
 Assert.ok(!feed.loaded, "ListsFeed is not loaded");
 Assert.ok(!feed.enabled);
});

add_task(async function test_onAction_INIT() {
 let feed = new ListsFeed();

 feed.store = {
   getState() {
     return this.state;
   },
   dispatch: sinon.spy(),
   state: {
     Prefs: {
       values: {
         [PREF_LISTS_ENABLED]: true,
         [PREF_SYSTEM_LISTS_ENABLED]: true,
       },
     },
   },
 };

 info("ListsFeed.onAction INIT should set initialized");

 await feed.onAction({
   type: actionTypes.INIT,
 });

 Assert.ok(feed.initialized);
});

add_task(async function test_isEnabled() {
 let feed = new ListsFeed();

 feed.store = {
   getState() {
     return this.state;
   },
   dispatch: sinon.spy(),
   state: {
     Prefs: {
       values: {
         [PREF_LISTS_ENABLED]: true,
         [PREF_SYSTEM_LISTS_ENABLED]: true,
       },
     },
   },
 };

 info("ListsFeed should be enabled via system pref");
 Assert.ok(feed.enabled);
});

add_task(async function test_isEnabled() {
 let feed = new ListsFeed();

 feed.store = {
   getState() {
     return this.state;
   },
   dispatch: sinon.spy(),
   state: {
     Prefs: {
       values: {
         [PREF_LISTS_ENABLED]: true,
         trainhopConfig: {
           widgets: {
             enabled: true,
             listsEnabled: true,
             timerEnabled: true,
           },
         },
       },
     },
   },
 };

 info("ListsFeed should be enabled via trainhopConfig");
 Assert.ok(feed.enabled);
});

add_task(async function test_isEnabled() {
 let feed = new ListsFeed();

 feed.store = {
   getState() {
     return this.state;
   },
   dispatch: sinon.spy(),
   state: {
     Prefs: {
       values: {
         [PREF_LISTS_ENABLED]: true,
         widgetsConfig: {
           enabled: true,
           listsEnabled: true,
           timerEnabled: true,
         },
       },
     },
   },
 };

 info("ListsFeed should be enabled via widgetsConfig");
 Assert.ok(feed.enabled);
});

add_task(async function test_syncLists_moves_completed_tasks_and_dispatches() {
 const feed = new ListsFeed();

 // create mock data for Persistent Cache
 const cachedListData = {
   lists: {
     myList: {
       label: "My List",
       tasks: [
         { id: 1, title: "Active task", completed: false },
         { id: 2, title: "Completed task", completed: true },
       ],
     },
   },
 };

 const dispatchSpy = sinon.spy();

 feed.store = {
   getState() {
     return {
       Prefs: {
         values: {
           [PREF_LISTS_ENABLED]: true,
           [PREF_SYSTEM_LISTS_ENABLED]: true,
         },
       },
     };
   },
   dispatch: dispatchSpy,
 };

 const getStub = sinon.stub(feed.cache, "get").resolves(cachedListData);

 await feed.syncLists();

 // Check that the tasks have been properly split
 const [firstCall] = dispatchSpy.getCalls();
 const listsData = firstCall.args[0].data;

 Assert.equal(listsData.myList.tasks.length, 1, "1 active task");
 Assert.equal(listsData.myList.completed.length, 1, "1 completed task");

 Assert.equal(
   firstCall.args[0].type,
   actionTypes.WIDGETS_LISTS_SET,
   "dispatches lists"
 );

 getStub.restore();
});

add_task(async function test_syncLists_errors_when_over_max() {
 const PREF_WIDGETS_LISTS_MAX_LISTS = "widgets.lists.maxLists";

 const feed = new ListsFeed();
 const dispatchSpy = sinon.spy();

 // Store state: lists enabled, system lists enabled, max count = 1
 feed.store = {
   getState() {
     return {
       Prefs: {
         values: {
           [PREF_LISTS_ENABLED]: true,
           [PREF_SYSTEM_LISTS_ENABLED]: true,
           [PREF_WIDGETS_LISTS_MAX_LISTS]: 1,
         },
       },
     };
   },
   dispatch: dispatchSpy,
 };

 // Cached data with 2 lists -> exceeds max (1)
 const cachedListData = {
   lists: {
     listA: { label: "List A", tasks: [], completed: [] },
     listB: { label: "List B", tasks: [], completed: [] },
   },
 };

 const getStub = sinon.stub(feed.cache, "get").resolves(cachedListData);

 // Expect an error and NO dispatches
 await Assert.rejects(
   feed.syncLists(),
   /Over the maximum list count/,
   "syncLists should throw when over the maximum list count"
 );

 Assert.equal(
   dispatchSpy.callCount,
   0,
   "No dispatch should occur when over the maximum list count"
 );

 getStub.restore();
});