@wxcc-desktop/sdk 1.2.6 → 1.2.10

package/src/jsapi/agent-contact-jsapi.test.ts

@@ -1,217 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createAgentContactJsApi } from "./agent-contact-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      },
-      aqm: ({
-        contact: {
-          accept: jest.fn().mockImplementation(async p => p),
-          consultAccept: jest.fn().mockImplementation(async p => p),
-          buddyAgents: jest.fn().mockImplementation(async p => p),
-          end: jest.fn().mockImplementation(async p => p),
-          consultEnd: jest.fn().mockImplementation(async p => p),
-          cancelCtq: jest.fn().mockImplementation(async p => p),
-          wrapup: jest.fn().mockImplementation(async p => p),
-          vteamTransfer: jest.fn().mockImplementation(async p => p),
-          blindTransfer: jest.fn().mockImplementation(async p => p),
-          hold: jest.fn().mockImplementation(async p => p),
-          unHold: jest.fn().mockImplementation(async p => p),
-          consult: jest.fn().mockImplementation(async p => p),
-          consultConference: jest.fn().mockImplementation(async p => p),
-          decline: jest.fn().mockImplementation(async p => p),
-          consultTransfer: jest.fn().mockImplementation(async p => p),
-          vteamList: jest.fn().mockImplementation(async p => p),
-          pauseRecording: jest.fn().mockImplementation(async p => p),
-          resumeRecording: jest.fn().mockImplementation(async p => p),
-          //
-          eAgentContact: { listen: jest.fn(), listenOnce: jest.fn() }
-        }
-      } as unknown) as AgentxServices["aqm"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("Contact JSAPI", () => {
-  let contact: ReturnType<typeof createAgentContactJsApi>;
-
-  beforeEach(async () => {
-    await (SERVICE as AgentxServices).init("fake-token");
-
-    contact = createAgentContactJsApi();
-
-    contact.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(contact).toBeDefined();
-    expect(contact["logger"]).toBeDefined();
-    expect(contact["serviceChecker"]).toBeDefined();
-    expect(contact["aqmEvents"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(contact["checkService"]()).toBeTruthy();
-    expect(contact["aqmEvents"].isInited).toBeTruthy();
-  });
-
-  it("cleanups", () => {
-    contact.cleanup();
-
-    expect(contact["SERVICE"]).toBeUndefined();
-  });
-
-  it("checks service", () => {
-    contact["serviceChecker"].check = jest.fn();
-    contact["checkService"]();
-
-    expect(contact["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("calls data", async () => {
-    const r: any = { test: "TEST" };
-
-    {
-      const p = await contact.accept(r);
-      expect(SERVICE.aqm.contact.accept).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.consultAccept(r);
-      expect(SERVICE.aqm.contact.consultAccept).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.buddyAgents(r);
-      expect(SERVICE.aqm.contact.buddyAgents).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.end(r);
-      expect(SERVICE.aqm.contact.end).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.consultEnd(r);
-      expect(SERVICE.aqm.contact.consultEnd).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.cancelCtq(r);
-      expect(SERVICE.aqm.contact.cancelCtq).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.wrapup(r);
-      expect(SERVICE.aqm.contact.wrapup).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.vteamTransfer(r);
-      expect(SERVICE.aqm.contact.vteamTransfer).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.blindTransfer(r);
-      expect(SERVICE.aqm.contact.blindTransfer).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.hold(r);
-      expect(SERVICE.aqm.contact.hold).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.unHold(r);
-      expect(SERVICE.aqm.contact.unHold).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.consult(r);
-      expect(SERVICE.aqm.contact.consult).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.consultConference(r);
-      expect(SERVICE.aqm.contact.consultConference).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.decline(r);
-      expect(SERVICE.aqm.contact.decline).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.consultTransfer(r);
-      expect(SERVICE.aqm.contact.consultTransfer).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.vteamList(r);
-      expect(SERVICE.aqm.contact.vteamList).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.pauseRecording(r);
-      expect(SERVICE.aqm.contact.pauseRecording).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-
-    {
-      const p = await contact.resumeRecording(r);
-      expect(SERVICE.aqm.contact.resumeRecording).toHaveBeenCalledWith(r);
-      expect(p).toEqual(r);
-    }
-  });
-
-  it("listens", () => {
-    const listener = () => {};
-    contact.addEventListener("eAgentContact", listener);
-    expect(contact["aqmEvents"]["listeners"].size).toBe(1);
-    expect(SERVICE.aqm.contact.eAgentContact.listen).toHaveBeenCalledWith(listener);
-    contact.removeEventListener("eAgentContact", listener);
-    expect(contact["aqmEvents"]["listeners"].size).toBe(0);
-  });
-
-  it("listensOnce", () => {
-    const listener = () => {};
-    contact.addOnceEventListener("eAgentContact", listener);
-    expect(contact["aqmEvents"]["listenersOnce"].size).toBe(1);
-    expect(SERVICE.aqm.contact.eAgentContact.listenOnce).toHaveBeenCalledWith(listener);
-    contact.removeOnceEventListener("eAgentContact", listener);
-    expect(contact["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-
-  it("removesAllListeners", () => {
-    const listener1 = () => {};
-    const listener2 = () => {};
-    contact.addEventListener("eAgentContact", listener1);
-    contact.addOnceEventListener("eAgentContact", listener2);
-    expect(contact["aqmEvents"]["listeners"].size).toBe(1);
-    expect(contact["aqmEvents"]["listenersOnce"].size).toBe(1);
-    contact.removeAllEventListeners();
-    expect(contact["aqmEvents"]["listeners"].size).toBe(0);
-    expect(contact["aqmEvents"]["listenersOnce"].size).toBe(0);
-  });
-});

package/src/jsapi/agent-contact-jsapi.ts

@@ -1,275 +0,0 @@
-import { AgentxService, Service } from "@wxcc-desktop/sdk-types";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-import { createServiceChecker } from "./common/_service-checker";
-import { AqmServiceEntityEvents, createServiceEvents } from "./common/_service-events";
-
-type Listeners = {
-  eAgentContact: Parameters<AgentxService["aqm"]["contact"]["eAgentContact"]["listen"]>[0];
-  eAgentContactAssigned: Parameters<AgentxService["aqm"]["contact"]["eAgentContactAssigned"]["listen"]>[0];
-  eAgentContactEnded: Parameters<AgentxService["aqm"]["contact"]["eAgentContactEnded"]["listen"]>[0];
-  eAgentContactWrappedUp: Parameters<AgentxService["aqm"]["contact"]["eAgentContactWrappedUp"]["listen"]>[0];
-  eAgentOfferContact: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferContact"]["listen"]>[0];
-  eAgentOfferContactRona: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferContactRona"]["listen"]>[0];
-  eAgentOfferConsult: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferConsult"]["listen"]>[0];
-  eAgentWrapup: Parameters<AgentxService["aqm"]["contact"]["eAgentWrapup"]["listen"]>[0];
-  eAgentContactHeld: Parameters<AgentxService["aqm"]["contact"]["eAgentContactHeld"]["listen"]>[0];
-  eAgentContactUnHeld: Parameters<AgentxService["aqm"]["contact"]["eAgentContactUnHeld"]["listen"]>[0];
-  eCallRecordingStarted: Parameters<AgentxService["aqm"]["contact"]["eCallRecordingStarted"]["listen"]>[0];
-  eAgentConsultCreated: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultCreated"]["listen"]>[0];
-  eAgentConsultConferenced: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultConferenced"]["listen"]>[0];
-  eAgentConsultEnded: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultEnded"]["listen"]>[0];
-  eAgentCtqCancelled: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqCancelled"]["listen"]>[0];
-  eAgentConsulting: Parameters<AgentxService["aqm"]["contact"]["eAgentConsulting"]["listen"]>[0];
-  eAgentConsultFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultFailed"]["listen"]>[0];
-  eAgentConsultEndFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultEndFailed"]["listen"]>[0];
-  eAgentCtqFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqFailed"]["listen"]>[0];
-  eAgentCtqCancelFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqCancelFailed"]["listen"]>[0];
-  eAgentConsultConferenceEndFailed: Parameters<
-    AgentxService["aqm"]["contact"]["eAgentConsultConferenceEndFailed"]["listen"]
-  >[0];
-};
-
-type AqmContactEvents = AqmServiceEntityEvents<Listeners>;
-
-type Config = {
-  logger: ReturnType<typeof createJsApiLogger>;
-  serviceChecker: ReturnType<typeof createServiceChecker>;
-  aqmEvents: AqmContactEvents;
-};
-
-export class AgentContactJsApi {
-  private readonly logger: Config["logger"];
-  private readonly serviceChecker: Config["serviceChecker"];
-  private readonly aqmEvents: Config["aqmEvents"];
-
-  private SERVICE?: AgentxService;
-
-  private checkService() {
-    return this.serviceChecker.check(this.SERVICE);
-  }
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-    this.aqmEvents = config.aqmEvents;
-    this.serviceChecker = config.serviceChecker;
-  }
-
-  //
-  init(SERVICE?: AgentxService) {
-    if (SERVICE) {
-      this.SERVICE = SERVICE;
-    }
-
-    if (!this.checkService()) {
-      return;
-    }
-
-    this.aqmEvents.init({
-      aqmServiceEntity: this.SERVICE!.aqm.contact,
-      aqmServiceEntityString: "SERVICE.aqm.contact"
-    });
-
-    this.logger.info("Inited");
-  }
-
-  cleanup() {
-    this.aqmEvents.cleanup();
-
-    this.SERVICE = undefined;
-
-    this.logger.info("Cleaned");
-  }
-
-  // data calls
-  async accept(p: { interactionId: string }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.accept(p);
-  }
-
-  async consultAccept(p: { interactionId: string }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.consultAccept(p);
-  }
-
-  async buddyAgents(p: { data: Service.Aqm.Contact.BuddyAgents }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.buddyAgents(p);
-  }
-
-  async end(p: { interactionId: string }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.end(p);
-  }
-
-  async consultEnd(p: { interactionId: string; isConsult: boolean }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.consultEnd(p);
-  }
-
-  async cancelCtq(p: { interactionId: string; data: Service.Aqm.Contact.cancelCtq }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.cancelCtq(p);
-  }
-
-  async wrapup(p: { interactionId: string; data: Service.Aqm.Contact.WrapupPayLoad }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.wrapup(p);
-  }
-
-  async vteamTransfer(p: { interactionId: string; data: Service.Aqm.Contact.vteamTransferPayLoad }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.vteamTransfer(p);
-  }
-
-  async blindTransfer(p: { interactionId: string; data: Service.Aqm.Contact.blindTransferPayLoad }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.blindTransfer(p);
-  }
-
-  async hold(p: {
-    interactionId: string;
-    data: {
-      mediaResourceId: string;
-    };
-  }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.hold(p);
-  }
-
-  async unHold(p: {
-    interactionId: string;
-    data: {
-      mediaResourceId: string;
-    };
-  }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.unHold(p);
-  }
-
-  async consult(p: {
-    interactionId: string;
-    data:
-      | Service.Aqm.Contact.ConsultPayload
-      | Service.Aqm.Contact.ConsultDN
-      | Service.Aqm.Contact.ConsultAgent
-      | Service.Aqm.Contact.ConsultQueue;
-    url: string;
-  }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.consult(p);
-  }
-
-  async consultConference(p: { interactionId: string; data: Service.Aqm.Contact.ConsultPayload }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.consultConference(p);
-  }
-
-  async decline(p: {
-    interactionId: string;
-    data: {
-      mediaResourceId: string;
-    };
-    isConsult: boolean;
-  }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.decline(p);
-  }
-
-  async consultTransfer(p: { interactionId: string; data: Service.Aqm.Contact.consultTransferPayLoad }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.consultTransfer(p);
-  }
-
-  async vteamList(p: { data: Service.Aqm.Contact.VTeam }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.vteamList(p);
-  }
-
-  async pauseRecording(p: { interactionId: string }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.pauseRecording(p);
-  }
-
-  async resumeRecording(p: { interactionId: string; data: { autoResumed: boolean } }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.contact.resumeRecording(p);
-  }
-
-  // data events
-  addEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.aqmEvents.addEventListener(eventName, listener);
-  }
-
-  addOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.aqmEvents.addOnceEventListener(eventName, listener);
-  }
-
-  removeEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    this.aqmEvents.removeEventListener(eventName, listener);
-  }
-
-  removeOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]) {
-    this.aqmEvents.removeOnceEventListener(eventName, listener);
-  }
-
-  removeAllEventListeners() {
-    this.aqmEvents.removeAllEventListeners();
-  }
-}
-
-const agentContactJsApiLogger = createJsApiLogger(logger, "[AgentContact JSAPI] =>");
-const aqmServiceAgentContactJsApiLogger = createJsApiLogger(agentContactJsApiLogger, "[AqmServiceEvents: Contact] => ");
-
-// Standalone init
-export const createAgentContactJsApi = () =>
-  new AgentContactJsApi({
-    // LOGGER
-    logger: agentContactJsApiLogger,
-    // CHECK
-    serviceChecker: createServiceChecker({ logger: agentContactJsApiLogger }),
-    // EVENTS
-    aqmEvents: createServiceEvents<Listeners>({ logger: aqmServiceAgentContactJsApiLogger })
-  });

package/src/jsapi/agent-state-info-jsapi.test.ts

@@ -1,176 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { AgentStateInfoJsapi, createAgentStateInfoJsApi } from "./agent-state-info-jsapi";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      },
-      conf: ({
-        fetchProfile: jest.fn()
-      } as unknown) as AgentxServices["conf"],
-      aqm: ({
-        agent: {
-          updated: jest.fn(),
-          stateChange: jest.fn(),
-          mockOutdialAniList: jest.fn(),
-          fetchAddressBooks: jest.fn(),
-          //
-          eAgentReloginSuccess: {
-            listen: jest.fn(),
-            listenOnce: jest.fn()
-          },
-          eAgentStationLoginSuccess: {
-            listen: jest.fn(),
-            listenOnce: jest.fn()
-          },
-          eAgentStateChangeSuccess: {
-            listen: jest.fn(),
-            listenOnce: jest.fn()
-          },
-          eAgentDNRegistered: {
-            listen: jest.fn(),
-            listenOnce: jest.fn()
-          }
-        }
-      } as unknown) as AgentxServices["aqm"]
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("StateInfo JSAPI", () => {
-  let stateInfo: ReturnType<typeof createAgentStateInfoJsApi>;
-
-  beforeEach(async () => {
-    await (SERVICE as AgentxServices).init("fake-token");
-
-    stateInfo = createAgentStateInfoJsApi();
-
-    await stateInfo.init(SERVICE);
-  });
-
-  it("creates", () => {
-    expect(stateInfo).toBeDefined();
-    expect(stateInfo["logger"]).toBeDefined();
-    expect(stateInfo["serviceChecker"]).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(stateInfo["checkService"]()).toBeTruthy();
-    expect(stateInfo["listeners"].size).toBe(4);
-    expect(SERVICE.aqm.agent.eAgentReloginSuccess.listen).toHaveBeenCalled();
-    expect(SERVICE.aqm.agent.eAgentStationLoginSuccess.listen).toHaveBeenCalled();
-    expect(SERVICE.aqm.agent.eAgentStateChangeSuccess.listen).toHaveBeenCalled();
-    expect(SERVICE.aqm.agent.eAgentDNRegistered.listen).toHaveBeenCalled();
-    expect(SERVICE.conf.fetchProfile).toHaveBeenCalled();
-  });
-
-  it("cleanups", () => {
-    stateInfo["update"] = jest.fn();
-    stateInfo["unsubscribeSelfDataEvents"] = jest.fn();
-    stateInfo["removeAllEventListeners"] = jest.fn();
-
-    stateInfo.cleanup();
-
-    expect(stateInfo["SERVICE"]).toBeUndefined();
-
-    expect(stateInfo["update"]).toHaveBeenCalled();
-    expect(stateInfo["unsubscribeSelfDataEvents"]).toHaveBeenCalled();
-    expect(stateInfo["removeAllEventListeners"]).toHaveBeenCalled();
-  });
-
-  it("checks service", () => {
-    stateInfo["serviceChecker"].check = jest.fn();
-    stateInfo["checkService"]();
-
-    expect(stateInfo["serviceChecker"].check).toHaveBeenCalled();
-  });
-
-  it("calls data", () => {
-    stateInfo.stateChange({ test: "A" } as any);
-    expect(SERVICE.aqm.agent.stateChange).toHaveBeenCalledWith({ data: { test: "A" } });
-
-    stateInfo.mockOutdialAniList();
-    expect(SERVICE.aqm.agent.mockOutdialAniList).toHaveBeenCalled();
-
-    stateInfo.fetchAddressBooks();
-    expect(SERVICE.aqm.agent.fetchAddressBooks).toHaveBeenCalled();
-  });
-
-  it("listens", () => {
-    stateInfo["emitter"].on = jest.fn();
-    stateInfo["emitter"].off = jest.fn();
-
-    const listener = () => {};
-
-    stateInfo.addEventListener("updated", listener);
-    expect(stateInfo["emitter"].on).toHaveBeenCalledWith("updated", listener);
-
-    stateInfo.removeEventListener("updated", listener);
-    expect(stateInfo["emitter"].off).toHaveBeenCalledWith("updated", listener);
-  });
-
-  it("updates", () => {
-    stateInfo["emit"] = jest.fn();
-
-    stateInfo["update"]({ status: "test" });
-
-    expect(stateInfo["emit"]).toHaveBeenCalledWith("updated", [
-      {
-        name: "status",
-        oldValue: undefined,
-        value: "test"
-      }
-    ]);
-  });
-
-  it("emits", () => {
-    stateInfo["emitter"].emit = jest.fn();
-
-    stateInfo["emit"]("updated", { test: "A" } as any);
-
-    expect(stateInfo["emitter"].emit).toHaveBeenCalledWith("updated", { test: "A" });
-  });
-
-  it("finds outdial regexp", () => {
-    expect(
-      AgentStateInfoJsapi["getOutdialRegex"]({
-        type: "adhocDial",
-        dialPlanEntity: [{ regex: "test", prefix: "pfx", strippedChars: "st", name: "Any Format" }]
-      })
-    ).toBe("test");
-
-    expect(
-      AgentStateInfoJsapi["getOutdialRegex"]({
-        type: "adhocDial",
-        dialPlanEntity: [{ regex: "test", prefix: "pfx", strippedChars: "st", name: "" }]
-      })
-    ).toBe("");
-  });
-
-  it("fetches latest data", () => {
-    stateInfo["fetchLatestData"]();
-    expect(SERVICE.conf.fetchProfile).toHaveBeenCalled();
-  });
-
-  it("subscribes", () => {
-    //stateInfo["checkService"] = jest.fn().mockImplementation(() => true);
-
-    expect(stateInfo["listeners"].size).toBe(4);
-
-    stateInfo["subscribeSelfDataEvents"]();
-
-    expect(stateInfo["listeners"].size).toBe(8);
-  });
-
-  it("unsubscribes", () => {
-    expect(stateInfo["listeners"].size).toBe(4);
-
-    stateInfo["unsubscribeSelfDataEvents"]();
-
-    expect(stateInfo["listeners"].size).toBe(0);
-  });
-});