admin/ota-admin-portal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CEC-5308: remove dead code (#475)

Browse Source
This commit is contained in:
Tristan Timblin
2023-11-06 12:58:33 -08:00
committed by GitHub
parent 4adbc1dd7f
commit dd33b505be
10 changed files with 5974 additions and 5424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/components/App/App.test.js
View File

@@ -1,5 +1,4 @@
jest.mock("../Contexts/CarUpdatesContext");
jest.mock("../Contexts/FileUploadContext");
jest.mock("../Contexts/VehicleContext");
jest.mock("../Contexts/ManifestsContext");
jest.mock("../Contexts/UserContext");

108
src/components/Contexts/FileUploadContext.jsx
View File

@@ -1,108 +0,0 @@
import React, { useContext, useState } from "react";
import { uploadFile, getCancelToken } from "../../services/uploadFile";
const FileUploadContext = React.createContext();
export const FileUploadProvider = ({ children }) => {
const [uploading, setUploading] = useState(false);
const [progress, setProgress] = useState(0);
const [status, setStatus] = useState(null);
const [cancelUpload, setCancelUpload] = useState(null);
const [files, setFiles] = useState(null);
const done = () => {
setCancelUpload(null);
setUploading(false);
setProgress(0);
};
const cancel = async () => {
if (cancelUpload && progress < 100) {
cancelUpload.cancel();
setStatus("Upload canceled");
}
done();
};
const validateUpload = (formData, accessToken, uploadFiles) => {
if (!formData) {
throw new Error("Missing package update data");
}
if (!formData.packagename || formData.packagename.length === 0) {
throw new Error("Package name required");
}
if (!formData.version || formData.version.length === 0) {
throw new Error("Package update version required");
}
if (!uploadFiles || uploadFiles.length === 0) {
throw new Error("File required");
}
if (!accessToken || accessToken.length === 0) {
throw new Error("Access token required");
}
if (!formData.description || formData.description.length === 0) {
throw new Error("Package update description required");
}
if (!formData.releasenotes || formData.releasenotes.length === 0) {
throw new Error("Package update release notes link required");
}
};
const upload = async (formData, accessToken, uploadFiles) => {
validateUpload(formData, accessToken, uploadFiles);
try {
const file = uploadFiles[0];
const filename = file.name;
setUploading(true);
setProgress(0);
setStatus(`Uploading ${filename}`);
setCancelUpload(getCancelToken());
const data = await uploadFile(
file,
formData,
accessToken,
setProgress,
cancelUpload
);
if (data.message) {
throw new Error(`${data.error}. ${data.message}`);
}
setStatus(`Uploaded ${filename}`);
setCancelUpload(null);
setProgress(100);
return data;
} catch (e) {
setUploading(true);
setStatus(`Error occured: ${e.message}`);
setProgress(-1);
}
};
return (
<FileUploadContext.Provider
value={{
uploading,
progress,
status,
files,
upload,
cancel,
setFiles,
}}
>
{children}
</FileUploadContext.Provider>
);
};
export const useFileUploadContext = () => useContext(FileUploadContext);

155
src/components/Contexts/FileUploadContext.test.jsx
View File

@@ -1,155 +0,0 @@
jest.mock("../../services/uploadFile");
import {
render,
cleanup,
screen,
fireEvent,
waitFor,
} from "@testing-library/react";
import { useState } from "react";
import { setUploadFileDelay } from "../../services/uploadFile";
import {
FileUploadProvider,
useFileUploadContext,
} from "../Contexts/FileUploadContext";
import { StatusProvider, useStatusContext } from "../Contexts/StatusContext";
const checkState = (uploading, progress, status, linkURL, message) => {
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);
expect(screen.getByTestId("message").innerHTML).toEqual(message);
};
describe("FileUploadContext", () => {
beforeEach(() => {
const TestComp = () => {
const {
progress,
uploading,
status,
upload,
cancel,
} = useFileUploadContext();
const { message, setMessage } = useStatusContext();
const [link, setLink] = useState(null);
const TEST_FILE = [{ name: "test.jpg", size: 0 }];
const TEST_ACCESSTOKEN = "ACCESSTOKEN";
const TEST_FORMDATA = {
packagename: "TEST",
version: "VERSION",
vehicles: ["VIN"],
description: "TEST DESC",
releasenotes: "http://releasenotes.com",
};
const exec = async (form, token, file) => {
try {
const data = await upload(form, token, file);
if (data.link) {
setLink(data.link);
}
} catch (e) {
setMessage(e.message);
}
};
return (
<>
<div data-testid="uploading">{uploading.toString()}</div>
<div data-testid="progress">{progress.toString()}</div>
<div data-testid="status">{status}</div>
<div data-testid="message">{message}</div>
<div data-testid="linkURL">{link}</div>
<button
data-testid="uploadNoFile"
onClick={() => {
exec(TEST_FORMDATA, TEST_ACCESSTOKEN, null);
}}
/>
<button
data-testid="uploadNoToken"
onClick={() => {
exec(TEST_FORMDATA, null, TEST_FILE);
}}
/>
<button
data-testid="uploadNoFormData"
onClick={() => {
exec({}, TEST_ACCESSTOKEN, TEST_FILE);
}}
/>
<button
data-testid="upload"
onClick={() => exec(TEST_FORMDATA, TEST_ACCESSTOKEN, TEST_FILE)}
/>
<button data-testid="cancel" onClick={() => cancel()} />
</>
);
};
render(
<StatusProvider>
<FileUploadProvider>
<TestComp />
</FileUploadProvider>
</StatusProvider>
);
});
afterEach(() => {
cleanup();
});
it("Initial state", async () => {
checkState("false", "0", "", "", "");
});
it("Upload no file", async () => {
fireEvent.click(screen.getByTestId("uploadNoFile"));
await waitFor(() =>
expect(screen.getByTestId("message").innerHTML).not.toBe("")
);
checkState("false", "0", "", "", "File required");
});
it("Upload no access token", async () => {
fireEvent.click(screen.getByTestId("uploadNoToken"));
await waitFor(() =>
expect(screen.getByTestId("message").innerHTML).not.toBe("")
);
checkState("false", "0", "", "", "Access token required");
});
it("Upload no form data", async () => {
fireEvent.click(screen.getByTestId("uploadNoFormData"));
await waitFor(() =>
expect(screen.getByTestId("message").innerHTML).not.toBe("")
);
checkState("false", "0", "", "", "Package name required");
});
it("Upload file", async () => {
fireEvent.click(screen.getByTestId("upload"));
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")
);
checkState("true", "50", "Uploading test.jpg", "", "");
fireEvent.click(screen.getByTestId("cancel"));
await waitFor(() =>
expect(screen.getByTestId("progress").innerHTML).toEqual("0")
);
checkState("false", "0", "Upload canceled", "", "");
});
});

22
src/components/Contexts/__mocks__/FileUploadContext.jsx
View File

@@ -1,22 +0,0 @@
import React from "react";
let uploading = false;
let progress = 0;
let status = null;
let files = null;
export const FileUploadProvider = ({ children }) => {
return <div data-testid="mocked-fileuploadprovider">{children}</div>;
};
export const useFileUploadContext = () => ({
uploading,
progress,
status,
files,
upload: jest.fn(),
cancel: jest.fn(),
setFiles: jest.fn((value) => {
files = value;
}),
});

87
src/components/Controls/FileDragArea/index.jsx
View File

@@ -1,87 +0,0 @@
import React, { useRef, useState } from "react";
import clsx from "clsx";
import useStyles from "../../useStyles";
import { useStatusContext } from "../../Contexts/StatusContext";
const FileDragArea = ({
onFileSelect,
onDragEnter,
onDragOver,
onDragLeave,
children,
}) => {
const { setMessage } = useStatusContext();
const [over, setOver] = useState(false);
const classes = useStyles();
const inputFile = useRef();
const dragEnterHandler = (e) => {
setOver(true);
if (onDragEnter) onDragEnter(e);
};
const dragOverHandler = (e) => {
setOver(true);
if (onDragEnter) onDragOver(e);
};
const dragLeaveHandler = (e) => {
setOver(false);
if (onDragLeave) onDragLeave(e);
};
const dropHandler = (e) => {
try {
const { files } = e.dataTransfer;
if (onFileSelect) onFileSelect(files);
setOver(false);
} catch (err) {
setMessage(err);
}
};
const selectHandler = (e) => {
try {
const { files } = e.target;
if (onFileSelect) onFileSelect(files);
} catch (err) {
setMessage(err);
}
};
const onClick = (e) => {
try {
inputFile.current.click();
} catch (err) {
setMessage(err);
}
};
return (
<>
<div
onDragEnter={dragEnterHandler}
onDragOver={dragOverHandler}
onDragLeave={dragLeaveHandler}
onDrop={dropHandler}
onClick={onClick}
className={clsx(
classes.fileDropArea,
classes.clickable,
over ? classes.overHighlight : null
)}
>
{children}
</div>
<input
type="file"
onChange={selectHandler}
ref={inputFile}
className={classes.hidden}
/>
</>
);
};
export default FileDragArea;

6
src/components/useStyles.jsx
View File

@@ -288,12 +288,6 @@ const useStyles = makeStyles((theme) => ({
progressError: { color: "red" },
hidden: { display: "none" },
clickable: { cursor: "pointer" },
fileDropArea: {
width: "100%",
height: "100%",
textAlign: "center",
color: "Black",
},
overHighlight: { background: "green" },
pseudoLink: {
cursor: "pointer",

29
src/services/__mocks__/uploadFile.js
View File

@@ -1,29 +0,0 @@
import delay from "../../utils/delay";
let uploadFileResponse = { link: "CLOUDFRONT_URL" };
let uploadFileDelay = false;
let issuedCancelToken = null;
export const getCancelToken = () => {
issuedCancelToken = {
cancel: jest.fn()
}
return issuedCancelToken;
}
export const uploadFile = async (file, data, token, onProgress, cancelToken) => {
if (!uploadFileDelay) return uploadFileResponse;
onProgress(50);
await delay(10000);
return {};
};
export const setUploadFileResponse = (value) => {
uploadFileResponse = value;
}
export const setUploadFileDelay = (value) => {
uploadFileDelay = value;
}
export const getIssuedCancelToken = () => issuedCancelToken;

49
src/services/uploadFile.js
View File

@@ -1,49 +0,0 @@
import axios from "axios";
const UPLOAD_ENDPOINT = process.env.REACT_APP_OTA_SERVICE_URL;
const fileField = "file";
export const getCancelToken = () => {
const token = axios.CancelToken;
return token.source();
};
export const uploadFile = (data, token, onProgress, cancelToken) => {
const form = new FormData();
let options = {
method: "POST",
headers: {
"Content-Type": "multipart/form-data",
Authorization: `Bearer ${token}`,
},
cancelToken,
};
if (onProgress) {
options = {
...options,
onUploadProgress: (event) => {
onProgress(event.loaded / event.total);
},
};
}
for (let key in data) {
if (key !== fileField) form.append(key, data[key]);
}
form.append(fileField, data[fileField]);
return axios
.post(`${UPLOAD_ENDPOINT}/manifestfile`, form, options)
.then((response) => response.data)
.catch((error) => {
if (typeof error.response.data === "string") {
return {
error: error.response.statusText,
message: error.response.data,
};
}
return error.response.data;
});
};