import { ContextKeysManager, REFERENCE_NAMESPACE, NOTHING } from "../..";
import { buildNamespaceKey } from "../../utils";
import { StorageType } from "../../consts";

describe("Context Keys Manager - getKeyByReference", () => {
  it("returns null if storage is not found", async () => {
    // setup
    const key = "key";
    const namespace = "namespace";

    const mockedLogger = {
      warn: jest.fn(),
    };

    const mockedSessionStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedLocalStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedSecureStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedReferenceStorage = {
      getItem: jest.fn().mockResolvedValueOnce(undefined),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const contextManager = new ContextKeysManager({
      logger: mockedLogger,
      sessionStorage: mockedSessionStorage,
      localStorage: mockedLocalStorage,
      secureStorage: mockedSecureStorage,
      referenceStorage: mockedReferenceStorage,
    });

    // run
    const result = await contextManager.getKeyByReference(key, namespace);

    // verify
    expect(result).toEqual(NOTHING);

    expect(mockedLogger.warn).not.toHaveBeenCalled();

    expect(mockedSessionStorage.getItem).not.toHaveBeenCalled();
    expect(mockedLocalStorage.getItem).not.toHaveBeenCalled();
    expect(mockedSecureStorage.getItem).not.toHaveBeenCalled();

    expect(mockedReferenceStorage.getItem).toHaveBeenCalledWith(
      buildNamespaceKey(key, namespace),
      REFERENCE_NAMESPACE
    );
  });

  it("returns null if storage is unknown", async () => {
    // setup
    const key = "key";
    const namespace = "namespace";

    const mockedLogger = {
      warn: jest.fn(),
    };

    const mockedSessionStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedLocalStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedSecureStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedReferenceStorage = {
      getItem: jest.fn().mockResolvedValueOnce("unknown"),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const contextManager = new ContextKeysManager({
      logger: mockedLogger,
      sessionStorage: mockedSessionStorage,
      localStorage: mockedLocalStorage,
      secureStorage: mockedSecureStorage,
      referenceStorage: mockedReferenceStorage,
    });

    // run
    const result = await contextManager.getKeyByReference(key, namespace);

    // verify
    expect(result).toEqual(NOTHING);

    expect(mockedLogger.warn).not.toHaveBeenCalled();

    expect(mockedSessionStorage.getItem).not.toHaveBeenCalled();
    expect(mockedLocalStorage.getItem).not.toHaveBeenCalled();
    expect(mockedSecureStorage.getItem).not.toHaveBeenCalled();

    expect(mockedReferenceStorage.getItem).toHaveBeenCalledWith(
      buildNamespaceKey(key, namespace),
      REFERENCE_NAMESPACE
    );
  });

  it("returns value from session storage", async () => {
    // setup
    const key = "key";
    const namespace = "namespace";
    const value = "value";

    const mockedLogger = {
      warn: jest.fn(),
    };

    const mockedSessionStorage = {
      getItem: jest.fn().mockResolvedValueOnce(value),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedLocalStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedSecureStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedReferenceStorage = {
      getItem: jest.fn().mockResolvedValueOnce(StorageType.session),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const contextManager = new ContextKeysManager({
      logger: mockedLogger,
      sessionStorage: mockedSessionStorage,
      localStorage: mockedLocalStorage,
      secureStorage: mockedSecureStorage,
      referenceStorage: mockedReferenceStorage,
    });

    // run
    const result = await contextManager.getKeyByReference(key, namespace);

    // verify
    expect(result).toEqual(value);

    expect(mockedLogger.warn).not.toHaveBeenCalled();

    expect(mockedSessionStorage.getItem).toHaveBeenCalledWith(key, namespace);
    expect(mockedLocalStorage.getItem).not.toHaveBeenCalled();
    expect(mockedSecureStorage.getItem).not.toHaveBeenCalled();

    expect(mockedReferenceStorage.getItem).toHaveBeenCalledWith(
      buildNamespaceKey(key, namespace),
      REFERENCE_NAMESPACE
    );
  });

  it("returns value from local storage", async () => {
    // setup
    const key = "key";
    const namespace = "namespace";
    const value = "value";

    const mockedLogger = {
      warn: jest.fn(),
    };

    const mockedSessionStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedLocalStorage = {
      getItem: jest.fn().mockResolvedValueOnce(value),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedSecureStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedReferenceStorage = {
      getItem: jest.fn().mockResolvedValueOnce(StorageType.local),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const contextManager = new ContextKeysManager({
      logger: mockedLogger,
      sessionStorage: mockedSessionStorage,
      localStorage: mockedLocalStorage,
      secureStorage: mockedSecureStorage,
      referenceStorage: mockedReferenceStorage,
    });

    // run
    const result = await contextManager.getKeyByReference(key, namespace);

    // verify
    expect(result).toEqual(value);

    expect(mockedLogger.warn).not.toHaveBeenCalled();

    expect(mockedSessionStorage.getItem).not.toHaveBeenCalled();
    expect(mockedLocalStorage.getItem).toHaveBeenCalledWith(key, namespace);
    expect(mockedSecureStorage.getItem).not.toHaveBeenCalled();

    expect(mockedReferenceStorage.getItem).toHaveBeenCalledWith(
      buildNamespaceKey(key, namespace),
      REFERENCE_NAMESPACE
    );
  });

  it("returns value from secure storage", async () => {
    // setup
    const key = "key";
    const namespace = "namespace";
    const value = "value";

    const mockedLogger = {
      warn: jest.fn(),
    };

    const mockedSessionStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedLocalStorage = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedSecureStorage = {
      getItem: jest.fn().mockResolvedValueOnce(value),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const mockedReferenceStorage = {
      getItem: jest.fn().mockResolvedValueOnce(StorageType.secure),
      setItem: jest.fn(),
      removeItem: jest.fn(),
    };

    const contextManager = new ContextKeysManager({
      logger: mockedLogger,
      sessionStorage: mockedSessionStorage,
      localStorage: mockedLocalStorage,
      secureStorage: mockedSecureStorage,
      referenceStorage: mockedReferenceStorage,
    });

    // run
    const result = await contextManager.getKeyByReference(key, namespace);

    // verify
    expect(result).toEqual(value);

    expect(mockedLogger.warn).not.toHaveBeenCalled();

    expect(mockedSessionStorage.getItem).not.toHaveBeenCalled();
    expect(mockedLocalStorage.getItem).not.toHaveBeenCalled();
    expect(mockedSecureStorage.getItem).toHaveBeenCalledWith(key, namespace);

    expect(mockedReferenceStorage.getItem).toHaveBeenCalledWith(
      buildNamespaceKey(key, namespace),
      REFERENCE_NAMESPACE
    );
  });
});