CEC-1182 fleet filter forms (#131)

* forms for fleet can filters

* unit tests for fleet filters

* removing warnings

* updating regex

src/components/Contexts/FleetContext.jsx

@@ -12,6 +12,9 @@ export const FleetProvider = ({ children }) => {
   const [fleetVehicles, setFleetVehicles] = useState([]);
   const [totalFleetVehicles, setTotalFleetVehicles] = useState(0);
 
+  const [fleetCANFilters, setFleetCANFilters] = useState([]);
+  const [totalFleetCANFilters, setTotalFleetCANFilters] = useState(0);
+
   const addFleet = async (fleet, token) => {
     try {
       setBusy(true);
@@ -60,7 +63,7 @@ export const FleetProvider = ({ children }) => {
     } finally {
       setBusy(false);
     }
-  }
+  };
 
   const deleteFleet = async (name, token) => {
     try {
@@ -79,7 +82,7 @@ export const FleetProvider = ({ children }) => {
     } finally {
       setBusy(false);
     }
-  }
+  };
 
   const getFleetVehicles = async (name, search, token) => {
     try {
@@ -99,7 +102,7 @@ export const FleetProvider = ({ children }) => {
     } finally {
       setBusy(false);
     }
-  }
+  };
 
   const addFleetVehicle = async (name, vehicle, token) => {
     try {
@@ -116,7 +119,7 @@ export const FleetProvider = ({ children }) => {
     } finally {
       setBusy(false);
     }
-  }
+  };
 
   const deleteFleetVehicle = async (name, vehicle, token) => {
     try {
@@ -136,8 +139,83 @@ export const FleetProvider = ({ children }) => {
     } finally {
       setBusy(false);
     }
+  };
+
+  const getFleetCANFilters = async (name, search, token) => {
+    try {
+      setBusy(true);
+
+      const result = await api.getFleetCANFilters(name, search, token);
+      if (result.error) {
+        setFleetCANFilters([])
+        throw new Error(`Get fleet filters error. ${result.message}`);
+      }
+
+      setFleetCANFilters(result.data)
+      if (result.total) {
+        setTotalFleetCANFilters(result.total);
+      }
+      return result;
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const addFleetCANFilter = async (name, filter, token) => {
+    try {
+      setBusy(true);
+
+      validateFleetName(name);
+      validateFilter(filter);
+
+      const result = await api.addFleetCANFilter(name, filter, token);
+      if (result.error) {
+        throw new Error(`Add fleet CAN filter error. ${result.message}`);
+      }
+      return result;
+    } finally {
+      setBusy(false);
+    }
   }
 
+  const updateFleetCANFilter = async (name, can_id, filter, token) => {
+    try {
+      setBusy(true);
+
+      validateFleetName(name);
+      validateCANID(can_id);
+      validateFilter(filter);
+
+      const result = await api.updateFleetCANFilter(name, can_id, filter, token);
+      if (result.error) {
+        throw new Error(`Update fleet CAN filter error. ${result.message}`);
+      }
+      return result;
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const deleteFleetCANFilter = async (name, can_id, token) => {
+    try {
+      setBusy(true);
+
+      validateFleetName(name);
+      validateCANID(can_id);
+
+      const result = await api.deleteFleetCANFilter(name, can_id, token);
+      if (result.error) {
+        throw new Error(`Delete fleet vehicle error. ${result.message}`);
+      }
+
+      const index = fleetCANFilters.findIndex(element => element.can_id === can_id);
+      if (index >= 0) fleetCANFilters.splice(index, 1);
+      return result;
+    } finally {
+      setBusy(false);
+    }
+  };
+
   return (
     <FleetContext.Provider
       value={{
@@ -154,7 +232,14 @@ export const FleetProvider = ({ children }) => {
         totalFleetVehicles,
         getFleetVehicles,
         addFleetVehicle,
-        deleteFleetVehicle
+        deleteFleetVehicle,
+
+        fleetCANFilters,
+        totalFleetCANFilters,
+        getFleetCANFilters,
+        addFleetCANFilter,
+        updateFleetCANFilter,
+        deleteFleetCANFilter
       }}
     >
       {children}
@@ -171,7 +256,7 @@ const validateFleet = (fleet) => {
 }
 
 const validateFleetName = (name) => {
-  if (name == null || !/^[0-9A-Za-z-]+$/.test(name)) {
+  if (name == null || !/^[\w-]+$/.test(name)) {
     throw new Error("Invalid name");
   }
 }
@@ -182,4 +267,22 @@ const validateVIN = (vin) => {
   }
 }
 
+const validateFilter = (filter) => {
+  if (filter == null) {
+    throw new Error("No CAN filter data");
+  }
+
+  validateCANID(filter.can_id)
+
+  if (filter.interval == null || !/^\d+$/.test(filter.interval)) {
+    throw new Error("Invalid interval");
+  }
+}
+
+const validateCANID = (can_id) => {
+  if (can_id == null || !/^\d+(-\d+)?$/.test(can_id)) {
+    throw new Error("Invalid CAN ID");
+  }
+}
+
 export const useFleetContext = () => useContext(FleetContext);

src/components/Contexts/FleetContext.test.jsx

@@ -20,6 +20,11 @@ const checkFleetVehicleResults = (error, busy, vehicles) => {
   expect(screen.getByTestId("fleet-vehicles").innerHTML).toEqual(vehicles);
 }
 
+const checkFleetCANFilterResults = (error, busy, filters) => {
+  checkBaseResults(error, busy);
+  expect(screen.getByTestId("fleet-filters").innerHTML).toEqual(filters);
+}
+
 const checkBaseResults = (error, busy) => {
   expect(screen.getByTestId("error").innerHTML).toEqual(error);
   expect(screen.getByTestId("busy").innerHTML).toEqual(busy);
@@ -457,6 +462,187 @@ describe("FleetContext", () => {
       checkBaseResults("", "false");
     });
   });
+
+  describe("getFleetCANFilters", () => {
+    beforeEach(() => {
+      const TestComp = () => {
+        const { busy, error, fleetCANFilters, getFleetCANFilters } = useFleetContext();
+
+        return (
+          <>
+            <div data-testid="error">{error}</div>
+            <div data-testid="busy">{busy.toString()}</div>
+            <div data-testid="fleet-filters">{JSON.stringify(fleetCANFilters)}</div>
+            <button
+              data-testid="getFleetCANFilters"
+              onClick={() => getFleetCANFilters("US-TEST")}
+            />
+          </>
+        );
+      };
+      render(
+        <FleetProvider>
+          <TestComp />
+        </FleetProvider>
+      );
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it("initial state", () => {
+      checkFleetCANFilterResults("", "false", "[]");
+    });
+
+    it("getFleetCANFilters", async () => {
+      fireEvent.click(screen.getByTestId("getFleetCANFilters"));
+      await waitFor(() =>
+        expect(screen.getByTestId("fleet-filters").innerHTML).not.toBe("[]")
+      );
+      checkFleetCANFilterResults("", "false", JSON.stringify(expectedFleetCANFiltersData));
+    });
+  });
+
+  describe("addFleetCANFilter", () => {
+    beforeEach(async () => {
+      const TestComp = () => {
+        const { busy, addFleetCANFilter } = useFleetContext();
+        const { message, setMessage } = useStatusContext();
+        const add = async (name, filter) => {
+          try {
+            await addFleetCANFilter(name, filter);
+          } catch (e) {
+            setMessage(e.message);
+          }
+        };
+
+        return (
+          <>
+            <div data-testid="error">{message}</div>
+            <div data-testid="busy">{busy.toString()}</div>
+            <button data-testid="addFleetCANFilterNull" onClick={() => add(null)} />
+            <button data-testid="addFleetCANFilterNoName" onClick={() => add({})} />
+            <button
+              data-testid="addFleetCANFilter"
+              onClick={() =>
+                add("US-TEST", { can_id: "111", interval: 222 })
+              }
+            />
+          </>
+        );
+      };
+      render(
+        <StatusProvider>
+          <FleetProvider>
+            <TestComp />
+          </FleetProvider>
+        </StatusProvider>
+      );
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it("initial state", () => {
+      checkBaseResults("", "false");
+    });
+
+    it("addFleetCANFilterNull", async () => {
+      fireEvent.click(screen.getByTestId("addFleetCANFilterNull"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid name", "false");
+    });
+
+    it("addFleetCANFilterNoName", async () => {
+      fireEvent.click(screen.getByTestId("addFleetCANFilterNoName"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid name", "false");
+    });
+
+    it("addFleetCANFilter", async () => {
+      fireEvent.click(screen.getByTestId("addFleetCANFilter"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("", "false");
+    });
+  });
+
+  describe("deleteFleetCANFilter", () => {
+    beforeEach(async () => {
+      const TestComp = () => {
+        const { busy, deleteFleetCANFilter } = useFleetContext();
+        const { message, setMessage } = useStatusContext();
+        const deleteFF = async (name, can_id) => {
+          try {
+            await deleteFleetCANFilter(name, can_id);
+          } catch (e) {
+            setMessage(e.message);
+          }
+        };
+
+        return (
+          <>
+            <div data-testid="error">{message}</div>
+            <div data-testid="busy">{busy.toString()}</div>
+            <button data-testid="deleteFleetCANFilterNull" onClick={() => deleteFF("US-WEST", null)} />
+            <button data-testid="deleteFleetCANFilterInvalid" onClick={() => deleteFF("US-WEST", "INVALID")} />
+            <button
+              data-testid="deleteFleetCANFilter"
+              onClick={() =>
+                deleteFF("US-WEST", "123-456")
+              }
+            />
+          </>
+        );
+      };
+      render(
+        <StatusProvider>
+          <FleetProvider>
+            <TestComp />
+          </FleetProvider>
+        </StatusProvider>
+      );
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it("initial state", () => {
+      checkBaseResults("", "false");
+    });
+
+    it("deleteFleetCANFilterNull", async () => {
+      fireEvent.click(screen.getByTestId("deleteFleetCANFilterNull"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid CAN ID", "false");
+    });
+
+    it("deleteFleetCANFilterNonexistent", async () => {
+      fireEvent.click(screen.getByTestId("deleteFleetCANFilterInvalid"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid CAN ID", "false");
+    });
+
+    it("deleteFleetCANFilter", async () => {
+      fireEvent.click(screen.getByTestId("deleteFleetCANFilter"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("", "false");
+    });
+  });
 });
 
 const expectedFleetsData = [
@@ -480,4 +666,19 @@ const expectedFleetsData = [
   },
 ];
 
-const expectedFleetVehiclesData = ["USWESTVIN12345678", "USWESTVIN12345679", "USWESTVIN12345670"]
+const expectedFleetVehiclesData = ["USWESTVIN12345678", "USWESTVIN12345679", "USWESTVIN12345670"];
+
+const expectedFleetCANFiltersData = [
+  {
+    can_id: "123-456",
+    interval: 789
+  },
+  {
+    can_id: "1",
+    interval: 1000
+  },
+  {
+    can_id: "1000",
+    interval: 1
+  }
+];

src/components/Contexts/__mocks__/FleetContext.jsx

@@ -22,6 +22,21 @@ let fleets = [
 let totalFleets = 3;
 let fleetVehicles = ["USWESTVIN12345678", "USWESTVIN12345679", "USWESTVIN12345670"];
 let totalFleetVehicles = 3;
+let fleetCANFilters = [
+  {
+    can_id: "123-456",
+    interval: 789
+  },
+  {
+    can_id: "1",
+    interval: 1000
+  },
+  {
+    can_id: "1000",
+    interval: 1
+  }
+]
+let totalFleetCANFilters = 3;
 
 export const FleetProvider = ({ children }) => {
   return <div data-testid="mocked-fleetprovider">{children}</div>;
@@ -41,5 +56,12 @@ export const useFleetContext = () => ({
   totalFleetVehicles,
   getFleetVehicles: jest.fn(),
   addFleetVehicle: jest.fn(),
-  deleteFleetVehicle: jest.fn()
+  deleteFleetVehicle: jest.fn(),
+
+  fleetCANFilters,
+  totalFleetCANFilters,
+  getFleetCANFilters: jest.fn(),
+  addFleetCANFilter: jest.fn(),
+  updateFleetCANFilter: jest.fn(),
+  deleteFleetCANFilter: jest.fn(),
 });