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 --- .../components/newtab/test/unit/lib/Store.test.js | 305 +++++++++++++++++++++ 1 file changed, 305 insertions(+) create mode 100644 browser/components/newtab/test/unit/lib/Store.test.js (limited to 'browser/components/newtab/test/unit/lib/Store.test.js') diff --git a/browser/components/newtab/test/unit/lib/Store.test.js b/browser/components/newtab/test/unit/lib/Store.test.js new file mode 100644 index 0000000000..eeeef3bf51 --- /dev/null +++ b/browser/components/newtab/test/unit/lib/Store.test.js @@ -0,0 +1,305 @@ +import { addNumberReducer, FakePrefs } from "test/unit/utils"; +import { createStore } from "redux"; +import injector from "inject!lib/Store.jsm"; + +describe("Store", () => { + let Store; + let sandbox; + let store; + let dbStub; + beforeEach(() => { + sandbox = sinon.createSandbox(); + function ActivityStreamMessageChannel(options) { + this.dispatch = options.dispatch; + this.createChannel = sandbox.spy(); + this.destroyChannel = sandbox.spy(); + this.middleware = sandbox.spy(s => next => action => next(action)); + this.simulateMessagesForExistingTabs = sandbox.stub(); + } + dbStub = sandbox.stub().resolves(); + function FakeActivityStreamStorage() { + this.db = {}; + sinon.stub(this, "db").get(dbStub); + } + ({ Store } = injector({ + "lib/ActivityStreamMessageChannel.jsm": { ActivityStreamMessageChannel }, + "lib/ActivityStreamPrefs.jsm": { Prefs: FakePrefs }, + "lib/ActivityStreamStorage.jsm": { + ActivityStreamStorage: FakeActivityStreamStorage, + }, + })); + store = new Store(); + sandbox.stub(store, "_initIndexedDB").resolves(); + }); + afterEach(() => { + sandbox.restore(); + }); + it("should have a .feeds property that is a Map", () => { + assert.instanceOf(store.feeds, Map); + assert.equal(store.feeds.size, 0, ".feeds.size"); + }); + it("should have a redux store at ._store", () => { + assert.ok(store._store); + assert.property(store, "dispatch"); + assert.property(store, "getState"); + }); + it("should create a ActivityStreamMessageChannel with the right dispatcher", () => { + assert.ok(store.getMessageChannel()); + assert.equal(store.getMessageChannel().dispatch, store.dispatch); + assert.equal(store.getMessageChannel(), store._messageChannel); + }); + it("should connect the ActivityStreamMessageChannel's middleware", () => { + store.dispatch({ type: "FOO" }); + assert.calledOnce(store._messageChannel.middleware); + }); + describe("#initFeed", () => { + it("should add an instance of the feed to .feeds", () => { + class Foo {} + store._prefs.set("foo", true); + store.init(new Map([["foo", () => new Foo()]])); + store.initFeed("foo"); + + assert.isTrue(store.feeds.has("foo"), "foo is set"); + assert.instanceOf(store.feeds.get("foo"), Foo); + }); + it("should call the feed's onAction with uninit action if it exists", () => { + let feed; + function createFeed() { + feed = { onAction: sinon.spy() }; + return feed; + } + const action = { type: "FOO" }; + store._feedFactories = new Map([["foo", createFeed]]); + + store.initFeed("foo", action); + + assert.calledOnce(feed.onAction); + assert.calledWith(feed.onAction, action); + }); + it("should add a .store property to the feed", () => { + class Foo {} + store._feedFactories = new Map([["foo", () => new Foo()]]); + store.initFeed("foo"); + + assert.propertyVal(store.feeds.get("foo"), "store", store); + }); + }); + describe("#uninitFeed", () => { + it("should not throw if no feed with that name exists", () => { + assert.doesNotThrow(() => { + store.uninitFeed("bar"); + }); + }); + it("should call the feed's onAction with uninit action if it exists", () => { + let feed; + function createFeed() { + feed = { onAction: sinon.spy() }; + return feed; + } + const action = { type: "BAR" }; + store._feedFactories = new Map([["foo", createFeed]]); + store.initFeed("foo"); + + store.uninitFeed("foo", action); + + assert.calledOnce(feed.onAction); + assert.calledWith(feed.onAction, action); + }); + it("should remove the feed from .feeds", () => { + class Foo {} + store._feedFactories = new Map([["foo", () => new Foo()]]); + + store.initFeed("foo"); + store.uninitFeed("foo"); + + assert.isFalse(store.feeds.has("foo"), "foo is not in .feeds"); + }); + }); + describe("onPrefChanged", () => { + beforeEach(() => { + sinon.stub(store, "initFeed"); + sinon.stub(store, "uninitFeed"); + store._prefs.set("foo", false); + store.init(new Map([["foo", () => ({})]])); + }); + it("should initialize the feed if called with true", () => { + store.onPrefChanged("foo", true); + + assert.calledWith(store.initFeed, "foo"); + assert.notCalled(store.uninitFeed); + }); + it("should uninitialize the feed if called with false", () => { + store.onPrefChanged("foo", false); + + assert.calledWith(store.uninitFeed, "foo"); + assert.notCalled(store.initFeed); + }); + it("should do nothing if not an expected feed", () => { + store.onPrefChanged("bar", false); + + assert.notCalled(store.initFeed); + assert.notCalled(store.uninitFeed); + }); + }); + describe("#init", () => { + it("should call .initFeed with each key", async () => { + sinon.stub(store, "initFeed"); + store._prefs.set("foo", true); + store._prefs.set("bar", true); + await store.init( + new Map([ + ["foo", () => {}], + ["bar", () => {}], + ]) + ); + assert.calledWith(store.initFeed, "foo"); + assert.calledWith(store.initFeed, "bar"); + }); + it("should call _initIndexedDB", async () => { + await store.init(new Map()); + + assert.calledOnce(store._initIndexedDB); + assert.calledWithExactly(store._initIndexedDB, "feeds.telemetry"); + }); + it("should access the db property of indexedDB", async () => { + store._initIndexedDB.restore(); + await store.init(new Map()); + + assert.calledOnce(dbStub); + }); + it("should reset ActivityStreamStorage telemetry if opening the db fails", async () => { + store._initIndexedDB.restore(); + // Force an IndexedDB error + dbStub.rejects(); + + await store.init(new Map()); + + assert.calledOnce(dbStub); + assert.isNull(store.dbStorage.telemetry); + }); + it("should not initialize the feed if the Pref is set to false", async () => { + sinon.stub(store, "initFeed"); + store._prefs.set("foo", false); + await store.init(new Map([["foo", () => {}]])); + assert.notCalled(store.initFeed); + }); + it("should observe the pref branch", async () => { + sinon.stub(store._prefs, "observeBranch"); + await store.init(new Map()); + assert.calledOnce(store._prefs.observeBranch); + assert.calledWith(store._prefs.observeBranch, store); + }); + it("should initialize the ActivityStreamMessageChannel channel", async () => { + await store.init(new Map()); + }); + it("should emit an initial event if provided", async () => { + sinon.stub(store, "dispatch"); + const action = { type: "FOO" }; + + await store.init(new Map(), action); + + assert.calledOnce(store.dispatch); + assert.calledWith(store.dispatch, action); + }); + it("should initialize the telemtry feed first", () => { + store._prefs.set("feeds.foo", true); + store._prefs.set("feeds.telemetry", true); + const telemetrySpy = sandbox.stub().returns({}); + const fooSpy = sandbox.stub().returns({}); + // Intentionally put the telemetry feed as the second item. + const feedFactories = new Map([ + ["feeds.foo", fooSpy], + ["feeds.telemetry", telemetrySpy], + ]); + store.init(feedFactories); + assert.ok(telemetrySpy.calledBefore(fooSpy)); + }); + it("should dispatch init/load events", async () => { + await store.init(new Map(), { type: "FOO" }); + + assert.calledOnce( + store.getMessageChannel().simulateMessagesForExistingTabs + ); + }); + it("should dispatch INIT before LOAD", async () => { + const init = { type: "INIT" }; + const load = { type: "TAB_LOAD" }; + sandbox.stub(store, "dispatch"); + store + .getMessageChannel() + .simulateMessagesForExistingTabs.callsFake(() => store.dispatch(load)); + await store.init(new Map(), init); + + assert.calledTwice(store.dispatch); + assert.equal(store.dispatch.firstCall.args[0], init); + assert.equal(store.dispatch.secondCall.args[0], load); + }); + }); + describe("#uninit", () => { + it("should emit an uninit event if provided on init", () => { + sinon.stub(store, "dispatch"); + const action = { type: "BAR" }; + store.init(new Map(), null, action); + + store.uninit(); + + assert.calledOnce(store.dispatch); + assert.calledWith(store.dispatch, action); + }); + it("should clear .feeds and ._feedFactories", () => { + store._prefs.set("a", true); + store.init( + new Map([ + ["a", () => ({})], + ["b", () => ({})], + ["c", () => ({})], + ]) + ); + + store.uninit(); + + assert.equal(store.feeds.size, 0); + assert.isNull(store._feedFactories); + }); + }); + describe("#getState", () => { + it("should return the redux state", () => { + store._store = createStore((prevState = 123) => prevState); + const { getState } = store; + assert.equal(getState(), 123); + }); + }); + describe("#dispatch", () => { + it("should call .onAction of each feed", async () => { + const { dispatch } = store; + const sub = { onAction: sinon.spy() }; + const action = { type: "FOO" }; + + store._prefs.set("sub", true); + await store.init(new Map([["sub", () => sub]])); + + dispatch(action); + + assert.calledWith(sub.onAction, action); + }); + it("should call the reducers", () => { + const { dispatch } = store; + store._store = createStore(addNumberReducer); + + dispatch({ type: "ADD", data: 14 }); + + assert.equal(store.getState(), 14); + }); + }); + describe("#subscribe", () => { + it("should subscribe to changes to the store", () => { + const sub = sinon.spy(); + const action = { type: "FOO" }; + + store.subscribe(sub); + store.dispatch(action); + + assert.calledOnce(sub); + }); + }); +}); -- cgit v1.2.3