Use compute auth service and fix static code analyzer warnings (#15)

* Clean up formatting * Use new compute_auth service Implment SSO Implement token refresh Clean up unit tests * Fix unit tests * Fix auth test Fix warnings * Update default settings for compute_auth
2021-03-04 14:30:56 -08:00
parent e1f0006d5e
commit 39e779dc1d
34 changed files with 703 additions and 1462 deletions
--- a/src/components/Contexts/FileUploadContext.jsx
+++ b/src/components/Contexts/FileUploadContext.jsx
@@ -26,26 +26,36 @@ export const FileUploadProvider = ({ children }) => {

  const upload = async (files, accessToken) => {
    try {
-      if (!files || files.length === 0) throw new Error("File required");
-      if (!accessToken || accessToken.length === 0) throw new Error("Access token required")
+      if (!files || files.length === 0) {
+        throw new Error("File required");
+      }
+      if (!accessToken || accessToken.length === 0) {
+        throw new Error("Access token required");
+      }
      const file = files[0].file;
      const filename = file.name;
-  
+
      setUploading(true);
      setLinkURL(null);
      setProgress(0);
      setStatus(`Uploading ${filename}`);
      setCancelUpload(getCancelToken());
-      
-      const { data } = await uploadFile(file, accessToken, setProgress, cancelUpload);
-      if (data.message) throw new Error(`${data.error}. ${data.message}`);
-      const url = ((data && data.link) ? data.link : "No URL available");
+
+      const { data } = await uploadFile(
+        file,
+        accessToken,
+        setProgress,
+        cancelUpload
+      );
+      if (data.message) {
+        throw new Error(`${data.error}. ${data.message}`);
+      }
+      const url = data && data.link ? data.link : "No URL available";
      setLinkURL(url);
      setStatus(`Uploaded ${filename}`);
      setCancelUpload(null);
      setProgress(100);
-    }
-    catch (e) {
+    } catch (e) {
      setStatus(`Error occured: ${e.message}`);
      setProgress(-1);
    }
@@ -59,15 +69,17 @@ export const FileUploadProvider = ({ children }) => {
  };

  return (
-    <FileUploadContext.Provider value={{
-      uploading,
-      progress,
-      status,
-      linkURL,
-      upload,
-      cancel,
-      rejectedFile,
-    }}>
+    <FileUploadContext.Provider
+      value={{
+        uploading,
+        progress,
+        status,
+        linkURL,
+        upload,
+        cancel,
+        rejectedFile,
+      }}
+    >
      {children}
    </FileUploadContext.Provider>
  );
--- a/src/components/Contexts/FileUploadContext.test.jsx
+++ b/src/components/Contexts/FileUploadContext.test.jsx
@@ -1,15 +1,37 @@
 jest.mock("../../services/uploadFile");

-import { setUploadFileDelay } from "../../services/uploadFile"
-import { FileUploadProvider, useFileUploadContext }  from "../Contexts/FileUploadContext";
-import {render, cleanup, screen, fireEvent, waitFor} from "@testing-library/react"
+import { setUploadFileDelay } from "../../services/uploadFile";
+import {
+  FileUploadProvider,
+  useFileUploadContext,
+} from "../Contexts/FileUploadContext";
+import {
+  render,
+  cleanup,
+  screen,
+  fireEvent,
+  waitFor,
+} from "@testing-library/react";
+
+const checkState = (uploading, progress, status, linkURL) => {
+  expect(screen.getByTestId("uploading").innerHTML).toEqual(uploading);
+  expect(screen.getByTestId("progress").innerHTML).toEqual(progress);
+  expect(screen.getByTestId("status").innerHTML).toEqual(status);
+  expect(screen.getByTestId("linkURL").innerHTML).toEqual(linkURL);
+};

 describe("FileUploadContext", () => {
-
  beforeEach(() => {
    const TestComp = () => {
-      const { progress, uploading, status, linkURL, upload, cancel } = useFileUploadContext();
-      const TEST_FILE = [{ file: { name: "test.jpg", size: 0 }}];
+      const {
+        progress,
+        uploading,
+        status,
+        linkURL,
+        upload,
+        cancel,
+      } = useFileUploadContext();
+      const TEST_FILE = [{ file: { name: "test.jpg", size: 0 } }];
      const TEST_ACCESSTOKEN = "ACCESSTOKEN";
      return (
        <>
@@ -17,14 +39,24 @@ describe("FileUploadContext", () => {
          <div data-testid="progress">{progress.toString()}</div>
          <div data-testid="status">{status}</div>
          <div data-testid="linkURL">{linkURL}</div>
-          <button data-testid="uploadNoFile" onClick={() => upload()}/>
-          <button data-testid="uploadNoToken" onClick={() => upload(TEST_FILE)}/>
-          <button data-testid="upload" onClick={() => upload(TEST_FILE, TEST_ACCESSTOKEN)}/>
-          <button data-testid="cancel" onClick={() => cancel()}/>
+          <button data-testid="uploadNoFile" onClick={() => upload()} />
+          <button
+            data-testid="uploadNoToken"
+            onClick={() => upload(TEST_FILE)}
+          />
+          <button
+            data-testid="upload"
+            onClick={() => upload(TEST_FILE, TEST_ACCESSTOKEN)}
+          />
+          <button data-testid="cancel" onClick={() => cancel()} />
        </>
      );
    };
-    render(<FileUploadProvider><TestComp /></FileUploadProvider>);  
+    render(
+      <FileUploadProvider>
+        <TestComp />
+      </FileUploadProvider>
+    );
  });

  afterEach(() => {
@@ -32,46 +64,39 @@ describe("FileUploadContext", () => {
  });

  it("Initial state", async () => {
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("false");
-    expect(screen.getByTestId("progress").innerHTML).toEqual("0");
-    expect(screen.getByTestId("status").innerHTML).toEqual("");
-    expect(screen.getByTestId("linkURL").innerHTML).toEqual("");
-  })
+    checkState("false", "0", "", "");
+  });

  it("Upload no file", async () => {
    fireEvent.click(screen.getByTestId("uploadNoFile"));
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("false");
-    expect(screen.getByTestId("progress").innerHTML).toEqual("-1");
-    expect(screen.getByTestId("status").innerHTML).toEqual("Error occured: File required");
-    expect(screen.getByTestId("linkURL").innerHTML).toEqual("");
-  })
+    checkState("false", "-1", "Error occured: File required", "");
+  });

  it("Upload no access token", async () => {
    fireEvent.click(screen.getByTestId("uploadNoToken"));
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("false");
-    expect(screen.getByTestId("progress").innerHTML).toEqual("-1");
-    expect(screen.getByTestId("status").innerHTML).toEqual("Error occured: Access token required");
-    expect(screen.getByTestId("linkURL").innerHTML).toEqual("");
-  })
+    checkState("false", "-1", "Error occured: Access token required", "");
+  });

  it("Upload file", async () => {
    fireEvent.click(screen.getByTestId("upload"));
-    await waitFor(() => expect(screen.getByTestId("progress").innerHTML).toEqual("100"));
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("true");
-    expect(screen.getByTestId("status").innerHTML).toEqual(`Uploaded test.jpg`);
-    expect(screen.getByTestId("linkURL").innerHTML).toEqual(`CLOUDFRONT_URL`);
-  })
+    await waitFor(() =>
+      expect(screen.getByTestId("progress").innerHTML).toEqual("100")
+    );
+    checkState("true", "100", "Uploaded test.jpg", "CLOUDFRONT_URL");
+  });

  it("Cancel upload", async () => {
    setUploadFileDelay(true);
    fireEvent.click(screen.getByTestId("upload"));
-    await waitFor(() => expect(screen.getByTestId("progress").innerHTML).toEqual("50"));
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("true");
-    expect(screen.getByTestId("status").innerHTML).toEqual("Uploading test.jpg");
+    await waitFor(() =>
+      expect(screen.getByTestId("progress").innerHTML).toEqual("50")
+    );
+    checkState("true", "50", "Uploading test.jpg", "");
+
    fireEvent.click(screen.getByTestId("cancel"));
-    await waitFor(() => expect(screen.getByTestId("progress").innerHTML).toEqual("0"));
-    expect(screen.getByTestId("uploading").innerHTML).toEqual("false");
-    expect(screen.getByTestId("status").innerHTML).toEqual("Upload cancelled");
-    expect(screen.getByTestId("linkURL").innerHTML).toEqual("");
-  })
-})
+    await waitFor(() =>
+      expect(screen.getByTestId("progress").innerHTML).toEqual("0")
+    );
+    checkState("false", "0", "Upload cancelled", "");
+  });
+});
--- a/src/components/Contexts/UserContext.jsx
+++ b/src/components/Contexts/UserContext.jsx
@@ -17,98 +17,86 @@ export const UserProvider = ({ children }) => {
    if (!t.idToken.payload || !t.idToken.payload.exp) return;
    setToken(t);
  }, []);
- 
+
  useEffect(() => {
    if (!token) return;
-    const { idToken: { jwtToken }} = token;
+    const {
+      idToken: { jwtToken },
+    } = token;
    verifyToken(jwtToken);
    return () => {
      if (timer) timer.terminate();
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [token])
+  }, [token]);

-  const verifyToken = async (accessToken) => {
-    const result = await auth.verify(accessToken);
+  const refreshTokens = async () => {
+    if (!token || !token.refreshToken || !token.refreshToken.token) return null;
+    const result = await refresh(token.refreshToken.token);
+    return result;
+  }

-    if (!result.authenticated || !token.idToken.payload || !token.idToken.payload.exp) {
-      signOut();
-      return;
-    }
+  const isError = (resp) => {
+    if (resp === null) return true;
+    if (resp && resp.error) return true;
+    return false;
+  }

-    const duration = (1000 * token.idToken.payload.exp) - (new Date()).getTime();
+  const startSessionTimer = () => {
+    const duration = 1000 * token.idToken.payload.exp - new Date().getTime();
    if (!timer) {
-       timer = getTimerWorker();
-       timer.onMessage((e) => {
+      timer = getTimerWorker();
+      timer.onMessage(async (e) => {
        if (e.data === "timeout") {
+          const t = await refreshTokens();
+          if (!isError(t)) return;
          signOut();
        }
-      })  
+      });
    }
    timer.start(duration);
  };

-  const signIn = async (username, password) => {
+  const verifyToken = async (idToken) => {
+    try {
+      const result = await auth.verify(idToken);
+
+      if (
+        !result.authenticated ||
+        !token.idToken.payload ||
+        !token.idToken.payload.exp
+      ) {
+        const t = await refreshTokens();
+        if (!isError(t)) return;
+        signOut();
+        return;
+      }
+  
+      startSessionTimer();  
+    }
+    catch (e) {
+      setError(e.message);
+    }
+  };
+
+  const signIn = async (code) => {
    let result = null;

    try {
-      if (!username) throw new Error('Email is required');
-      if (!password) throw new Error('Password is required');
-  
+      if (!code) return;
+
      setFetching(true);
      setError(null);
-  
-      result = await auth.signIn(username, password);

-      if (result.message) throw new Error(result.message);
+      result = await auth.signIn(code);
+      if (result.message) {
+        throw new Error(result.message);
+      }
+
      signedIn(result);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
-      setFetching(false);
-    }
-
-    return result;
-  };
-
-  const signUp = async (username, password, confirmPassword) => {
-    let result = null;
-
-    try {
-      if (!username) throw new Error('Email is required');
-      if (!password) throw new Error('Password is required');
-      if (password !== confirmPassword) throw new Error('Passwords do not match');
-
-      setFetching(true);
-      setError(null);
-
-      result = await auth.signUp(username, password);
-      if (result.message) throw new Error(result.message);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
-      setFetching(false);
-    }
-
-    return result;
-  };
-
-  const signUpAndIn =  async (username, password, confirmPassword) => {
-    let result = null;
-
-    try {
-      result = await signUp(username, password, confirmPassword);
-      if (result.message) throw new Error(result.message);
-      result = await signIn(username, password);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
+    } catch (err) {
+      setError(`Sign in error. ${err.message}`);
+    } finally {
      setFetching(false);
    }

@@ -117,27 +105,61 @@ export const UserProvider = ({ children }) => {

  const signOut = () => {
    setToken(null);
-    if (!localStorage) return;
-    localStorage.removeItem("token");
+    if (localStorage) {
+      localStorage.removeItem("token");
+    }
+    return getLogoutURL();
  };

-  const signedIn = (token) => {
-    setToken(token);
-    if (!localStorage || !token || !token.idToken) return;
-    localStorage.setItem("token", JSON.stringify(token));
-  }
+  const signedIn = (value) => {
+    setToken(value);
+    if (!localStorage || !value || !value.idToken) return;
+    localStorage.setItem("token", JSON.stringify(value));
+  };
+
+  const refresh = async (value) => {
+    let result = null;
+
+    try {
+      if (!value) {
+        throw new Error("Token required");
+      }
+      setFetching(true);
+      setError(null);
+
+      // eslint-disable-next-line
+      result = await auth.refresh(value);
+
+      if (result.message) {
+        throw new Error(result.message);
+      }
+      signedIn(result);
+    } catch (err) {
+      setError(`Refresh error. ${err.message}`);
+    } finally {
+      setFetching(false);
+    }
+
+    return result;
+  };
+
+  const getAuthorizeURL = () => auth.ssoAuthorize();
+  const getLogoutURL = () => auth.ssoLogout();

  return (
-    <UserContext.Provider value={{
-      fetching,
-      token,
-      error,
-      setError,
-      signIn,
-      signUp,
-      signUpAndIn,
-      signOut,
-    }}>
+    <UserContext.Provider
+      value={{
+        fetching,
+        token,
+        error,
+        setError,
+        signIn,
+        signOut,
+        refresh,
+        getAuthorizeURL,
+        getLogoutURL,
+      }}
+    >
      {children}
    </UserContext.Provider>
  );
--- a/src/components/Contexts/UserContext.test.jsx
+++ b/src/components/Contexts/UserContext.test.jsx
@@ -1,98 +1,88 @@
 jest.mock("../../services/auth");
 jest.mock("../../services/timer");

-import {render, cleanup, screen, fireEvent, waitFor} from "@testing-library/react"
-import { UserProvider, useUserContext }  from "../Contexts/UserContext";
+import {
+  render,
+  cleanup,
+  screen,
+  fireEvent,
+  waitFor,
+} from "@testing-library/react";
+import { UserProvider, useUserContext } from "../Contexts/UserContext";
 import auth from "../../services/auth";
 import getTimerWorker from "../../services/timer";

-const TEST_TOKEN = { idToken: { 
-  jwtToken: "TEST",
-  payload: {
-    exp: (new Date().getTime() / 1000)
+const TEST_TOKEN = {
+  idToken: {
+    jwtToken: "TEST",
+    payload: {
+      exp: new Date().getTime() / 1000,
+    },
+  },
+};
+
+const INVALID_TOKEN_RESPONSE = {
+  error: "Bad Request Error",
+  message: "Bad Request Message",
+};
+
+const setupRefreshEnv = (refreshResponse, authenticated) => {
+  auth.setRefreshResponse(refreshResponse);
+  auth.setVerifyResponse({ authenticated });
+};
+
+const setupSignInEnv = (refreshResponse, authenticated) => {
+  auth.setSignInResponse(refreshResponse);
+  auth.setVerifyResponse({ authenticated });
+};
+
+const checkBaseResults = (error, fetching, token) => {
+  expect(screen.getByTestId("error").innerHTML).toEqual(error);
+  expect(screen.getByTestId("fetching").innerHTML).toEqual(fetching);
+  expect(screen.getByTestId("token").innerHTML).toEqual(token);
+};
+
+const checkTokenResults = (timer, token) => {
+  expect(timer.start.mock.calls.length).toEqual(1);
+  expect(timer.onMessage.mock.calls.length).toEqual(1);
+  expect(timer.stop.mock.calls.length).toEqual(0);
+  expect(timer.terminate.mock.calls.length).toEqual(0);
+  if (!localStorage) {
+    expect(localStorage.getItem("token")).toEqual(token);
+    localStorage.removeItem("token");
  }
-}};
+};

 describe("UseContext", () => {
-  
-  describe("Signup", () => {
-    beforeEach(() => {
-      const TestComp = () => {
-        const { signUp, error, fetching } = useUserContext();
-        return (
-          <>
-            <div data-testid="error">{error}</div>
-            <div data-testid="fetching">{fetching.toString()}</div>
-            <button data-testid="signUpNoEmail" onClick={() => signUp("")}/>
-            <button data-testid="signUpNoPassword" onClick={() => signUp("test@test.com", "")}/>
-            <button data-testid="signUpBadConfirm" onClick={() => signUp("test@test.com", "password", "")}/>
-            <button data-testid="signUp" onClick={() => signUp("test@test.com", "password", "password")}/>        
-          </>
-        );
-      };
-      render(<UserProvider><TestComp /></UserProvider>);  
-    });
-
-    afterEach(() => {
-      cleanup();
-    });
-
-    it("Initial state", () => {
-      expect(screen.getByTestId("error").innerHTML).toEqual("");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-    });
-
-    it("Error with no email address", () => {
-      fireEvent.click(screen.getByTestId("signUpNoEmail"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("Email is required");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-    });
-
-    it("Error with no password", () => {
-      fireEvent.click(screen.getByTestId("signUpNoPassword"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("Password is required");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-    });
-
-    it("Error with non-matching password", () => {
-      fireEvent.click(screen.getByTestId("signUpBadConfirm"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("Passwords do not match");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-    });
-
-    it("No error sign up", async () => {
-      fireEvent.click(screen.getByTestId("signUp"));
-      await waitFor(() => expect(screen.getByTestId("fetching").innerHTML).toEqual("false"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("");
-    });
-
-    it("Handle server error", async () => {
-      auth.setSignInResponse({ message: "SIGN-IN-ERROR" })
-      auth.setSignUpResponse({ message: "SIGN-UP-ERROR", error: "ERR" });
-      fireEvent.click(screen.getByTestId("signUp"));
-      await waitFor(() => expect(screen.getByTestId("fetching").innerHTML).toEqual("false"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("SIGN-UP-ERROR");
-      auth.setSignUpResponse({});
-    });
-  });
-
  describe("Signin", () => {
-
    beforeEach(() => {
      const TestComp = () => {
-        const { signIn, error, token, fetching } = useUserContext();
+        const {
+          signIn,
+          error,
+          token,
+          fetching,
+        } = useUserContext();
+
        return (
          <>
            <div data-testid="error">{error}</div>
            <div data-testid="fetching">{fetching.toString()}</div>
            <div data-testid="token">{JSON.stringify(token)}</div>
-            <button data-testid="signInNoEmail" onClick={() => signIn("")}/>
-            <button data-testid="signInNoPassword" onClick={() => signIn("test@test.com", "")}/>
-            <button data-testid="signIn" onClick={() => signIn("test@test.com", "password", "password")}/>          
+            <button data-testid="signInNoCode" onClick={() => signIn("")} />
+            <button
+              data-testid="signInInvalidCode"
+              onClick={() => signIn("INVALID_CODE")}
+            />
+            <button data-testid="signIn" onClick={() => signIn("TEST_CODE")} />
          </>
        );
      };
-      render(<UserProvider><TestComp /></UserProvider>);  
+      render(
+        <UserProvider>
+          <TestComp />
+        </UserProvider>
+      );
    });

    afterEach(() => {
@@ -100,51 +90,41 @@ describe("UseContext", () => {
    });

    it("Initial state", () => {
-      expect(screen.getByTestId("error").innerHTML).toEqual("");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-      expect(screen.getByTestId("token").innerHTML).toEqual("null");
+      checkBaseResults("", "false", "null");
    });

-    it("Error with no email address", () => {
-      fireEvent.click(screen.getByTestId("signInNoEmail"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("Email is required");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-      expect(screen.getByTestId("token").innerHTML).toEqual("null");
+    it("No auth code", () => {
+      fireEvent.click(screen.getByTestId("signInNoCode"));
+
+      checkBaseResults("", "false", "null");
    });

-    it("Error with no password", () => {
-      fireEvent.click(screen.getByTestId("signInNoPassword"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("Password is required");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-      expect(screen.getByTestId("token").innerHTML).toEqual("null");
+    it("Invalid auth code", async () => {
+      setupSignInEnv(INVALID_TOKEN_RESPONSE, false);
+
+      fireEvent.click(screen.getByTestId("signInInvalidCode"));
+
+      await waitFor(() =>
+        expect(screen.getByTestId("fetching").innerHTML).toEqual("true")
+      );
+
+      checkBaseResults("Sign in error. Bad Request Message", "false", "null");
    });

-    it("No error sign in", async () => {
+    it("Sign in form", async () => {
      const TOKEN_STRING = JSON.stringify(TEST_TOKEN);
      const timer = getTimerWorker();

-      auth.setSignInResponse(TEST_TOKEN);
-      auth.setVerifyResponse({ authenticated: true })
-      fireEvent.click(screen.getByTestId("signIn"));
-      await waitFor(() => expect(screen.getByTestId("fetching").innerHTML).toEqual("false"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("");
-      expect(screen.getByTestId("token").innerHTML).toEqual(TOKEN_STRING);
-      expect(timer.start.mock.calls.length).toEqual(1);
-      expect(timer.onMessage.mock.calls.length).toEqual(1);
-      expect(timer.stop.mock.calls.length).toEqual(0);
-      expect(timer.terminate.mock.calls.length).toEqual(0);
-      if (!localStorage) {
-        expect(localStorage.getItem("token")).toEqual(TOKEN_STRING);
-        localStorage.removeItem("token");  
-      }
-  });
+      setupSignInEnv(TEST_TOKEN, true);

-    it("Handle server error", async () => {
-      auth.setSignInResponse({ message: "SERVER-ERROR", error: "ERR" });
      fireEvent.click(screen.getByTestId("signIn"));
-      await waitFor(() => expect(screen.getByTestId("fetching").innerHTML).toEqual("false"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("SERVER-ERROR");
-      auth.setSignUpResponse({});
+
+      await waitFor(() =>
+        expect(screen.getByTestId("fetching").innerHTML).toEqual("true")
+      );
+
+      checkBaseResults("", "false", TOKEN_STRING);
+      checkTokenResults(timer, TOKEN_STRING);
    });
  });

@@ -157,15 +137,21 @@ describe("UseContext", () => {
            <div data-testid="error">{error}</div>
            <div data-testid="fetching">{fetching.toString()}</div>
            <div data-testid="token">{JSON.stringify(token)}</div>
-            <button data-testid="signIn" onClick={() => signIn("test@test.com", "password", "password")}/>          
-            <button data-testid="signOut" onClick={() => signOut()}/>          
+            <button data-testid="signIn" onClick={() => signIn("TEST_CODE")} />
+            <button data-testid="signOut" onClick={() => signOut()} />
          </>
        );
      };
-      render(<UserProvider><TestComp /></UserProvider>);  
+      render(
+        <UserProvider>
+          <TestComp />
+        </UserProvider>
+      );
      auth.setSignInResponse(TEST_TOKEN);
      fireEvent.click(screen.getByTestId("signIn"));
-      await waitFor(() => expect(screen.getByTestId("fetching").innerHTML).toEqual("false"));
+      await waitFor(() =>
+        expect(screen.getByTestId("fetching").innerHTML).toEqual("true")
+      );
    });

    afterEach(() => {
@@ -175,11 +161,81 @@ describe("UseContext", () => {

    it("Token cleared", () => {
      fireEvent.click(screen.getByTestId("signOut"));
-      expect(screen.getByTestId("error").innerHTML).toEqual("");
-      expect(screen.getByTestId("fetching").innerHTML).toEqual("false");
-      expect(screen.getByTestId("token").innerHTML).toEqual("null");
+
+      checkBaseResults("", "false", "null");
      if (!localStorage) return;
-      expect(localStorage.getItem('token')).toBeNull();
-    })
-  })
-});
+      expect(localStorage.getItem("token")).toBeNull();
+    });
+  });
+
+  describe("Refresh", () => {
+    beforeEach(() => {
+      const TestComp = () => {
+        const {
+          refresh,
+          error,
+          token,
+          fetching,
+        } = useUserContext();
+
+        return (
+          <>
+            <div data-testid="error">{error}</div>
+            <div data-testid="fetching">{fetching.toString()}</div>
+            <div data-testid="token">{JSON.stringify(token)}</div>
+            <button data-testid="refreshNoToken" onClick={() => refresh("")} />
+            <button
+              data-testid="refreshInvalidToken"
+              onClick={() => refresh("INVALID_TOKEN")}
+            />
+            <button data-testid="refreshValidToken" onClick={() => refresh("TEST_TOKEN")} />
+          </>
+        );
+      };
+      render(
+        <UserProvider>
+          <TestComp />
+        </UserProvider>
+      );
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it("Initial state", () => {
+      checkBaseResults("", "false", "null");
+    });
+
+    it("No refresh token", () => {
+      fireEvent.click(screen.getByTestId("refreshNoToken"));
+      checkBaseResults("Refresh error. Token required", "false", "null");
+    });
+
+    it("Invalid refresh token", async () => {
+      setupRefreshEnv(INVALID_TOKEN_RESPONSE, false);
+
+      fireEvent.click(screen.getByTestId("refreshInvalidToken"));
+      await waitFor(() =>
+        expect(screen.getByTestId("fetching").innerHTML).toEqual("true")
+      );
+
+      checkBaseResults("Refresh error. Bad Request Message", "false", "null");
+    });
+
+    it("Valid refresh token", async () => {
+      const TOKEN_STRING = JSON.stringify(TEST_TOKEN);
+      const timer = getTimerWorker();
+
+      setupRefreshEnv(TEST_TOKEN, true);
+
+      fireEvent.click(screen.getByTestId("refreshValidToken"));
+      await waitFor(() =>
+        expect(screen.getByTestId("fetching").innerHTML).toEqual("true")
+      );
+
+      checkBaseResults("", "false", TOKEN_STRING);
+      checkTokenResults(timer, TOKEN_STRING);
+    });
+  });
+});
--- a/src/components/Contexts/mocks/FileUploadContext.jsx
+++ b/src/components/Contexts/mocks/FileUploadContext.jsx
@@ -5,11 +5,7 @@ let progress = 0;
 let status = null;

 export const FileUploadProvider = ({ children }) => {
-  return (
-    <div data-testid="mocked-fileuploadprovider">
-      {children}
-    </div>
-  );
+  return <div data-testid="mocked-fileuploadprovider">{children}</div>;
 };

 export const useFileUploadContext = () => ({
--- a/src/components/Contexts/mocks/UserContext.jsx
+++ b/src/components/Contexts/mocks/UserContext.jsx
@@ -1,30 +1,27 @@
-import React from 'react';
+import React from "react";

 let token = null;
 let fetching = false;
 let error = null;
 let signInResp = {};
-let signUpResp = {};
+let authorizeURL = "https://cognito.com/authorize?redirect=https://example.com/callback";
+let logoutURL = "https://cognito.com/logout?redirect=https://example.com/callback";

 export const UserProvider = ({ children }) => {
-  return (
-    <div data-testid="mocked-userprovider">
-      {children}
-    </div>
-  );
+  return <div data-testid="mocked-userprovider">{children}</div>;
 };

 export const useUserContext = () => ({
  token,
  fetching,
  error,
+  signIn: jest.fn(() => signInResp),
+  signOut: jest.fn(),
+  getAuthorizeURL: jest.fn(() => authorizeURL),
+  getLogoutURL: jest.fn(() => logoutURL),
  setError: jest.fn((value) => {
    error = value;
  }),
-  signIn: jest.fn(() => signInResp),
-  signUp: jest.fn(() => signUpResp),
-  signOut: jest.fn(),
-  signUpAndIn: jest.fn(),
 });

 export const setToken = (val) => {
@@ -38,7 +35,3 @@ export const setFetching = (val) => {
 export const setError = (val) => {
  error = val;
 };
-
-export const setSignUpResp = (val) => {
-  signUpResp = val;
-};