attachHandlers_spec.js

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { expect } from "chai";
import { attachHandlers } from "../src/attachHandlers";
import * as packager from "../src/packageLogs";

describe("attachHandlers", () => {
  it("attaches all the event handlers without duplicates", (done) => {
    let duplicateEvents = 0;
    const initialDocument = global.document;
    const initialWindow = global.window;
    // List of supported document events
    const missingDocumentEvents = [
      "click",
      "dblclick",
      "mousedown",
      "mouseup",
      "focus",
      "blur",
      "input",
      "change",
      "dragstart",
      "dragend",
      "drag",
      "drop",
      "keydown",
      "mouseover",
      "submit",
    ];

    // List of supported window events
    const missingWindowEvents = [
      "wheel",
      "scroll",
      "resize",
      "load",
      "blur",
      "focus",
    ];

    // List of supported interval events
    const missingIntervalEvents = [
      "click",
      "focus",
      "blur",
      "input",
      "change",
      "mouseover",
      "submit",
    ];

    // Acts as a kind of Proxy for addEventListener. Keeps track of added listeners.
    const listenerHook = (eventList) => (ev) => {
      const evIndex = eventList.indexOf(ev);
      if (evIndex !== -1) {
        eventList.splice(evIndex, 1);
      } else {
        duplicateEvents++;
      }
    };

    const missingDocumentAndIntervalEvents = missingDocumentEvents.concat(
      missingIntervalEvents,
    );

    // MOCK
    global.document = {
      addEventListener: listenerHook(missingDocumentAndIntervalEvents),
    };
    global.window = { addEventListener: listenerHook(missingWindowEvents) };
    attachHandlers({ logDetails: true });
    expect(duplicateEvents).to.equal(0);
    expect(missingDocumentAndIntervalEvents.length).to.equal(0);
    expect(missingWindowEvents.length).to.equal(0);

    // UNMOCK
    global.document = initialDocument;
    global.window = initialWindow;
    done();
  });
  it("debounces bufferedEvents", (done) => {
    let callCount = 0;
    let testingEvent = false;
    const bufferedEvents = ["wheel", "scroll", "resize"];
    const initialWindow = global.window;
    const initialDocument = global.document;
    const rate = 500;
    const initialPackage = packager.packageLog;
    packager.packageLog = () => {
      callCount++;
    };
    global.document = { addEventListener: () => {} };
    // Tries to call an event 3 times. Twice in quick succession, then once after the set delay.
    // Number of actual calls to packageLog are recorded in callCount. Should amount to exactly 2 calls.
    global.window = {
      addEventListener: (ev, fn, ...args) => {
        if (!testingEvent && bufferedEvents.indexOf(ev) !== -1) {
          testingEvent = true;
          fn();
          fn();
          setTimeout(() => {
            fn();
            global.window = initialWindow;
            global.document = initialDocument;
            packager.packageLog = initialPackage;
            expect(callCount).to.equal(2);
            done();
          }, rate + 1);
        }
      },
    };
    attachHandlers({ resolution: rate });
  });

  describe("defineDetails", () => {
    // TODO: clarify what constitutes "high detail events" and what is "correct"
    it("configures high detail events correctly");
  });
});