websecure-local-storage/src/lib/__tests__/secureStorage.test.js

secure localstorage data

import secureStorage from '../secureStorage';

const storageDataItems = [
  // encrypted keys are a base64 over a SHA1
  {
    key: "accessTokenExpiresInNaturaWeb",
    encrypted_key: "NmU3MjlhYTNiMmQ5MThlMDgxYzUwM2EyOGVmN2I3ZGVmNGE1OTQ1Yw==",
    value: new Date(),
    encrypted_value: "",
  },
  {
    key: "personIdNaturaWeb",
    encrypted_key: "Y2I0YmJhMGUzYmEwYjA0YjA0Y2E2ZjljMWU1OWNlYjNjZmFhODVmNw==",
    value: "10000593",
    encrypted_value: "",
  },
  {
    key: "teste_100",
    encrypted_key: "YjQzODM2N2JhMGRmMWQxNTY1NTkzODA1NzU4NWQzOGNhMGIzNzdlNA==",
    value: "string_.json#100",
    encrypted_value: "",
  },
  {
    key: "valid_key_with_objects",
    encrypted_key: "MTYyYjFhZWU2NjJjYTE4MTJmMzljMGVjMjdhZjAxYWE4NzMxNGMzNw==",
    value: "valid_key_with_objects_value",
    encrypted_value: "",
  },
  {
    key: "long_key_without_special_chars_with_value",
    encrypted_key: "OTcyYjk0ZmFhOTQ5Njg5NTU3ODQzZWY4MjA3YzY5NmM3MGQxMmFmZA==",
    value: "without_special_chars_with_value",
    encrypted_value: "",
  },
  {
    key: "long_key_with_many_special_chars@*-+.,=&%$#:",
    encrypted_key: "MjQ4MjhmZDdjMDc0NjAzYThkZTZiZTM2ZDY0ZDJkN2FmMmMxZTQ0ZA==",
    value: "",
    encrypted_value: "",
  },
];
const InvalidStorageDataItems = [
  {
    key: {},
    encrypted_key: {},
    value: {},
    encrypted_value: {},
  },
  {
    key: false,
    encrypted_key: false,
    value: false,
    encrypted_value: false,
  },
  {
    key: true,
    encrypted_key: true,
    value: true,
    encrypted_value: true,
  },
  {
    key: null,
    encrypted_key: null,
    value: null,
    encrypted_value: null,
  },
  {
    key: "",
    encrypted_key: "",
    value: " ",
    encrypted_value: "",
  },
  {
    key: undefined,
    encrypted_key: undefined,
    value: undefined,
    encrypted_value: undefined,
  },
];

describe("manage all itens to localStorage", () => {
  it("should clear the localStorage", () => {
    const dataItems = InvalidStorageDataItems.concat(storageDataItems);
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    // Act
    secureStorage().clear();
    const storage_size = secureStorage().length;
    dataItems.forEach((item) => {
      const seted_item = secureStorage().getItem(item.key);
      // Assert
      expect(seted_item).toBeNull();
    });
    expect(storage_size).toEqual(0);
  });
});

describe("manage invalid itens to localStorage", () => {
  const dataItems = InvalidStorageDataItems;

  it("should not set items to localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    // Act
    const countActiveItems = secureStorage().length;

    // Assert
    dataItems.forEach((item) => {
      const insertedItem = secureStorage().getItem(item.key);
      expect(insertedItem).toBeNull();
    });
    expect(countActiveItems).toEqual(0);
  });

  it("should not get items from localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    dataItems.forEach((item) => {
      // Act
      const obtained_by_secureStorage_fn = secureStorage().getItem(item.key);
      const obtained_by_localstorage_fn_using_encripted_key = localStorage.getItem(
        item.encrypted_key
      );

      const obtained_by_localstorage_Fn = localStorage.getItem(item.key);
      const obtained_by_secureStorage_fn_using_encripted_key = secureStorage().getItem(
        item.encrypted_key
      );

      // Assert
      expect(obtained_by_secureStorage_fn).toBeNull();
      expect(obtained_by_localstorage_fn_using_encripted_key).toBeNull();

      expect(obtained_by_localstorage_Fn).toBeNull();
      expect(obtained_by_secureStorage_fn_using_encripted_key).toBeNull();
    });
  });

  // nt = enésimo
  it("should get key-nt name from localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    for (let idx = 0; idx < dataItems.length; idx++) {
      // Act
      const keyname = secureStorage().key(idx);

      // Assert
      expect(keyname).toBeNull();
    }
  });
});

describe("manage valid itens to localStorage", () => {
  const dataItems = storageDataItems;

  it("should set items to localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    // Act
    const countActiveItems = secureStorage().length;
    const countItemsToSet = dataItems.length;

    // Assert
    dataItems.forEach((item) => {
      const insertedItem = secureStorage().getItem(item.key);

      expect(insertedItem).not.toBeNull();
    });
    expect(countActiveItems).toEqual(countItemsToSet);
  });

  it("should get items from localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    dataItems.forEach((item) => {
      // Act
      const obtained_by_secureStorage_fn = secureStorage().getItem(item.key);
      const obtained_by_localstorage_fn_using_encripted_key = localStorage.getItem(
        item.encrypted_key
      );

      const obtained_by_localstorage_Fn = localStorage.getItem(item.key);
      const obtained_by_secureStorage_fn_using_encripted_key = secureStorage().getItem(
        item.encrypted_key
      );

      // Assert
      expect(obtained_by_secureStorage_fn).toEqual(`${item.value}`);
      expect(obtained_by_localstorage_fn_using_encripted_key).not.toBeNull();

      expect(obtained_by_localstorage_Fn).toBeNull();
      expect(obtained_by_secureStorage_fn_using_encripted_key).toBeNull();
    });
  });

  it("should clear the localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    // Act
    secureStorage().clear();

    dataItems.forEach((item) => {
      const seted_item = secureStorage().getItem(item.key);
      const storage_size = secureStorage().length;

      // Assert
      expect(seted_item).toBeNull();
      expect(storage_size).toEqual(0);
    });
  });

  it("should remove from localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });
    let countItens = secureStorage().length;

    dataItems.forEach((item) => {
      // Act
      const existing_item = secureStorage().getItem(item.key);
      secureStorage().removeItem(item.key);
      countItens--;
      const storage_size = secureStorage().length;
      const removed_item = secureStorage().getItem(item.key);

      // Assert
      expect(storage_size).toEqual(countItens);
      expect(existing_item).not.toBeNull();
      expect(removed_item).toBeNull();
    });
  });

  // nt = enésimo
  it("should get key-nt name from localStorage", () => {
    // Arrange
    dataItems.forEach((item) => {
      secureStorage().setItem(item.key, item.value);
    });

    for (let idx = 0; idx < dataItems.length; idx++) {
      const element = dataItems[idx];

      // Act
      const keyname = secureStorage().key(idx);
      const g = localStorage.key(idx);

      // Assert
      expect(keyname).not.toBeNull();
      expect(keyname).toEqual(`${element.encrypted_key}`);
    }
  });
});